Subversion Repositories shark

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
55 pj 1
/* $Id: dlist.c,v 1.1 2003-02-28 11:41:59 pj Exp $ */
2
 
3
/*
4
 * Mesa 3-D graphics library
5
 * Version:  5.0
6
 *
7
 * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
8
 *
9
 * Permission is hereby granted, free of charge, to any person obtaining a
10
 * copy of this software and associated documentation files (the "Software"),
11
 * to deal in the Software without restriction, including without limitation
12
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13
 * and/or sell copies of the Software, and to permit persons to whom the
14
 * Software is furnished to do so, subject to the following conditions:
15
 *
16
 * The above copyright notice and this permission notice shall be included
17
 * in all copies or substantial portions of the Software.
18
 *
19
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
22
 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23
 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25
 */
26
 
27
#include "glheader.h"
28
#include "imports.h"
29
#include "api_loopback.h"
30
#include "attrib.h"
31
#include "blend.h"
32
#include "buffers.h"
33
#include "clip.h"
34
#include "colormac.h"
35
#include "colortab.h"
36
#include "context.h"
37
#include "convolve.h"
38
#include "depth.h"
39
#include "dlist.h"
40
#include "enable.h"
41
#include "enums.h"
42
#include "eval.h"
43
#include "extensions.h"
44
#include "feedback.h"
45
#include "get.h"
46
#include "glapi.h"
47
#include "hash.h"
48
#include "histogram.h"
49
#include "image.h"
50
#include "light.h"
51
#include "lines.h"
52
#include "dlist.h"
53
#include "macros.h"
54
#include "matrix.h"
55
#include "pixel.h"
56
#include "points.h"
57
#include "polygon.h"
58
#include "state.h"
59
#include "texobj.h"
60
#include "teximage.h"
61
#include "texstate.h"
62
#include "mtypes.h"
63
#include "varray.h"
64
#if FEATURE_NV_vertex_program
65
#include "vpstate.h"
66
#endif
67
 
68
#include "math/m_matrix.h"
69
#include "math/m_xform.h"
70
 
71
 
72
 
73
/*
74
Functions which aren't compiled but executed immediately:
75
        glIsList
76
        glGenLists
77
        glDeleteLists
78
        glEndList  --- BUT:  call ctx->Driver.EndList at end of list execution?
79
        glFeedbackBuffer
80
        glSelectBuffer
81
        glRenderMode
82
        glReadPixels
83
        glPixelStore
84
        glFlush
85
        glFinish
86
        glIsEnabled
87
        glGet*
88
 
89
Functions which cause errors if called while compiling a display list:
90
        glNewList
91
*/
92
 
93
 
94
 
95
/*
96
 * Display list instructions are stored as sequences of "nodes".  Nodes
97
 * are allocated in blocks.  Each block has BLOCK_SIZE nodes.  Blocks
98
 * are linked together with a pointer.
99
 */
100
 
101
 
102
/* How many nodes to allocate at a time:
103
 * - reduced now that we hold vertices etc. elsewhere.
104
 */
105
#define BLOCK_SIZE 256
106
 
107
 
108
/*
109
 * Display list opcodes.
110
 *
111
 * The fact that these identifiers are assigned consecutive
112
 * integer values starting at 0 is very important, see InstSize array usage)
113
 *
114
 */
115
typedef enum {
116
        OPCODE_ACCUM,
117
        OPCODE_ALPHA_FUNC,
118
        OPCODE_BIND_TEXTURE,
119
        OPCODE_BITMAP,
120
        OPCODE_BLEND_COLOR,
121
        OPCODE_BLEND_EQUATION,
122
        OPCODE_BLEND_FUNC,
123
        OPCODE_BLEND_FUNC_SEPARATE,
124
        OPCODE_CALL_LIST,
125
        OPCODE_CALL_LIST_OFFSET,
126
        OPCODE_CLEAR,
127
        OPCODE_CLEAR_ACCUM,
128
        OPCODE_CLEAR_COLOR,
129
        OPCODE_CLEAR_DEPTH,
130
        OPCODE_CLEAR_INDEX,
131
        OPCODE_CLEAR_STENCIL,
132
        OPCODE_CLIP_PLANE,
133
        OPCODE_COLOR_MASK,
134
        OPCODE_COLOR_MATERIAL,
135
        OPCODE_COLOR_TABLE,
136
        OPCODE_COLOR_TABLE_PARAMETER_FV,
137
        OPCODE_COLOR_TABLE_PARAMETER_IV,
138
        OPCODE_COLOR_SUB_TABLE,
139
        OPCODE_CONVOLUTION_FILTER_1D,
140
        OPCODE_CONVOLUTION_FILTER_2D,
141
        OPCODE_CONVOLUTION_PARAMETER_I,
142
        OPCODE_CONVOLUTION_PARAMETER_IV,
143
        OPCODE_CONVOLUTION_PARAMETER_F,
144
        OPCODE_CONVOLUTION_PARAMETER_FV,
145
        OPCODE_COPY_COLOR_SUB_TABLE,
146
        OPCODE_COPY_COLOR_TABLE,
147
        OPCODE_COPY_PIXELS,
148
        OPCODE_COPY_TEX_IMAGE1D,
149
        OPCODE_COPY_TEX_IMAGE2D,
150
        OPCODE_COPY_TEX_SUB_IMAGE1D,
151
        OPCODE_COPY_TEX_SUB_IMAGE2D,
152
        OPCODE_COPY_TEX_SUB_IMAGE3D,
153
        OPCODE_CULL_FACE,
154
        OPCODE_DEPTH_FUNC,
155
        OPCODE_DEPTH_MASK,
156
        OPCODE_DEPTH_RANGE,
157
        OPCODE_DISABLE,
158
        OPCODE_DRAW_BUFFER,
159
        OPCODE_DRAW_PIXELS,
160
        OPCODE_ENABLE,
161
        OPCODE_EVALMESH1,
162
        OPCODE_EVALMESH2,
163
        OPCODE_FOG,
164
        OPCODE_FRONT_FACE,
165
        OPCODE_FRUSTUM,
166
        OPCODE_HINT,
167
        OPCODE_HISTOGRAM,
168
        OPCODE_INDEX_MASK,
169
        OPCODE_INIT_NAMES,
170
        OPCODE_LIGHT,
171
        OPCODE_LIGHT_MODEL,
172
        OPCODE_LINE_STIPPLE,
173
        OPCODE_LINE_WIDTH,
174
        OPCODE_LIST_BASE,
175
        OPCODE_LOAD_IDENTITY,
176
        OPCODE_LOAD_MATRIX,
177
        OPCODE_LOAD_NAME,
178
        OPCODE_LOGIC_OP,
179
        OPCODE_MAP1,
180
        OPCODE_MAP2,
181
        OPCODE_MAPGRID1,
182
        OPCODE_MAPGRID2,
183
        OPCODE_MATRIX_MODE,
184
        OPCODE_MIN_MAX,
185
        OPCODE_MULT_MATRIX,
186
        OPCODE_ORTHO,
187
        OPCODE_PASSTHROUGH,
188
        OPCODE_PIXEL_MAP,
189
        OPCODE_PIXEL_TRANSFER,
190
        OPCODE_PIXEL_ZOOM,
191
        OPCODE_POINT_SIZE,
192
        OPCODE_POINT_PARAMETERS,
193
        OPCODE_POLYGON_MODE,
194
        OPCODE_POLYGON_STIPPLE,
195
        OPCODE_POLYGON_OFFSET,
196
        OPCODE_POP_ATTRIB,
197
        OPCODE_POP_MATRIX,
198
        OPCODE_POP_NAME,
199
        OPCODE_PRIORITIZE_TEXTURE,
200
        OPCODE_PUSH_ATTRIB,
201
        OPCODE_PUSH_MATRIX,
202
        OPCODE_PUSH_NAME,
203
        OPCODE_RASTER_POS,
204
        OPCODE_READ_BUFFER,
205
        OPCODE_RESET_HISTOGRAM,
206
        OPCODE_RESET_MIN_MAX,
207
        OPCODE_ROTATE,
208
        OPCODE_SCALE,
209
        OPCODE_SCISSOR,
210
        OPCODE_SELECT_TEXTURE_SGIS,
211
        OPCODE_SELECT_TEXTURE_COORD_SET,
212
        OPCODE_SHADE_MODEL,
213
        OPCODE_STENCIL_FUNC,
214
        OPCODE_STENCIL_MASK,
215
        OPCODE_STENCIL_OP,
216
        OPCODE_TEXENV,
217
        OPCODE_TEXGEN,
218
        OPCODE_TEXPARAMETER,
219
        OPCODE_TEX_IMAGE1D,
220
        OPCODE_TEX_IMAGE2D,
221
        OPCODE_TEX_IMAGE3D,
222
        OPCODE_TEX_SUB_IMAGE1D,
223
        OPCODE_TEX_SUB_IMAGE2D,
224
        OPCODE_TEX_SUB_IMAGE3D,
225
        OPCODE_TRANSLATE,
226
        OPCODE_VIEWPORT,
227
        OPCODE_WINDOW_POS,
228
        /* GL_ARB_multitexture */
229
        OPCODE_ACTIVE_TEXTURE,
230
        /* GL_SGIX/SGIS_pixel_texture */
231
        OPCODE_PIXEL_TEXGEN_SGIX,
232
        OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS,
233
        /* GL_ARB_texture_compression */
234
        OPCODE_COMPRESSED_TEX_IMAGE_1D,
235
        OPCODE_COMPRESSED_TEX_IMAGE_2D,
236
        OPCODE_COMPRESSED_TEX_IMAGE_3D,
237
        OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D,
238
        OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D,
239
        OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D,
240
        /* GL_ARB_multisample */
241
        OPCODE_SAMPLE_COVERAGE,
242
        /* GL_ARB_window_pos */
243
        OPCODE_WINDOW_POS_ARB,
244
        /* GL_NV_vertex_program */
245
        OPCODE_BIND_PROGRAM_NV,
246
        OPCODE_EXECUTE_PROGRAM_NV,
247
        OPCODE_REQUEST_PROGRAMS_RESIDENT_NV,
248
        OPCODE_LOAD_PROGRAM_NV,
249
        OPCODE_PROGRAM_PARAMETER4F_NV,
250
        OPCODE_TRACK_MATRIX_NV,
251
        /* GL_EXT_stencil_two_side */
252
        OPCODE_ACTIVE_STENCIL_FACE_EXT,
253
        /* The following three are meta instructions */
254
        OPCODE_ERROR,           /* raise compiled-in error */
255
        OPCODE_CONTINUE,
256
        OPCODE_END_OF_LIST,
257
        OPCODE_DRV_0
258
} OpCode;
259
 
260
 
261
/*
262
 * Each instruction in the display list is stored as a sequence of
263
 * contiguous nodes in memory.
264
 * Each node is the union of a variety of datatypes.
265
 */
266
union node {
267
        OpCode          opcode;
268
        GLboolean       b;
269
        GLbitfield      bf;
270
        GLubyte         ub;
271
        GLshort         s;
272
        GLushort        us;
273
        GLint           i;
274
        GLuint          ui;
275
        GLenum          e;
276
        GLfloat         f;
277
        GLvoid          *data;
278
        void            *next;  /* If prev node's opcode==OPCODE_CONTINUE */
279
};
280
 
281
 
282
 
283
/* Number of nodes of storage needed for each instruction.  Sizes for
284
 * dynamically allocated opcodes are stored in the context struct.
285
 */
286
static GLuint InstSize[ OPCODE_END_OF_LIST+1 ];
287
 
288
void mesa_print_display_list( GLuint list );
289
 
290
 
291
/**********************************************************************/
292
/*****                           Private                          *****/
293
/**********************************************************************/
294
 
295
 
296
 
297
 
298
 
299
/*
300
 * Make an empty display list.  This is used by glGenLists() to
301
 * reserver display list IDs.
302
 */
303
static Node *make_empty_list( void )
304
{
305
   Node *n = (Node *) MALLOC( sizeof(Node) );
306
   n[0].opcode = OPCODE_END_OF_LIST;
307
   return n;
308
}
309
 
310
 
311
 
312
/*
313
 * Destroy all nodes in a display list.
314
 * Input:  list - display list number
315
 */
316
void _mesa_destroy_list( GLcontext *ctx, GLuint list )
317
{
318
   Node *n, *block;
319
   GLboolean done;
320
 
321
   if (list==0)
322
      return;
323
 
324
   block = (Node *) _mesa_HashLookup(ctx->Shared->DisplayList, list);
325
   n = block;
326
 
327
   done = block ? GL_FALSE : GL_TRUE;
328
   while (!done) {
329
 
330
      /* check for extension opcodes first */
331
 
332
      GLint i = (GLint) n[0].opcode - (GLint) OPCODE_DRV_0;
333
      if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) {
334
         ctx->listext.opcode[i].destroy(ctx, &n[1]);
335
         n += ctx->listext.opcode[i].size;
336
      }
337
      else {
338
         switch (n[0].opcode) {
339
         case OPCODE_MAP1:
340
            FREE(n[6].data);
341
            n += InstSize[n[0].opcode];
342
            break;
343
         case OPCODE_MAP2:
344
            FREE(n[10].data);
345
            n += InstSize[n[0].opcode];
346
            break;
347
         case OPCODE_DRAW_PIXELS:
348
            FREE( n[5].data );
349
            n += InstSize[n[0].opcode];
350
            break;
351
         case OPCODE_BITMAP:
352
            FREE( n[7].data );
353
            n += InstSize[n[0].opcode];
354
            break;
355
         case OPCODE_COLOR_TABLE:
356
            FREE( n[6].data );
357
            n += InstSize[n[0].opcode];
358
            break;
359
         case OPCODE_COLOR_SUB_TABLE:
360
            FREE( n[6].data );
361
            n += InstSize[n[0].opcode];
362
            break;
363
         case OPCODE_CONVOLUTION_FILTER_1D:
364
            FREE( n[6].data );
365
            n += InstSize[n[0].opcode];
366
            break;
367
         case OPCODE_CONVOLUTION_FILTER_2D:
368
            FREE( n[7].data );
369
            n += InstSize[n[0].opcode];
370
            break;
371
         case OPCODE_POLYGON_STIPPLE:
372
            FREE( n[1].data );
373
            n += InstSize[n[0].opcode];
374
            break;
375
         case OPCODE_TEX_IMAGE1D:
376
            FREE(n[8].data);
377
            n += InstSize[n[0].opcode];
378
            break;
379
         case OPCODE_TEX_IMAGE2D:
380
            FREE( n[9]. data );
381
            n += InstSize[n[0].opcode];
382
            break;
383
         case OPCODE_TEX_IMAGE3D:
384
            FREE( n[10]. data );
385
            n += InstSize[n[0].opcode];
386
            break;
387
         case OPCODE_TEX_SUB_IMAGE1D:
388
            FREE(n[7].data);
389
            n += InstSize[n[0].opcode];
390
            break;
391
         case OPCODE_TEX_SUB_IMAGE2D:
392
            FREE(n[9].data);
393
            n += InstSize[n[0].opcode];
394
            break;
395
         case OPCODE_TEX_SUB_IMAGE3D:
396
            FREE(n[11].data);
397
            n += InstSize[n[0].opcode];
398
            break;
399
         case OPCODE_COMPRESSED_TEX_IMAGE_1D:
400
            FREE(n[7].data);
401
            n += InstSize[n[0].opcode];
402
            break;
403
         case OPCODE_COMPRESSED_TEX_IMAGE_2D:
404
            FREE(n[8].data);
405
            n += InstSize[n[0].opcode];
406
            break;
407
         case OPCODE_COMPRESSED_TEX_IMAGE_3D:
408
            FREE(n[9].data);
409
            n += InstSize[n[0].opcode];
410
            break;
411
         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D:
412
            FREE(n[7].data);
413
            n += InstSize[n[0].opcode];
414
            break;
415
         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D:
416
            FREE(n[9].data);
417
            n += InstSize[n[0].opcode];
418
            break;
419
         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D:
420
            FREE(n[11].data);
421
            n += InstSize[n[0].opcode];
422
            break;
423
         case OPCODE_CONTINUE:
424
            n = (Node *) n[1].next;
425
            FREE( block );
426
            block = n;
427
            break;
428
         case OPCODE_END_OF_LIST:
429
            FREE( block );
430
            done = GL_TRUE;
431
            break;
432
         default:
433
            /* Most frequent case */
434
            n += InstSize[n[0].opcode];
435
            break;
436
         }
437
      }
438
   }
439
 
440
   _mesa_HashRemove(ctx->Shared->DisplayList, list);
441
}
442
 
443
 
444
 
445
/*
446
 * Translate the nth element of list from type to GLuint.
447
 */
448
static GLuint translate_id( GLsizei n, GLenum type, const GLvoid *list )
449
{
450
   GLbyte *bptr;
451
   GLubyte *ubptr;
452
   GLshort *sptr;
453
   GLushort *usptr;
454
   GLint *iptr;
455
   GLuint *uiptr;
456
   GLfloat *fptr;
457
 
458
   switch (type) {
459
      case GL_BYTE:
460
         bptr = (GLbyte *) list;
461
         return (GLuint) *(bptr+n);
462
      case GL_UNSIGNED_BYTE:
463
         ubptr = (GLubyte *) list;
464
         return (GLuint) *(ubptr+n);
465
      case GL_SHORT:
466
         sptr = (GLshort *) list;
467
         return (GLuint) *(sptr+n);
468
      case GL_UNSIGNED_SHORT:
469
         usptr = (GLushort *) list;
470
         return (GLuint) *(usptr+n);
471
      case GL_INT:
472
         iptr = (GLint *) list;
473
         return (GLuint) *(iptr+n);
474
      case GL_UNSIGNED_INT:
475
         uiptr = (GLuint *) list;
476
         return (GLuint) *(uiptr+n);
477
      case GL_FLOAT:
478
         fptr = (GLfloat *) list;
479
         return (GLuint) *(fptr+n);
480
      case GL_2_BYTES:
481
         ubptr = ((GLubyte *) list) + 2*n;
482
         return (GLuint) *ubptr * 256 + (GLuint) *(ubptr+1);
483
      case GL_3_BYTES:
484
         ubptr = ((GLubyte *) list) + 3*n;
485
         return (GLuint) *ubptr * 65536
486
              + (GLuint) *(ubptr+1) * 256
487
              + (GLuint) *(ubptr+2);
488
      case GL_4_BYTES:
489
         ubptr = ((GLubyte *) list) + 4*n;
490
         return (GLuint) *ubptr * 16777216
491
              + (GLuint) *(ubptr+1) * 65536
492
              + (GLuint) *(ubptr+2) * 256
493
              + (GLuint) *(ubptr+3);
494
      default:
495
         return 0;
496
   }
497
}
498
 
499
 
500
 
501
 
502
/**********************************************************************/
503
/*****                        Public                              *****/
504
/**********************************************************************/
505
 
506
void _mesa_init_lists( void )
507
{
508
   static int init_flag = 0;
509
 
510
   if (init_flag==0) {
511
      InstSize[OPCODE_ACCUM] = 3;
512
      InstSize[OPCODE_ALPHA_FUNC] = 3;
513
      InstSize[OPCODE_BIND_TEXTURE] = 3;
514
      InstSize[OPCODE_BITMAP] = 8;
515
      InstSize[OPCODE_BLEND_COLOR] = 5;
516
      InstSize[OPCODE_BLEND_EQUATION] = 2;
517
      InstSize[OPCODE_BLEND_FUNC] = 3;
518
      InstSize[OPCODE_BLEND_FUNC_SEPARATE] = 5;
519
      InstSize[OPCODE_CALL_LIST] = 2;
520
      InstSize[OPCODE_CALL_LIST_OFFSET] = 3;
521
      InstSize[OPCODE_CLEAR] = 2;
522
      InstSize[OPCODE_CLEAR_ACCUM] = 5;
523
      InstSize[OPCODE_CLEAR_COLOR] = 5;
524
      InstSize[OPCODE_CLEAR_DEPTH] = 2;
525
      InstSize[OPCODE_CLEAR_INDEX] = 2;
526
      InstSize[OPCODE_CLEAR_STENCIL] = 2;
527
      InstSize[OPCODE_CLIP_PLANE] = 6;
528
      InstSize[OPCODE_COLOR_MASK] = 5;
529
      InstSize[OPCODE_COLOR_MATERIAL] = 3;
530
      InstSize[OPCODE_COLOR_TABLE] = 7;
531
      InstSize[OPCODE_COLOR_TABLE_PARAMETER_FV] = 7;
532
      InstSize[OPCODE_COLOR_TABLE_PARAMETER_IV] = 7;
533
      InstSize[OPCODE_COLOR_SUB_TABLE] = 7;
534
      InstSize[OPCODE_CONVOLUTION_FILTER_1D] = 7;
535
      InstSize[OPCODE_CONVOLUTION_FILTER_2D] = 8;
536
      InstSize[OPCODE_CONVOLUTION_PARAMETER_I] = 4;
537
      InstSize[OPCODE_CONVOLUTION_PARAMETER_IV] = 7;
538
      InstSize[OPCODE_CONVOLUTION_PARAMETER_F] = 4;
539
      InstSize[OPCODE_CONVOLUTION_PARAMETER_FV] = 7;
540
      InstSize[OPCODE_COPY_PIXELS] = 6;
541
      InstSize[OPCODE_COPY_COLOR_SUB_TABLE] = 6;
542
      InstSize[OPCODE_COPY_COLOR_TABLE] = 6;
543
      InstSize[OPCODE_COPY_TEX_IMAGE1D] = 8;
544
      InstSize[OPCODE_COPY_TEX_IMAGE2D] = 9;
545
      InstSize[OPCODE_COPY_TEX_SUB_IMAGE1D] = 7;
546
      InstSize[OPCODE_COPY_TEX_SUB_IMAGE2D] = 9;
547
      InstSize[OPCODE_COPY_TEX_SUB_IMAGE3D] = 10;
548
      InstSize[OPCODE_CULL_FACE] = 2;
549
      InstSize[OPCODE_DEPTH_FUNC] = 2;
550
      InstSize[OPCODE_DEPTH_MASK] = 2;
551
      InstSize[OPCODE_DEPTH_RANGE] = 3;
552
      InstSize[OPCODE_DISABLE] = 2;
553
      InstSize[OPCODE_DRAW_BUFFER] = 2;
554
      InstSize[OPCODE_DRAW_PIXELS] = 6;
555
      InstSize[OPCODE_ENABLE] = 2;
556
      InstSize[OPCODE_EVALMESH1] = 4;
557
      InstSize[OPCODE_EVALMESH2] = 6;
558
      InstSize[OPCODE_FOG] = 6;
559
      InstSize[OPCODE_FRONT_FACE] = 2;
560
      InstSize[OPCODE_FRUSTUM] = 7;
561
      InstSize[OPCODE_HINT] = 3;
562
      InstSize[OPCODE_HISTOGRAM] = 5;
563
      InstSize[OPCODE_INDEX_MASK] = 2;
564
      InstSize[OPCODE_INIT_NAMES] = 1;
565
      InstSize[OPCODE_LIGHT] = 7;
566
      InstSize[OPCODE_LIGHT_MODEL] = 6;
567
      InstSize[OPCODE_LINE_STIPPLE] = 3;
568
      InstSize[OPCODE_LINE_WIDTH] = 2;
569
      InstSize[OPCODE_LIST_BASE] = 2;
570
      InstSize[OPCODE_LOAD_IDENTITY] = 1;
571
      InstSize[OPCODE_LOAD_MATRIX] = 17;
572
      InstSize[OPCODE_LOAD_NAME] = 2;
573
      InstSize[OPCODE_LOGIC_OP] = 2;
574
      InstSize[OPCODE_MAP1] = 7;
575
      InstSize[OPCODE_MAP2] = 11;
576
      InstSize[OPCODE_MAPGRID1] = 4;
577
      InstSize[OPCODE_MAPGRID2] = 7;
578
      InstSize[OPCODE_MATRIX_MODE] = 2;
579
      InstSize[OPCODE_MIN_MAX] = 4;
580
      InstSize[OPCODE_MULT_MATRIX] = 17;
581
      InstSize[OPCODE_ORTHO] = 7;
582
      InstSize[OPCODE_PASSTHROUGH] = 2;
583
      InstSize[OPCODE_PIXEL_MAP] = 4;
584
      InstSize[OPCODE_PIXEL_TRANSFER] = 3;
585
      InstSize[OPCODE_PIXEL_ZOOM] = 3;
586
      InstSize[OPCODE_POINT_SIZE] = 2;
587
      InstSize[OPCODE_POINT_PARAMETERS] = 5;
588
      InstSize[OPCODE_POLYGON_MODE] = 3;
589
      InstSize[OPCODE_POLYGON_STIPPLE] = 2;
590
      InstSize[OPCODE_POLYGON_OFFSET] = 3;
591
      InstSize[OPCODE_POP_ATTRIB] = 1;
592
      InstSize[OPCODE_POP_MATRIX] = 1;
593
      InstSize[OPCODE_POP_NAME] = 1;
594
      InstSize[OPCODE_PRIORITIZE_TEXTURE] = 3;
595
      InstSize[OPCODE_PUSH_ATTRIB] = 2;
596
      InstSize[OPCODE_PUSH_MATRIX] = 1;
597
      InstSize[OPCODE_PUSH_NAME] = 2;
598
      InstSize[OPCODE_RASTER_POS] = 5;
599
      InstSize[OPCODE_READ_BUFFER] = 2;
600
      InstSize[OPCODE_RESET_HISTOGRAM] = 2;
601
      InstSize[OPCODE_RESET_MIN_MAX] = 2;
602
      InstSize[OPCODE_ROTATE] = 5;
603
      InstSize[OPCODE_SCALE] = 4;
604
      InstSize[OPCODE_SCISSOR] = 5;
605
      InstSize[OPCODE_STENCIL_FUNC] = 4;
606
      InstSize[OPCODE_STENCIL_MASK] = 2;
607
      InstSize[OPCODE_STENCIL_OP] = 4;
608
      InstSize[OPCODE_SHADE_MODEL] = 2;
609
      InstSize[OPCODE_TEXENV] = 7;
610
      InstSize[OPCODE_TEXGEN] = 7;
611
      InstSize[OPCODE_TEXPARAMETER] = 7;
612
      InstSize[OPCODE_TEX_IMAGE1D] = 9;
613
      InstSize[OPCODE_TEX_IMAGE2D] = 10;
614
      InstSize[OPCODE_TEX_IMAGE3D] = 11;
615
      InstSize[OPCODE_TEX_SUB_IMAGE1D] = 8;
616
      InstSize[OPCODE_TEX_SUB_IMAGE2D] = 10;
617
      InstSize[OPCODE_TEX_SUB_IMAGE3D] = 12;
618
      InstSize[OPCODE_TRANSLATE] = 4;
619
      InstSize[OPCODE_VIEWPORT] = 5;
620
      InstSize[OPCODE_WINDOW_POS] = 5;
621
      InstSize[OPCODE_CONTINUE] = 2;
622
      InstSize[OPCODE_ERROR] = 3;
623
      InstSize[OPCODE_END_OF_LIST] = 1;
624
      /* GL_SGIX/SGIS_pixel_texture */
625
      InstSize[OPCODE_PIXEL_TEXGEN_SGIX] = 2;
626
      InstSize[OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS] = 3;
627
      /* GL_ARB_texture_compression */
628
      InstSize[OPCODE_COMPRESSED_TEX_IMAGE_1D] = 8;
629
      InstSize[OPCODE_COMPRESSED_TEX_IMAGE_2D] = 9;
630
      InstSize[OPCODE_COMPRESSED_TEX_IMAGE_3D] = 10;
631
      InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D] = 8;
632
      InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D] = 10;
633
      InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D] = 12;
634
      /* GL_ARB_multisample */
635
      InstSize[OPCODE_SAMPLE_COVERAGE] = 3;
636
      /* GL_ARB_multitexture */
637
      InstSize[OPCODE_ACTIVE_TEXTURE] = 2;
638
      /* GL_ARB_window_pos */
639
      InstSize[OPCODE_WINDOW_POS_ARB] = 4;
640
      /* GL_NV_vertex_program */
641
      InstSize[OPCODE_BIND_PROGRAM_NV] = 3;
642
      InstSize[OPCODE_EXECUTE_PROGRAM_NV] = 7;
643
      InstSize[OPCODE_REQUEST_PROGRAMS_RESIDENT_NV] = 2;
644
      InstSize[OPCODE_LOAD_PROGRAM_NV] = 4;
645
      InstSize[OPCODE_PROGRAM_PARAMETER4F_NV] = 7;
646
      InstSize[OPCODE_TRACK_MATRIX_NV] = 5;
647
      /* GL_EXT_stencil_two_side */
648
      InstSize[OPCODE_ACTIVE_STENCIL_FACE_EXT] = 2;
649
   }
650
   init_flag = 1;
651
}
652
 
653
 
654
/*
655
 * Allocate space for a display list instruction.
656
 * Input:  opcode - type of instruction
657
 *         argcount - size in bytes of data required.
658
 * Return: pointer to the usable data area (not including the internal
659
 *         opcode).
660
 */
661
void *
662
_mesa_alloc_instruction( GLcontext *ctx, int opcode, GLint sz )
663
{
664
   Node *n, *newblock;
665
   GLuint count = 1 + (sz + sizeof(Node) - 1) / sizeof(Node);
666
 
667
#ifdef DEBUG
668
   if (opcode < (int) OPCODE_DRV_0) {
669
      assert( count == InstSize[opcode] );
670
   }
671
#endif
672
 
673
   if (ctx->CurrentPos + count + 2 > BLOCK_SIZE) {
674
      /* This block is full.  Allocate a new block and chain to it */
675
      n = ctx->CurrentBlock + ctx->CurrentPos;
676
      n[0].opcode = OPCODE_CONTINUE;
677
      newblock = (Node *) MALLOC( sizeof(Node) * BLOCK_SIZE );
678
      if (!newblock) {
679
         _mesa_error( ctx, GL_OUT_OF_MEMORY, "Building display list" );
680
         return NULL;
681
      }
682
      n[1].next = (Node *) newblock;
683
      ctx->CurrentBlock = newblock;
684
      ctx->CurrentPos = 0;
685
   }
686
 
687
   n = ctx->CurrentBlock + ctx->CurrentPos;
688
   ctx->CurrentPos += count;
689
 
690
   n[0].opcode = (OpCode) opcode;
691
 
692
   return (void *)&n[1];
693
}
694
 
695
 
696
/* Allow modules and drivers to get their own opcodes.
697
 */
698
int
699
_mesa_alloc_opcode( GLcontext *ctx,
700
                    GLuint sz,
701
                    void (*execute)( GLcontext *, void * ),
702
                    void (*destroy)( GLcontext *, void * ),
703
                    void (*print)( GLcontext *, void * ) )
704
{
705
   if (ctx->listext.nr_opcodes < GL_MAX_EXT_OPCODES) {
706
      GLuint i = ctx->listext.nr_opcodes++;
707
      ctx->listext.opcode[i].size = 1 + (sz + sizeof(Node) - 1)/sizeof(Node);
708
      ctx->listext.opcode[i].execute = execute;
709
      ctx->listext.opcode[i].destroy = destroy;
710
      ctx->listext.opcode[i].print = print;
711
      return i + OPCODE_DRV_0;
712
   }
713
   return -1;
714
}
715
 
716
 
717
 
718
/* Mimic the old behaviour of alloc_instruction:
719
 *   - sz is in units of sizeof(Node)
720
 *   - return value a pointer to sizeof(Node) before the actual
721
 *     usable data area.
722
 */
723
#define ALLOC_INSTRUCTION(ctx, opcode, sz) \
724
        ((Node *)_mesa_alloc_instruction(ctx, opcode, sz*sizeof(Node)) - 1)
725
 
726
 
727
 
728
/*
729
 * Display List compilation functions
730
 */
731
static void save_Accum( GLenum op, GLfloat value )
732
{
733
   GET_CURRENT_CONTEXT(ctx);
734
   Node *n;
735
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
736
   n = ALLOC_INSTRUCTION( ctx, OPCODE_ACCUM, 2 );
737
   if (n) {
738
      n[1].e = op;
739
      n[2].f = value;
740
   }
741
   if (ctx->ExecuteFlag) {
742
      (*ctx->Exec->Accum)( op, value );
743
   }
744
}
745
 
746
 
747
static void save_AlphaFunc( GLenum func, GLclampf ref )
748
{
749
   GET_CURRENT_CONTEXT(ctx);
750
   Node *n;
751
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
752
   n = ALLOC_INSTRUCTION( ctx, OPCODE_ALPHA_FUNC, 2 );
753
   if (n) {
754
      n[1].e = func;
755
      n[2].f = (GLfloat) ref;
756
   }
757
   if (ctx->ExecuteFlag) {
758
      (*ctx->Exec->AlphaFunc)( func, ref );
759
   }
760
}
761
 
762
 
763
static void save_BindTexture( GLenum target, GLuint texture )
764
{
765
   GET_CURRENT_CONTEXT(ctx);
766
   Node *n;
767
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
768
   n = ALLOC_INSTRUCTION( ctx, OPCODE_BIND_TEXTURE, 2 );
769
   if (n) {
770
      n[1].e = target;
771
      n[2].ui = texture;
772
   }
773
   if (ctx->ExecuteFlag) {
774
      (*ctx->Exec->BindTexture)( target, texture );
775
   }
776
}
777
 
778
 
779
static void save_Bitmap( GLsizei width, GLsizei height,
780
                         GLfloat xorig, GLfloat yorig,
781
                         GLfloat xmove, GLfloat ymove,
782
                         const GLubyte *pixels )
783
{
784
   GET_CURRENT_CONTEXT(ctx);
785
   GLvoid *image = _mesa_unpack_bitmap( width, height, pixels, &ctx->Unpack );
786
   Node *n;
787
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
788
   n = ALLOC_INSTRUCTION( ctx, OPCODE_BITMAP, 7 );
789
   if (n) {
790
      n[1].i = (GLint) width;
791
      n[2].i = (GLint) height;
792
      n[3].f = xorig;
793
      n[4].f = yorig;
794
      n[5].f = xmove;
795
      n[6].f = ymove;
796
      n[7].data = image;
797
   }
798
   else if (image) {
799
      FREE(image);
800
   }
801
   if (ctx->ExecuteFlag) {
802
      (*ctx->Exec->Bitmap)( width, height,
803
                           xorig, yorig, xmove, ymove, pixels );
804
   }
805
}
806
 
807
 
808
static void save_BlendEquation( GLenum mode )
809
{
810
   GET_CURRENT_CONTEXT(ctx);
811
   Node *n;
812
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
813
   n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_EQUATION, 1 );
814
   if (n) {
815
      n[1].e = mode;
816
   }
817
   if (ctx->ExecuteFlag) {
818
      (*ctx->Exec->BlendEquation)( mode );
819
   }
820
}
821
 
822
 
823
static void save_BlendFunc( GLenum sfactor, GLenum dfactor )
824
{
825
   GET_CURRENT_CONTEXT(ctx);
826
   Node *n;
827
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
828
   n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_FUNC, 2 );
829
   if (n) {
830
      n[1].e = sfactor;
831
      n[2].e = dfactor;
832
   }
833
   if (ctx->ExecuteFlag) {
834
      (*ctx->Exec->BlendFunc)( sfactor, dfactor );
835
   }
836
}
837
 
838
 
839
static void save_BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB,
840
                                      GLenum sfactorA, GLenum dfactorA)
841
{
842
   GET_CURRENT_CONTEXT(ctx);
843
   Node *n;
844
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
845
   n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_FUNC_SEPARATE, 4 );
846
   if (n) {
847
      n[1].e = sfactorRGB;
848
      n[2].e = dfactorRGB;
849
      n[3].e = sfactorA;
850
      n[4].e = dfactorA;
851
   }
852
   if (ctx->ExecuteFlag) {
853
      (*ctx->Exec->BlendFuncSeparateEXT)( sfactorRGB, dfactorRGB,
854
                                          sfactorA, dfactorA);
855
   }
856
}
857
 
858
 
859
static void save_BlendColor( GLfloat red, GLfloat green,
860
                             GLfloat blue, GLfloat alpha )
861
{
862
   GET_CURRENT_CONTEXT(ctx);
863
   Node *n;
864
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
865
   n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_COLOR, 4 );
866
   if (n) {
867
      n[1].f = red;
868
      n[2].f = green;
869
      n[3].f = blue;
870
      n[4].f = alpha;
871
   }
872
   if (ctx->ExecuteFlag) {
873
      (*ctx->Exec->BlendColor)( red, green, blue, alpha );
874
   }
875
}
876
 
877
 
878
void _mesa_save_CallList( GLuint list )
879
{
880
   GET_CURRENT_CONTEXT(ctx);
881
   Node *n;
882
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
883
   FLUSH_CURRENT(ctx, 0);
884
 
885
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CALL_LIST, 1 );
886
   if (n) {
887
      n[1].ui = list;
888
   }
889
   if (ctx->ExecuteFlag) {
890
      (*ctx->Exec->CallList)( list );
891
   }
892
}
893
 
894
 
895
void _mesa_save_CallLists( GLsizei n, GLenum type, const GLvoid *lists )
896
{
897
   GET_CURRENT_CONTEXT(ctx);
898
   GLint i;
899
   GLboolean typeErrorFlag;
900
 
901
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
902
   FLUSH_CURRENT(ctx, 0);
903
 
904
   switch (type) {
905
      case GL_BYTE:
906
      case GL_UNSIGNED_BYTE:
907
      case GL_SHORT:
908
      case GL_UNSIGNED_SHORT:
909
      case GL_INT:
910
      case GL_UNSIGNED_INT:
911
      case GL_FLOAT:
912
      case GL_2_BYTES:
913
      case GL_3_BYTES:
914
      case GL_4_BYTES:
915
         typeErrorFlag = GL_FALSE;
916
         break;
917
      default:
918
         typeErrorFlag = GL_TRUE;
919
   }
920
 
921
   for (i=0;i<n;i++) {
922
      GLuint list = translate_id( i, type, lists );
923
      Node *n = ALLOC_INSTRUCTION( ctx, OPCODE_CALL_LIST_OFFSET, 2 );
924
      if (n) {
925
         n[1].ui = list;
926
         n[2].b = typeErrorFlag;
927
      }
928
   }
929
   if (ctx->ExecuteFlag) {
930
      (*ctx->Exec->CallLists)( n, type, lists );
931
   }
932
}
933
 
934
 
935
static void save_Clear( GLbitfield mask )
936
{
937
   GET_CURRENT_CONTEXT(ctx);
938
   Node *n;
939
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
940
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR, 1 );
941
   if (n) {
942
      n[1].bf = mask;
943
   }
944
   if (ctx->ExecuteFlag) {
945
      (*ctx->Exec->Clear)( mask );
946
   }
947
}
948
 
949
 
950
static void save_ClearAccum( GLfloat red, GLfloat green,
951
                             GLfloat blue, GLfloat alpha )
952
{
953
   GET_CURRENT_CONTEXT(ctx);
954
   Node *n;
955
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
956
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_ACCUM, 4 );
957
   if (n) {
958
      n[1].f = red;
959
      n[2].f = green;
960
      n[3].f = blue;
961
      n[4].f = alpha;
962
   }
963
   if (ctx->ExecuteFlag) {
964
      (*ctx->Exec->ClearAccum)( red, green, blue, alpha );
965
   }
966
}
967
 
968
 
969
static void save_ClearColor( GLclampf red, GLclampf green,
970
                             GLclampf blue, GLclampf alpha )
971
{
972
   GET_CURRENT_CONTEXT(ctx);
973
   Node *n;
974
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
975
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_COLOR, 4 );
976
   if (n) {
977
      n[1].f = red;
978
      n[2].f = green;
979
      n[3].f = blue;
980
      n[4].f = alpha;
981
   }
982
   if (ctx->ExecuteFlag) {
983
      (*ctx->Exec->ClearColor)( red, green, blue, alpha );
984
   }
985
}
986
 
987
 
988
static void save_ClearDepth( GLclampd depth )
989
{
990
   GET_CURRENT_CONTEXT(ctx);
991
   Node *n;
992
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
993
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_DEPTH, 1 );
994
   if (n) {
995
      n[1].f = (GLfloat) depth;
996
   }
997
   if (ctx->ExecuteFlag) {
998
      (*ctx->Exec->ClearDepth)( depth );
999
   }
1000
}
1001
 
1002
 
1003
static void save_ClearIndex( GLfloat c )
1004
{
1005
   GET_CURRENT_CONTEXT(ctx);
1006
   Node *n;
1007
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1008
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_INDEX, 1 );
1009
   if (n) {
1010
      n[1].f = c;
1011
   }
1012
   if (ctx->ExecuteFlag) {
1013
      (*ctx->Exec->ClearIndex)( c );
1014
   }
1015
}
1016
 
1017
 
1018
static void save_ClearStencil( GLint s )
1019
{
1020
   GET_CURRENT_CONTEXT(ctx);
1021
   Node *n;
1022
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1023
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_STENCIL, 1 );
1024
   if (n) {
1025
      n[1].i = s;
1026
   }
1027
   if (ctx->ExecuteFlag) {
1028
      (*ctx->Exec->ClearStencil)( s );
1029
   }
1030
}
1031
 
1032
 
1033
static void save_ClipPlane( GLenum plane, const GLdouble *equ )
1034
{
1035
   GET_CURRENT_CONTEXT(ctx);
1036
   Node *n;
1037
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1038
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLIP_PLANE, 5 );
1039
   if (n) {
1040
      n[1].e = plane;
1041
      n[2].f = (GLfloat) equ[0];
1042
      n[3].f = (GLfloat) equ[1];
1043
      n[4].f = (GLfloat) equ[2];
1044
      n[5].f = (GLfloat) equ[3];
1045
   }
1046
   if (ctx->ExecuteFlag) {
1047
      (*ctx->Exec->ClipPlane)( plane, equ );
1048
   }
1049
}
1050
 
1051
 
1052
 
1053
static void save_ColorMask( GLboolean red, GLboolean green,
1054
                            GLboolean blue, GLboolean alpha )
1055
{
1056
   GET_CURRENT_CONTEXT(ctx);
1057
   Node *n;
1058
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1059
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_MASK, 4 );
1060
   if (n) {
1061
      n[1].b = red;
1062
      n[2].b = green;
1063
      n[3].b = blue;
1064
      n[4].b = alpha;
1065
   }
1066
   if (ctx->ExecuteFlag) {
1067
      (*ctx->Exec->ColorMask)( red, green, blue, alpha );
1068
   }
1069
}
1070
 
1071
 
1072
static void save_ColorMaterial( GLenum face, GLenum mode )
1073
{
1074
   GET_CURRENT_CONTEXT(ctx);
1075
   Node *n;
1076
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1077
   FLUSH_CURRENT(ctx, 0);
1078
 
1079
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_MATERIAL, 2 );
1080
   if (n) {
1081
      n[1].e = face;
1082
      n[2].e = mode;
1083
   }
1084
   if (ctx->ExecuteFlag) {
1085
      (*ctx->Exec->ColorMaterial)( face, mode );
1086
   }
1087
}
1088
 
1089
 
1090
static void save_ColorTable( GLenum target, GLenum internalFormat,
1091
                             GLsizei width, GLenum format, GLenum type,
1092
                             const GLvoid *table )
1093
{
1094
   GET_CURRENT_CONTEXT(ctx);
1095
   if (target == GL_PROXY_TEXTURE_1D ||
1096
       target == GL_PROXY_TEXTURE_2D ||
1097
       target == GL_PROXY_TEXTURE_3D ||
1098
       target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
1099
      /* execute immediately */
1100
      (*ctx->Exec->ColorTable)( target, internalFormat, width,
1101
                                format, type, table );
1102
   }
1103
   else {
1104
      GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type, table,
1105
                                         &ctx->Unpack);
1106
      Node *n;
1107
      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1108
      n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE, 6 );
1109
      if (n) {
1110
         n[1].e = target;
1111
         n[2].e = internalFormat;
1112
         n[3].i = width;
1113
         n[4].e = format;
1114
         n[5].e = type;
1115
         n[6].data = image;
1116
      }
1117
      else if (image) {
1118
         FREE(image);
1119
      }
1120
      if (ctx->ExecuteFlag) {
1121
         (*ctx->Exec->ColorTable)( target, internalFormat, width,
1122
                                   format, type, table );
1123
      }
1124
   }
1125
}
1126
 
1127
 
1128
 
1129
static void
1130
save_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
1131
{
1132
   GET_CURRENT_CONTEXT(ctx);
1133
   Node *n;
1134
 
1135
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1136
 
1137
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE_PARAMETER_FV, 6 );
1138
   if (n) {
1139
      n[1].e = target;
1140
      n[2].e = pname;
1141
      n[3].f = params[0];
1142
      if (pname == GL_COLOR_TABLE_SGI ||
1143
          pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
1144
          pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) {
1145
         n[4].f = params[1];
1146
         n[5].f = params[2];
1147
         n[6].f = params[3];
1148
      }
1149
   }
1150
 
1151
   if (ctx->ExecuteFlag) {
1152
      (*ctx->Exec->ColorTableParameterfv)( target, pname, params );
1153
   }
1154
}
1155
 
1156
 
1157
static void
1158
save_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
1159
{
1160
   GET_CURRENT_CONTEXT(ctx);
1161
   Node *n;
1162
 
1163
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1164
 
1165
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE_PARAMETER_IV, 6 );
1166
   if (n) {
1167
      n[1].e = target;
1168
      n[2].e = pname;
1169
      n[3].i = params[0];
1170
      if (pname == GL_COLOR_TABLE_SGI ||
1171
          pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
1172
          pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI) {
1173
         n[4].i = params[1];
1174
         n[5].i = params[2];
1175
         n[6].i = params[3];
1176
      }
1177
   }
1178
 
1179
   if (ctx->ExecuteFlag) {
1180
      (*ctx->Exec->ColorTableParameteriv)( target, pname, params );
1181
   }
1182
}
1183
 
1184
 
1185
 
1186
static void save_ColorSubTable( GLenum target, GLsizei start, GLsizei count,
1187
                                GLenum format, GLenum type,
1188
                                const GLvoid *table)
1189
{
1190
   GET_CURRENT_CONTEXT(ctx);
1191
   GLvoid *image = _mesa_unpack_image(count, 1, 1, format, type, table,
1192
                                      &ctx->Unpack);
1193
   Node *n;
1194
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1195
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_SUB_TABLE, 6 );
1196
   if (n) {
1197
      n[1].e = target;
1198
      n[2].i = start;
1199
      n[3].i = count;
1200
      n[4].e = format;
1201
      n[5].e = type;
1202
      n[6].data = image;
1203
   }
1204
   else if (image) {
1205
      FREE(image);
1206
   }
1207
   if (ctx->ExecuteFlag) {
1208
      (*ctx->Exec->ColorSubTable)(target, start, count, format, type, table);
1209
   }
1210
}
1211
 
1212
 
1213
static void
1214
save_CopyColorSubTable(GLenum target, GLsizei start,
1215
                       GLint x, GLint y, GLsizei width)
1216
{
1217
   GET_CURRENT_CONTEXT(ctx);
1218
   Node *n;
1219
 
1220
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1221
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_COLOR_SUB_TABLE, 5 );
1222
   if (n) {
1223
      n[1].e = target;
1224
      n[2].i = start;
1225
      n[3].i = x;
1226
      n[4].i = y;
1227
      n[5].i = width;
1228
   }
1229
   if (ctx->ExecuteFlag) {
1230
      (*ctx->Exec->CopyColorSubTable)(target, start, x, y, width);
1231
   }
1232
}
1233
 
1234
 
1235
static void
1236
save_CopyColorTable(GLenum target, GLenum internalformat,
1237
                    GLint x, GLint y, GLsizei width)
1238
{
1239
   GET_CURRENT_CONTEXT(ctx);
1240
   Node *n;
1241
 
1242
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1243
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_COLOR_TABLE, 5 );
1244
   if (n) {
1245
      n[1].e = target;
1246
      n[2].e = internalformat;
1247
      n[3].i = x;
1248
      n[4].i = y;
1249
      n[5].i = width;
1250
   }
1251
   if (ctx->ExecuteFlag) {
1252
      (*ctx->Exec->CopyColorTable)(target, internalformat, x, y, width);
1253
   }
1254
}
1255
 
1256
 
1257
static void
1258
save_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width,
1259
                         GLenum format, GLenum type, const GLvoid *filter)
1260
{
1261
   GET_CURRENT_CONTEXT(ctx);
1262
   GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type, filter,
1263
                                      &ctx->Unpack);
1264
   Node *n;
1265
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1266
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_FILTER_1D, 6 );
1267
   if (n) {
1268
      n[1].e = target;
1269
      n[2].e = internalFormat;
1270
      n[3].i = width;
1271
      n[4].e = format;
1272
      n[5].e = type;
1273
      n[6].data = image;
1274
   }
1275
   else if (image) {
1276
      FREE(image);
1277
   }
1278
   if (ctx->ExecuteFlag) {
1279
      (*ctx->Exec->ConvolutionFilter1D)( target, internalFormat, width,
1280
                                         format, type, filter );
1281
   }
1282
}
1283
 
1284
 
1285
static void
1286
save_ConvolutionFilter2D(GLenum target, GLenum internalFormat,
1287
                         GLsizei width, GLsizei height, GLenum format,
1288
                         GLenum type, const GLvoid *filter)
1289
{
1290
   GET_CURRENT_CONTEXT(ctx);
1291
   GLvoid *image = _mesa_unpack_image(width, height, 1, format, type, filter,
1292
                                      &ctx->Unpack);
1293
   Node *n;
1294
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1295
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_FILTER_2D, 7 );
1296
   if (n) {
1297
      n[1].e = target;
1298
      n[2].e = internalFormat;
1299
      n[3].i = width;
1300
      n[4].i = height;
1301
      n[5].e = format;
1302
      n[6].e = type;
1303
      n[7].data = image;
1304
   }
1305
   else if (image) {
1306
      FREE(image);
1307
   }
1308
   if (ctx->ExecuteFlag) {
1309
      (*ctx->Exec->ConvolutionFilter2D)( target, internalFormat, width, height,
1310
                                         format, type, filter );
1311
   }
1312
}
1313
 
1314
 
1315
static void
1316
save_ConvolutionParameteri(GLenum target, GLenum pname, GLint param)
1317
{
1318
   GET_CURRENT_CONTEXT(ctx);
1319
   Node *n;
1320
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1321
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_I, 3 );
1322
   if (n) {
1323
      n[1].e = target;
1324
      n[2].e = pname;
1325
      n[3].i = param;
1326
   }
1327
   if (ctx->ExecuteFlag) {
1328
      (*ctx->Exec->ConvolutionParameteri)( target, pname, param );
1329
   }
1330
}
1331
 
1332
 
1333
static void
1334
save_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
1335
{
1336
   GET_CURRENT_CONTEXT(ctx);
1337
   Node *n;
1338
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1339
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_IV, 6 );
1340
   if (n) {
1341
      n[1].e = target;
1342
      n[2].e = pname;
1343
      n[3].i = params[0];
1344
      if (pname == GL_CONVOLUTION_BORDER_COLOR ||
1345
          pname == GL_CONVOLUTION_FILTER_SCALE ||
1346
          pname == GL_CONVOLUTION_FILTER_BIAS) {
1347
         n[4].i = params[1];
1348
         n[5].i = params[2];
1349
         n[6].i = params[3];
1350
      }
1351
      else {
1352
         n[4].i = n[5].i = n[6].i = 0;
1353
      }
1354
   }
1355
   if (ctx->ExecuteFlag) {
1356
      (*ctx->Exec->ConvolutionParameteriv)( target, pname, params );
1357
   }
1358
}
1359
 
1360
 
1361
static void
1362
save_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat param)
1363
{
1364
   GET_CURRENT_CONTEXT(ctx);
1365
   Node *n;
1366
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1367
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_F, 3 );
1368
   if (n) {
1369
      n[1].e = target;
1370
      n[2].e = pname;
1371
      n[3].f = param;
1372
   }
1373
   if (ctx->ExecuteFlag) {
1374
      (*ctx->Exec->ConvolutionParameterf)( target, pname, param );
1375
   }
1376
}
1377
 
1378
 
1379
static void
1380
save_ConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
1381
{
1382
   GET_CURRENT_CONTEXT(ctx);
1383
   Node *n;
1384
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1385
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_FV, 6 );
1386
   if (n) {
1387
      n[1].e = target;
1388
      n[2].e = pname;
1389
      n[3].f = params[0];
1390
      if (pname == GL_CONVOLUTION_BORDER_COLOR ||
1391
          pname == GL_CONVOLUTION_FILTER_SCALE ||
1392
          pname == GL_CONVOLUTION_FILTER_BIAS) {
1393
         n[4].f = params[1];
1394
         n[5].f = params[2];
1395
         n[6].f = params[3];
1396
      }
1397
      else {
1398
         n[4].f = n[5].f = n[6].f = 0.0F;
1399
      }
1400
   }
1401
   if (ctx->ExecuteFlag) {
1402
      (*ctx->Exec->ConvolutionParameterfv)( target, pname, params );
1403
   }
1404
}
1405
 
1406
 
1407
static void
1408
save_CopyPixels( GLint x, GLint y,
1409
                 GLsizei width, GLsizei height, GLenum type )
1410
{
1411
   GET_CURRENT_CONTEXT(ctx);
1412
   Node *n;
1413
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1414
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_PIXELS, 5 );
1415
   if (n) {
1416
      n[1].i = x;
1417
      n[2].i = y;
1418
      n[3].i = (GLint) width;
1419
      n[4].i = (GLint) height;
1420
      n[5].e = type;
1421
   }
1422
   if (ctx->ExecuteFlag) {
1423
      (*ctx->Exec->CopyPixels)( x, y, width, height, type );
1424
   }
1425
}
1426
 
1427
 
1428
 
1429
static void
1430
save_CopyTexImage1D( GLenum target, GLint level, GLenum internalformat,
1431
                     GLint x, GLint y, GLsizei width, GLint border )
1432
{
1433
   GET_CURRENT_CONTEXT(ctx);
1434
   Node *n;
1435
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1436
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_IMAGE1D, 7 );
1437
   if (n) {
1438
      n[1].e = target;
1439
      n[2].i = level;
1440
      n[3].e = internalformat;
1441
      n[4].i = x;
1442
      n[5].i = y;
1443
      n[6].i = width;
1444
      n[7].i = border;
1445
   }
1446
   if (ctx->ExecuteFlag) {
1447
      (*ctx->Exec->CopyTexImage1D)( target, level, internalformat,
1448
                                   x, y, width, border );
1449
   }
1450
}
1451
 
1452
 
1453
static void
1454
save_CopyTexImage2D( GLenum target, GLint level,
1455
                     GLenum internalformat,
1456
                     GLint x, GLint y, GLsizei width,
1457
                     GLsizei height, GLint border )
1458
{
1459
   GET_CURRENT_CONTEXT(ctx);
1460
   Node *n;
1461
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1462
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_IMAGE2D, 8 );
1463
   if (n) {
1464
      n[1].e = target;
1465
      n[2].i = level;
1466
      n[3].e = internalformat;
1467
      n[4].i = x;
1468
      n[5].i = y;
1469
      n[6].i = width;
1470
      n[7].i = height;
1471
      n[8].i = border;
1472
   }
1473
   if (ctx->ExecuteFlag) {
1474
      (*ctx->Exec->CopyTexImage2D)( target, level, internalformat,
1475
                                   x, y, width, height, border );
1476
   }
1477
}
1478
 
1479
 
1480
 
1481
static void
1482
save_CopyTexSubImage1D( GLenum target, GLint level,
1483
                        GLint xoffset, GLint x, GLint y,
1484
                        GLsizei width )
1485
{
1486
   GET_CURRENT_CONTEXT(ctx);
1487
   Node *n;
1488
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1489
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6 );
1490
   if (n) {
1491
      n[1].e = target;
1492
      n[2].i = level;
1493
      n[3].i = xoffset;
1494
      n[4].i = x;
1495
      n[5].i = y;
1496
      n[6].i = width;
1497
   }
1498
   if (ctx->ExecuteFlag) {
1499
      (*ctx->Exec->CopyTexSubImage1D)( target, level, xoffset, x, y, width );
1500
   }
1501
}
1502
 
1503
 
1504
static void
1505
save_CopyTexSubImage2D( GLenum target, GLint level,
1506
                        GLint xoffset, GLint yoffset,
1507
                        GLint x, GLint y,
1508
                        GLsizei width, GLint height )
1509
{
1510
   GET_CURRENT_CONTEXT(ctx);
1511
   Node *n;
1512
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1513
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8 );
1514
   if (n) {
1515
      n[1].e = target;
1516
      n[2].i = level;
1517
      n[3].i = xoffset;
1518
      n[4].i = yoffset;
1519
      n[5].i = x;
1520
      n[6].i = y;
1521
      n[7].i = width;
1522
      n[8].i = height;
1523
   }
1524
   if (ctx->ExecuteFlag) {
1525
      (*ctx->Exec->CopyTexSubImage2D)( target, level, xoffset, yoffset,
1526
                               x, y, width, height );
1527
   }
1528
}
1529
 
1530
 
1531
static void
1532
save_CopyTexSubImage3D( GLenum target, GLint level,
1533
                        GLint xoffset, GLint yoffset, GLint zoffset,
1534
                        GLint x, GLint y,
1535
                        GLsizei width, GLint height )
1536
{
1537
   GET_CURRENT_CONTEXT(ctx);
1538
   Node *n;
1539
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1540
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9 );
1541
   if (n) {
1542
      n[1].e = target;
1543
      n[2].i = level;
1544
      n[3].i = xoffset;
1545
      n[4].i = yoffset;
1546
      n[5].i = zoffset;
1547
      n[6].i = x;
1548
      n[7].i = y;
1549
      n[8].i = width;
1550
      n[9].i = height;
1551
   }
1552
   if (ctx->ExecuteFlag) {
1553
      (*ctx->Exec->CopyTexSubImage3D)( target, level,
1554
                                      xoffset, yoffset, zoffset,
1555
                                      x, y, width, height );
1556
   }
1557
}
1558
 
1559
 
1560
static void save_CullFace( GLenum mode )
1561
{
1562
   GET_CURRENT_CONTEXT(ctx);
1563
   Node *n;
1564
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1565
   n = ALLOC_INSTRUCTION( ctx, OPCODE_CULL_FACE, 1 );
1566
   if (n) {
1567
      n[1].e = mode;
1568
   }
1569
   if (ctx->ExecuteFlag) {
1570
      (*ctx->Exec->CullFace)( mode );
1571
   }
1572
}
1573
 
1574
 
1575
static void save_DepthFunc( GLenum func )
1576
{
1577
   GET_CURRENT_CONTEXT(ctx);
1578
   Node *n;
1579
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1580
   n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_FUNC, 1 );
1581
   if (n) {
1582
      n[1].e = func;
1583
   }
1584
   if (ctx->ExecuteFlag) {
1585
      (*ctx->Exec->DepthFunc)( func );
1586
   }
1587
}
1588
 
1589
 
1590
static void save_DepthMask( GLboolean mask )
1591
{
1592
   GET_CURRENT_CONTEXT(ctx);
1593
   Node *n;
1594
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1595
   n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_MASK, 1 );
1596
   if (n) {
1597
      n[1].b = mask;
1598
   }
1599
   if (ctx->ExecuteFlag) {
1600
      (*ctx->Exec->DepthMask)( mask );
1601
   }
1602
}
1603
 
1604
 
1605
static void save_DepthRange( GLclampd nearval, GLclampd farval )
1606
{
1607
   GET_CURRENT_CONTEXT(ctx);
1608
   Node *n;
1609
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1610
   n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_RANGE, 2 );
1611
   if (n) {
1612
      n[1].f = (GLfloat) nearval;
1613
      n[2].f = (GLfloat) farval;
1614
   }
1615
   if (ctx->ExecuteFlag) {
1616
      (*ctx->Exec->DepthRange)( nearval, farval );
1617
   }
1618
}
1619
 
1620
 
1621
static void save_Disable( GLenum cap )
1622
{
1623
   GET_CURRENT_CONTEXT(ctx);
1624
   Node *n;
1625
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1626
   n = ALLOC_INSTRUCTION( ctx, OPCODE_DISABLE, 1 );
1627
   if (n) {
1628
      n[1].e = cap;
1629
   }
1630
   if (ctx->ExecuteFlag) {
1631
      (*ctx->Exec->Disable)( cap );
1632
   }
1633
}
1634
 
1635
 
1636
static void save_DrawBuffer( GLenum mode )
1637
{
1638
   GET_CURRENT_CONTEXT(ctx);
1639
   Node *n;
1640
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1641
   n = ALLOC_INSTRUCTION( ctx, OPCODE_DRAW_BUFFER, 1 );
1642
   if (n) {
1643
      n[1].e = mode;
1644
   }
1645
   if (ctx->ExecuteFlag) {
1646
      (*ctx->Exec->DrawBuffer)( mode );
1647
   }
1648
}
1649
 
1650
 
1651
static void save_DrawPixels( GLsizei width, GLsizei height,
1652
                             GLenum format, GLenum type,
1653
                             const GLvoid *pixels )
1654
{
1655
   GET_CURRENT_CONTEXT(ctx);
1656
   GLvoid *image = _mesa_unpack_image(width, height, 1, format, type,
1657
                                      pixels, &ctx->Unpack);
1658
   Node *n;
1659
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1660
   n = ALLOC_INSTRUCTION( ctx, OPCODE_DRAW_PIXELS, 5 );
1661
   if (n) {
1662
      n[1].i = width;
1663
      n[2].i = height;
1664
      n[3].e = format;
1665
      n[4].e = type;
1666
      n[5].data = image;
1667
   }
1668
   else if (image) {
1669
      FREE(image);
1670
   }
1671
   if (ctx->ExecuteFlag) {
1672
      (*ctx->Exec->DrawPixels)( width, height, format, type, pixels );
1673
   }
1674
}
1675
 
1676
 
1677
 
1678
static void save_Enable( GLenum cap )
1679
{
1680
   GET_CURRENT_CONTEXT(ctx);
1681
   Node *n;
1682
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1683
   n = ALLOC_INSTRUCTION( ctx, OPCODE_ENABLE, 1 );
1684
   if (n) {
1685
      n[1].e = cap;
1686
   }
1687
   if (ctx->ExecuteFlag) {
1688
      (*ctx->Exec->Enable)( cap );
1689
   }
1690
}
1691
 
1692
 
1693
 
1694
void _mesa_save_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
1695
{
1696
   GET_CURRENT_CONTEXT(ctx);
1697
   Node *n;
1698
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1699
   n = ALLOC_INSTRUCTION( ctx, OPCODE_EVALMESH1, 3 );
1700
   if (n) {
1701
      n[1].e = mode;
1702
      n[2].i = i1;
1703
      n[3].i = i2;
1704
   }
1705
   if (ctx->ExecuteFlag) {
1706
      (*ctx->Exec->EvalMesh1)( mode, i1, i2 );
1707
   }
1708
}
1709
 
1710
 
1711
void _mesa_save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
1712
{
1713
   GET_CURRENT_CONTEXT(ctx);
1714
   Node *n;
1715
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1716
   n = ALLOC_INSTRUCTION( ctx, OPCODE_EVALMESH2, 5 );
1717
   if (n) {
1718
      n[1].e = mode;
1719
      n[2].i = i1;
1720
      n[3].i = i2;
1721
      n[4].i = j1;
1722
      n[5].i = j2;
1723
   }
1724
   if (ctx->ExecuteFlag) {
1725
      (*ctx->Exec->EvalMesh2)( mode, i1, i2, j1, j2 );
1726
   }
1727
}
1728
 
1729
 
1730
 
1731
 
1732
static void save_Fogfv( GLenum pname, const GLfloat *params )
1733
{
1734
   GET_CURRENT_CONTEXT(ctx);
1735
   Node *n;
1736
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1737
   n = ALLOC_INSTRUCTION( ctx, OPCODE_FOG, 5 );
1738
   if (n) {
1739
      n[1].e = pname;
1740
      n[2].f = params[0];
1741
      n[3].f = params[1];
1742
      n[4].f = params[2];
1743
      n[5].f = params[3];
1744
   }
1745
   if (ctx->ExecuteFlag) {
1746
      (*ctx->Exec->Fogfv)( pname, params );
1747
   }
1748
}
1749
 
1750
 
1751
static void save_Fogf( GLenum pname, GLfloat param )
1752
{
1753
   save_Fogfv(pname, &param);
1754
}
1755
 
1756
 
1757
static void save_Fogiv(GLenum pname, const GLint *params )
1758
{
1759
   GLfloat p[4];
1760
   switch (pname) {
1761
      case GL_FOG_MODE:
1762
      case GL_FOG_DENSITY:
1763
      case GL_FOG_START:
1764
      case GL_FOG_END:
1765
      case GL_FOG_INDEX:
1766
         p[0] = (GLfloat) *params;
1767
         break;
1768
      case GL_FOG_COLOR:
1769
         p[0] = INT_TO_FLOAT( params[0] );
1770
         p[1] = INT_TO_FLOAT( params[1] );
1771
         p[2] = INT_TO_FLOAT( params[2] );
1772
         p[3] = INT_TO_FLOAT( params[3] );
1773
         break;
1774
      default:
1775
         /* Error will be caught later in gl_Fogfv */
1776
         ;
1777
   }
1778
   save_Fogfv(pname, p);
1779
}
1780
 
1781
 
1782
static void save_Fogi(GLenum pname, GLint param )
1783
{
1784
   save_Fogiv(pname, &param);
1785
}
1786
 
1787
 
1788
static void save_FrontFace( GLenum mode )
1789
{
1790
   GET_CURRENT_CONTEXT(ctx);
1791
   Node *n;
1792
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1793
   n = ALLOC_INSTRUCTION( ctx, OPCODE_FRONT_FACE, 1 );
1794
   if (n) {
1795
      n[1].e = mode;
1796
   }
1797
   if (ctx->ExecuteFlag) {
1798
      (*ctx->Exec->FrontFace)( mode );
1799
   }
1800
}
1801
 
1802
 
1803
static void save_Frustum( GLdouble left, GLdouble right,
1804
                      GLdouble bottom, GLdouble top,
1805
                      GLdouble nearval, GLdouble farval )
1806
{
1807
   GET_CURRENT_CONTEXT(ctx);
1808
   Node *n;
1809
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1810
   n = ALLOC_INSTRUCTION( ctx, OPCODE_FRUSTUM, 6 );
1811
   if (n) {
1812
      n[1].f = (GLfloat) left;
1813
      n[2].f = (GLfloat) right;
1814
      n[3].f = (GLfloat) bottom;
1815
      n[4].f = (GLfloat) top;
1816
      n[5].f = (GLfloat) nearval;
1817
      n[6].f = (GLfloat) farval;
1818
   }
1819
   if (ctx->ExecuteFlag) {
1820
      (*ctx->Exec->Frustum)( left, right, bottom, top, nearval, farval );
1821
   }
1822
}
1823
 
1824
 
1825
static void save_Hint( GLenum target, GLenum mode )
1826
{
1827
   GET_CURRENT_CONTEXT(ctx);
1828
   Node *n;
1829
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1830
   n = ALLOC_INSTRUCTION( ctx, OPCODE_HINT, 2 );
1831
   if (n) {
1832
      n[1].e = target;
1833
      n[2].e = mode;
1834
   }
1835
   if (ctx->ExecuteFlag) {
1836
      (*ctx->Exec->Hint)( target, mode );
1837
   }
1838
}
1839
 
1840
 
1841
static void
1842
save_Histogram(GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink)
1843
{
1844
   GET_CURRENT_CONTEXT(ctx);
1845
   Node *n;
1846
 
1847
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1848
   n = ALLOC_INSTRUCTION( ctx, OPCODE_HISTOGRAM, 4 );
1849
   if (n) {
1850
      n[1].e = target;
1851
      n[2].i = width;
1852
      n[3].e = internalFormat;
1853
      n[4].b = sink;
1854
   }
1855
   if (ctx->ExecuteFlag) {
1856
      (*ctx->Exec->Histogram)( target, width, internalFormat, sink );
1857
   }
1858
}
1859
 
1860
 
1861
static void save_IndexMask( GLuint mask )
1862
{
1863
   GET_CURRENT_CONTEXT(ctx);
1864
   Node *n;
1865
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1866
   n = ALLOC_INSTRUCTION( ctx, OPCODE_INDEX_MASK, 1 );
1867
   if (n) {
1868
      n[1].ui = mask;
1869
   }
1870
   if (ctx->ExecuteFlag) {
1871
      (*ctx->Exec->IndexMask)( mask );
1872
   }
1873
}
1874
 
1875
 
1876
static void save_InitNames( void )
1877
{
1878
   GET_CURRENT_CONTEXT(ctx);
1879
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1880
   (void) ALLOC_INSTRUCTION( ctx, OPCODE_INIT_NAMES, 0 );
1881
   if (ctx->ExecuteFlag) {
1882
      (*ctx->Exec->InitNames)();
1883
   }
1884
}
1885
 
1886
 
1887
static void save_Lightfv( GLenum light, GLenum pname, const GLfloat *params )
1888
{
1889
   GET_CURRENT_CONTEXT(ctx);
1890
   Node *n;
1891
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1892
   n = ALLOC_INSTRUCTION( ctx, OPCODE_LIGHT, 6 );
1893
   if (OPCODE_LIGHT) {
1894
      GLint i, nParams;
1895
      n[1].e = light;
1896
      n[2].e = pname;
1897
      switch (pname) {
1898
         case GL_AMBIENT:
1899
            nParams = 4;
1900
            break;
1901
         case GL_DIFFUSE:
1902
            nParams = 4;
1903
            break;
1904
         case GL_SPECULAR:
1905
            nParams = 4;
1906
            break;
1907
         case GL_POSITION:
1908
            nParams = 4;
1909
            break;
1910
         case GL_SPOT_DIRECTION:
1911
            nParams = 3;
1912
            break;
1913
         case GL_SPOT_EXPONENT:
1914
            nParams = 1;
1915
            break;
1916
         case GL_SPOT_CUTOFF:
1917
            nParams = 1;
1918
            break;
1919
         case GL_CONSTANT_ATTENUATION:
1920
            nParams = 1;
1921
            break;
1922
         case GL_LINEAR_ATTENUATION:
1923
            nParams = 1;
1924
            break;
1925
         case GL_QUADRATIC_ATTENUATION:
1926
            nParams = 1;
1927
            break;
1928
         default:
1929
            nParams = 0;
1930
      }
1931
      for (i = 0; i < nParams; i++) {
1932
         n[3+i].f = params[i];
1933
      }
1934
   }
1935
   if (ctx->ExecuteFlag) {
1936
      (*ctx->Exec->Lightfv)( light, pname, params );
1937
   }
1938
}
1939
 
1940
 
1941
static void save_Lightf( GLenum light, GLenum pname, GLfloat params )
1942
{
1943
   save_Lightfv(light, pname, &params);
1944
}
1945
 
1946
 
1947
static void save_Lightiv( GLenum light, GLenum pname, const GLint *params )
1948
{
1949
   GLfloat fparam[4];
1950
   switch (pname) {
1951
      case GL_AMBIENT:
1952
      case GL_DIFFUSE:
1953
      case GL_SPECULAR:
1954
         fparam[0] = INT_TO_FLOAT( params[0] );
1955
         fparam[1] = INT_TO_FLOAT( params[1] );
1956
         fparam[2] = INT_TO_FLOAT( params[2] );
1957
         fparam[3] = INT_TO_FLOAT( params[3] );
1958
         break;
1959
      case GL_POSITION:
1960
         fparam[0] = (GLfloat) params[0];
1961
         fparam[1] = (GLfloat) params[1];
1962
         fparam[2] = (GLfloat) params[2];
1963
         fparam[3] = (GLfloat) params[3];
1964
         break;
1965
      case GL_SPOT_DIRECTION:
1966
         fparam[0] = (GLfloat) params[0];
1967
         fparam[1] = (GLfloat) params[1];
1968
         fparam[2] = (GLfloat) params[2];
1969
         break;
1970
      case GL_SPOT_EXPONENT:
1971
      case GL_SPOT_CUTOFF:
1972
      case GL_CONSTANT_ATTENUATION:
1973
      case GL_LINEAR_ATTENUATION:
1974
      case GL_QUADRATIC_ATTENUATION:
1975
         fparam[0] = (GLfloat) params[0];
1976
         break;
1977
      default:
1978
         /* error will be caught later in gl_Lightfv */
1979
         ;
1980
   }
1981
   save_Lightfv( light, pname, fparam );
1982
}
1983
 
1984
 
1985
static void save_Lighti( GLenum light, GLenum pname, GLint param )
1986
{
1987
   save_Lightiv( light, pname, &param );
1988
}
1989
 
1990
 
1991
static void save_LightModelfv( GLenum pname, const GLfloat *params )
1992
{
1993
   GET_CURRENT_CONTEXT(ctx);
1994
   Node *n;
1995
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1996
   n = ALLOC_INSTRUCTION( ctx, OPCODE_LIGHT_MODEL, 5 );
1997
   if (n) {
1998
      n[1].e = pname;
1999
      n[2].f = params[0];
2000
      n[3].f = params[1];
2001
      n[4].f = params[2];
2002
      n[5].f = params[3];
2003
   }
2004
   if (ctx->ExecuteFlag) {
2005
      (*ctx->Exec->LightModelfv)( pname, params );
2006
   }
2007
}
2008
 
2009
 
2010
static void save_LightModelf( GLenum pname, GLfloat param )
2011
{
2012
   save_LightModelfv(pname, &param);
2013
}
2014
 
2015
 
2016
static void save_LightModeliv( GLenum pname, const GLint *params )
2017
{
2018
   GLfloat fparam[4];
2019
   switch (pname) {
2020
      case GL_LIGHT_MODEL_AMBIENT:
2021
         fparam[0] = INT_TO_FLOAT( params[0] );
2022
         fparam[1] = INT_TO_FLOAT( params[1] );
2023
         fparam[2] = INT_TO_FLOAT( params[2] );
2024
         fparam[3] = INT_TO_FLOAT( params[3] );
2025
         break;
2026
      case GL_LIGHT_MODEL_LOCAL_VIEWER:
2027
      case GL_LIGHT_MODEL_TWO_SIDE:
2028
      case GL_LIGHT_MODEL_COLOR_CONTROL:
2029
         fparam[0] = (GLfloat) params[0];
2030
         break;
2031
      default:
2032
         /* Error will be caught later in gl_LightModelfv */
2033
         ;
2034
   }
2035
   save_LightModelfv(pname, fparam);
2036
}
2037
 
2038
 
2039
static void save_LightModeli( GLenum pname, GLint param )
2040
{
2041
   save_LightModeliv(pname, &param);
2042
}
2043
 
2044
 
2045
static void save_LineStipple( GLint factor, GLushort pattern )
2046
{
2047
   GET_CURRENT_CONTEXT(ctx);
2048
   Node *n;
2049
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2050
   n = ALLOC_INSTRUCTION( ctx, OPCODE_LINE_STIPPLE, 2 );
2051
   if (n) {
2052
      n[1].i = factor;
2053
      n[2].us = pattern;
2054
   }
2055
   if (ctx->ExecuteFlag) {
2056
      (*ctx->Exec->LineStipple)( factor, pattern );
2057
   }
2058
}
2059
 
2060
 
2061
static void save_LineWidth( GLfloat width )
2062
{
2063
   GET_CURRENT_CONTEXT(ctx);
2064
   Node *n;
2065
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2066
   n = ALLOC_INSTRUCTION( ctx, OPCODE_LINE_WIDTH, 1 );
2067
   if (n) {
2068
      n[1].f = width;
2069
   }
2070
   if (ctx->ExecuteFlag) {
2071
      (*ctx->Exec->LineWidth)( width );
2072
   }
2073
}
2074
 
2075
 
2076
static void save_ListBase( GLuint base )
2077
{
2078
   GET_CURRENT_CONTEXT(ctx);
2079
   Node *n;
2080
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2081
   n = ALLOC_INSTRUCTION( ctx, OPCODE_LIST_BASE, 1 );
2082
   if (n) {
2083
      n[1].ui = base;
2084
   }
2085
   if (ctx->ExecuteFlag) {
2086
      (*ctx->Exec->ListBase)( base );
2087
   }
2088
}
2089
 
2090
 
2091
static void save_LoadIdentity( void )
2092
{
2093
   GET_CURRENT_CONTEXT(ctx);
2094
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2095
   (void) ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_IDENTITY, 0 );
2096
   if (ctx->ExecuteFlag) {
2097
      (*ctx->Exec->LoadIdentity)();
2098
   }
2099
}
2100
 
2101
 
2102
static void save_LoadMatrixf( const GLfloat *m )
2103
{
2104
   GET_CURRENT_CONTEXT(ctx);
2105
   Node *n;
2106
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2107
   n = ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_MATRIX, 16 );
2108
   if (n) {
2109
      GLuint i;
2110
      for (i=0;i<16;i++) {
2111
         n[1+i].f = m[i];
2112
      }
2113
   }
2114
   if (ctx->ExecuteFlag) {
2115
      (*ctx->Exec->LoadMatrixf)( m );
2116
   }
2117
}
2118
 
2119
 
2120
static void save_LoadMatrixd( const GLdouble *m )
2121
{
2122
   GLfloat f[16];
2123
   GLint i;
2124
   for (i = 0; i < 16; i++) {
2125
      f[i] = (GLfloat) m[i];
2126
   }
2127
   save_LoadMatrixf(f);
2128
}
2129
 
2130
 
2131
static void save_LoadName( GLuint name )
2132
{
2133
   GET_CURRENT_CONTEXT(ctx);
2134
   Node *n;
2135
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2136
   n = ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_NAME, 1 );
2137
   if (n) {
2138
      n[1].ui = name;
2139
   }
2140
   if (ctx->ExecuteFlag) {
2141
      (*ctx->Exec->LoadName)( name );
2142
   }
2143
}
2144
 
2145
 
2146
static void save_LogicOp( GLenum opcode )
2147
{
2148
   GET_CURRENT_CONTEXT(ctx);
2149
   Node *n;
2150
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2151
   n = ALLOC_INSTRUCTION( ctx, OPCODE_LOGIC_OP, 1 );
2152
   if (n) {
2153
      n[1].e = opcode;
2154
   }
2155
   if (ctx->ExecuteFlag) {
2156
      (*ctx->Exec->LogicOp)( opcode );
2157
   }
2158
}
2159
 
2160
 
2161
static void save_Map1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
2162
                        GLint order, const GLdouble *points)
2163
{
2164
   GET_CURRENT_CONTEXT(ctx);
2165
   Node *n;
2166
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2167
   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP1, 6 );
2168
   if (n) {
2169
      GLfloat *pnts = _mesa_copy_map_points1d( target, stride, order, points );
2170
      n[1].e = target;
2171
      n[2].f = (GLfloat) u1;
2172
      n[3].f = (GLfloat) u2;
2173
      n[4].i = _mesa_evaluator_components(target);  /* stride */
2174
      n[5].i = order;
2175
      n[6].data = (void *) pnts;
2176
   }
2177
   if (ctx->ExecuteFlag) {
2178
      (*ctx->Exec->Map1d)( target, u1, u2, stride, order, points );
2179
   }
2180
}
2181
 
2182
static void save_Map1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
2183
                        GLint order, const GLfloat *points)
2184
{
2185
   GET_CURRENT_CONTEXT(ctx);
2186
   Node *n;
2187
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2188
   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP1, 6 );
2189
   if (n) {
2190
      GLfloat *pnts = _mesa_copy_map_points1f( target, stride, order, points );
2191
      n[1].e = target;
2192
      n[2].f = u1;
2193
      n[3].f = u2;
2194
      n[4].i = _mesa_evaluator_components(target);  /* stride */
2195
      n[5].i = order;
2196
      n[6].data = (void *) pnts;
2197
   }
2198
   if (ctx->ExecuteFlag) {
2199
      (*ctx->Exec->Map1f)( target, u1, u2, stride, order, points );
2200
   }
2201
}
2202
 
2203
 
2204
static void save_Map2d( GLenum target,
2205
                        GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
2206
                        GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
2207
                        const GLdouble *points )
2208
{
2209
   GET_CURRENT_CONTEXT(ctx);
2210
   Node *n;
2211
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2212
   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP2, 10 );
2213
   if (n) {
2214
      GLfloat *pnts = _mesa_copy_map_points2d( target, ustride, uorder,
2215
                                            vstride, vorder, points );
2216
      n[1].e = target;
2217
      n[2].f = (GLfloat) u1;
2218
      n[3].f = (GLfloat) u2;
2219
      n[4].f = (GLfloat) v1;
2220
      n[5].f = (GLfloat) v2;
2221
      /* XXX verify these strides are correct */
2222
      n[6].i = _mesa_evaluator_components(target) * vorder;  /*ustride*/
2223
      n[7].i = _mesa_evaluator_components(target);           /*vstride*/
2224
      n[8].i = uorder;
2225
      n[9].i = vorder;
2226
      n[10].data = (void *) pnts;
2227
   }
2228
   if (ctx->ExecuteFlag) {
2229
      (*ctx->Exec->Map2d)( target,
2230
                          u1, u2, ustride, uorder,
2231
                          v1, v2, vstride, vorder, points );
2232
   }
2233
}
2234
 
2235
 
2236
static void save_Map2f( GLenum target,
2237
                        GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
2238
                        GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
2239
                        const GLfloat *points )
2240
{
2241
   GET_CURRENT_CONTEXT(ctx);
2242
   Node *n;
2243
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2244
   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP2, 10 );
2245
   if (n) {
2246
      GLfloat *pnts = _mesa_copy_map_points2f( target, ustride, uorder,
2247
                                            vstride, vorder, points );
2248
      n[1].e = target;
2249
      n[2].f = u1;
2250
      n[3].f = u2;
2251
      n[4].f = v1;
2252
      n[5].f = v2;
2253
      /* XXX verify these strides are correct */
2254
      n[6].i = _mesa_evaluator_components(target) * vorder;  /*ustride*/
2255
      n[7].i = _mesa_evaluator_components(target);           /*vstride*/
2256
      n[8].i = uorder;
2257
      n[9].i = vorder;
2258
      n[10].data = (void *) pnts;
2259
   }
2260
   if (ctx->ExecuteFlag) {
2261
      (*ctx->Exec->Map2f)( target, u1, u2, ustride, uorder,
2262
                          v1, v2, vstride, vorder, points );
2263
   }
2264
}
2265
 
2266
 
2267
static void save_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
2268
{
2269
   GET_CURRENT_CONTEXT(ctx);
2270
   Node *n;
2271
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2272
   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAPGRID1, 3 );
2273
   if (n) {
2274
      n[1].i = un;
2275
      n[2].f = u1;
2276
      n[3].f = u2;
2277
   }
2278
   if (ctx->ExecuteFlag) {
2279
      (*ctx->Exec->MapGrid1f)( un, u1, u2 );
2280
   }
2281
}
2282
 
2283
 
2284
static void save_MapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
2285
{
2286
   save_MapGrid1f(un, (GLfloat) u1, (GLfloat) u2);
2287
}
2288
 
2289
 
2290
static void save_MapGrid2f( GLint un, GLfloat u1, GLfloat u2,
2291
                            GLint vn, GLfloat v1, GLfloat v2 )
2292
{
2293
   GET_CURRENT_CONTEXT(ctx);
2294
   Node *n;
2295
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2296
   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAPGRID2, 6 );
2297
   if (n) {
2298
      n[1].i = un;
2299
      n[2].f = u1;
2300
      n[3].f = u2;
2301
      n[4].i = vn;
2302
      n[5].f = v1;
2303
      n[6].f = v2;
2304
   }
2305
   if (ctx->ExecuteFlag) {
2306
      (*ctx->Exec->MapGrid2f)( un, u1, u2, vn, v1, v2 );
2307
   }
2308
}
2309
 
2310
 
2311
 
2312
static void save_MapGrid2d( GLint un, GLdouble u1, GLdouble u2,
2313
                            GLint vn, GLdouble v1, GLdouble v2 )
2314
{
2315
   save_MapGrid2f(un, (GLfloat) u1, (GLfloat) u2,
2316
                  vn, (GLfloat) v1, (GLfloat) v2);
2317
}
2318
 
2319
 
2320
static void save_MatrixMode( GLenum mode )
2321
{
2322
   GET_CURRENT_CONTEXT(ctx);
2323
   Node *n;
2324
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2325
   n = ALLOC_INSTRUCTION( ctx, OPCODE_MATRIX_MODE, 1 );
2326
   if (n) {
2327
      n[1].e = mode;
2328
   }
2329
   if (ctx->ExecuteFlag) {
2330
      (*ctx->Exec->MatrixMode)( mode );
2331
   }
2332
}
2333
 
2334
 
2335
static void
2336
save_Minmax(GLenum target, GLenum internalFormat, GLboolean sink)
2337
{
2338
   GET_CURRENT_CONTEXT(ctx);
2339
   Node *n;
2340
 
2341
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2342
   n = ALLOC_INSTRUCTION( ctx, OPCODE_MIN_MAX, 3 );
2343
   if (n) {
2344
      n[1].e = target;
2345
      n[2].e = internalFormat;
2346
      n[3].b = sink;
2347
   }
2348
   if (ctx->ExecuteFlag) {
2349
      (*ctx->Exec->Minmax)( target, internalFormat, sink );
2350
   }
2351
}
2352
 
2353
 
2354
static void save_MultMatrixf( const GLfloat *m )
2355
{
2356
   GET_CURRENT_CONTEXT(ctx);
2357
   Node *n;
2358
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2359
   n = ALLOC_INSTRUCTION( ctx, OPCODE_MULT_MATRIX, 16 );
2360
   if (n) {
2361
      GLuint i;
2362
      for (i=0;i<16;i++) {
2363
         n[1+i].f = m[i];
2364
      }
2365
   }
2366
   if (ctx->ExecuteFlag) {
2367
      (*ctx->Exec->MultMatrixf)( m );
2368
   }
2369
}
2370
 
2371
 
2372
static void save_MultMatrixd( const GLdouble *m )
2373
{
2374
   GLfloat f[16];
2375
   GLint i;
2376
   for (i = 0; i < 16; i++) {
2377
      f[i] = (GLfloat) m[i];
2378
   }
2379
   save_MultMatrixf(f);
2380
}
2381
 
2382
 
2383
static void save_NewList( GLuint list, GLenum mode )
2384
{
2385
   GET_CURRENT_CONTEXT(ctx);
2386
   /* It's an error to call this function while building a display list */
2387
   _mesa_error( ctx, GL_INVALID_OPERATION, "glNewList" );
2388
   (void) list;
2389
   (void) mode;
2390
}
2391
 
2392
 
2393
 
2394
static void save_Ortho( GLdouble left, GLdouble right,
2395
                    GLdouble bottom, GLdouble top,
2396
                    GLdouble nearval, GLdouble farval )
2397
{
2398
   GET_CURRENT_CONTEXT(ctx);
2399
   Node *n;
2400
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2401
   n = ALLOC_INSTRUCTION( ctx, OPCODE_ORTHO, 6 );
2402
   if (n) {
2403
      n[1].f = (GLfloat) left;
2404
      n[2].f = (GLfloat) right;
2405
      n[3].f = (GLfloat) bottom;
2406
      n[4].f = (GLfloat) top;
2407
      n[5].f = (GLfloat) nearval;
2408
      n[6].f = (GLfloat) farval;
2409
   }
2410
   if (ctx->ExecuteFlag) {
2411
      (*ctx->Exec->Ortho)( left, right, bottom, top, nearval, farval );
2412
   }
2413
}
2414
 
2415
 
2416
static void
2417
save_PixelMapfv( GLenum map, GLint mapsize, const GLfloat *values )
2418
{
2419
   GET_CURRENT_CONTEXT(ctx);
2420
   Node *n;
2421
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2422
   n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_MAP, 3 );
2423
   if (n) {
2424
      n[1].e = map;
2425
      n[2].i = mapsize;
2426
      n[3].data  = (void *) MALLOC( mapsize * sizeof(GLfloat) );
2427
      MEMCPY( n[3].data, (void *) values, mapsize * sizeof(GLfloat) );
2428
   }
2429
   if (ctx->ExecuteFlag) {
2430
      (*ctx->Exec->PixelMapfv)( map, mapsize, values );
2431
   }
2432
}
2433
 
2434
 
2435
static void
2436
save_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values )
2437
{
2438
   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
2439
   GLint i;
2440
   if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
2441
      for (i=0;i<mapsize;i++) {
2442
         fvalues[i] = (GLfloat) values[i];
2443
      }
2444
   }
2445
   else {
2446
      for (i=0;i<mapsize;i++) {
2447
         fvalues[i] = UINT_TO_FLOAT( values[i] );
2448
      }
2449
   }
2450
   save_PixelMapfv(map, mapsize, fvalues);
2451
}
2452
 
2453
 
2454
static void
2455
save_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
2456
{
2457
   GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
2458
   GLint i;
2459
   if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
2460
      for (i=0;i<mapsize;i++) {
2461
         fvalues[i] = (GLfloat) values[i];
2462
      }
2463
   }
2464
   else {
2465
      for (i=0;i<mapsize;i++) {
2466
         fvalues[i] = USHORT_TO_FLOAT( values[i] );
2467
      }
2468
   }
2469
   save_PixelMapfv(map, mapsize, fvalues);
2470
}
2471
 
2472
 
2473
static void
2474
save_PixelTransferf( GLenum pname, GLfloat param )
2475
{
2476
   GET_CURRENT_CONTEXT(ctx);
2477
   Node *n;
2478
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2479
   n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TRANSFER, 2 );
2480
   if (n) {
2481
      n[1].e = pname;
2482
      n[2].f = param;
2483
   }
2484
   if (ctx->ExecuteFlag) {
2485
      (*ctx->Exec->PixelTransferf)( pname, param );
2486
   }
2487
}
2488
 
2489
 
2490
static void
2491
save_PixelTransferi( GLenum pname, GLint param )
2492
{
2493
   save_PixelTransferf( pname, (GLfloat) param );
2494
}
2495
 
2496
 
2497
static void
2498
save_PixelZoom( GLfloat xfactor, GLfloat yfactor )
2499
{
2500
   GET_CURRENT_CONTEXT(ctx);
2501
   Node *n;
2502
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2503
   n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_ZOOM, 2 );
2504
   if (n) {
2505
      n[1].f = xfactor;
2506
      n[2].f = yfactor;
2507
   }
2508
   if (ctx->ExecuteFlag) {
2509
      (*ctx->Exec->PixelZoom)( xfactor, yfactor );
2510
   }
2511
}
2512
 
2513
 
2514
static void
2515
save_PointParameterfvEXT( GLenum pname, const GLfloat *params )
2516
{
2517
   GET_CURRENT_CONTEXT(ctx);
2518
   Node *n;
2519
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2520
   n = ALLOC_INSTRUCTION( ctx, OPCODE_POINT_PARAMETERS, 4 );
2521
   if (n) {
2522
      n[1].e = pname;
2523
      n[2].f = params[0];
2524
      n[3].f = params[1];
2525
      n[4].f = params[2];
2526
   }
2527
   if (ctx->ExecuteFlag) {
2528
      (*ctx->Exec->PointParameterfvEXT)( pname, params );
2529
   }
2530
}
2531
 
2532
 
2533
static void save_PointParameterfEXT( GLenum pname, GLfloat param )
2534
{
2535
   save_PointParameterfvEXT(pname, &param);
2536
}
2537
 
2538
static void save_PointParameteriNV( GLenum pname, GLint param )
2539
{
2540
   GLfloat p = (GLfloat) param;
2541
   save_PointParameterfvEXT(pname, &p);
2542
}
2543
 
2544
static void save_PointParameterivNV( GLenum pname, const GLint *param )
2545
{
2546
   GLfloat p = (GLfloat) param[0];
2547
   save_PointParameterfvEXT(pname, &p);
2548
}
2549
 
2550
 
2551
static void save_PointSize( GLfloat size )
2552
{
2553
   GET_CURRENT_CONTEXT(ctx);
2554
   Node *n;
2555
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2556
   n = ALLOC_INSTRUCTION( ctx, OPCODE_POINT_SIZE, 1 );
2557
   if (n) {
2558
      n[1].f = size;
2559
   }
2560
   if (ctx->ExecuteFlag) {
2561
      (*ctx->Exec->PointSize)( size );
2562
   }
2563
}
2564
 
2565
 
2566
static void save_PolygonMode( GLenum face, GLenum mode )
2567
{
2568
   GET_CURRENT_CONTEXT(ctx);
2569
   Node *n;
2570
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2571
   n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_MODE, 2 );
2572
   if (n) {
2573
      n[1].e = face;
2574
      n[2].e = mode;
2575
   }
2576
   if (ctx->ExecuteFlag) {
2577
      (*ctx->Exec->PolygonMode)( face, mode );
2578
   }
2579
}
2580
 
2581
 
2582
/*
2583
 * Polygon stipple must have been upacked already!
2584
 */
2585
static void save_PolygonStipple( const GLubyte *pattern )
2586
{
2587
   GET_CURRENT_CONTEXT(ctx);
2588
   Node *n;
2589
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2590
   n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_STIPPLE, 1 );
2591
   if (n) {
2592
      void *data;
2593
      n[1].data = MALLOC( 32 * 4 );
2594
      data = n[1].data;   /* This needed for Acorn compiler */
2595
      MEMCPY( data, pattern, 32 * 4 );
2596
   }
2597
   if (ctx->ExecuteFlag) {
2598
      (*ctx->Exec->PolygonStipple)( (GLubyte*) pattern );
2599
   }
2600
}
2601
 
2602
 
2603
static void save_PolygonOffset( GLfloat factor, GLfloat units )
2604
{
2605
   GET_CURRENT_CONTEXT(ctx);
2606
   Node *n;
2607
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2608
   n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_OFFSET, 2 );
2609
   if (n) {
2610
      n[1].f = factor;
2611
      n[2].f = units;
2612
   }
2613
   if (ctx->ExecuteFlag) {
2614
      (*ctx->Exec->PolygonOffset)( factor, units );
2615
   }
2616
}
2617
 
2618
 
2619
static void save_PolygonOffsetEXT( GLfloat factor, GLfloat bias )
2620
{
2621
   GET_CURRENT_CONTEXT(ctx);
2622
   save_PolygonOffset(factor, ctx->DepthMaxF * bias);
2623
}
2624
 
2625
 
2626
static void save_PopAttrib( void )
2627
{
2628
   GET_CURRENT_CONTEXT(ctx);
2629
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2630
   (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_ATTRIB, 0 );
2631
   if (ctx->ExecuteFlag) {
2632
      (*ctx->Exec->PopAttrib)();
2633
   }
2634
}
2635
 
2636
 
2637
static void save_PopMatrix( void )
2638
{
2639
   GET_CURRENT_CONTEXT(ctx);
2640
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2641
   FLUSH_CURRENT(ctx, 0);
2642
   (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_MATRIX, 0 );
2643
   if (ctx->ExecuteFlag) {
2644
      (*ctx->Exec->PopMatrix)();
2645
   }
2646
}
2647
 
2648
 
2649
static void save_PopName( void )
2650
{
2651
   GET_CURRENT_CONTEXT(ctx);
2652
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2653
   (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_NAME, 0 );
2654
   if (ctx->ExecuteFlag) {
2655
      (*ctx->Exec->PopName)();
2656
   }
2657
}
2658
 
2659
 
2660
static void save_PrioritizeTextures( GLsizei num, const GLuint *textures,
2661
                                     const GLclampf *priorities )
2662
{
2663
   GET_CURRENT_CONTEXT(ctx);
2664
   GLint i;
2665
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2666
 
2667
   for (i=0;i<num;i++) {
2668
      Node *n;
2669
      n = ALLOC_INSTRUCTION( ctx,  OPCODE_PRIORITIZE_TEXTURE, 2 );
2670
      if (n) {
2671
         n[1].ui = textures[i];
2672
         n[2].f = priorities[i];
2673
      }
2674
   }
2675
   if (ctx->ExecuteFlag) {
2676
      (*ctx->Exec->PrioritizeTextures)( num, textures, priorities );
2677
   }
2678
}
2679
 
2680
 
2681
static void save_PushAttrib( GLbitfield mask )
2682
{
2683
   GET_CURRENT_CONTEXT(ctx);
2684
   Node *n;
2685
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2686
   FLUSH_CURRENT(ctx, 0);
2687
   n = ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_ATTRIB, 1 );
2688
   if (n) {
2689
      n[1].bf = mask;
2690
   }
2691
   if (ctx->ExecuteFlag) {
2692
      (*ctx->Exec->PushAttrib)( mask );
2693
   }
2694
}
2695
 
2696
 
2697
static void save_PushMatrix( void )
2698
{
2699
   GET_CURRENT_CONTEXT(ctx);
2700
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2701
   (void) ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_MATRIX, 0 );
2702
   if (ctx->ExecuteFlag) {
2703
      (*ctx->Exec->PushMatrix)();
2704
   }
2705
}
2706
 
2707
 
2708
static void save_PushName( GLuint name )
2709
{
2710
   GET_CURRENT_CONTEXT(ctx);
2711
   Node *n;
2712
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2713
   n = ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_NAME, 1 );
2714
   if (n) {
2715
      n[1].ui = name;
2716
   }
2717
   if (ctx->ExecuteFlag) {
2718
      (*ctx->Exec->PushName)( name );
2719
   }
2720
}
2721
 
2722
 
2723
static void save_RasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
2724
{
2725
   GET_CURRENT_CONTEXT(ctx);
2726
   Node *n;
2727
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2728
   FLUSH_CURRENT(ctx, 0);
2729
   n = ALLOC_INSTRUCTION( ctx, OPCODE_RASTER_POS, 4 );
2730
   if (n) {
2731
      n[1].f = x;
2732
      n[2].f = y;
2733
      n[3].f = z;
2734
      n[4].f = w;
2735
   }
2736
   if (ctx->ExecuteFlag) {
2737
      (*ctx->Exec->RasterPos4f)( x, y, z, w );
2738
   }
2739
}
2740
 
2741
static void save_RasterPos2d(GLdouble x, GLdouble y)
2742
{
2743
   save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
2744
}
2745
 
2746
static void save_RasterPos2f(GLfloat x, GLfloat y)
2747
{
2748
   save_RasterPos4f(x, y, 0.0F, 1.0F);
2749
}
2750
 
2751
static void save_RasterPos2i(GLint x, GLint y)
2752
{
2753
   save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
2754
}
2755
 
2756
static void save_RasterPos2s(GLshort x, GLshort y)
2757
{
2758
   save_RasterPos4f(x, y, 0.0F, 1.0F);
2759
}
2760
 
2761
static void save_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
2762
{
2763
   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
2764
}
2765
 
2766
static void save_RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
2767
{
2768
   save_RasterPos4f(x, y, z, 1.0F);
2769
}
2770
 
2771
static void save_RasterPos3i(GLint x, GLint y, GLint z)
2772
{
2773
   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
2774
}
2775
 
2776
static void save_RasterPos3s(GLshort x, GLshort y, GLshort z)
2777
{
2778
   save_RasterPos4f(x, y, z, 1.0F);
2779
}
2780
 
2781
static void save_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2782
{
2783
   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
2784
}
2785
 
2786
static void save_RasterPos4i(GLint x, GLint y, GLint z, GLint w)
2787
{
2788
   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
2789
}
2790
 
2791
static void save_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
2792
{
2793
   save_RasterPos4f(x, y, z, w);
2794
}
2795
 
2796
static void save_RasterPos2dv(const GLdouble *v)
2797
{
2798
   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
2799
}
2800
 
2801
static void save_RasterPos2fv(const GLfloat *v)
2802
{
2803
   save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
2804
}
2805
 
2806
static void save_RasterPos2iv(const GLint *v)
2807
{
2808
   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
2809
}
2810
 
2811
static void save_RasterPos2sv(const GLshort *v)
2812
{
2813
   save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
2814
}
2815
 
2816
static void save_RasterPos3dv(const GLdouble *v)
2817
{
2818
   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
2819
}
2820
 
2821
static void save_RasterPos3fv(const GLfloat *v)
2822
{
2823
   save_RasterPos4f(v[0], v[1], v[2], 1.0F);
2824
}
2825
 
2826
static void save_RasterPos3iv(const GLint *v)
2827
{
2828
   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
2829
}
2830
 
2831
static void save_RasterPos3sv(const GLshort *v)
2832
{
2833
   save_RasterPos4f(v[0], v[1], v[2], 1.0F);
2834
}
2835
 
2836
static void save_RasterPos4dv(const GLdouble *v)
2837
{
2838
   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],
2839
                    (GLfloat) v[2], (GLfloat) v[3]);
2840
}
2841
 
2842
static void save_RasterPos4fv(const GLfloat *v)
2843
{
2844
   save_RasterPos4f(v[0], v[1], v[2], v[3]);
2845
}
2846
 
2847
static void save_RasterPos4iv(const GLint *v)
2848
{
2849
   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],
2850
                    (GLfloat) v[2], (GLfloat) v[3]);
2851
}
2852
 
2853
static void save_RasterPos4sv(const GLshort *v)
2854
{
2855
   save_RasterPos4f(v[0], v[1], v[2], v[3]);
2856
}
2857
 
2858
 
2859
static void save_PassThrough( GLfloat token )
2860
{
2861
   GET_CURRENT_CONTEXT(ctx);
2862
   Node *n;
2863
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2864
   n = ALLOC_INSTRUCTION( ctx, OPCODE_PASSTHROUGH, 1 );
2865
   if (n) {
2866
      n[1].f = token;
2867
   }
2868
   if (ctx->ExecuteFlag) {
2869
      (*ctx->Exec->PassThrough)( token );
2870
   }
2871
}
2872
 
2873
 
2874
static void save_ReadBuffer( GLenum mode )
2875
{
2876
   GET_CURRENT_CONTEXT(ctx);
2877
   Node *n;
2878
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2879
   n = ALLOC_INSTRUCTION( ctx, OPCODE_READ_BUFFER, 1 );
2880
   if (n) {
2881
      n[1].e = mode;
2882
   }
2883
   if (ctx->ExecuteFlag) {
2884
      (*ctx->Exec->ReadBuffer)( mode );
2885
   }
2886
}
2887
 
2888
 
2889
static void
2890
save_ResetHistogram(GLenum target)
2891
{
2892
   GET_CURRENT_CONTEXT(ctx);
2893
   Node *n;
2894
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2895
   n = ALLOC_INSTRUCTION( ctx, OPCODE_RESET_HISTOGRAM, 1 );
2896
   if (n) {
2897
      n[1].e = target;
2898
   }
2899
   if (ctx->ExecuteFlag) {
2900
      (*ctx->Exec->ResetHistogram)( target );
2901
   }
2902
}
2903
 
2904
 
2905
static void
2906
save_ResetMinmax(GLenum target)
2907
{
2908
   GET_CURRENT_CONTEXT(ctx);
2909
   Node *n;
2910
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2911
   n = ALLOC_INSTRUCTION( ctx, OPCODE_RESET_MIN_MAX, 1 );
2912
   if (n) {
2913
      n[1].e = target;
2914
   }
2915
   if (ctx->ExecuteFlag) {
2916
      (*ctx->Exec->ResetMinmax)( target );
2917
   }
2918
}
2919
 
2920
 
2921
static void save_Rotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
2922
{
2923
   GET_CURRENT_CONTEXT(ctx);
2924
   Node *n;
2925
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2926
   n = ALLOC_INSTRUCTION( ctx, OPCODE_ROTATE, 4 );
2927
   if (n) {
2928
      n[1].f = angle;
2929
      n[2].f = x;
2930
      n[3].f = y;
2931
      n[4].f = z;
2932
   }
2933
   if (ctx->ExecuteFlag) {
2934
      (*ctx->Exec->Rotatef)( angle, x, y, z );
2935
   }
2936
}
2937
 
2938
 
2939
static void save_Rotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
2940
{
2941
   save_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z);
2942
}
2943
 
2944
 
2945
static void save_Scalef( GLfloat x, GLfloat y, GLfloat z )
2946
{
2947
   GET_CURRENT_CONTEXT(ctx);
2948
   Node *n;
2949
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2950
   n = ALLOC_INSTRUCTION( ctx, OPCODE_SCALE, 3 );
2951
   if (n) {
2952
      n[1].f = x;
2953
      n[2].f = y;
2954
      n[3].f = z;
2955
   }
2956
   if (ctx->ExecuteFlag) {
2957
      (*ctx->Exec->Scalef)( x, y, z );
2958
   }
2959
}
2960
 
2961
 
2962
static void save_Scaled( GLdouble x, GLdouble y, GLdouble z )
2963
{
2964
   save_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z);
2965
}
2966
 
2967
 
2968
static void save_Scissor( GLint x, GLint y, GLsizei width, GLsizei height )
2969
{
2970
   GET_CURRENT_CONTEXT(ctx);
2971
   Node *n;
2972
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2973
   n = ALLOC_INSTRUCTION( ctx, OPCODE_SCISSOR, 4 );
2974
   if (n) {
2975
      n[1].i = x;
2976
      n[2].i = y;
2977
      n[3].i = width;
2978
      n[4].i = height;
2979
   }
2980
   if (ctx->ExecuteFlag) {
2981
      (*ctx->Exec->Scissor)( x, y, width, height );
2982
   }
2983
}
2984
 
2985
 
2986
static void save_ShadeModel( GLenum mode )
2987
{
2988
   GET_CURRENT_CONTEXT(ctx);
2989
   Node *n;
2990
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2991
   n = ALLOC_INSTRUCTION( ctx, OPCODE_SHADE_MODEL, 1 );
2992
   if (n) {
2993
      n[1].e = mode;
2994
   }
2995
   if (ctx->ExecuteFlag) {
2996
      (*ctx->Exec->ShadeModel)( mode );
2997
   }
2998
}
2999
 
3000
 
3001
static void save_StencilFunc( GLenum func, GLint ref, GLuint mask )
3002
{
3003
   GET_CURRENT_CONTEXT(ctx);
3004
   Node *n;
3005
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3006
   n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_FUNC, 3 );
3007
   if (n) {
3008
      n[1].e = func;
3009
      n[2].i = ref;
3010
      n[3].ui = mask;
3011
   }
3012
   if (ctx->ExecuteFlag) {
3013
      (*ctx->Exec->StencilFunc)( func, ref, mask );
3014
   }
3015
}
3016
 
3017
 
3018
static void save_StencilMask( GLuint mask )
3019
{
3020
   GET_CURRENT_CONTEXT(ctx);
3021
   Node *n;
3022
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3023
   n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_MASK, 1 );
3024
   if (n) {
3025
      n[1].ui = mask;
3026
   }
3027
   if (ctx->ExecuteFlag) {
3028
      (*ctx->Exec->StencilMask)( mask );
3029
   }
3030
}
3031
 
3032
 
3033
static void save_StencilOp( GLenum fail, GLenum zfail, GLenum zpass )
3034
{
3035
   GET_CURRENT_CONTEXT(ctx);
3036
   Node *n;
3037
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3038
   n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_OP, 3 );
3039
   if (n) {
3040
      n[1].e = fail;
3041
      n[2].e = zfail;
3042
      n[3].e = zpass;
3043
   }
3044
   if (ctx->ExecuteFlag) {
3045
      (*ctx->Exec->StencilOp)( fail, zfail, zpass );
3046
   }
3047
}
3048
 
3049
 
3050
static void save_TexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
3051
{
3052
   GET_CURRENT_CONTEXT(ctx);
3053
   Node *n;
3054
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3055
   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXENV, 6 );
3056
   if (n) {
3057
      n[1].e = target;
3058
      n[2].e = pname;
3059
      n[3].f = params[0];
3060
      n[4].f = params[1];
3061
      n[5].f = params[2];
3062
      n[6].f = params[3];
3063
   }
3064
   if (ctx->ExecuteFlag) {
3065
      (*ctx->Exec->TexEnvfv)( target, pname, params );
3066
   }
3067
}
3068
 
3069
 
3070
static void save_TexEnvf( GLenum target, GLenum pname, GLfloat param )
3071
{
3072
   save_TexEnvfv( target, pname, &param );
3073
}
3074
 
3075
 
3076
static void save_TexEnvi( GLenum target, GLenum pname, GLint param )
3077
{
3078
   GLfloat p[4];
3079
   p[0] = (GLfloat) param;
3080
   p[1] = p[2] = p[3] = 0.0;
3081
   save_TexEnvfv( target, pname, p );
3082
}
3083
 
3084
 
3085
static void save_TexEnviv( GLenum target, GLenum pname, const GLint *param )
3086
{
3087
   GLfloat p[4];
3088
   p[0] = INT_TO_FLOAT( param[0] );
3089
   p[1] = INT_TO_FLOAT( param[1] );
3090
   p[2] = INT_TO_FLOAT( param[2] );
3091
   p[3] = INT_TO_FLOAT( param[3] );
3092
   save_TexEnvfv( target, pname, p );
3093
}
3094
 
3095
 
3096
static void save_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
3097
{
3098
   GET_CURRENT_CONTEXT(ctx);
3099
   Node *n;
3100
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3101
   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXGEN, 6 );
3102
   if (n) {
3103
      n[1].e = coord;
3104
      n[2].e = pname;
3105
      n[3].f = params[0];
3106
      n[4].f = params[1];
3107
      n[5].f = params[2];
3108
      n[6].f = params[3];
3109
   }
3110
   if (ctx->ExecuteFlag) {
3111
      (*ctx->Exec->TexGenfv)( coord, pname, params );
3112
   }
3113
}
3114
 
3115
 
3116
static void save_TexGeniv(GLenum coord, GLenum pname, const GLint *params )
3117
{
3118
   GLfloat p[4];
3119
   p[0] = (GLfloat) params[0];
3120
   p[1] = (GLfloat) params[1];
3121
   p[2] = (GLfloat) params[2];
3122
   p[3] = (GLfloat) params[3];
3123
   save_TexGenfv(coord, pname, p);
3124
}
3125
 
3126
 
3127
static void save_TexGend(GLenum coord, GLenum pname, GLdouble param )
3128
{
3129
   GLfloat p = (GLfloat) param;
3130
   save_TexGenfv( coord, pname, &p );
3131
}
3132
 
3133
 
3134
static void save_TexGendv(GLenum coord, GLenum pname, const GLdouble *params )
3135
{
3136
   GLfloat p[4];
3137
   p[0] = (GLfloat) params[0];
3138
   p[1] = (GLfloat) params[1];
3139
   p[2] = (GLfloat) params[2];
3140
   p[3] = (GLfloat) params[3];
3141
   save_TexGenfv( coord, pname, p );
3142
}
3143
 
3144
 
3145
static void save_TexGenf( GLenum coord, GLenum pname, GLfloat param )
3146
{
3147
   save_TexGenfv(coord, pname, &param);
3148
}
3149
 
3150
 
3151
static void save_TexGeni( GLenum coord, GLenum pname, GLint param )
3152
{
3153
   save_TexGeniv( coord, pname, &param );
3154
}
3155
 
3156
 
3157
static void save_TexParameterfv( GLenum target,
3158
                             GLenum pname, const GLfloat *params )
3159
{
3160
   GET_CURRENT_CONTEXT(ctx);
3161
   Node *n;
3162
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3163
   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXPARAMETER, 6 );
3164
   if (n) {
3165
      n[1].e = target;
3166
      n[2].e = pname;
3167
      n[3].f = params[0];
3168
      n[4].f = params[1];
3169
      n[5].f = params[2];
3170
      n[6].f = params[3];
3171
   }
3172
   if (ctx->ExecuteFlag) {
3173
      (*ctx->Exec->TexParameterfv)( target, pname, params );
3174
   }
3175
}
3176
 
3177
 
3178
static void save_TexParameterf( GLenum target, GLenum pname, GLfloat param )
3179
{
3180
   save_TexParameterfv(target, pname, &param);
3181
}
3182
 
3183
 
3184
static void save_TexParameteri( GLenum target, GLenum pname, GLint param )
3185
{
3186
   GLfloat fparam[4];
3187
   fparam[0] = (GLfloat) param;
3188
   fparam[1] = fparam[2] = fparam[3] = 0.0;
3189
   save_TexParameterfv(target, pname, fparam);
3190
}
3191
 
3192
 
3193
static void save_TexParameteriv( GLenum target, GLenum pname, const GLint *params )
3194
{
3195
   GLfloat fparam[4];
3196
   fparam[0] = (GLfloat) params[0];
3197
   fparam[1] = fparam[2] = fparam[3] = 0.0;
3198
   save_TexParameterfv(target, pname, fparam);
3199
}
3200
 
3201
 
3202
static void save_TexImage1D( GLenum target,
3203
                             GLint level, GLint components,
3204
                             GLsizei width, GLint border,
3205
                             GLenum format, GLenum type,
3206
                             const GLvoid *pixels )
3207
{
3208
   GET_CURRENT_CONTEXT(ctx);
3209
   if (target == GL_PROXY_TEXTURE_1D) {
3210
      /* don't compile, execute immediately */
3211
      (*ctx->Exec->TexImage1D)( target, level, components, width,
3212
                               border, format, type, pixels );
3213
   }
3214
   else {
3215
      GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type,
3216
                                         pixels, &ctx->Unpack);
3217
      Node *n;
3218
      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3219
      n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE1D, 8 );
3220
      if (n) {
3221
         n[1].e = target;
3222
         n[2].i = level;
3223
         n[3].i = components;
3224
         n[4].i = (GLint) width;
3225
         n[5].i = border;
3226
         n[6].e = format;
3227
         n[7].e = type;
3228
         n[8].data = image;
3229
      }
3230
      else if (image) {
3231
         FREE(image);
3232
      }
3233
      if (ctx->ExecuteFlag) {
3234
         (*ctx->Exec->TexImage1D)( target, level, components, width,
3235
                                  border, format, type, pixels );
3236
      }
3237
   }
3238
}
3239
 
3240
 
3241
static void save_TexImage2D( GLenum target,
3242
                             GLint level, GLint components,
3243
                             GLsizei width, GLsizei height, GLint border,
3244
                             GLenum format, GLenum type,
3245
                             const GLvoid *pixels)
3246
{
3247
   GET_CURRENT_CONTEXT(ctx);
3248
   if (target == GL_PROXY_TEXTURE_2D) {
3249
      /* don't compile, execute immediately */
3250
      (*ctx->Exec->TexImage2D)( target, level, components, width,
3251
                               height, border, format, type, pixels );
3252
   }
3253
   else {
3254
      GLvoid *image = _mesa_unpack_image(width, height, 1, format, type,
3255
                                         pixels, &ctx->Unpack);
3256
      Node *n;
3257
      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3258
      n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE2D, 9 );
3259
      if (n) {
3260
         n[1].e = target;
3261
         n[2].i = level;
3262
         n[3].i = components;
3263
         n[4].i = (GLint) width;
3264
         n[5].i = (GLint) height;
3265
         n[6].i = border;
3266
         n[7].e = format;
3267
         n[8].e = type;
3268
         n[9].data = image;
3269
      }
3270
      else if (image) {
3271
         FREE(image);
3272
      }
3273
      if (ctx->ExecuteFlag) {
3274
         (*ctx->Exec->TexImage2D)( target, level, components, width,
3275
                                  height, border, format, type, pixels );
3276
      }
3277
   }
3278
}
3279
 
3280
 
3281
static void save_TexImage3D( GLenum target,
3282
                             GLint level, GLint internalFormat,
3283
                             GLsizei width, GLsizei height, GLsizei depth,
3284
                             GLint border,
3285
                             GLenum format, GLenum type,
3286
                             const GLvoid *pixels )
3287
{
3288
   GET_CURRENT_CONTEXT(ctx);
3289
   if (target == GL_PROXY_TEXTURE_3D) {
3290
      /* don't compile, execute immediately */
3291
      (*ctx->Exec->TexImage3D)( target, level, internalFormat, width,
3292
                               height, depth, border, format, type, pixels );
3293
   }
3294
   else {
3295
      Node *n;
3296
      GLvoid *image = _mesa_unpack_image(width, height, depth, format, type,
3297
                                         pixels, &ctx->Unpack);
3298
      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3299
      n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE3D, 10 );
3300
      if (n) {
3301
         n[1].e = target;
3302
         n[2].i = level;
3303
         n[3].i = (GLint) internalFormat;
3304
         n[4].i = (GLint) width;
3305
         n[5].i = (GLint) height;
3306
         n[6].i = (GLint) depth;
3307
         n[7].i = border;
3308
         n[8].e = format;
3309
         n[9].e = type;
3310
         n[10].data = image;
3311
      }
3312
      else if (image) {
3313
         FREE(image);
3314
      }
3315
      if (ctx->ExecuteFlag) {
3316
         (*ctx->Exec->TexImage3D)( target, level, internalFormat, width,
3317
                                height, depth, border, format, type, pixels );
3318
      }
3319
   }
3320
}
3321
 
3322
 
3323
static void save_TexSubImage1D( GLenum target, GLint level, GLint xoffset,
3324
                                GLsizei width, GLenum format, GLenum type,
3325
                                const GLvoid *pixels )
3326
{
3327
   GET_CURRENT_CONTEXT(ctx);
3328
   Node *n;
3329
   GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type,
3330
                                      pixels, &ctx->Unpack);
3331
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3332
   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE1D, 7 );
3333
   if (n) {
3334
      n[1].e = target;
3335
      n[2].i = level;
3336
      n[3].i = xoffset;
3337
      n[4].i = (GLint) width;
3338
      n[5].e = format;
3339
      n[6].e = type;
3340
      n[7].data = image;
3341
   }
3342
   else if (image) {
3343
      FREE(image);
3344
   }
3345
   if (ctx->ExecuteFlag) {
3346
      (*ctx->Exec->TexSubImage1D)( target, level, xoffset, width,
3347
                                  format, type, pixels );
3348
   }
3349
}
3350
 
3351
 
3352
static void save_TexSubImage2D( GLenum target, GLint level,
3353
                                GLint xoffset, GLint yoffset,
3354
                                GLsizei width, GLsizei height,
3355
                                GLenum format, GLenum type,
3356
                                const GLvoid *pixels )
3357
{
3358
   GET_CURRENT_CONTEXT(ctx);
3359
   Node *n;
3360
   GLvoid *image = _mesa_unpack_image(width, height, 1, format, type,
3361
                                      pixels, &ctx->Unpack);
3362
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3363
   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE2D, 9 );
3364
   if (n) {
3365
      n[1].e = target;
3366
      n[2].i = level;
3367
      n[3].i = xoffset;
3368
      n[4].i = yoffset;
3369
      n[5].i = (GLint) width;
3370
      n[6].i = (GLint) height;
3371
      n[7].e = format;
3372
      n[8].e = type;
3373
      n[9].data = image;
3374
   }
3375
   else if (image) {
3376
      FREE(image);
3377
   }
3378
   if (ctx->ExecuteFlag) {
3379
      (*ctx->Exec->TexSubImage2D)( target, level, xoffset, yoffset,
3380
                           width, height, format, type, pixels );
3381
   }
3382
}
3383
 
3384
 
3385
static void save_TexSubImage3D( GLenum target, GLint level,
3386
                                GLint xoffset, GLint yoffset,GLint zoffset,
3387
                                GLsizei width, GLsizei height, GLsizei depth,
3388
                                GLenum format, GLenum type,
3389
                                const GLvoid *pixels )
3390
{
3391
   GET_CURRENT_CONTEXT(ctx);
3392
   Node *n;
3393
   GLvoid *image = _mesa_unpack_image(width, height, depth, format, type,
3394
                                      pixels, &ctx->Unpack);
3395
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3396
   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE3D, 11 );
3397
   if (n) {
3398
      n[1].e = target;
3399
      n[2].i = level;
3400
      n[3].i = xoffset;
3401
      n[4].i = yoffset;
3402
      n[5].i = zoffset;
3403
      n[6].i = (GLint) width;
3404
      n[7].i = (GLint) height;
3405
      n[8].i = (GLint) depth;
3406
      n[9].e = format;
3407
      n[10].e = type;
3408
      n[11].data = image;
3409
   }
3410
   else if (image) {
3411
      FREE(image);
3412
   }
3413
   if (ctx->ExecuteFlag) {
3414
      (*ctx->Exec->TexSubImage3D)( target, level,
3415
                                  xoffset, yoffset, zoffset,
3416
                                  width, height, depth, format, type, pixels );
3417
   }
3418
}
3419
 
3420
 
3421
static void save_Translatef( GLfloat x, GLfloat y, GLfloat z )
3422
{
3423
   GET_CURRENT_CONTEXT(ctx);
3424
   Node *n;
3425
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3426
   n = ALLOC_INSTRUCTION( ctx,  OPCODE_TRANSLATE, 3 );
3427
   if (n) {
3428
      n[1].f = x;
3429
      n[2].f = y;
3430
      n[3].f = z;
3431
   }
3432
   if (ctx->ExecuteFlag) {
3433
      (*ctx->Exec->Translatef)( x, y, z );
3434
   }
3435
}
3436
 
3437
 
3438
static void save_Translated( GLdouble x, GLdouble y, GLdouble z )
3439
{
3440
   save_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z);
3441
}
3442
 
3443
 
3444
 
3445
static void save_Viewport( GLint x, GLint y, GLsizei width, GLsizei height )
3446
{
3447
   GET_CURRENT_CONTEXT(ctx);
3448
   Node *n;
3449
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3450
   n = ALLOC_INSTRUCTION( ctx,  OPCODE_VIEWPORT, 4 );
3451
   if (n) {
3452
      n[1].i = x;
3453
      n[2].i = y;
3454
      n[3].i = (GLint) width;
3455
      n[4].i = (GLint) height;
3456
   }
3457
   if (ctx->ExecuteFlag) {
3458
      (*ctx->Exec->Viewport)( x, y, width, height );
3459
   }
3460
}
3461
 
3462
 
3463
static void save_WindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
3464
{
3465
   GET_CURRENT_CONTEXT(ctx);
3466
   Node *n;
3467
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3468
   FLUSH_CURRENT(ctx, 0);
3469
   n = ALLOC_INSTRUCTION( ctx,  OPCODE_WINDOW_POS, 4 );
3470
   if (n) {
3471
      n[1].f = x;
3472
      n[2].f = y;
3473
      n[3].f = z;
3474
      n[4].f = w;
3475
   }
3476
   if (ctx->ExecuteFlag) {
3477
      (*ctx->Exec->WindowPos4fMESA)( x, y, z, w );
3478
   }
3479
}
3480
 
3481
static void save_WindowPos2dMESA(GLdouble x, GLdouble y)
3482
{
3483
   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
3484
}
3485
 
3486
static void save_WindowPos2fMESA(GLfloat x, GLfloat y)
3487
{
3488
   save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
3489
}
3490
 
3491
static void save_WindowPos2iMESA(GLint x, GLint y)
3492
{
3493
   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
3494
}
3495
 
3496
static void save_WindowPos2sMESA(GLshort x, GLshort y)
3497
{
3498
   save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
3499
}
3500
 
3501
static void save_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
3502
{
3503
   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
3504
}
3505
 
3506
static void save_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
3507
{
3508
   save_WindowPos4fMESA(x, y, z, 1.0F);
3509
}
3510
 
3511
static void save_WindowPos3iMESA(GLint x, GLint y, GLint z)
3512
{
3513
   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
3514
}
3515
 
3516
static void save_WindowPos3sMESA(GLshort x, GLshort y, GLshort z)
3517
{
3518
   save_WindowPos4fMESA(x, y, z, 1.0F);
3519
}
3520
 
3521
static void save_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
3522
{
3523
   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
3524
}
3525
 
3526
static void save_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
3527
{
3528
   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
3529
}
3530
 
3531
static void save_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
3532
{
3533
   save_WindowPos4fMESA(x, y, z, w);
3534
}
3535
 
3536
static void save_WindowPos2dvMESA(const GLdouble *v)
3537
{
3538
   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
3539
}
3540
 
3541
static void save_WindowPos2fvMESA(const GLfloat *v)
3542
{
3543
   save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
3544
}
3545
 
3546
static void save_WindowPos2ivMESA(const GLint *v)
3547
{
3548
   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
3549
}
3550
 
3551
static void save_WindowPos2svMESA(const GLshort *v)
3552
{
3553
   save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
3554
}
3555
 
3556
static void save_WindowPos3dvMESA(const GLdouble *v)
3557
{
3558
   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
3559
}
3560
 
3561
static void save_WindowPos3fvMESA(const GLfloat *v)
3562
{
3563
   save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
3564
}
3565
 
3566
static void save_WindowPos3ivMESA(const GLint *v)
3567
{
3568
   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
3569
}
3570
 
3571
static void save_WindowPos3svMESA(const GLshort *v)
3572
{
3573
   save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
3574
}
3575
 
3576
static void save_WindowPos4dvMESA(const GLdouble *v)
3577
{
3578
   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],
3579
                        (GLfloat) v[2], (GLfloat) v[3]);
3580
}
3581
 
3582
static void save_WindowPos4fvMESA(const GLfloat *v)
3583
{
3584
   save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
3585
}
3586
 
3587
static void save_WindowPos4ivMESA(const GLint *v)
3588
{
3589
   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],
3590
                        (GLfloat) v[2], (GLfloat) v[3]);
3591
}
3592
 
3593
static void save_WindowPos4svMESA(const GLshort *v)
3594
{
3595
   save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
3596
}
3597
 
3598
 
3599
 
3600
/* GL_ARB_multitexture */
3601
static void save_ActiveTextureARB( GLenum target )
3602
{
3603
   GET_CURRENT_CONTEXT(ctx);
3604
   Node *n;
3605
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3606
   n = ALLOC_INSTRUCTION( ctx, OPCODE_ACTIVE_TEXTURE, 1 );
3607
   if (n) {
3608
      n[1].e = target;
3609
   }
3610
   if (ctx->ExecuteFlag) {
3611
      (*ctx->Exec->ActiveTextureARB)( target );
3612
   }
3613
}
3614
 
3615
 
3616
/* GL_ARB_transpose_matrix */
3617
 
3618
static void save_LoadTransposeMatrixdARB( const GLdouble m[16] )
3619
{
3620
   GLfloat tm[16];
3621
   _math_transposefd(tm, m);
3622
   save_LoadMatrixf(tm);
3623
}
3624
 
3625
 
3626
static void save_LoadTransposeMatrixfARB( const GLfloat m[16] )
3627
{
3628
   GLfloat tm[16];
3629
   _math_transposef(tm, m);
3630
   save_LoadMatrixf(tm);
3631
}
3632
 
3633
 
3634
static void
3635
save_MultTransposeMatrixdARB( const GLdouble m[16] )
3636
{
3637
   GLfloat tm[16];
3638
   _math_transposefd(tm, m);
3639
   save_MultMatrixf(tm);
3640
}
3641
 
3642
 
3643
static void
3644
save_MultTransposeMatrixfARB( const GLfloat m[16] )
3645
{
3646
   GLfloat tm[16];
3647
   _math_transposef(tm, m);
3648
   save_MultMatrixf(tm);
3649
}
3650
 
3651
 
3652
static void
3653
save_PixelTexGenSGIX(GLenum mode)
3654
{
3655
   GET_CURRENT_CONTEXT(ctx);
3656
   Node *n;
3657
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3658
   n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TEXGEN_SGIX, 1 );
3659
   if (n) {
3660
      n[1].e = mode;
3661
   }
3662
   if (ctx->ExecuteFlag) {
3663
      (*ctx->Exec->PixelTexGenSGIX)( mode );
3664
   }
3665
}
3666
 
3667
 
3668
/* GL_ARB_texture_compression */
3669
static void
3670
save_CompressedTexImage1DARB(GLenum target, GLint level,
3671
                             GLenum internalFormat, GLsizei width,
3672
                             GLint border, GLsizei imageSize,
3673
                             const GLvoid *data)
3674
{
3675
   GET_CURRENT_CONTEXT(ctx);
3676
   if (target == GL_PROXY_TEXTURE_1D) {
3677
      /* don't compile, execute immediately */
3678
      (*ctx->Exec->CompressedTexImage1DARB)(target, level, internalFormat,
3679
                                            width, border, imageSize, data);
3680
   }
3681
   else {
3682
      Node *n;
3683
      GLvoid *image;
3684
      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3685
      /* make copy of image */
3686
      image = MALLOC(imageSize);
3687
      if (!image) {
3688
         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");
3689
         return;
3690
      }
3691
      MEMCPY(image, data, imageSize);
3692
      n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D, 7 );
3693
      if (n) {
3694
         n[1].e = target;
3695
         n[2].i = level;
3696
         n[3].e = internalFormat;
3697
         n[4].i = (GLint) width;
3698
         n[5].i = border;
3699
         n[6].i = imageSize;
3700
         n[7].data = image;
3701
      }
3702
      else if (image) {
3703
         FREE(image);
3704
      }
3705
      if (ctx->ExecuteFlag) {
3706
         (*ctx->Exec->CompressedTexImage1DARB)(target, level, internalFormat,
3707
                                               width, border, imageSize, data);
3708
      }
3709
   }
3710
}
3711
 
3712
 
3713
static void
3714
save_CompressedTexImage2DARB(GLenum target, GLint level,
3715
                             GLenum internalFormat, GLsizei width,
3716
                             GLsizei height, GLint border, GLsizei imageSize,
3717
                             const GLvoid *data)
3718
{
3719
   GET_CURRENT_CONTEXT(ctx);
3720
   if (target == GL_PROXY_TEXTURE_2D) {
3721
      /* don't compile, execute immediately */
3722
      (*ctx->Exec->CompressedTexImage2DARB)(target, level, internalFormat,
3723
                                       width, height, border, imageSize, data);
3724
   }
3725
   else {
3726
      Node *n;
3727
      GLvoid *image;
3728
      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3729
      /* make copy of image */
3730
      image = MALLOC(imageSize);
3731
      if (!image) {
3732
         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
3733
         return;
3734
      }
3735
      MEMCPY(image, data, imageSize);
3736
      n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D, 8 );
3737
      if (n) {
3738
         n[1].e = target;
3739
         n[2].i = level;
3740
         n[3].e = internalFormat;
3741
         n[4].i = (GLint) width;
3742
         n[5].i = (GLint) height;
3743
         n[6].i = border;
3744
         n[7].i = imageSize;
3745
         n[8].data = image;
3746
      }
3747
      else if (image) {
3748
         FREE(image);
3749
      }
3750
      if (ctx->ExecuteFlag) {
3751
         (*ctx->Exec->CompressedTexImage2DARB)(target, level, internalFormat,
3752
                                      width, height, border, imageSize, data);
3753
      }
3754
   }
3755
}
3756
 
3757
 
3758
static void
3759
save_CompressedTexImage3DARB(GLenum target, GLint level,
3760
                             GLenum internalFormat, GLsizei width,
3761
                             GLsizei height, GLsizei depth, GLint border,
3762
                             GLsizei imageSize, const GLvoid *data)
3763
{
3764
   GET_CURRENT_CONTEXT(ctx);
3765
   if (target == GL_PROXY_TEXTURE_3D) {
3766
      /* don't compile, execute immediately */
3767
      (*ctx->Exec->CompressedTexImage3DARB)(target, level, internalFormat,
3768
                                width, height, depth, border, imageSize, data);
3769
   }
3770
   else {
3771
      Node *n;
3772
      GLvoid *image;
3773
      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3774
      /* make copy of image */
3775
      image = MALLOC(imageSize);
3776
      if (!image) {
3777
         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");
3778
         return;
3779
      }
3780
      MEMCPY(image, data, imageSize);
3781
      n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D, 9 );
3782
      if (n) {
3783
         n[1].e = target;
3784
         n[2].i = level;
3785
         n[3].e = internalFormat;
3786
         n[4].i = (GLint) width;
3787
         n[5].i = (GLint) height;
3788
         n[6].i = (GLint) depth;
3789
         n[7].i = border;
3790
         n[8].i = imageSize;
3791
         n[9].data = image;
3792
      }
3793
      else if (image) {
3794
         FREE(image);
3795
      }
3796
      if (ctx->ExecuteFlag) {
3797
         (*ctx->Exec->CompressedTexImage3DARB)(target, level, internalFormat,
3798
                                width, height, depth, border, imageSize, data);
3799
      }
3800
   }
3801
}
3802
 
3803
 
3804
static void
3805
save_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
3806
                                GLsizei width, GLenum format,
3807
                                GLsizei imageSize, const GLvoid *data)
3808
{
3809
   Node *n;
3810
   GLvoid *image;
3811
 
3812
   GET_CURRENT_CONTEXT(ctx);
3813
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3814
 
3815
   /* make copy of image */
3816
   image = MALLOC(imageSize);
3817
   if (!image) {
3818
      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage1DARB");
3819
      return;
3820
   }
3821
   MEMCPY(image, data, imageSize);
3822
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D, 7 );
3823
   if (n) {
3824
      n[1].e = target;
3825
      n[2].i = level;
3826
      n[3].i = xoffset;
3827
      n[4].i = (GLint) width;
3828
      n[5].e = format;
3829
      n[6].i = imageSize;
3830
      n[7].data = image;
3831
   }
3832
   else if (image) {
3833
      FREE(image);
3834
   }
3835
   if (ctx->ExecuteFlag) {
3836
      (*ctx->Exec->CompressedTexSubImage1DARB)(target, level, xoffset,
3837
                                            width, format, imageSize, data);
3838
   }
3839
}
3840
 
3841
 
3842
static void
3843
save_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
3844
                                GLint yoffset, GLsizei width, GLsizei height,
3845
                                GLenum format, GLsizei imageSize,
3846
                                const GLvoid *data)
3847
{
3848
   Node *n;
3849
   GLvoid *image;
3850
 
3851
   GET_CURRENT_CONTEXT(ctx);
3852
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3853
 
3854
   /* make copy of image */
3855
   image = MALLOC(imageSize);
3856
   if (!image) {
3857
      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage2DARB");
3858
      return;
3859
   }
3860
   MEMCPY(image, data, imageSize);
3861
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D, 9 );
3862
   if (n) {
3863
      n[1].e = target;
3864
      n[2].i = level;
3865
      n[3].i = xoffset;
3866
      n[4].i = yoffset;
3867
      n[5].i = (GLint) width;
3868
      n[6].i = (GLint) height;
3869
      n[7].e = format;
3870
      n[8].i = imageSize;
3871
      n[9].data = image;
3872
   }
3873
   else if (image) {
3874
      FREE(image);
3875
   }
3876
   if (ctx->ExecuteFlag) {
3877
      (*ctx->Exec->CompressedTexSubImage2DARB)(target, level, xoffset, yoffset,
3878
                                       width, height, format, imageSize, data);
3879
   }
3880
}
3881
 
3882
 
3883
static void
3884
save_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
3885
                                GLint yoffset, GLint zoffset, GLsizei width,
3886
                                GLsizei height, GLsizei depth, GLenum format,
3887
                                GLsizei imageSize, const GLvoid *data)
3888
{
3889
   Node *n;
3890
   GLvoid *image;
3891
 
3892
   GET_CURRENT_CONTEXT(ctx);
3893
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3894
 
3895
   /* make copy of image */
3896
   image = MALLOC(imageSize);
3897
   if (!image) {
3898
      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage3DARB");
3899
      return;
3900
   }
3901
   MEMCPY(image, data, imageSize);
3902
   n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D, 11 );
3903
   if (n) {
3904
      n[1].e = target;
3905
      n[2].i = level;
3906
      n[3].i = xoffset;
3907
      n[4].i = yoffset;
3908
      n[5].i = zoffset;
3909
      n[6].i = (GLint) width;
3910
      n[7].i = (GLint) height;
3911
      n[8].i = (GLint) depth;
3912
      n[9].e = format;
3913
      n[10].i = imageSize;
3914
      n[11].data = image;
3915
   }
3916
   else if (image) {
3917
      FREE(image);
3918
   }
3919
   if (ctx->ExecuteFlag) {
3920
      (*ctx->Exec->CompressedTexSubImage3DARB)(target, level, xoffset, yoffset,
3921
                       zoffset, width, height, depth, format, imageSize, data);
3922
   }
3923
}
3924
 
3925
 
3926
/* GL_ARB_multisample */
3927
static void
3928
save_SampleCoverageARB(GLclampf value, GLboolean invert)
3929
{
3930
   GET_CURRENT_CONTEXT(ctx);
3931
   Node *n;
3932
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3933
   n = ALLOC_INSTRUCTION( ctx, OPCODE_SAMPLE_COVERAGE, 2 );
3934
   if (n) {
3935
      n[1].f = value;
3936
      n[2].b = invert;
3937
   }
3938
   if (ctx->ExecuteFlag) {
3939
      (*ctx->Exec->SampleCoverageARB)( value, invert );
3940
   }
3941
}
3942
 
3943
 
3944
/* GL_SGIS_pixel_texture */
3945
 
3946
static void
3947
save_PixelTexGenParameteriSGIS(GLenum target, GLint value)
3948
{
3949
   GET_CURRENT_CONTEXT(ctx);
3950
   Node *n;
3951
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3952
   n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS, 2 );
3953
   if (n) {
3954
      n[1].e = target;
3955
      n[2].i = value;
3956
   }
3957
   if (ctx->ExecuteFlag) {
3958
      (*ctx->Exec->PixelTexGenParameteriSGIS)( target, value );
3959
   }
3960
}
3961
 
3962
 
3963
static void
3964
save_PixelTexGenParameterfSGIS(GLenum target, GLfloat value)
3965
{
3966
   save_PixelTexGenParameteriSGIS(target, (GLint) value);
3967
}
3968
 
3969
 
3970
static void
3971
save_PixelTexGenParameterivSGIS(GLenum target, const GLint *value)
3972
{
3973
   save_PixelTexGenParameteriSGIS(target, *value);
3974
}
3975
 
3976
 
3977
static void
3978
save_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value)
3979
{
3980
   save_PixelTexGenParameteriSGIS(target, (GLint) *value);
3981
}
3982
 
3983
 
3984
/*
3985
 * GL_NV_vertex_program
3986
 */
3987
#if FEATURE_NV_vertex_program
3988
static void
3989
save_BindProgramNV(GLenum target, GLuint id)
3990
{
3991
   GET_CURRENT_CONTEXT(ctx);
3992
   Node *n;
3993
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3994
   n = ALLOC_INSTRUCTION( ctx, OPCODE_BIND_PROGRAM_NV, 2 );
3995
   if (n) {
3996
      n[1].e = target;
3997
      n[2].ui = id;
3998
   }
3999
   if (ctx->ExecuteFlag) {
4000
      (*ctx->Exec->BindProgramNV)( target, id );
4001
   }
4002
}
4003
 
4004
static void
4005
save_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params)
4006
{
4007
   GET_CURRENT_CONTEXT(ctx);
4008
   Node *n;
4009
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4010
   n = ALLOC_INSTRUCTION( ctx, OPCODE_EXECUTE_PROGRAM_NV, 6 );
4011
   if (n) {
4012
      n[1].e = target;
4013
      n[2].ui = id;
4014
      n[3].f = params[0];
4015
      n[4].f = params[1];
4016
      n[5].f = params[2];
4017
      n[6].f = params[3];
4018
   }
4019
   if (ctx->ExecuteFlag) {
4020
      (*ctx->Exec->ExecuteProgramNV)(target, id, params);
4021
   }
4022
}
4023
 
4024
 
4025
static void
4026
save_ProgramParameter4fNV(GLenum target, GLuint index,
4027
                          GLfloat x, GLfloat y,
4028
                          GLfloat z, GLfloat w)
4029
{
4030
   GET_CURRENT_CONTEXT(ctx);
4031
   Node *n;
4032
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4033
   n = ALLOC_INSTRUCTION( ctx, OPCODE_PROGRAM_PARAMETER4F_NV, 6 );
4034
   if (n) {
4035
      n[1].e = target;
4036
      n[2].ui = index;
4037
      n[3].f = x;
4038
      n[4].f = y;
4039
      n[5].f = z;
4040
      n[6].f = w;
4041
   }
4042
   if (ctx->ExecuteFlag) {
4043
      (*ctx->Exec->ProgramParameter4fNV)(target, index, x, y, z, w);
4044
   }
4045
}
4046
 
4047
 
4048
static void
4049
save_ProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat *params)
4050
{
4051
   save_ProgramParameter4fNV(target, index, params[0], params[1],
4052
                             params[2], params[3]);
4053
}
4054
 
4055
 
4056
static void
4057
save_ProgramParameter4dNV(GLenum target, GLuint index,
4058
                          GLdouble x, GLdouble y,
4059
                          GLdouble z, GLdouble w)
4060
{
4061
   save_ProgramParameter4fNV(target, index, (GLfloat) x, (GLfloat) y,
4062
                             (GLfloat) z, (GLfloat) w);
4063
}
4064
 
4065
 
4066
static void
4067
save_ProgramParameter4dvNV(GLenum target, GLuint index,
4068
                           const GLdouble *params)
4069
{
4070
   save_ProgramParameter4fNV(target, index, (GLfloat) params[0],
4071
                             (GLfloat) params[1], (GLfloat) params[2],
4072
                             (GLfloat) params[3]);
4073
}
4074
 
4075
 
4076
static void
4077
save_ProgramParameters4dvNV(GLenum target, GLuint index,
4078
                            GLuint num, const GLdouble *params)
4079
{
4080
   GLuint i;
4081
   for (i = 0; i < num; i++) {
4082
      save_ProgramParameter4dvNV(target, index + i, params + 4 * i);
4083
   }
4084
}
4085
 
4086
 
4087
static void
4088
save_ProgramParameters4fvNV(GLenum target, GLuint index,
4089
                            GLuint num, const GLfloat *params)
4090
{
4091
   GLuint i;
4092
   for (i = 0; i < num; i++) {
4093
      save_ProgramParameter4fvNV(target, index + i, params + 4 * i);
4094
   }
4095
}
4096
 
4097
 
4098
 
4099
static void
4100
save_TrackMatrixNV(GLenum target, GLuint address,
4101
                   GLenum matrix, GLenum transform)
4102
{
4103
   GET_CURRENT_CONTEXT(ctx);
4104
   Node *n;
4105
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4106
   n = ALLOC_INSTRUCTION( ctx, OPCODE_TRACK_MATRIX_NV, 4 );
4107
   if (n) {
4108
      n[1].e = target;
4109
      n[2].ui = address;
4110
      n[3].e = matrix;
4111
      n[4].e = transform;
4112
   }
4113
   if (ctx->ExecuteFlag) {
4114
      (*ctx->Exec->TrackMatrixNV)(target, address, matrix, transform);
4115
   }
4116
}
4117
#endif /* FEATURE_NV_vertex_program */
4118
 
4119
 
4120
/* GL_EXT_stencil_two_side */
4121
static void save_ActiveStencilFaceEXT( GLenum face )
4122
{
4123
   GET_CURRENT_CONTEXT(ctx);
4124
   Node *n;
4125
   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4126
   n = ALLOC_INSTRUCTION( ctx, OPCODE_ACTIVE_STENCIL_FACE_EXT, 1 );
4127
   if (n) {
4128
      n[1].e = face;
4129
   }
4130
   if (ctx->ExecuteFlag) {
4131
      (*ctx->Exec->ActiveStencilFaceEXT)( face );
4132
   }
4133
}
4134
 
4135
 
4136
 
4137
/* KW: Compile commands
4138
 *
4139
 * Will appear in the list before the vertex buffer containing the
4140
 * command that provoked the error.  I don't see this as a problem.
4141
 */
4142
void
4143
_mesa_save_error( GLcontext *ctx, GLenum error, const char *s )
4144
{
4145
   Node *n;
4146
   n = ALLOC_INSTRUCTION( ctx, OPCODE_ERROR, 2 );
4147
   if (n) {
4148
      n[1].e = error;
4149
      n[2].data = (void *) s;
4150
   }
4151
   /* execute already done */
4152
}
4153
 
4154
 
4155
/*
4156
 * Compile an error into current display list.
4157
 */
4158
void
4159
_mesa_compile_error( GLcontext *ctx, GLenum error, const char *s )
4160
{
4161
   if (ctx->CompileFlag)
4162
      _mesa_save_error( ctx, error, s );
4163
 
4164
   if (ctx->ExecuteFlag)
4165
      _mesa_error( ctx, error, s );
4166
}
4167
 
4168
 
4169
 
4170
static GLboolean
4171
islist(GLcontext *ctx, GLuint list)
4172
{
4173
   if (list > 0 && _mesa_HashLookup(ctx->Shared->DisplayList, list)) {
4174
      return GL_TRUE;
4175
   }
4176
   else {
4177
      return GL_FALSE;
4178
   }
4179
}
4180
 
4181
 
4182
 
4183
/**********************************************************************/
4184
/*                     Display list execution                         */
4185
/**********************************************************************/
4186
 
4187
 
4188
/*
4189
 * Execute a display list.  Note that the ListBase offset must have already
4190
 * been added before calling this function.  I.e. the list argument is
4191
 * the absolute list number, not relative to ListBase.
4192
 * Input:  list - display list number
4193
 */
4194
static void
4195
execute_list( GLcontext *ctx, GLuint list )
4196
{
4197
   Node *n;
4198
   GLboolean done;
4199
 
4200
   if (!islist(ctx,list))
4201
      return;
4202
 
4203
   if (ctx->Driver.BeginCallList)
4204
      ctx->Driver.BeginCallList( ctx, list );
4205
 
4206
   ctx->CallDepth++;
4207
 
4208
   n = (Node *) _mesa_HashLookup(ctx->Shared->DisplayList, list);
4209
 
4210
   done = GL_FALSE;
4211
   while (!done) {
4212
      OpCode opcode = n[0].opcode;
4213
      int i = (int)n[0].opcode - (int)OPCODE_DRV_0;
4214
 
4215
      if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) {
4216
         ctx->listext.opcode[i].execute(ctx, &n[1]);
4217
         n += ctx->listext.opcode[i].size;
4218
      }
4219
      else {
4220
         switch (opcode) {
4221
         case OPCODE_ERROR:
4222
            _mesa_error( ctx, n[1].e, (const char *) n[2].data );
4223
            break;
4224
         case OPCODE_ACCUM:
4225
            (*ctx->Exec->Accum)( n[1].e, n[2].f );
4226
            break;
4227
         case OPCODE_ALPHA_FUNC:
4228
            (*ctx->Exec->AlphaFunc)( n[1].e, n[2].f );
4229
            break;
4230
         case OPCODE_BIND_TEXTURE:
4231
            (*ctx->Exec->BindTexture)( n[1].e, n[2].ui );
4232
            break;
4233
         case OPCODE_BITMAP:
4234
            {
4235
               struct gl_pixelstore_attrib save = ctx->Unpack;
4236
               ctx->Unpack = _mesa_native_packing;
4237
               (*ctx->Exec->Bitmap)( (GLsizei) n[1].i, (GLsizei) n[2].i,
4238
                 n[3].f, n[4].f, n[5].f, n[6].f, (const GLubyte *) n[7].data );
4239
               ctx->Unpack = save;  /* restore */
4240
            }
4241
            break;
4242
         case OPCODE_BLEND_COLOR:
4243
            (*ctx->Exec->BlendColor)( n[1].f, n[2].f, n[3].f, n[4].f );
4244
            break;
4245
         case OPCODE_BLEND_EQUATION:
4246
            (*ctx->Exec->BlendEquation)( n[1].e );
4247
            break;
4248
         case OPCODE_BLEND_FUNC:
4249
            (*ctx->Exec->BlendFunc)( n[1].e, n[2].e );
4250
            break;
4251
         case OPCODE_BLEND_FUNC_SEPARATE:
4252
            (*ctx->Exec->BlendFuncSeparateEXT)(n[1].e, n[2].e, n[3].e, n[4].e);
4253
            break;
4254
         case OPCODE_CALL_LIST:
4255
            /* Generated by glCallList(), don't add ListBase */
4256
            if (ctx->CallDepth<MAX_LIST_NESTING) {
4257
               execute_list( ctx, n[1].ui );
4258
            }
4259
            break;
4260
         case OPCODE_CALL_LIST_OFFSET:
4261
            /* Generated by glCallLists() so we must add ListBase */
4262
            if (n[2].b) {
4263
               /* user specified a bad datatype at compile time */
4264
               _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
4265
            }
4266
            else if (ctx->CallDepth < MAX_LIST_NESTING) {
4267
               execute_list( ctx, ctx->List.ListBase + n[1].ui );
4268
            }
4269
            break;
4270
         case OPCODE_CLEAR:
4271
            (*ctx->Exec->Clear)( n[1].bf );
4272
            break;
4273
         case OPCODE_CLEAR_COLOR:
4274
            (*ctx->Exec->ClearColor)( n[1].f, n[2].f, n[3].f, n[4].f );
4275
            break;
4276
         case OPCODE_CLEAR_ACCUM:
4277
            (*ctx->Exec->ClearAccum)( n[1].f, n[2].f, n[3].f, n[4].f );
4278
            break;
4279
         case OPCODE_CLEAR_DEPTH:
4280
            (*ctx->Exec->ClearDepth)( (GLclampd) n[1].f );
4281
            break;
4282
         case OPCODE_CLEAR_INDEX:
4283
            (*ctx->Exec->ClearIndex)( (GLfloat) n[1].ui );
4284
            break;
4285
         case OPCODE_CLEAR_STENCIL:
4286
            (*ctx->Exec->ClearStencil)( n[1].i );
4287
            break;
4288
         case OPCODE_CLIP_PLANE:
4289
            {
4290
               GLdouble eq[4];
4291
               eq[0] = n[2].f;
4292
               eq[1] = n[3].f;
4293
               eq[2] = n[4].f;
4294
               eq[3] = n[5].f;
4295
               (*ctx->Exec->ClipPlane)( n[1].e, eq );
4296
            }
4297
            break;
4298
         case OPCODE_COLOR_MASK:
4299
            (*ctx->Exec->ColorMask)( n[1].b, n[2].b, n[3].b, n[4].b );
4300
            break;
4301
         case OPCODE_COLOR_MATERIAL:
4302
            (*ctx->Exec->ColorMaterial)( n[1].e, n[2].e );
4303
            break;
4304
         case OPCODE_COLOR_TABLE:
4305
            {
4306
               struct gl_pixelstore_attrib save = ctx->Unpack;
4307
               ctx->Unpack = _mesa_native_packing;
4308
               (*ctx->Exec->ColorTable)( n[1].e, n[2].e, n[3].i, n[4].e,
4309
                                         n[5].e, n[6].data );
4310
               ctx->Unpack = save;  /* restore */
4311
            }
4312
            break;
4313
         case OPCODE_COLOR_TABLE_PARAMETER_FV:
4314
            {
4315
               GLfloat params[4];
4316
               params[0] = n[3].f;
4317
               params[1] = n[4].f;
4318
               params[2] = n[5].f;
4319
               params[3] = n[6].f;
4320
               (*ctx->Exec->ColorTableParameterfv)( n[1].e, n[2].e, params );
4321
            }
4322
            break;
4323
         case OPCODE_COLOR_TABLE_PARAMETER_IV:
4324
            {
4325
               GLint params[4];
4326
               params[0] = n[3].i;
4327
               params[1] = n[4].i;
4328
               params[2] = n[5].i;
4329
               params[3] = n[6].i;
4330
               (*ctx->Exec->ColorTableParameteriv)( n[1].e, n[2].e, params );
4331
            }
4332
            break;
4333
         case OPCODE_COLOR_SUB_TABLE:
4334
            {
4335
               struct gl_pixelstore_attrib save = ctx->Unpack;
4336
               ctx->Unpack = _mesa_native_packing;
4337
               (*ctx->Exec->ColorSubTable)( n[1].e, n[2].i, n[3].i,
4338
                                            n[4].e, n[5].e, n[6].data );
4339
               ctx->Unpack = save;  /* restore */
4340
            }
4341
            break;
4342
         case OPCODE_CONVOLUTION_FILTER_1D:
4343
            {
4344
               struct gl_pixelstore_attrib save = ctx->Unpack;
4345
               ctx->Unpack = _mesa_native_packing;
4346
               (*ctx->Exec->ConvolutionFilter1D)( n[1].e, n[2].i, n[3].i,
4347
                                                  n[4].e, n[5].e, n[6].data );
4348
               ctx->Unpack = save;  /* restore */
4349
            }
4350
            break;
4351
         case OPCODE_CONVOLUTION_FILTER_2D:
4352
            {
4353
               struct gl_pixelstore_attrib save = ctx->Unpack;
4354
               ctx->Unpack = _mesa_native_packing;
4355
               (*ctx->Exec->ConvolutionFilter2D)( n[1].e, n[2].i, n[3].i,
4356
                                       n[4].i, n[5].e, n[6].e, n[7].data );
4357
               ctx->Unpack = save;  /* restore */
4358
            }
4359
            break;
4360
         case OPCODE_CONVOLUTION_PARAMETER_I:
4361
            (*ctx->Exec->ConvolutionParameteri)( n[1].e, n[2].e, n[3].i );
4362
            break;
4363
         case OPCODE_CONVOLUTION_PARAMETER_IV:
4364
            {
4365
               GLint params[4];
4366
               params[0] = n[3].i;
4367
               params[1] = n[4].i;
4368
               params[2] = n[5].i;
4369
               params[3] = n[6].i;
4370
               (*ctx->Exec->ConvolutionParameteriv)( n[1].e, n[2].e, params );
4371
            }
4372
            break;
4373
         case OPCODE_CONVOLUTION_PARAMETER_F:
4374
            (*ctx->Exec->ConvolutionParameterf)( n[1].e, n[2].e, n[3].f );
4375
            break;
4376
         case OPCODE_CONVOLUTION_PARAMETER_FV:
4377
            {
4378
               GLfloat params[4];
4379
               params[0] = n[3].f;
4380
               params[1] = n[4].f;
4381
               params[2] = n[5].f;
4382
               params[3] = n[6].f;
4383
               (*ctx->Exec->ConvolutionParameterfv)( n[1].e, n[2].e, params );
4384
            }
4385
            break;
4386
         case OPCODE_COPY_COLOR_SUB_TABLE:
4387
            (*ctx->Exec->CopyColorSubTable)( n[1].e, n[2].i,
4388
                                             n[3].i, n[4].i, n[5].i );
4389
            break;
4390
         case OPCODE_COPY_COLOR_TABLE:
4391
            (*ctx->Exec->CopyColorSubTable)( n[1].e, n[2].i,
4392
                                             n[3].i, n[4].i, n[5].i );
4393
            break;
4394
         case OPCODE_COPY_PIXELS:
4395
            (*ctx->Exec->CopyPixels)( n[1].i, n[2].i,
4396
                           (GLsizei) n[3].i, (GLsizei) n[4].i, n[5].e );
4397
            break;
4398
         case OPCODE_COPY_TEX_IMAGE1D:
4399
            (*ctx->Exec->CopyTexImage1D)( n[1].e, n[2].i, n[3].e, n[4].i,
4400
                                         n[5].i, n[6].i, n[7].i );
4401
            break;
4402
         case OPCODE_COPY_TEX_IMAGE2D:
4403
            (*ctx->Exec->CopyTexImage2D)( n[1].e, n[2].i, n[3].e, n[4].i,
4404
                                         n[5].i, n[6].i, n[7].i, n[8].i );
4405
            break;
4406
         case OPCODE_COPY_TEX_SUB_IMAGE1D:
4407
            (*ctx->Exec->CopyTexSubImage1D)( n[1].e, n[2].i, n[3].i,
4408
                                            n[4].i, n[5].i, n[6].i );
4409
            break;
4410
         case OPCODE_COPY_TEX_SUB_IMAGE2D:
4411
            (*ctx->Exec->CopyTexSubImage2D)( n[1].e, n[2].i, n[3].i,
4412
                                     n[4].i, n[5].i, n[6].i, n[7].i, n[8].i );
4413
            break;
4414
         case OPCODE_COPY_TEX_SUB_IMAGE3D:
4415
            (*ctx->Exec->CopyTexSubImage3D)( n[1].e, n[2].i, n[3].i,
4416
                            n[4].i, n[5].i, n[6].i, n[7].i, n[8].i , n[9].i);
4417
            break;
4418
         case OPCODE_CULL_FACE:
4419
            (*ctx->Exec->CullFace)( n[1].e );
4420
            break;
4421
         case OPCODE_DEPTH_FUNC:
4422
            (*ctx->Exec->DepthFunc)( n[1].e );
4423
            break;
4424
         case OPCODE_DEPTH_MASK:
4425
            (*ctx->Exec->DepthMask)( n[1].b );
4426
            break;
4427
         case OPCODE_DEPTH_RANGE:
4428
            (*ctx->Exec->DepthRange)( (GLclampd) n[1].f, (GLclampd) n[2].f );
4429
            break;
4430
         case OPCODE_DISABLE:
4431
            (*ctx->Exec->Disable)( n[1].e );
4432
            break;
4433
         case OPCODE_DRAW_BUFFER:
4434
            (*ctx->Exec->DrawBuffer)( n[1].e );
4435
            break;
4436
         case OPCODE_DRAW_PIXELS:
4437
            {
4438
               struct gl_pixelstore_attrib save = ctx->Unpack;
4439
               ctx->Unpack = _mesa_native_packing;
4440
               (*ctx->Exec->DrawPixels)( n[1].i, n[2].i, n[3].e, n[4].e,
4441
                                        n[5].data );
4442
               ctx->Unpack = save;  /* restore */
4443
            }
4444
            break;
4445
         case OPCODE_ENABLE:
4446
            (*ctx->Exec->Enable)( n[1].e );
4447
            break;
4448
         case OPCODE_EVALMESH1:
4449
            (*ctx->Exec->EvalMesh1)( n[1].e, n[2].i, n[3].i );
4450
            break;
4451
         case OPCODE_EVALMESH2:
4452
            (*ctx->Exec->EvalMesh2)( n[1].e, n[2].i, n[3].i, n[4].i, n[5].i );
4453
            break;
4454
         case OPCODE_FOG:
4455
            {
4456
               GLfloat p[4];
4457
               p[0] = n[2].f;
4458
               p[1] = n[3].f;
4459
               p[2] = n[4].f;
4460
               p[3] = n[5].f;
4461
               (*ctx->Exec->Fogfv)( n[1].e, p );
4462
            }
4463
            break;
4464
         case OPCODE_FRONT_FACE:
4465
            (*ctx->Exec->FrontFace)( n[1].e );
4466
            break;
4467
         case OPCODE_FRUSTUM:
4468
            (*ctx->Exec->Frustum)( n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
4469
            break;
4470
         case OPCODE_HINT:
4471
            (*ctx->Exec->Hint)( n[1].e, n[2].e );
4472
            break;
4473
         case OPCODE_HISTOGRAM:
4474
            (*ctx->Exec->Histogram)( n[1].e, n[2].i, n[3].e, n[4].b );
4475
            break;
4476
         case OPCODE_INDEX_MASK:
4477
            (*ctx->Exec->IndexMask)( n[1].ui );
4478
            break;
4479
         case OPCODE_INIT_NAMES:
4480
            (*ctx->Exec->InitNames)();
4481
            break;
4482
         case OPCODE_LIGHT:
4483
            {
4484
               GLfloat p[4];
4485
               p[0] = n[3].f;
4486
               p[1] = n[4].f;
4487
               p[2] = n[5].f;
4488
               p[3] = n[6].f;
4489
               (*ctx->Exec->Lightfv)( n[1].e, n[2].e, p );
4490
            }
4491
            break;
4492
         case OPCODE_LIGHT_MODEL:
4493
            {
4494
               GLfloat p[4];
4495
               p[0] = n[2].f;
4496
               p[1] = n[3].f;
4497
               p[2] = n[4].f;
4498
               p[3] = n[5].f;
4499
               (*ctx->Exec->LightModelfv)( n[1].e, p );
4500
            }
4501
            break;
4502
         case OPCODE_LINE_STIPPLE:
4503
            (*ctx->Exec->LineStipple)( n[1].i, n[2].us );
4504
            break;
4505
         case OPCODE_LINE_WIDTH:
4506
            (*ctx->Exec->LineWidth)( n[1].f );
4507
            break;
4508
         case OPCODE_LIST_BASE:
4509
            (*ctx->Exec->ListBase)( n[1].ui );
4510
            break;
4511
         case OPCODE_LOAD_IDENTITY:
4512
            (*ctx->Exec->LoadIdentity)();
4513
            break;
4514
         case OPCODE_LOAD_MATRIX:
4515
            if (sizeof(Node)==sizeof(GLfloat)) {
4516
               (*ctx->Exec->LoadMatrixf)( &n[1].f );
4517
            }
4518
            else {
4519
               GLfloat m[16];
4520
               GLuint i;
4521
               for (i=0;i<16;i++) {
4522
                  m[i] = n[1+i].f;
4523
               }
4524
               (*ctx->Exec->LoadMatrixf)( m );
4525
            }
4526
            break;
4527
         case OPCODE_LOAD_NAME:
4528
            (*ctx->Exec->LoadName)( n[1].ui );
4529
            break;
4530
         case OPCODE_LOGIC_OP:
4531
            (*ctx->Exec->LogicOp)( n[1].e );
4532
            break;
4533
         case OPCODE_MAP1:
4534
            {
4535
               GLenum target = n[1].e;
4536
               GLint ustride = _mesa_evaluator_components(target);
4537
               GLint uorder = n[5].i;
4538
               GLfloat u1 = n[2].f;
4539
               GLfloat u2 = n[3].f;
4540
               (*ctx->Exec->Map1f)( target, u1, u2, ustride, uorder,
4541
                                   (GLfloat *) n[6].data );
4542
            }
4543
            break;
4544
         case OPCODE_MAP2:
4545
            {
4546
               GLenum target = n[1].e;
4547
               GLfloat u1 = n[2].f;
4548
               GLfloat u2 = n[3].f;
4549
               GLfloat v1 = n[4].f;
4550
               GLfloat v2 = n[5].f;
4551
               GLint ustride = n[6].i;
4552
               GLint vstride = n[7].i;
4553
               GLint uorder = n[8].i;
4554
               GLint vorder = n[9].i;
4555
               (*ctx->Exec->Map2f)( target, u1, u2, ustride, uorder,
4556
                                   v1, v2, vstride, vorder,
4557
                                   (GLfloat *) n[10].data );
4558
            }
4559
            break;
4560
         case OPCODE_MAPGRID1:
4561
            (*ctx->Exec->MapGrid1f)( n[1].i, n[2].f, n[3].f );
4562
            break;
4563
         case OPCODE_MAPGRID2:
4564
            (*ctx->Exec->MapGrid2f)( n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);
4565
            break;
4566
         case OPCODE_MATRIX_MODE:
4567
            (*ctx->Exec->MatrixMode)( n[1].e );
4568
            break;
4569
         case OPCODE_MIN_MAX:
4570
            (*ctx->Exec->Minmax)(n[1].e, n[2].e, n[3].b);
4571
            break;
4572
         case OPCODE_MULT_MATRIX:
4573
            if (sizeof(Node)==sizeof(GLfloat)) {
4574
               (*ctx->Exec->MultMatrixf)( &n[1].f );
4575
            }
4576
            else {
4577
               GLfloat m[16];
4578
               GLuint i;
4579
               for (i=0;i<16;i++) {
4580
                  m[i] = n[1+i].f;
4581
               }
4582
               (*ctx->Exec->MultMatrixf)( m );
4583
            }
4584
            break;
4585
         case OPCODE_ORTHO:
4586
            (*ctx->Exec->Ortho)( n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
4587
            break;
4588
         case OPCODE_PASSTHROUGH:
4589
            (*ctx->Exec->PassThrough)( n[1].f );
4590
            break;
4591
         case OPCODE_PIXEL_MAP:
4592
            (*ctx->Exec->PixelMapfv)( n[1].e, n[2].i, (GLfloat *) n[3].data );
4593
            break;
4594
         case OPCODE_PIXEL_TRANSFER:
4595
            (*ctx->Exec->PixelTransferf)( n[1].e, n[2].f );
4596
            break;
4597
         case OPCODE_PIXEL_ZOOM:
4598
            (*ctx->Exec->PixelZoom)( n[1].f, n[2].f );
4599
            break;
4600
         case OPCODE_POINT_SIZE:
4601
            (*ctx->Exec->PointSize)( n[1].f );
4602
            break;
4603
         case OPCODE_POINT_PARAMETERS:
4604
            {
4605
                GLfloat params[3];
4606
                params[0] = n[2].f;
4607
                params[1] = n[3].f;
4608
                params[2] = n[4].f;
4609
                (*ctx->Exec->PointParameterfvEXT)( n[1].e, params );
4610
            }
4611
            break;
4612
         case OPCODE_POLYGON_MODE:
4613
            (*ctx->Exec->PolygonMode)( n[1].e, n[2].e );
4614
            break;
4615
         case OPCODE_POLYGON_STIPPLE:
4616
            (*ctx->Exec->PolygonStipple)( (GLubyte *) n[1].data );
4617
            break;
4618
         case OPCODE_POLYGON_OFFSET:
4619
            (*ctx->Exec->PolygonOffset)( n[1].f, n[2].f );
4620
            break;
4621
         case OPCODE_POP_ATTRIB:
4622
            (*ctx->Exec->PopAttrib)();
4623
            break;
4624
         case OPCODE_POP_MATRIX:
4625
            (*ctx->Exec->PopMatrix)();
4626
            break;
4627
         case OPCODE_POP_NAME:
4628
            (*ctx->Exec->PopName)();
4629
            break;
4630
         case OPCODE_PRIORITIZE_TEXTURE:
4631
            (*ctx->Exec->PrioritizeTextures)( 1, &n[1].ui, &n[2].f );
4632
            break;
4633
         case OPCODE_PUSH_ATTRIB:
4634
            (*ctx->Exec->PushAttrib)( n[1].bf );
4635
            break;
4636
         case OPCODE_PUSH_MATRIX:
4637
            (*ctx->Exec->PushMatrix)();
4638
            break;
4639
         case OPCODE_PUSH_NAME:
4640
            (*ctx->Exec->PushName)( n[1].ui );
4641
            break;
4642
         case OPCODE_RASTER_POS:
4643
            (*ctx->Exec->RasterPos4f)( n[1].f, n[2].f, n[3].f, n[4].f );
4644
            break;
4645
         case OPCODE_READ_BUFFER:
4646
            (*ctx->Exec->ReadBuffer)( n[1].e );
4647
            break;
4648
         case OPCODE_RESET_HISTOGRAM:
4649
            (*ctx->Exec->ResetHistogram)( n[1].e );
4650
            break;
4651
         case OPCODE_RESET_MIN_MAX:
4652
            (*ctx->Exec->ResetMinmax)( n[1].e );
4653
            break;
4654
         case OPCODE_ROTATE:
4655
            (*ctx->Exec->Rotatef)( n[1].f, n[2].f, n[3].f, n[4].f );
4656
            break;
4657
         case OPCODE_SCALE:
4658
            (*ctx->Exec->Scalef)( n[1].f, n[2].f, n[3].f );
4659
            break;
4660
         case OPCODE_SCISSOR:
4661
            (*ctx->Exec->Scissor)( n[1].i, n[2].i, n[3].i, n[4].i );
4662
            break;
4663
         case OPCODE_SHADE_MODEL:
4664
            (*ctx->Exec->ShadeModel)( n[1].e );
4665
            break;
4666
         case OPCODE_STENCIL_FUNC:
4667
            (*ctx->Exec->StencilFunc)( n[1].e, n[2].i, n[3].ui );
4668
            break;
4669
         case OPCODE_STENCIL_MASK:
4670
            (*ctx->Exec->StencilMask)( n[1].ui );
4671
            break;
4672
         case OPCODE_STENCIL_OP:
4673
            (*ctx->Exec->StencilOp)( n[1].e, n[2].e, n[3].e );
4674
            break;
4675
         case OPCODE_TEXENV:
4676
            {
4677
               GLfloat params[4];
4678
               params[0] = n[3].f;
4679
               params[1] = n[4].f;
4680
               params[2] = n[5].f;
4681
               params[3] = n[6].f;
4682
               (*ctx->Exec->TexEnvfv)( n[1].e, n[2].e, params );
4683
            }
4684
            break;
4685
         case OPCODE_TEXGEN:
4686
            {
4687
               GLfloat params[4];
4688
               params[0] = n[3].f;
4689
               params[1] = n[4].f;
4690
               params[2] = n[5].f;
4691
               params[3] = n[6].f;
4692
               (*ctx->Exec->TexGenfv)( n[1].e, n[2].e, params );
4693
            }
4694
            break;
4695
         case OPCODE_TEXPARAMETER:
4696
            {
4697
               GLfloat params[4];
4698
               params[0] = n[3].f;
4699
               params[1] = n[4].f;
4700
               params[2] = n[5].f;
4701
               params[3] = n[6].f;
4702
               (*ctx->Exec->TexParameterfv)( n[1].e, n[2].e, params );
4703
            }
4704
            break;
4705
         case OPCODE_TEX_IMAGE1D:
4706
            {
4707
               struct gl_pixelstore_attrib save = ctx->Unpack;
4708
               ctx->Unpack = _mesa_native_packing;
4709
               (*ctx->Exec->TexImage1D)(
4710
                                        n[1].e, /* target */
4711
                                        n[2].i, /* level */
4712
                                        n[3].i, /* components */
4713
                                        n[4].i, /* width */
4714
                                        n[5].e, /* border */
4715
                                        n[6].e, /* format */
4716
                                        n[7].e, /* type */
4717
                                        n[8].data );
4718
               ctx->Unpack = save;  /* restore */
4719
            }
4720
            break;
4721
         case OPCODE_TEX_IMAGE2D:
4722
            {
4723
               struct gl_pixelstore_attrib save = ctx->Unpack;
4724
               ctx->Unpack = _mesa_native_packing;
4725
               (*ctx->Exec->TexImage2D)(
4726
                                        n[1].e, /* target */
4727
                                        n[2].i, /* level */
4728
                                        n[3].i, /* components */
4729
                                        n[4].i, /* width */
4730
                                        n[5].i, /* height */
4731
                                        n[6].e, /* border */
4732
                                        n[7].e, /* format */
4733
                                        n[8].e, /* type */
4734
                                        n[9].data );
4735
               ctx->Unpack = save;  /* restore */
4736
            }
4737
            break;
4738
         case OPCODE_TEX_IMAGE3D:
4739
            {
4740
               struct gl_pixelstore_attrib save = ctx->Unpack;
4741
               ctx->Unpack = _mesa_native_packing;
4742
               (*ctx->Exec->TexImage3D)(
4743
                                        n[1].e, /* target */
4744
                                        n[2].i, /* level */
4745
                                        n[3].i, /* components */
4746
                                        n[4].i, /* width */
4747
                                        n[5].i, /* height */
4748
                                        n[6].i, /* depth  */
4749
                                        n[7].e, /* border */
4750
                                        n[8].e, /* format */
4751
                                        n[9].e, /* type */
4752
                                        n[10].data );
4753
               ctx->Unpack = save;  /* restore */
4754
            }
4755
            break;
4756
         case OPCODE_TEX_SUB_IMAGE1D:
4757
            {
4758
               struct gl_pixelstore_attrib save = ctx->Unpack;
4759
               ctx->Unpack = _mesa_native_packing;
4760
               (*ctx->Exec->TexSubImage1D)( n[1].e, n[2].i, n[3].i,
4761
                                           n[4].i, n[5].e,
4762
                                           n[6].e, n[7].data );
4763
               ctx->Unpack = save;  /* restore */
4764
            }
4765
            break;
4766
         case OPCODE_TEX_SUB_IMAGE2D:
4767
            {
4768
               struct gl_pixelstore_attrib save = ctx->Unpack;
4769
               ctx->Unpack = _mesa_native_packing;
4770
               (*ctx->Exec->TexSubImage2D)( n[1].e, n[2].i, n[3].i,
4771
                                           n[4].i, n[5].e,
4772
                                           n[6].i, n[7].e, n[8].e, n[9].data );
4773
               ctx->Unpack = save;  /* restore */
4774
            }
4775
            break;
4776
         case OPCODE_TEX_SUB_IMAGE3D:
4777
            {
4778
               struct gl_pixelstore_attrib save = ctx->Unpack;
4779
               ctx->Unpack = _mesa_native_packing;
4780
               (*ctx->Exec->TexSubImage3D)( n[1].e, n[2].i, n[3].i,
4781
                                           n[4].i, n[5].i, n[6].i, n[7].i,
4782
                                           n[8].i, n[9].e, n[10].e,
4783
                                           n[11].data );
4784
               ctx->Unpack = save;  /* restore */
4785
            }
4786
            break;
4787
         case OPCODE_TRANSLATE:
4788
            (*ctx->Exec->Translatef)( n[1].f, n[2].f, n[3].f );
4789
            break;
4790
         case OPCODE_VIEWPORT:
4791
            (*ctx->Exec->Viewport)(n[1].i, n[2].i,
4792
                                  (GLsizei) n[3].i, (GLsizei) n[4].i);
4793
            break;
4794
         case OPCODE_WINDOW_POS:
4795
            (*ctx->Exec->WindowPos4fMESA)( n[1].f, n[2].f, n[3].f, n[4].f );
4796
            break;
4797
         case OPCODE_ACTIVE_TEXTURE:  /* GL_ARB_multitexture */
4798
            (*ctx->Exec->ActiveTextureARB)( n[1].e );
4799
            break;
4800
         case OPCODE_PIXEL_TEXGEN_SGIX:  /* GL_SGIX_pixel_texture */
4801
            (*ctx->Exec->PixelTexGenSGIX)( n[1].e );
4802
            break;
4803
         case OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS:  /* GL_SGIS_pixel_texture */
4804
            (*ctx->Exec->PixelTexGenParameteriSGIS)( n[1].e, n[2].i );
4805
            break;
4806
         case OPCODE_COMPRESSED_TEX_IMAGE_1D: /* GL_ARB_texture_compression */
4807
            (*ctx->Exec->CompressedTexImage1DARB)(n[1].e, n[2].i, n[3].e,
4808
                                            n[4].i, n[5].i, n[6].i, n[7].data);
4809
            break;
4810
         case OPCODE_COMPRESSED_TEX_IMAGE_2D: /* GL_ARB_texture_compression */
4811
            (*ctx->Exec->CompressedTexImage2DARB)(n[1].e, n[2].i, n[3].e,
4812
                                    n[4].i, n[5].i, n[6].i, n[7].i, n[8].data);
4813
            break;
4814
         case OPCODE_COMPRESSED_TEX_IMAGE_3D: /* GL_ARB_texture_compression */
4815
            (*ctx->Exec->CompressedTexImage3DARB)(n[1].e, n[2].i, n[3].e,
4816
                            n[4].i, n[5].i, n[6].i, n[7].i, n[8].i, n[9].data);
4817
            break;
4818
         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D: /* GL_ARB_texture_compress */
4819
            (*ctx->Exec->CompressedTexSubImage1DARB)(n[1].e, n[2].i, n[3].i,
4820
                                            n[4].i, n[5].e, n[6].i, n[7].data);
4821
            break;
4822
         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D: /* GL_ARB_texture_compress */
4823
            (*ctx->Exec->CompressedTexSubImage2DARB)(n[1].e, n[2].i, n[3].i,
4824
                            n[4].i, n[5].i, n[6].i, n[7].e, n[8].i, n[9].data);
4825
            break;
4826
         case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D: /* GL_ARB_texture_compress */
4827
            (*ctx->Exec->CompressedTexSubImage3DARB)(n[1].e, n[2].i, n[3].i,
4828
                                        n[4].i, n[5].i, n[6].i, n[7].i, n[8].i,
4829
                                        n[9].e, n[10].i, n[11].data);
4830
            break;
4831
         case OPCODE_SAMPLE_COVERAGE: /* GL_ARB_multisample */
4832
            (*ctx->Exec->SampleCoverageARB)(n[1].f, n[2].b);
4833
            break;
4834
         case OPCODE_WINDOW_POS_ARB: /* GL_ARB_window_pos */
4835
            (*ctx->Exec->WindowPos3fMESA)( n[1].f, n[2].f, n[3].f );
4836
            break;
4837
         case OPCODE_BIND_PROGRAM_NV: /* GL_NV_vertex_program */
4838
            (*ctx->Exec->BindProgramNV)( n[1].e, n[2].ui );
4839
            break;
4840
         case OPCODE_EXECUTE_PROGRAM_NV:
4841
            {
4842
               GLfloat v[4];
4843
               v[0] = n[3].f;
4844
               v[1] = n[4].f;
4845
               v[2] = n[5].f;
4846
               v[3] = n[6].f;
4847
               (*ctx->Exec->ExecuteProgramNV)(n[1].e, n[2].ui, v);
4848
            }
4849
            break;
4850
         case OPCODE_REQUEST_PROGRAMS_RESIDENT_NV:
4851
            /*
4852
            (*ctx->Exec->RequestResidentProgramsNV)();
4853
            */
4854
            break;
4855
         case OPCODE_LOAD_PROGRAM_NV:
4856
            /*
4857
            (*ctx->Exec->LoadProgramNV)();
4858
            */
4859
            break;
4860
         case OPCODE_PROGRAM_PARAMETER4F_NV:
4861
            (*ctx->Exec->ProgramParameter4fNV)(n[1].e, n[2].ui, n[3].f,
4862
                                               n[4].f, n[5].f, n[6].f);
4863
            break;
4864
         case OPCODE_TRACK_MATRIX_NV:
4865
            (*ctx->Exec->TrackMatrixNV)(n[1].e, n[2].ui, n[3].e, n[4].e);
4866
            break;
4867
 
4868
         case OPCODE_CONTINUE:
4869
            n = (Node *) n[1].next;
4870
            break;
4871
         case OPCODE_END_OF_LIST:
4872
            done = GL_TRUE;
4873
            break;
4874
         default:
4875
            {
4876
               char msg[1000];
4877
               _mesa_sprintf(msg, "Error in execute_list: opcode=%d", (int) opcode);
4878
               _mesa_problem(ctx, msg);
4879
            }
4880
            done = GL_TRUE;
4881
         }
4882
 
4883
         /* increment n to point to next compiled command */
4884
         if (opcode!=OPCODE_CONTINUE) {
4885
            n += InstSize[opcode];
4886
         }
4887
      }
4888
   }
4889
   ctx->CallDepth--;
4890
 
4891
   if (ctx->Driver.EndCallList)
4892
      ctx->Driver.EndCallList( ctx );
4893
}
4894
 
4895
 
4896
 
4897
 
4898
 
4899
/**********************************************************************/
4900
/*                           GL functions                             */
4901
/**********************************************************************/
4902
 
4903
 
4904
 
4905
 
4906
/*
4907
 * Test if a display list number is valid.
4908
 */
4909
GLboolean
4910
_mesa_IsList( GLuint list )
4911
{
4912
   GET_CURRENT_CONTEXT(ctx);
4913
   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
4914
   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
4915
   return islist(ctx, list);
4916
}
4917
 
4918
 
4919
/*
4920
 * Delete a sequence of consecutive display lists.
4921
 */
4922
void
4923
_mesa_DeleteLists( GLuint list, GLsizei range )
4924
{
4925
   GET_CURRENT_CONTEXT(ctx);
4926
   GLuint i;
4927
   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
4928
   ASSERT_OUTSIDE_BEGIN_END(ctx);
4929
 
4930
   if (range<0) {
4931
      _mesa_error( ctx, GL_INVALID_VALUE, "glDeleteLists" );
4932
      return;
4933
   }
4934
   for (i=list;i<list+range;i++) {
4935
      _mesa_destroy_list( ctx, i );
4936
   }
4937
}
4938
 
4939
 
4940
 
4941
/*
4942
 * Return a display list number, n, such that lists n through n+range-1
4943
 * are free.
4944
 */
4945
GLuint
4946
_mesa_GenLists(GLsizei range )
4947
{
4948
   GET_CURRENT_CONTEXT(ctx);
4949
   GLuint base;
4950
   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
4951
   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
4952
 
4953
   if (range<0) {
4954
      _mesa_error( ctx, GL_INVALID_VALUE, "glGenLists" );
4955
      return 0;
4956
   }
4957
   if (range==0) {
4958
      return 0;
4959
   }
4960
 
4961
   /*
4962
    * Make this an atomic operation
4963
    */
4964
   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
4965
 
4966
   base = _mesa_HashFindFreeKeyBlock(ctx->Shared->DisplayList, range);
4967
   if (base) {
4968
      /* reserve the list IDs by with empty/dummy lists */
4969
      GLint i;
4970
      for (i=0; i<range; i++) {
4971
         _mesa_HashInsert(ctx->Shared->DisplayList, base+i, make_empty_list());
4972
      }
4973
   }
4974
 
4975
   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
4976
 
4977
   return base;
4978
}
4979
 
4980
 
4981
 
4982
/*
4983
 * Begin a new display list.
4984
 */
4985
void
4986
_mesa_NewList( GLuint list, GLenum mode )
4987
{
4988
   GET_CURRENT_CONTEXT(ctx);
4989
   FLUSH_CURRENT(ctx, 0);       /* must be called before assert */
4990
   ASSERT_OUTSIDE_BEGIN_END(ctx);
4991
 
4992
   if (MESA_VERBOSE&VERBOSE_API)
4993
      _mesa_debug(ctx, "glNewList %u %s\n", list,
4994
                  _mesa_lookup_enum_by_nr(mode));
4995
 
4996
   if (list==0) {
4997
      _mesa_error( ctx, GL_INVALID_VALUE, "glNewList" );
4998
      return;
4999
   }
5000
 
5001
   if (mode!=GL_COMPILE && mode!=GL_COMPILE_AND_EXECUTE) {
5002
      _mesa_error( ctx, GL_INVALID_ENUM, "glNewList" );
5003
      return;
5004
   }
5005
 
5006
   if (ctx->CurrentListPtr) {
5007
      /* already compiling a display list */
5008
      _mesa_error( ctx, GL_INVALID_OPERATION, "glNewList" );
5009
      return;
5010
   }
5011
 
5012
   /* Allocate new display list */
5013
   ctx->CurrentListNum = list;
5014
   ctx->CurrentBlock = (Node *) MALLOC( sizeof(Node) * BLOCK_SIZE );
5015
   ctx->CurrentListPtr = ctx->CurrentBlock;
5016
   ctx->CurrentPos = 0;
5017
   ctx->CompileFlag = GL_TRUE;
5018
   ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE);
5019
 
5020
   ctx->Driver.NewList( ctx, list, mode );
5021
 
5022
   ctx->CurrentDispatch = ctx->Save;
5023
   _glapi_set_dispatch( ctx->CurrentDispatch );
5024
}
5025
 
5026
 
5027
 
5028
/*
5029
 * End definition of current display list.  Is the current
5030
 * ASSERT_OUTSIDE_BEGIN_END strong enough to really guarentee that
5031
 * we are outside begin/end calls?
5032
 */
5033
void
5034
_mesa_EndList( void )
5035
{
5036
   GET_CURRENT_CONTEXT(ctx);
5037
   FLUSH_CURRENT(ctx, 0);       /* must be called before assert */
5038
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
5039
 
5040
   if (MESA_VERBOSE&VERBOSE_API)
5041
      _mesa_debug(ctx, "glEndList\n");
5042
 
5043
   /* Check that a list is under construction */
5044
   if (!ctx->CurrentListPtr) {
5045
      _mesa_error( ctx, GL_INVALID_OPERATION, "glEndList" );
5046
      return;
5047
   }
5048
 
5049
   (void) ALLOC_INSTRUCTION( ctx, OPCODE_END_OF_LIST, 0 );
5050
 
5051
   /* Destroy old list, if any */
5052
   _mesa_destroy_list(ctx, ctx->CurrentListNum);
5053
   /* Install the list */
5054
   _mesa_HashInsert(ctx->Shared->DisplayList, ctx->CurrentListNum, ctx->CurrentListPtr);
5055
 
5056
 
5057
   if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST)
5058
      mesa_print_display_list(ctx->CurrentListNum);
5059
 
5060
   ctx->CurrentListNum = 0;
5061
   ctx->CurrentListPtr = NULL;
5062
   ctx->ExecuteFlag = GL_TRUE;
5063
   ctx->CompileFlag = GL_FALSE;
5064
 
5065
   ctx->Driver.EndList( ctx );
5066
 
5067
   ctx->CurrentDispatch = ctx->Exec;
5068
   _glapi_set_dispatch( ctx->CurrentDispatch );
5069
}
5070
 
5071
 
5072
 
5073
void
5074
_mesa_CallList( GLuint list )
5075
{
5076
   GLboolean save_compile_flag;
5077
   GET_CURRENT_CONTEXT(ctx);
5078
   FLUSH_CURRENT(ctx, 0);
5079
   /* VERY IMPORTANT:  Save the CompileFlag status, turn it off, */
5080
   /* execute the display list, and restore the CompileFlag. */
5081
 
5082
 
5083
   if (MESA_VERBOSE & VERBOSE_API)
5084
      _mesa_debug(ctx, "_mesa_CallList %d\n", list);
5085
 
5086
/*     mesa_print_display_list( list ); */
5087
 
5088
   save_compile_flag = ctx->CompileFlag;
5089
   if (save_compile_flag) {
5090
      ctx->CompileFlag = GL_FALSE;
5091
   }
5092
 
5093
   execute_list( ctx, list );
5094
   ctx->CompileFlag = save_compile_flag;
5095
 
5096
   /* also restore API function pointers to point to "save" versions */
5097
   if (save_compile_flag) {
5098
      ctx->CurrentDispatch = ctx->Save;
5099
      _glapi_set_dispatch( ctx->CurrentDispatch );
5100
   }
5101
}
5102
 
5103
 
5104
 
5105
/*
5106
 * Execute glCallLists:  call multiple display lists.
5107
 */
5108
void
5109
_mesa_CallLists( GLsizei n, GLenum type, const GLvoid *lists )
5110
{
5111
   GET_CURRENT_CONTEXT(ctx);
5112
   GLuint list;
5113
   GLint i;
5114
   GLboolean save_compile_flag;
5115
 
5116
   if (MESA_VERBOSE & VERBOSE_API)
5117
      _mesa_debug(ctx, "_mesa_CallLists %d\n", n);
5118
 
5119
   switch (type) {
5120
      case GL_BYTE:
5121
      case GL_UNSIGNED_BYTE:
5122
      case GL_SHORT:
5123
      case GL_UNSIGNED_SHORT:
5124
      case GL_INT:
5125
      case GL_UNSIGNED_INT:
5126
      case GL_FLOAT:
5127
      case GL_2_BYTES:
5128
      case GL_3_BYTES:
5129
      case GL_4_BYTES:
5130
         /* OK */
5131
         break;
5132
      default:
5133
         _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
5134
         return;
5135
   }
5136
 
5137
   /* Save the CompileFlag status, turn it off, execute display list,
5138
    * and restore the CompileFlag.
5139
    */
5140
   save_compile_flag = ctx->CompileFlag;
5141
   ctx->CompileFlag = GL_FALSE;
5142
 
5143
   for (i=0;i<n;i++) {
5144
      list = translate_id( i, type, lists );
5145
      execute_list( ctx, ctx->List.ListBase + list );
5146
   }
5147
 
5148
   ctx->CompileFlag = save_compile_flag;
5149
 
5150
   /* also restore API function pointers to point to "save" versions */
5151
   if (save_compile_flag) {
5152
      ctx->CurrentDispatch = ctx->Save;
5153
      _glapi_set_dispatch( ctx->CurrentDispatch );
5154
   }
5155
}
5156
 
5157
 
5158
 
5159
/*
5160
 * Set the offset added to list numbers in glCallLists.
5161
 */
5162
void
5163
_mesa_ListBase( GLuint base )
5164
{
5165
   GET_CURRENT_CONTEXT(ctx);
5166
   FLUSH_VERTICES(ctx, 0);      /* must be called before assert */
5167
   ASSERT_OUTSIDE_BEGIN_END(ctx);
5168
   ctx->List.ListBase = base;
5169
}
5170
 
5171
 
5172
/* Can no longer assume ctx->Exec->Func is equal to _mesa_Func.
5173
 */
5174
static void exec_Finish( void )
5175
{
5176
   GET_CURRENT_CONTEXT(ctx);
5177
   FLUSH_VERTICES(ctx, 0);
5178
   ctx->Exec->Finish();
5179
}
5180
 
5181
static void exec_Flush( void )
5182
{
5183
   GET_CURRENT_CONTEXT(ctx);
5184
   FLUSH_VERTICES(ctx, 0);
5185
   ctx->Exec->Flush( );
5186
}
5187
 
5188
static void exec_GetBooleanv( GLenum pname, GLboolean *params )
5189
{
5190
   GET_CURRENT_CONTEXT(ctx);
5191
   FLUSH_VERTICES(ctx, 0);
5192
   ctx->Exec->GetBooleanv( pname, params );
5193
}
5194
 
5195
static void exec_GetClipPlane( GLenum plane, GLdouble *equation )
5196
{
5197
   GET_CURRENT_CONTEXT(ctx);
5198
   FLUSH_VERTICES(ctx, 0);
5199
   ctx->Exec->GetClipPlane( plane, equation );
5200
}
5201
 
5202
static void exec_GetDoublev( GLenum pname, GLdouble *params )
5203
{
5204
   GET_CURRENT_CONTEXT(ctx);
5205
   FLUSH_VERTICES(ctx, 0);
5206
   ctx->Exec->GetDoublev(  pname, params );
5207
}
5208
 
5209
static GLenum exec_GetError( void )
5210
{
5211
   GET_CURRENT_CONTEXT(ctx);
5212
   FLUSH_VERTICES(ctx, 0);
5213
   return ctx->Exec->GetError( );
5214
}
5215
 
5216
static void exec_GetFloatv( GLenum pname, GLfloat *params )
5217
{
5218
   GET_CURRENT_CONTEXT(ctx);
5219
   FLUSH_VERTICES(ctx, 0);
5220
   ctx->Exec->GetFloatv( pname, params );
5221
}
5222
 
5223
static void exec_GetIntegerv( GLenum pname, GLint *params )
5224
{
5225
   GET_CURRENT_CONTEXT(ctx);
5226
   FLUSH_VERTICES(ctx, 0);
5227
   ctx->Exec->GetIntegerv( pname, params );
5228
}
5229
 
5230
static void exec_GetLightfv( GLenum light, GLenum pname, GLfloat *params )
5231
{
5232
   GET_CURRENT_CONTEXT(ctx);
5233
   FLUSH_VERTICES(ctx, 0);
5234
   ctx->Exec->GetLightfv( light, pname, params );
5235
}
5236
 
5237
static void exec_GetLightiv( GLenum light, GLenum pname, GLint *params )
5238
{
5239
   GET_CURRENT_CONTEXT(ctx);
5240
   FLUSH_VERTICES(ctx, 0);
5241
   ctx->Exec->GetLightiv( light, pname, params );
5242
}
5243
 
5244
static void exec_GetMapdv( GLenum target, GLenum query, GLdouble *v )
5245
{
5246
   GET_CURRENT_CONTEXT(ctx);
5247
   FLUSH_VERTICES(ctx, 0);
5248
   ctx->Exec->GetMapdv( target, query, v );
5249
}
5250
 
5251
static void exec_GetMapfv( GLenum target, GLenum query, GLfloat *v )
5252
{
5253
   GET_CURRENT_CONTEXT(ctx);
5254
   FLUSH_VERTICES(ctx, 0);
5255
   ctx->Exec->GetMapfv( target, query, v );
5256
}
5257
 
5258
static void exec_GetMapiv( GLenum target, GLenum query, GLint *v )
5259
{
5260
   GET_CURRENT_CONTEXT(ctx);
5261
   FLUSH_VERTICES(ctx, 0);
5262
   ctx->Exec->GetMapiv( target, query, v );
5263
}
5264
 
5265
static void exec_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
5266
{
5267
   GET_CURRENT_CONTEXT(ctx);
5268
   FLUSH_VERTICES(ctx, 0);
5269
   ctx->Exec->GetMaterialfv( face, pname, params );
5270
}
5271
 
5272
static void exec_GetMaterialiv( GLenum face, GLenum pname, GLint *params )
5273
{
5274
   GET_CURRENT_CONTEXT(ctx);
5275
   FLUSH_VERTICES(ctx, 0);
5276
   ctx->Exec->GetMaterialiv( face, pname, params );
5277
}
5278
 
5279
static void exec_GetPixelMapfv( GLenum map, GLfloat *values )
5280
{
5281
   GET_CURRENT_CONTEXT(ctx);
5282
   FLUSH_VERTICES(ctx, 0);
5283
   ctx->Exec->GetPixelMapfv( map,  values );
5284
}
5285
 
5286
static void exec_GetPixelMapuiv( GLenum map, GLuint *values )
5287
{
5288
   GET_CURRENT_CONTEXT(ctx);
5289
   FLUSH_VERTICES(ctx, 0);
5290
   ctx->Exec->GetPixelMapuiv( map, values );
5291
}
5292
 
5293
static void exec_GetPixelMapusv( GLenum map, GLushort *values )
5294
{
5295
   GET_CURRENT_CONTEXT(ctx);
5296
   FLUSH_VERTICES(ctx, 0);
5297
   ctx->Exec->GetPixelMapusv( map, values );
5298
}
5299
 
5300
static void exec_GetPolygonStipple( GLubyte *dest )
5301
{
5302
   GET_CURRENT_CONTEXT(ctx);
5303
   FLUSH_VERTICES(ctx, 0);
5304
   ctx->Exec->GetPolygonStipple( dest );
5305
}
5306
 
5307
static const GLubyte *exec_GetString( GLenum name )
5308
{
5309
   GET_CURRENT_CONTEXT(ctx);
5310
   FLUSH_VERTICES(ctx, 0);
5311
   return ctx->Exec->GetString( name );
5312
}
5313
 
5314
static void exec_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
5315
{
5316
   GET_CURRENT_CONTEXT(ctx);
5317
   FLUSH_VERTICES(ctx, 0);
5318
   ctx->Exec->GetTexEnvfv( target, pname, params );
5319
}
5320
 
5321
static void exec_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
5322
{
5323
   GET_CURRENT_CONTEXT(ctx);
5324
   FLUSH_VERTICES(ctx, 0);
5325
   ctx->Exec->GetTexEnviv( target, pname, params );
5326
}
5327
 
5328
static void exec_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
5329
{
5330
   GET_CURRENT_CONTEXT(ctx);
5331
   FLUSH_VERTICES(ctx, 0);
5332
   ctx->Exec->GetTexGendv( coord, pname, params );
5333
}
5334
 
5335
static void exec_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
5336
{
5337
   GET_CURRENT_CONTEXT(ctx);
5338
   FLUSH_VERTICES(ctx, 0);
5339
   ctx->Exec->GetTexGenfv( coord, pname, params );
5340
}
5341
 
5342
static void exec_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
5343
{
5344
   GET_CURRENT_CONTEXT(ctx);
5345
   FLUSH_VERTICES(ctx, 0);
5346
   ctx->Exec->GetTexGeniv( coord, pname, params );
5347
}
5348
 
5349
static void exec_GetTexImage( GLenum target, GLint level, GLenum format,
5350
                   GLenum type, GLvoid *pixels )
5351
{
5352
   GET_CURRENT_CONTEXT(ctx);
5353
   FLUSH_VERTICES(ctx, 0);
5354
   ctx->Exec->GetTexImage( target, level, format, type, pixels );
5355
}
5356
 
5357
static void exec_GetTexLevelParameterfv( GLenum target, GLint level,
5358
                              GLenum pname, GLfloat *params )
5359
{
5360
   GET_CURRENT_CONTEXT(ctx);
5361
   FLUSH_VERTICES(ctx, 0);
5362
   ctx->Exec->GetTexLevelParameterfv( target, level, pname, params );
5363
}
5364
 
5365
static void exec_GetTexLevelParameteriv( GLenum target, GLint level,
5366
                              GLenum pname, GLint *params )
5367
{
5368
   GET_CURRENT_CONTEXT(ctx);
5369
   FLUSH_VERTICES(ctx, 0);
5370
   ctx->Exec->GetTexLevelParameteriv( target, level, pname, params );
5371
}
5372
 
5373
static void exec_GetTexParameterfv( GLenum target, GLenum pname,
5374
                                    GLfloat *params )
5375
{
5376
   GET_CURRENT_CONTEXT(ctx);
5377
   FLUSH_VERTICES(ctx, 0);
5378
   ctx->Exec->GetTexParameterfv( target, pname, params );
5379
}
5380
 
5381
static void exec_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
5382
{
5383
   GET_CURRENT_CONTEXT(ctx);
5384
   FLUSH_VERTICES(ctx, 0);
5385
   ctx->Exec->GetTexParameteriv( target, pname, params );
5386
}
5387
 
5388
static GLboolean exec_IsEnabled( GLenum cap )
5389
{
5390
   GET_CURRENT_CONTEXT(ctx);
5391
   FLUSH_VERTICES(ctx, 0);
5392
   return ctx->Exec->IsEnabled( cap );
5393
}
5394
 
5395
static void exec_PixelStoref( GLenum pname, GLfloat param )
5396
{
5397
   GET_CURRENT_CONTEXT(ctx);
5398
   FLUSH_VERTICES(ctx, 0);
5399
   ctx->Exec->PixelStoref( pname, param );
5400
}
5401
 
5402
static void exec_PixelStorei( GLenum pname, GLint param )
5403
{
5404
   GET_CURRENT_CONTEXT(ctx);
5405
   FLUSH_VERTICES(ctx, 0);
5406
   ctx->Exec->PixelStorei( pname, param );
5407
}
5408
 
5409
static void exec_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
5410
                  GLenum format, GLenum type, GLvoid *pixels )
5411
{
5412
   GET_CURRENT_CONTEXT(ctx);
5413
   FLUSH_VERTICES(ctx, 0);
5414
   ctx->Exec->ReadPixels( x, y, width, height, format, type, pixels );
5415
}
5416
 
5417
static GLint exec_RenderMode( GLenum mode )
5418
{
5419
   GET_CURRENT_CONTEXT(ctx);
5420
   FLUSH_VERTICES(ctx, 0);
5421
   return ctx->Exec->RenderMode( mode );
5422
}
5423
 
5424
static void exec_FeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
5425
{
5426
   GET_CURRENT_CONTEXT(ctx);
5427
   FLUSH_VERTICES(ctx, 0);
5428
   ctx->Exec->FeedbackBuffer( size, type, buffer );
5429
}
5430
 
5431
static void exec_SelectBuffer( GLsizei size, GLuint *buffer )
5432
{
5433
   GET_CURRENT_CONTEXT(ctx);
5434
   FLUSH_VERTICES(ctx, 0);
5435
   ctx->Exec->SelectBuffer( size, buffer );
5436
}
5437
 
5438
static GLboolean exec_AreTexturesResident(GLsizei n, const GLuint *texName,
5439
                                          GLboolean *residences)
5440
{
5441
   GET_CURRENT_CONTEXT(ctx);
5442
   FLUSH_VERTICES(ctx, 0);
5443
   return ctx->Exec->AreTexturesResident( n, texName, residences);
5444
}
5445
 
5446
static void exec_ColorPointer(GLint size, GLenum type, GLsizei stride,
5447
                              const GLvoid *ptr)
5448
{
5449
   GET_CURRENT_CONTEXT(ctx);
5450
   FLUSH_VERTICES(ctx, 0);
5451
   ctx->Exec->ColorPointer( size, type, stride, ptr);
5452
}
5453
 
5454
static void exec_DeleteTextures( GLsizei n, const GLuint *texName)
5455
{
5456
   GET_CURRENT_CONTEXT(ctx);
5457
   FLUSH_VERTICES(ctx, 0);
5458
   ctx->Exec->DeleteTextures( n, texName);
5459
}
5460
 
5461
static void exec_DisableClientState( GLenum cap )
5462
{
5463
   GET_CURRENT_CONTEXT(ctx);
5464
   FLUSH_VERTICES(ctx, 0);
5465
   ctx->Exec->DisableClientState( cap );
5466
}
5467
 
5468
static void exec_EdgeFlagPointer(GLsizei stride, const void *vptr)
5469
{
5470
   GET_CURRENT_CONTEXT(ctx);
5471
   FLUSH_VERTICES(ctx, 0);
5472
   ctx->Exec->EdgeFlagPointer( stride, vptr);
5473
}
5474
 
5475
static void exec_EnableClientState( GLenum cap )
5476
{
5477
   GET_CURRENT_CONTEXT(ctx);
5478
   FLUSH_VERTICES(ctx, 0);
5479
   ctx->Exec->EnableClientState( cap );
5480
}
5481
 
5482
static void exec_GenTextures( GLsizei n, GLuint *texName )
5483
{
5484
   GET_CURRENT_CONTEXT(ctx);
5485
   FLUSH_VERTICES(ctx, 0);
5486
   ctx->Exec->GenTextures( n, texName );
5487
}
5488
 
5489
static void exec_GetPointerv( GLenum pname, GLvoid **params )
5490
{
5491
   GET_CURRENT_CONTEXT(ctx);
5492
   FLUSH_VERTICES(ctx, 0);
5493
   ctx->Exec->GetPointerv( pname, params );
5494
}
5495
 
5496
static void exec_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
5497
{
5498
   GET_CURRENT_CONTEXT(ctx);
5499
   FLUSH_VERTICES(ctx, 0);
5500
   ctx->Exec->IndexPointer( type, stride, ptr);
5501
}
5502
 
5503
static void exec_InterleavedArrays(GLenum format, GLsizei stride,
5504
                                   const GLvoid *pointer)
5505
{
5506
   GET_CURRENT_CONTEXT(ctx);
5507
   FLUSH_VERTICES(ctx, 0);
5508
   ctx->Exec->InterleavedArrays( format, stride, pointer);
5509
}
5510
 
5511
static GLboolean exec_IsTexture( GLuint texture )
5512
{
5513
   GET_CURRENT_CONTEXT(ctx);
5514
   FLUSH_VERTICES(ctx, 0);
5515
   return ctx->Exec->IsTexture( texture );
5516
}
5517
 
5518
static void exec_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
5519
{
5520
   GET_CURRENT_CONTEXT(ctx);
5521
   FLUSH_VERTICES(ctx, 0);
5522
   ctx->Exec->NormalPointer( type, stride, ptr );
5523
}
5524
 
5525
static void exec_PopClientAttrib(void)
5526
{
5527
   GET_CURRENT_CONTEXT(ctx);
5528
   FLUSH_VERTICES(ctx, 0);
5529
   ctx->Exec->PopClientAttrib();
5530
}
5531
 
5532
static void exec_PushClientAttrib(GLbitfield mask)
5533
{
5534
   GET_CURRENT_CONTEXT(ctx);
5535
   FLUSH_VERTICES(ctx, 0);
5536
   ctx->Exec->PushClientAttrib( mask);
5537
}
5538
 
5539
static void exec_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
5540
                                 const GLvoid *ptr)
5541
{
5542
   GET_CURRENT_CONTEXT(ctx);
5543
   FLUSH_VERTICES(ctx, 0);
5544
   ctx->Exec->TexCoordPointer( size,  type,  stride, ptr);
5545
}
5546
 
5547
static void exec_GetCompressedTexImageARB(GLenum target, GLint level,
5548
                                          GLvoid *img)
5549
{
5550
   GET_CURRENT_CONTEXT(ctx);
5551
   FLUSH_VERTICES(ctx, 0);
5552
   ctx->Exec->GetCompressedTexImageARB( target, level, img);
5553
}
5554
 
5555
static void exec_VertexPointer(GLint size, GLenum type, GLsizei stride,
5556
                               const GLvoid *ptr)
5557
{
5558
   GET_CURRENT_CONTEXT(ctx);
5559
   FLUSH_VERTICES(ctx, 0);
5560
   ctx->Exec->VertexPointer( size, type, stride, ptr);
5561
}
5562
 
5563
static void exec_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat,
5564
                                         GLint x, GLint y, GLsizei width)
5565
{
5566
   GET_CURRENT_CONTEXT(ctx);
5567
   FLUSH_VERTICES(ctx, 0);
5568
   ctx->Exec->CopyConvolutionFilter1D( target, internalFormat, x, y, width);
5569
}
5570
 
5571
static void exec_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat,
5572
                                         GLint x, GLint y, GLsizei width,
5573
                                         GLsizei height)
5574
{
5575
   GET_CURRENT_CONTEXT(ctx);
5576
   FLUSH_VERTICES(ctx, 0);
5577
   ctx->Exec->CopyConvolutionFilter2D( target, internalFormat, x, y, width,
5578
                                       height);
5579
}
5580
 
5581
static void exec_GetColorTable( GLenum target, GLenum format,
5582
                                GLenum type, GLvoid *data )
5583
{
5584
   GET_CURRENT_CONTEXT(ctx);
5585
   FLUSH_VERTICES(ctx, 0);
5586
   ctx->Exec->GetColorTable( target, format, type, data );
5587
}
5588
 
5589
static void exec_GetColorTableParameterfv( GLenum target, GLenum pname,
5590
                                           GLfloat *params )
5591
{
5592
   GET_CURRENT_CONTEXT(ctx);
5593
   FLUSH_VERTICES(ctx, 0);
5594
   ctx->Exec->GetColorTableParameterfv( target, pname, params );
5595
}
5596
 
5597
static void exec_GetColorTableParameteriv( GLenum target, GLenum pname,
5598
                                           GLint *params )
5599
{
5600
   GET_CURRENT_CONTEXT(ctx);
5601
   FLUSH_VERTICES(ctx, 0);
5602
   ctx->Exec->GetColorTableParameteriv( target, pname, params );
5603
}
5604
 
5605
static void exec_GetConvolutionFilter(GLenum target, GLenum format, GLenum type,
5606
                                      GLvoid *image)
5607
{
5608
   GET_CURRENT_CONTEXT(ctx);
5609
   FLUSH_VERTICES(ctx, 0);
5610
   ctx->Exec->GetConvolutionFilter( target, format, type, image);
5611
}
5612
 
5613
static void exec_GetConvolutionParameterfv(GLenum target, GLenum pname,
5614
                                           GLfloat *params)
5615
{
5616
   GET_CURRENT_CONTEXT(ctx);
5617
   FLUSH_VERTICES(ctx, 0);
5618
   ctx->Exec->GetConvolutionParameterfv( target, pname, params);
5619
}
5620
 
5621
static void exec_GetConvolutionParameteriv(GLenum target, GLenum pname,
5622
                                           GLint *params)
5623
{
5624
   GET_CURRENT_CONTEXT(ctx);
5625
   FLUSH_VERTICES(ctx, 0);
5626
   ctx->Exec->GetConvolutionParameteriv( target, pname, params);
5627
}
5628
 
5629
static void exec_GetHistogram(GLenum target, GLboolean reset, GLenum format,
5630
                              GLenum type, GLvoid *values)
5631
{
5632
   GET_CURRENT_CONTEXT(ctx);
5633
   FLUSH_VERTICES(ctx, 0);
5634
   ctx->Exec->GetHistogram( target, reset, format, type, values);
5635
}
5636
 
5637
static void exec_GetHistogramParameterfv(GLenum target, GLenum pname,
5638
                                         GLfloat *params)
5639
{
5640
   GET_CURRENT_CONTEXT(ctx);
5641
   FLUSH_VERTICES(ctx, 0);
5642
   ctx->Exec->GetHistogramParameterfv( target, pname, params);
5643
}
5644
 
5645
static void exec_GetHistogramParameteriv(GLenum target, GLenum pname,
5646
                                         GLint *params)
5647
{
5648
   GET_CURRENT_CONTEXT(ctx);
5649
   FLUSH_VERTICES(ctx, 0);
5650
   ctx->Exec->GetHistogramParameteriv( target, pname, params);
5651
}
5652
 
5653
static void exec_GetMinmax(GLenum target, GLboolean reset, GLenum format,
5654
                           GLenum type, GLvoid *values)
5655
{
5656
   GET_CURRENT_CONTEXT(ctx);
5657
   FLUSH_VERTICES(ctx, 0);
5658
   ctx->Exec->GetMinmax( target, reset, format, type, values);
5659
}
5660
 
5661
static void exec_GetMinmaxParameterfv(GLenum target, GLenum pname,
5662
                                      GLfloat *params)
5663
{
5664
   GET_CURRENT_CONTEXT(ctx);
5665
   FLUSH_VERTICES(ctx, 0);
5666
   ctx->Exec->GetMinmaxParameterfv( target, pname, params);
5667
}
5668
 
5669
static void exec_GetMinmaxParameteriv(GLenum target, GLenum pname,
5670
                                      GLint *params)
5671
{
5672
   GET_CURRENT_CONTEXT(ctx);
5673
   FLUSH_VERTICES(ctx, 0);
5674
   ctx->Exec->GetMinmaxParameteriv( target, pname, params);
5675
}
5676
 
5677
static void exec_GetSeparableFilter(GLenum target, GLenum format, GLenum type,
5678
                                    GLvoid *row, GLvoid *column, GLvoid *span)
5679
{
5680
   GET_CURRENT_CONTEXT(ctx);
5681
   FLUSH_VERTICES(ctx, 0);
5682
   ctx->Exec->GetSeparableFilter( target, format, type, row, column, span);
5683
}
5684
 
5685
static void exec_SeparableFilter2D(GLenum target, GLenum internalFormat,
5686
                                   GLsizei width, GLsizei height, GLenum format,
5687
                                   GLenum type, const GLvoid *row,
5688
                                   const GLvoid *column)
5689
{
5690
   GET_CURRENT_CONTEXT(ctx);
5691
   FLUSH_VERTICES(ctx, 0);
5692
   ctx->Exec->SeparableFilter2D( target, internalFormat, width, height, format,
5693
                                 type, row, column);
5694
}
5695
 
5696
static void exec_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value)
5697
{
5698
   GET_CURRENT_CONTEXT(ctx);
5699
   FLUSH_VERTICES(ctx, 0);
5700
   ctx->Exec->GetPixelTexGenParameterivSGIS( target, value);
5701
}
5702
 
5703
static void exec_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value)
5704
{
5705
   GET_CURRENT_CONTEXT(ctx);
5706
   FLUSH_VERTICES(ctx, 0);
5707
   ctx->Exec->GetPixelTexGenParameterfvSGIS( target, value);
5708
}
5709
 
5710
static void exec_ColorPointerEXT(GLint size, GLenum type, GLsizei stride,
5711
                                 GLsizei count, const GLvoid *ptr)
5712
{
5713
   GET_CURRENT_CONTEXT(ctx);
5714
   FLUSH_VERTICES(ctx, 0);
5715
   ctx->Exec->ColorPointerEXT( size, type, stride, count, ptr);
5716
}
5717
 
5718
static void exec_EdgeFlagPointerEXT(GLsizei stride, GLsizei count,
5719
                                    const GLboolean *ptr)
5720
{
5721
   GET_CURRENT_CONTEXT(ctx);
5722
   FLUSH_VERTICES(ctx, 0);
5723
   ctx->Exec->EdgeFlagPointerEXT( stride, count, ptr);
5724
}
5725
 
5726
static void exec_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count,
5727
                      const GLvoid *ptr)
5728
{
5729
   GET_CURRENT_CONTEXT(ctx);
5730
   FLUSH_VERTICES(ctx, 0);
5731
   ctx->Exec->IndexPointerEXT( type, stride, count, ptr);
5732
}
5733
 
5734
static void exec_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
5735
                       const GLvoid *ptr)
5736
{
5737
   GET_CURRENT_CONTEXT(ctx);
5738
   FLUSH_VERTICES(ctx, 0);
5739
   ctx->Exec->NormalPointerEXT( type, stride, count, ptr);
5740
}
5741
 
5742
static void exec_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
5743
                                    GLsizei count, const GLvoid *ptr)
5744
{
5745
   GET_CURRENT_CONTEXT(ctx);
5746
   FLUSH_VERTICES(ctx, 0);
5747
   ctx->Exec->TexCoordPointerEXT( size, type, stride, count, ptr);
5748
}
5749
 
5750
static void exec_VertexPointerEXT(GLint size, GLenum type, GLsizei stride,
5751
                       GLsizei count, const GLvoid *ptr)
5752
{
5753
   GET_CURRENT_CONTEXT(ctx);
5754
   FLUSH_VERTICES(ctx, 0);
5755
   ctx->Exec->VertexPointerEXT( size, type, stride, count, ptr);
5756
}
5757
 
5758
static void exec_LockArraysEXT(GLint first, GLsizei count)
5759
{
5760
   GET_CURRENT_CONTEXT(ctx);
5761
   FLUSH_VERTICES(ctx, 0);
5762
   ctx->Exec->LockArraysEXT( first, count);
5763
}
5764
 
5765
static void exec_UnlockArraysEXT( void )
5766
{
5767
   GET_CURRENT_CONTEXT(ctx);
5768
   FLUSH_VERTICES(ctx, 0);
5769
   ctx->Exec->UnlockArraysEXT( );
5770
}
5771
 
5772
static void exec_ResizeBuffersMESA( void )
5773
{
5774
   GET_CURRENT_CONTEXT(ctx);
5775
   FLUSH_VERTICES(ctx, 0);
5776
   ctx->Exec->ResizeBuffersMESA( );
5777
}
5778
 
5779
 
5780
static void exec_ClientActiveTextureARB( GLenum target )
5781
{
5782
   GET_CURRENT_CONTEXT(ctx);
5783
   FLUSH_VERTICES(ctx, 0);
5784
   ctx->Exec->ClientActiveTextureARB(target);
5785
}
5786
 
5787
static void exec_SecondaryColorPointerEXT(GLint size, GLenum type,
5788
                               GLsizei stride, const GLvoid *ptr)
5789
{
5790
   GET_CURRENT_CONTEXT(ctx);
5791
   FLUSH_VERTICES(ctx, 0);
5792
   ctx->Exec->SecondaryColorPointerEXT( size, type, stride, ptr);
5793
}
5794
 
5795
static void exec_FogCoordPointerEXT(GLenum type, GLsizei stride,
5796
                                    const GLvoid *ptr)
5797
{
5798
   GET_CURRENT_CONTEXT(ctx);
5799
   FLUSH_VERTICES(ctx, 0);
5800
   ctx->Exec->FogCoordPointerEXT( type, stride, ptr);
5801
}
5802
 
5803
/* GL_EXT_multi_draw_arrays */
5804
static void exec_MultiDrawArraysEXT(GLenum mode, GLint *first,
5805
                                    GLsizei *count, GLsizei primcount)
5806
{
5807
   GET_CURRENT_CONTEXT(ctx);
5808
   FLUSH_VERTICES(ctx, 0);
5809
   ctx->Exec->MultiDrawArraysEXT( mode, first, count, primcount );
5810
}
5811
 
5812
/* GL_EXT_multi_draw_arrays */
5813
static void exec_MultiDrawElementsEXT(GLenum mode, const GLsizei *count,
5814
                                      GLenum type, const GLvoid **indices,
5815
                                      GLsizei primcount)
5816
{
5817
   GET_CURRENT_CONTEXT(ctx);
5818
   FLUSH_VERTICES(ctx, 0);
5819
   ctx->Exec->MultiDrawElementsEXT(mode, count, type, indices, primcount);
5820
}
5821
 
5822
 
5823
 
5824
/*
5825
 * Assign all the pointers in <table> to point to Mesa's display list
5826
 * building functions.
5827
 *
5828
 * This does not include any of the tnl functions - they are
5829
 * initialized from _mesa_init_api_defaults and from the active vtxfmt
5830
 * struct.
5831
 */
5832
void
5833
_mesa_init_dlist_table( struct _glapi_table *table, GLuint tableSize )
5834
{
5835
   _mesa_init_no_op_table(table, tableSize);
5836
 
5837
   _mesa_loopback_init_api_table( table, GL_TRUE );
5838
 
5839
   /* GL 1.0 */
5840
   table->Accum = save_Accum;
5841
   table->AlphaFunc = save_AlphaFunc;
5842
   table->Bitmap = save_Bitmap;
5843
   table->BlendFunc = save_BlendFunc;
5844
   table->CallList = _mesa_save_CallList;
5845
   table->CallLists = _mesa_save_CallLists;
5846
   table->Clear = save_Clear;
5847
   table->ClearAccum = save_ClearAccum;
5848
   table->ClearColor = save_ClearColor;
5849
   table->ClearDepth = save_ClearDepth;
5850
   table->ClearIndex = save_ClearIndex;
5851
   table->ClearStencil = save_ClearStencil;
5852
   table->ClipPlane = save_ClipPlane;
5853
   table->ColorMask = save_ColorMask;
5854
   table->ColorMaterial = save_ColorMaterial;
5855
   table->CopyPixels = save_CopyPixels;
5856
   table->CullFace = save_CullFace;
5857
   table->DeleteLists = _mesa_DeleteLists;
5858
   table->DepthFunc = save_DepthFunc;
5859
   table->DepthMask = save_DepthMask;
5860
   table->DepthRange = save_DepthRange;
5861
   table->Disable = save_Disable;
5862
   table->DrawBuffer = save_DrawBuffer;
5863
   table->DrawPixels = save_DrawPixels;
5864
   table->Enable = save_Enable;
5865
   table->EndList = _mesa_EndList;
5866
   table->EvalMesh1 = _mesa_save_EvalMesh1;
5867
   table->EvalMesh2 = _mesa_save_EvalMesh2;
5868
   table->Finish = exec_Finish;
5869
   table->Flush = exec_Flush;
5870
   table->Fogf = save_Fogf;
5871
   table->Fogfv = save_Fogfv;
5872
   table->Fogi = save_Fogi;
5873
   table->Fogiv = save_Fogiv;
5874
   table->FrontFace = save_FrontFace;
5875
   table->Frustum = save_Frustum;
5876
   table->GenLists = _mesa_GenLists;
5877
   table->GetBooleanv = exec_GetBooleanv;
5878
   table->GetClipPlane = exec_GetClipPlane;
5879
   table->GetDoublev = exec_GetDoublev;
5880
   table->GetError = exec_GetError;
5881
   table->GetFloatv = exec_GetFloatv;
5882
   table->GetIntegerv = exec_GetIntegerv;
5883
   table->GetLightfv = exec_GetLightfv;
5884
   table->GetLightiv = exec_GetLightiv;
5885
   table->GetMapdv = exec_GetMapdv;
5886
   table->GetMapfv = exec_GetMapfv;
5887
   table->GetMapiv = exec_GetMapiv;
5888
   table->GetMaterialfv = exec_GetMaterialfv;
5889
   table->GetMaterialiv = exec_GetMaterialiv;
5890
   table->GetPixelMapfv = exec_GetPixelMapfv;
5891
   table->GetPixelMapuiv = exec_GetPixelMapuiv;
5892
   table->GetPixelMapusv = exec_GetPixelMapusv;
5893
   table->GetPolygonStipple = exec_GetPolygonStipple;
5894
   table->GetString = exec_GetString;
5895
   table->GetTexEnvfv = exec_GetTexEnvfv;
5896
   table->GetTexEnviv = exec_GetTexEnviv;
5897
   table->GetTexGendv = exec_GetTexGendv;
5898
   table->GetTexGenfv = exec_GetTexGenfv;
5899
   table->GetTexGeniv = exec_GetTexGeniv;
5900
   table->GetTexImage = exec_GetTexImage;
5901
   table->GetTexLevelParameterfv = exec_GetTexLevelParameterfv;
5902
   table->GetTexLevelParameteriv = exec_GetTexLevelParameteriv;
5903
   table->GetTexParameterfv = exec_GetTexParameterfv;
5904
   table->GetTexParameteriv = exec_GetTexParameteriv;
5905
   table->Hint = save_Hint;
5906
   table->IndexMask = save_IndexMask;
5907
   table->InitNames = save_InitNames;
5908
   table->IsEnabled = exec_IsEnabled;
5909
   table->IsList = _mesa_IsList;
5910
   table->LightModelf = save_LightModelf;
5911
   table->LightModelfv = save_LightModelfv;
5912
   table->LightModeli = save_LightModeli;
5913
   table->LightModeliv = save_LightModeliv;
5914
   table->Lightf = save_Lightf;
5915
   table->Lightfv = save_Lightfv;
5916
   table->Lighti = save_Lighti;
5917
   table->Lightiv = save_Lightiv;
5918
   table->LineStipple = save_LineStipple;
5919
   table->LineWidth = save_LineWidth;
5920
   table->ListBase = save_ListBase;
5921
   table->LoadIdentity = save_LoadIdentity;
5922
   table->LoadMatrixd = save_LoadMatrixd;
5923
   table->LoadMatrixf = save_LoadMatrixf;
5924
   table->LoadName = save_LoadName;
5925
   table->LogicOp = save_LogicOp;
5926
   table->Map1d = save_Map1d;
5927
   table->Map1f = save_Map1f;
5928
   table->Map2d = save_Map2d;
5929
   table->Map2f = save_Map2f;
5930
   table->MapGrid1d = save_MapGrid1d;
5931
   table->MapGrid1f = save_MapGrid1f;
5932
   table->MapGrid2d = save_MapGrid2d;
5933
   table->MapGrid2f = save_MapGrid2f;
5934
   table->MatrixMode = save_MatrixMode;
5935
   table->MultMatrixd = save_MultMatrixd;
5936
   table->MultMatrixf = save_MultMatrixf;
5937
   table->NewList = save_NewList;
5938
   table->Ortho = save_Ortho;
5939
   table->PassThrough = save_PassThrough;
5940
   table->PixelMapfv = save_PixelMapfv;
5941
   table->PixelMapuiv = save_PixelMapuiv;
5942
   table->PixelMapusv = save_PixelMapusv;
5943
   table->PixelStoref = exec_PixelStoref;
5944
   table->PixelStorei = exec_PixelStorei;
5945
   table->PixelTransferf = save_PixelTransferf;
5946
   table->PixelTransferi = save_PixelTransferi;
5947
   table->PixelZoom = save_PixelZoom;
5948
   table->PointSize = save_PointSize;
5949
   table->PolygonMode = save_PolygonMode;
5950
   table->PolygonOffset = save_PolygonOffset;
5951
   table->PolygonStipple = save_PolygonStipple;
5952
   table->PopAttrib = save_PopAttrib;
5953
   table->PopMatrix = save_PopMatrix;
5954
   table->PopName = save_PopName;
5955
   table->PushAttrib = save_PushAttrib;
5956
   table->PushMatrix = save_PushMatrix;
5957
   table->PushName = save_PushName;
5958
   table->RasterPos2d = save_RasterPos2d;
5959
   table->RasterPos2dv = save_RasterPos2dv;
5960
   table->RasterPos2f = save_RasterPos2f;
5961
   table->RasterPos2fv = save_RasterPos2fv;
5962
   table->RasterPos2i = save_RasterPos2i;
5963
   table->RasterPos2iv = save_RasterPos2iv;
5964
   table->RasterPos2s = save_RasterPos2s;
5965
   table->RasterPos2sv = save_RasterPos2sv;
5966
   table->RasterPos3d = save_RasterPos3d;
5967
   table->RasterPos3dv = save_RasterPos3dv;
5968
   table->RasterPos3f = save_RasterPos3f;
5969
   table->RasterPos3fv = save_RasterPos3fv;
5970
   table->RasterPos3i = save_RasterPos3i;
5971
   table->RasterPos3iv = save_RasterPos3iv;
5972
   table->RasterPos3s = save_RasterPos3s;
5973
   table->RasterPos3sv = save_RasterPos3sv;
5974
   table->RasterPos4d = save_RasterPos4d;
5975
   table->RasterPos4dv = save_RasterPos4dv;
5976
   table->RasterPos4f = save_RasterPos4f;
5977
   table->RasterPos4fv = save_RasterPos4fv;
5978
   table->RasterPos4i = save_RasterPos4i;
5979
   table->RasterPos4iv = save_RasterPos4iv;
5980
   table->RasterPos4s = save_RasterPos4s;
5981
   table->RasterPos4sv = save_RasterPos4sv;
5982
   table->ReadBuffer = save_ReadBuffer;
5983
   table->ReadPixels = exec_ReadPixels;
5984
   table->RenderMode = exec_RenderMode;
5985
   table->Rotated = save_Rotated;
5986
   table->Rotatef = save_Rotatef;
5987
   table->Scaled = save_Scaled;
5988
   table->Scalef = save_Scalef;
5989
   table->Scissor = save_Scissor;
5990
   table->FeedbackBuffer = exec_FeedbackBuffer;
5991
   table->SelectBuffer = exec_SelectBuffer;
5992
   table->ShadeModel = save_ShadeModel;
5993
   table->StencilFunc = save_StencilFunc;
5994
   table->StencilMask = save_StencilMask;
5995
   table->StencilOp = save_StencilOp;
5996
   table->TexEnvf = save_TexEnvf;
5997
   table->TexEnvfv = save_TexEnvfv;
5998
   table->TexEnvi = save_TexEnvi;
5999
   table->TexEnviv = save_TexEnviv;
6000
   table->TexGend = save_TexGend;
6001
   table->TexGendv = save_TexGendv;
6002
   table->TexGenf = save_TexGenf;
6003
   table->TexGenfv = save_TexGenfv;
6004
   table->TexGeni = save_TexGeni;
6005
   table->TexGeniv = save_TexGeniv;
6006
   table->TexImage1D = save_TexImage1D;
6007
   table->TexImage2D = save_TexImage2D;
6008
   table->TexParameterf = save_TexParameterf;
6009
   table->TexParameterfv = save_TexParameterfv;
6010
   table->TexParameteri = save_TexParameteri;
6011
   table->TexParameteriv = save_TexParameteriv;
6012
   table->Translated = save_Translated;
6013
   table->Translatef = save_Translatef;
6014
   table->Viewport = save_Viewport;
6015
 
6016
   /* GL 1.1 */
6017
   table->AreTexturesResident = exec_AreTexturesResident;
6018
   table->AreTexturesResidentEXT = exec_AreTexturesResident;
6019
   table->BindTexture = save_BindTexture;
6020
   table->ColorPointer = exec_ColorPointer;
6021
   table->CopyTexImage1D = save_CopyTexImage1D;
6022
   table->CopyTexImage2D = save_CopyTexImage2D;
6023
   table->CopyTexSubImage1D = save_CopyTexSubImage1D;
6024
   table->CopyTexSubImage2D = save_CopyTexSubImage2D;
6025
   table->DeleteTextures = exec_DeleteTextures;
6026
   table->DisableClientState = exec_DisableClientState;
6027
   table->EdgeFlagPointer = exec_EdgeFlagPointer;
6028
   table->EnableClientState = exec_EnableClientState;
6029
   table->GenTextures = exec_GenTextures;
6030
   table->GenTexturesEXT = exec_GenTextures;
6031
   table->GetPointerv = exec_GetPointerv;
6032
   table->IndexPointer = exec_IndexPointer;
6033
   table->InterleavedArrays = exec_InterleavedArrays;
6034
   table->IsTexture = exec_IsTexture;
6035
   table->IsTextureEXT = exec_IsTexture;
6036
   table->NormalPointer = exec_NormalPointer;
6037
   table->PopClientAttrib = exec_PopClientAttrib;
6038
   table->PrioritizeTextures = save_PrioritizeTextures;
6039
   table->PushClientAttrib = exec_PushClientAttrib;
6040
   table->TexCoordPointer = exec_TexCoordPointer;
6041
   table->TexSubImage1D = save_TexSubImage1D;
6042
   table->TexSubImage2D = save_TexSubImage2D;
6043
   table->VertexPointer = exec_VertexPointer;
6044
 
6045
   /* GL 1.2 */
6046
   table->CopyTexSubImage3D = save_CopyTexSubImage3D;
6047
   table->TexImage3D = save_TexImage3D;
6048
   table->TexSubImage3D = save_TexSubImage3D;
6049
 
6050
   /* GL_ARB_imaging */
6051
   /* Not all are supported */
6052
   table->BlendColor = save_BlendColor;
6053
   table->BlendEquation = save_BlendEquation;
6054
   table->ColorSubTable = save_ColorSubTable;
6055
   table->ColorTable = save_ColorTable;
6056
   table->ColorTableParameterfv = save_ColorTableParameterfv;
6057
   table->ColorTableParameteriv = save_ColorTableParameteriv;
6058
   table->ConvolutionFilter1D = save_ConvolutionFilter1D;
6059
   table->ConvolutionFilter2D = save_ConvolutionFilter2D;
6060
   table->ConvolutionParameterf = save_ConvolutionParameterf;
6061
   table->ConvolutionParameterfv = save_ConvolutionParameterfv;
6062
   table->ConvolutionParameteri = save_ConvolutionParameteri;
6063
   table->ConvolutionParameteriv = save_ConvolutionParameteriv;
6064
   table->CopyColorSubTable = save_CopyColorSubTable;
6065
   table->CopyColorTable = save_CopyColorTable;
6066
   table->CopyConvolutionFilter1D = exec_CopyConvolutionFilter1D;
6067
   table->CopyConvolutionFilter2D = exec_CopyConvolutionFilter2D;
6068
   table->GetColorTable = exec_GetColorTable;
6069
   table->GetColorTableEXT = exec_GetColorTable;
6070
   table->GetColorTableParameterfv = exec_GetColorTableParameterfv;
6071
   table->GetColorTableParameterfvEXT = exec_GetColorTableParameterfv;
6072
   table->GetColorTableParameteriv = exec_GetColorTableParameteriv;
6073
   table->GetColorTableParameterivEXT = exec_GetColorTableParameteriv;
6074
   table->GetConvolutionFilter = exec_GetConvolutionFilter;
6075
   table->GetConvolutionFilterEXT = exec_GetConvolutionFilter;
6076
   table->GetConvolutionParameterfv = exec_GetConvolutionParameterfv;
6077
   table->GetConvolutionParameterfvEXT = exec_GetConvolutionParameterfv;
6078
   table->GetConvolutionParameteriv = exec_GetConvolutionParameteriv;
6079
   table->GetConvolutionParameterivEXT = exec_GetConvolutionParameteriv;
6080
   table->GetHistogram = exec_GetHistogram;
6081
   table->GetHistogramEXT = exec_GetHistogram;
6082
   table->GetHistogramParameterfv = exec_GetHistogramParameterfv;
6083
   table->GetHistogramParameterfvEXT = exec_GetHistogramParameterfv;
6084
   table->GetHistogramParameteriv = exec_GetHistogramParameteriv;
6085
   table->GetHistogramParameterivEXT = exec_GetHistogramParameteriv;
6086
   table->GetMinmax = exec_GetMinmax;
6087
   table->GetMinmaxEXT = exec_GetMinmax;
6088
   table->GetMinmaxParameterfv = exec_GetMinmaxParameterfv;
6089
   table->GetMinmaxParameterfvEXT = exec_GetMinmaxParameterfv;
6090
   table->GetMinmaxParameteriv = exec_GetMinmaxParameteriv;
6091
   table->GetMinmaxParameterivEXT = exec_GetMinmaxParameteriv;
6092
   table->GetSeparableFilter = exec_GetSeparableFilter;
6093
   table->GetSeparableFilterEXT = exec_GetSeparableFilter;
6094
   table->Histogram = save_Histogram;
6095
   table->Minmax = save_Minmax;
6096
   table->ResetHistogram = save_ResetHistogram;
6097
   table->ResetMinmax = save_ResetMinmax;
6098
   table->SeparableFilter2D = exec_SeparableFilter2D;
6099
 
6100
   /* 2. GL_EXT_blend_color */
6101
#if 0
6102
   table->BlendColorEXT = save_BlendColorEXT;
6103
#endif
6104
 
6105
   /* 3. GL_EXT_polygon_offset */
6106
   table->PolygonOffsetEXT = save_PolygonOffsetEXT;
6107
 
6108
   /* 6. GL_EXT_texture3d */
6109
#if 0
6110
   table->CopyTexSubImage3DEXT = save_CopyTexSubImage3D;
6111
   table->TexImage3DEXT = save_TexImage3DEXT;
6112
   table->TexSubImage3DEXT = save_TexSubImage3D;
6113
#endif
6114
 
6115
   /* 15. GL_SGIX_pixel_texture */
6116
   table->PixelTexGenSGIX = save_PixelTexGenSGIX;
6117
 
6118
   /* 15. GL_SGIS_pixel_texture */
6119
   table->PixelTexGenParameteriSGIS = save_PixelTexGenParameteriSGIS;
6120
   table->PixelTexGenParameterfSGIS = save_PixelTexGenParameterfSGIS;
6121
   table->PixelTexGenParameterivSGIS = save_PixelTexGenParameterivSGIS;
6122
   table->PixelTexGenParameterfvSGIS = save_PixelTexGenParameterfvSGIS;
6123
   table->GetPixelTexGenParameterivSGIS = exec_GetPixelTexGenParameterivSGIS;
6124
   table->GetPixelTexGenParameterfvSGIS = exec_GetPixelTexGenParameterfvSGIS;
6125
 
6126
   /* 30. GL_EXT_vertex_array */
6127
   table->ColorPointerEXT = exec_ColorPointerEXT;
6128
   table->EdgeFlagPointerEXT = exec_EdgeFlagPointerEXT;
6129
   table->IndexPointerEXT = exec_IndexPointerEXT;
6130
   table->NormalPointerEXT = exec_NormalPointerEXT;
6131
   table->TexCoordPointerEXT = exec_TexCoordPointerEXT;
6132
   table->VertexPointerEXT = exec_VertexPointerEXT;
6133
 
6134
   /* 37. GL_EXT_blend_minmax */
6135
#if 0
6136
   table->BlendEquationEXT = save_BlendEquationEXT;
6137
#endif
6138
 
6139
   /* 54. GL_EXT_point_parameters */
6140
   table->PointParameterfEXT = save_PointParameterfEXT;
6141
   table->PointParameterfvEXT = save_PointParameterfvEXT;
6142
 
6143
   /* 78. GL_EXT_paletted_texture */
6144
#if 0
6145
   table->ColorTableEXT = save_ColorTable;
6146
   table->ColorSubTableEXT = save_ColorSubTable;
6147
#endif
6148
   table->GetColorTableEXT = exec_GetColorTable;
6149
   table->GetColorTableParameterfvEXT = exec_GetColorTableParameterfv;
6150
   table->GetColorTableParameterivEXT = exec_GetColorTableParameteriv;
6151
 
6152
   /* 97. GL_EXT_compiled_vertex_array */
6153
   table->LockArraysEXT = exec_LockArraysEXT;
6154
   table->UnlockArraysEXT = exec_UnlockArraysEXT;
6155
 
6156
   /* 145. GL_EXT_secondary_color */
6157
   table->SecondaryColorPointerEXT = exec_SecondaryColorPointerEXT;
6158
 
6159
   /* 148. GL_EXT_multi_draw_arrays */
6160
   table->MultiDrawArraysEXT = exec_MultiDrawArraysEXT;
6161
   table->MultiDrawElementsEXT = exec_MultiDrawElementsEXT;
6162
 
6163
   /* 149. GL_EXT_fog_coord */
6164
   table->FogCoordPointerEXT = exec_FogCoordPointerEXT;
6165
 
6166
   /* 173. GL_EXT_blend_func_separate */
6167
   table->BlendFuncSeparateEXT = save_BlendFuncSeparateEXT;
6168
 
6169
   /* 196. GL_MESA_resize_buffers */
6170
   table->ResizeBuffersMESA = exec_ResizeBuffersMESA;
6171
 
6172
   /* 197. GL_MESA_window_pos */
6173
   table->WindowPos2dMESA = save_WindowPos2dMESA;
6174
   table->WindowPos2dvMESA = save_WindowPos2dvMESA;
6175
   table->WindowPos2fMESA = save_WindowPos2fMESA;
6176
   table->WindowPos2fvMESA = save_WindowPos2fvMESA;
6177
   table->WindowPos2iMESA = save_WindowPos2iMESA;
6178
   table->WindowPos2ivMESA = save_WindowPos2ivMESA;
6179
   table->WindowPos2sMESA = save_WindowPos2sMESA;
6180
   table->WindowPos2svMESA = save_WindowPos2svMESA;
6181
   table->WindowPos3dMESA = save_WindowPos3dMESA;
6182
   table->WindowPos3dvMESA = save_WindowPos3dvMESA;
6183
   table->WindowPos3fMESA = save_WindowPos3fMESA;
6184
   table->WindowPos3fvMESA = save_WindowPos3fvMESA;
6185
   table->WindowPos3iMESA = save_WindowPos3iMESA;
6186
   table->WindowPos3ivMESA = save_WindowPos3ivMESA;
6187
   table->WindowPos3sMESA = save_WindowPos3sMESA;
6188
   table->WindowPos3svMESA = save_WindowPos3svMESA;
6189
   table->WindowPos4dMESA = save_WindowPos4dMESA;
6190
   table->WindowPos4dvMESA = save_WindowPos4dvMESA;
6191
   table->WindowPos4fMESA = save_WindowPos4fMESA;
6192
   table->WindowPos4fvMESA = save_WindowPos4fvMESA;
6193
   table->WindowPos4iMESA = save_WindowPos4iMESA;
6194
   table->WindowPos4ivMESA = save_WindowPos4ivMESA;
6195
   table->WindowPos4sMESA = save_WindowPos4sMESA;
6196
   table->WindowPos4svMESA = save_WindowPos4svMESA;
6197
 
6198
#if FEATURE_NV_vertex_program
6199
   /* 233. GL_NV_vertex_program */
6200
   /* The following commands DO NOT go into display lists:
6201
    * AreProgramsResidentNV, IsProgramNV, GenProgramsNV, DeleteProgramsNV,
6202
    * VertexAttribPointerNV, GetProgram*, GetVertexAttrib*
6203
    */
6204
   table->BindProgramNV = save_BindProgramNV;
6205
   table->DeleteProgramsNV = _mesa_DeleteProgramsNV;
6206
   table->ExecuteProgramNV = save_ExecuteProgramNV;
6207
   table->GenProgramsNV = _mesa_GenProgramsNV;
6208
   table->AreProgramsResidentNV = _mesa_AreProgramsResidentNV;
6209
   table->RequestResidentProgramsNV = _mesa_RequestResidentProgramsNV;
6210
   table->GetProgramParameterfvNV = _mesa_GetProgramParameterfvNV;
6211
   table->GetProgramParameterdvNV = _mesa_GetProgramParameterdvNV;
6212
   table->GetProgramivNV = _mesa_GetProgramivNV;
6213
   table->GetProgramStringNV = _mesa_GetProgramStringNV;
6214
   table->GetTrackMatrixivNV = _mesa_GetTrackMatrixivNV;
6215
   table->GetVertexAttribdvNV = _mesa_GetVertexAttribdvNV;
6216
   table->GetVertexAttribfvNV = _mesa_GetVertexAttribfvNV;
6217
   table->GetVertexAttribivNV = _mesa_GetVertexAttribivNV;
6218
   table->GetVertexAttribPointervNV = _mesa_GetVertexAttribPointervNV;
6219
   table->IsProgramNV = _mesa_IsProgramNV;
6220
   table->LoadProgramNV = _mesa_LoadProgramNV;
6221
   table->ProgramParameter4dNV = save_ProgramParameter4dNV;
6222
   table->ProgramParameter4dvNV = save_ProgramParameter4dvNV;
6223
   table->ProgramParameter4fNV = save_ProgramParameter4fNV;
6224
   table->ProgramParameter4fvNV = save_ProgramParameter4fvNV;
6225
   table->ProgramParameters4dvNV = save_ProgramParameters4dvNV;
6226
   table->ProgramParameters4fvNV = save_ProgramParameters4fvNV;
6227
   table->TrackMatrixNV = save_TrackMatrixNV;
6228
   table->VertexAttribPointerNV = _mesa_VertexAttribPointerNV;
6229
#endif
6230
 
6231
   /* 262. GL_NV_point_sprite */
6232
   table->PointParameteriNV = save_PointParameteriNV;
6233
   table->PointParameterivNV = save_PointParameterivNV;
6234
 
6235
   /* 268. GL_EXT_stencil_two_side */
6236
   table->ActiveStencilFaceEXT = save_ActiveStencilFaceEXT;
6237
 
6238
   /* ARB 1. GL_ARB_multitexture */
6239
   table->ActiveTextureARB = save_ActiveTextureARB;
6240
   table->ClientActiveTextureARB = exec_ClientActiveTextureARB;
6241
 
6242
   /* ARB 3. GL_ARB_transpose_matrix */
6243
   table->LoadTransposeMatrixdARB = save_LoadTransposeMatrixdARB;
6244
   table->LoadTransposeMatrixfARB = save_LoadTransposeMatrixfARB;
6245
   table->MultTransposeMatrixdARB = save_MultTransposeMatrixdARB;
6246
   table->MultTransposeMatrixfARB = save_MultTransposeMatrixfARB;
6247
 
6248
   /* ARB 5. GL_ARB_multisample */
6249
   table->SampleCoverageARB = save_SampleCoverageARB;
6250
 
6251
   /* ARB 12. GL_ARB_texture_compression */
6252
   table->CompressedTexImage3DARB = save_CompressedTexImage3DARB;
6253
   table->CompressedTexImage2DARB = save_CompressedTexImage2DARB;
6254
   table->CompressedTexImage1DARB = save_CompressedTexImage1DARB;
6255
   table->CompressedTexSubImage3DARB = save_CompressedTexSubImage3DARB;
6256
   table->CompressedTexSubImage2DARB = save_CompressedTexSubImage2DARB;
6257
   table->CompressedTexSubImage1DARB = save_CompressedTexSubImage1DARB;
6258
   table->GetCompressedTexImageARB = exec_GetCompressedTexImageARB;
6259
 
6260
   /* ARB 14. GL_ARB_point_parameters */
6261
   /* re-use EXT_point_parameters functions */
6262
 
6263
   /* ARB 25. GL_ARB_window_pos */
6264
   /* re-use MESA_window_pos functions */
6265
}
6266
 
6267
 
6268
 
6269
/***
6270
 *** Debugging code
6271
 ***/
6272
static const char *enum_string( GLenum k )
6273
{
6274
   return _mesa_lookup_enum_by_nr( k );
6275
}
6276
 
6277
 
6278
/*
6279
 * Print the commands in a display list.  For debugging only.
6280
 * TODO: many commands aren't handled yet.
6281
 */
6282
static void print_list( GLcontext *ctx, GLuint list )
6283
{
6284
   Node *n;
6285
   GLboolean done;
6286
 
6287
   if (!glIsList(list)) {
6288
      _mesa_printf("%u is not a display list ID\n", list);
6289
      return;
6290
   }
6291
 
6292
   n = (Node *) _mesa_HashLookup(ctx->Shared->DisplayList, list);
6293
 
6294
   _mesa_printf("START-LIST %u, address %p\n", list, (void*)n );
6295
 
6296
   done = n ? GL_FALSE : GL_TRUE;
6297
   while (!done) {
6298
      OpCode opcode = n[0].opcode;
6299
      GLint i = (GLint) n[0].opcode - (GLint) OPCODE_DRV_0;
6300
 
6301
      if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) {
6302
         ctx->listext.opcode[i].print(ctx, &n[1]);
6303
         n += ctx->listext.opcode[i].size;
6304
      }
6305
      else {
6306
         switch (opcode) {
6307
         case OPCODE_ACCUM:
6308
            _mesa_printf("accum %s %g\n", enum_string(n[1].e), n[2].f );
6309
            break;
6310
         case OPCODE_BITMAP:
6311
            _mesa_printf("Bitmap %d %d %g %g %g %g %p\n", n[1].i, n[2].i,
6312
                       n[3].f, n[4].f, n[5].f, n[6].f, (void *) n[7].data );
6313
            break;
6314
         case OPCODE_CALL_LIST:
6315
            _mesa_printf("CallList %d\n", (int) n[1].ui );
6316
            break;
6317
         case OPCODE_CALL_LIST_OFFSET:
6318
            _mesa_printf("CallList %d + offset %u = %u\n", (int) n[1].ui,
6319
                    ctx->List.ListBase, ctx->List.ListBase + n[1].ui );
6320
            break;
6321
         case OPCODE_COLOR_TABLE_PARAMETER_FV:
6322
            _mesa_printf("ColorTableParameterfv %s %s %f %f %f %f\n",
6323
                    enum_string(n[1].e), enum_string(n[2].e),
6324
                    n[3].f, n[4].f, n[5].f, n[6].f);
6325
            break;
6326
         case OPCODE_COLOR_TABLE_PARAMETER_IV:
6327
            _mesa_printf("ColorTableParameteriv %s %s %d %d %d %d\n",
6328
                    enum_string(n[1].e), enum_string(n[2].e),
6329
                    n[3].i, n[4].i, n[5].i, n[6].i);
6330
            break;
6331
         case OPCODE_DISABLE:
6332
            _mesa_printf("Disable %s\n", enum_string(n[1].e));
6333
            break;
6334
         case OPCODE_ENABLE:
6335
            _mesa_printf("Enable %s\n", enum_string(n[1].e));
6336
            break;
6337
         case OPCODE_FRUSTUM:
6338
            _mesa_printf("Frustum %g %g %g %g %g %g\n",
6339
                    n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
6340
            break;
6341
         case OPCODE_LINE_STIPPLE:
6342
            _mesa_printf("LineStipple %d %x\n", n[1].i, (int) n[2].us );
6343
            break;
6344
         case OPCODE_LOAD_IDENTITY:
6345
            _mesa_printf("LoadIdentity\n");
6346
            break;
6347
         case OPCODE_LOAD_MATRIX:
6348
            _mesa_printf("LoadMatrix\n");
6349
            _mesa_printf("  %8f %8f %8f %8f\n",
6350
                         n[1].f, n[5].f,  n[9].f, n[13].f);
6351
            _mesa_printf("  %8f %8f %8f %8f\n",
6352
                         n[2].f, n[6].f, n[10].f, n[14].f);
6353
            _mesa_printf("  %8f %8f %8f %8f\n",
6354
                         n[3].f, n[7].f, n[11].f, n[15].f);
6355
            _mesa_printf("  %8f %8f %8f %8f\n",
6356
                         n[4].f, n[8].f, n[12].f, n[16].f);
6357
            break;
6358
         case OPCODE_MULT_MATRIX:
6359
            _mesa_printf("MultMatrix (or Rotate)\n");
6360
            _mesa_printf("  %8f %8f %8f %8f\n",
6361
                         n[1].f, n[5].f,  n[9].f, n[13].f);
6362
            _mesa_printf("  %8f %8f %8f %8f\n",
6363
                         n[2].f, n[6].f, n[10].f, n[14].f);
6364
            _mesa_printf("  %8f %8f %8f %8f\n",
6365
                         n[3].f, n[7].f, n[11].f, n[15].f);
6366
            _mesa_printf("  %8f %8f %8f %8f\n",
6367
                         n[4].f, n[8].f, n[12].f, n[16].f);
6368
            break;
6369
         case OPCODE_ORTHO:
6370
            _mesa_printf("Ortho %g %g %g %g %g %g\n",
6371
                    n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
6372
            break;
6373
         case OPCODE_POP_ATTRIB:
6374
            _mesa_printf("PopAttrib\n");
6375
            break;
6376
         case OPCODE_POP_MATRIX:
6377
            _mesa_printf("PopMatrix\n");
6378
            break;
6379
         case OPCODE_POP_NAME:
6380
            _mesa_printf("PopName\n");
6381
            break;
6382
         case OPCODE_PUSH_ATTRIB:
6383
            _mesa_printf("PushAttrib %x\n", n[1].bf );
6384
            break;
6385
         case OPCODE_PUSH_MATRIX:
6386
            _mesa_printf("PushMatrix\n");
6387
            break;
6388
         case OPCODE_PUSH_NAME:
6389
            _mesa_printf("PushName %d\n", (int) n[1].ui );
6390
            break;
6391
         case OPCODE_RASTER_POS:
6392
            _mesa_printf("RasterPos %g %g %g %g\n",
6393
                         n[1].f, n[2].f,n[3].f,n[4].f);
6394
            break;
6395
         case OPCODE_ROTATE:
6396
            _mesa_printf("Rotate %g %g %g %g\n",
6397
                         n[1].f, n[2].f, n[3].f, n[4].f );
6398
            break;
6399
         case OPCODE_SCALE:
6400
            _mesa_printf("Scale %g %g %g\n", n[1].f, n[2].f, n[3].f );
6401
            break;
6402
         case OPCODE_TRANSLATE:
6403
            _mesa_printf("Translate %g %g %g\n", n[1].f, n[2].f, n[3].f );
6404
            break;
6405
         case OPCODE_BIND_TEXTURE:
6406
            _mesa_printf("BindTexture %s %d\n",
6407
                         _mesa_lookup_enum_by_nr(n[1].ui), n[2].ui);
6408
            break;
6409
         case OPCODE_SHADE_MODEL:
6410
            _mesa_printf("ShadeModel %s\n",
6411
                         _mesa_lookup_enum_by_nr(n[1].ui));
6412
            break;
6413
         case OPCODE_MAP1:
6414
            _mesa_printf("Map1 %s %.3f %.3f %d %d\n",
6415
                    _mesa_lookup_enum_by_nr(n[1].ui),
6416
                    n[2].f, n[3].f, n[4].i, n[5].i);
6417
            break;
6418
         case OPCODE_MAP2:
6419
            _mesa_printf("Map2 %s %.3f %.3f %.3f %.3f %d %d %d %d\n",
6420
                         _mesa_lookup_enum_by_nr(n[1].ui),
6421
                         n[2].f, n[3].f, n[4].f, n[5].f,
6422
                         n[6].i, n[7].i, n[8].i, n[9].i);
6423
            break;
6424
         case OPCODE_MAPGRID1:
6425
            _mesa_printf("MapGrid1 %d %.3f %.3f\n",
6426
                         n[1].i, n[2].f, n[3].f);
6427
            break;
6428
         case OPCODE_MAPGRID2:
6429
            _mesa_printf("MapGrid2 %d %.3f %.3f, %d %.3f %.3f\n",
6430
                         n[1].i, n[2].f, n[3].f,
6431
                         n[4].i, n[5].f, n[6].f);
6432
            break;
6433
         case OPCODE_EVALMESH1:
6434
            _mesa_printf("EvalMesh1 %d %d\n", n[1].i, n[2].i);
6435
            break;
6436
         case OPCODE_EVALMESH2:
6437
            _mesa_printf("EvalMesh2 %d %d %d %d\n",
6438
                         n[1].i, n[2].i, n[3].i, n[4].i);
6439
            break;
6440
 
6441
         /*
6442
          * meta opcodes/commands
6443
          */
6444
         case OPCODE_ERROR:
6445
            _mesa_printf("Error: %s %s\n",
6446
                         enum_string(n[1].e), (const char *)n[2].data );
6447
            break;
6448
         case OPCODE_CONTINUE:
6449
            _mesa_printf("DISPLAY-LIST-CONTINUE\n");
6450
            n = (Node *) n[1].next;
6451
            break;
6452
         case OPCODE_END_OF_LIST:
6453
            _mesa_printf("END-LIST %u\n", list);
6454
            done = GL_TRUE;
6455
            break;
6456
         default:
6457
            if (opcode < 0 || opcode > OPCODE_END_OF_LIST) {
6458
               _mesa_printf("ERROR IN DISPLAY LIST: opcode = %d, address = %p\n",
6459
                            opcode, (void*) n);
6460
               return;
6461
            }
6462
            else {
6463
               _mesa_printf("command %d, %u operands\n", opcode, InstSize[opcode]);
6464
            }
6465
         }
6466
         /* increment n to point to next compiled command */
6467
         if (opcode!=OPCODE_CONTINUE) {
6468
            n += InstSize[opcode];
6469
         }
6470
      }
6471
   }
6472
}
6473
 
6474
 
6475
 
6476
/*
6477
 * Clients may call this function to help debug display list problems.
6478
 * This function is _ONLY_FOR_DEBUGGING_PURPOSES_.  It may be removed,
6479
 * changed, or break in the future without notice.
6480
 */
6481
void mesa_print_display_list( GLuint list )
6482
{
6483
   GET_CURRENT_CONTEXT(ctx);
6484
   print_list( ctx, list );
6485
}