home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / System / Mesa-3.1 / src / dlist.c < prev    next >
C/C++ Source or Header  |  2000-01-07  |  96KB  |  3,632 lines
  1. /* $Id: dlist.c,v 1.15 1999/11/09 17:00:25 keithw Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.1
  6.  * 
  7.  * Copyright (C) 1999  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.  
  28. /* $XFree86: xc/lib/GL/mesa/src/dlist.c,v 1.3 1999/04/04 00:20:22 dawes Exp $ */
  29.  
  30. #ifdef PC_HEADER
  31. #include "all.h"
  32. #else
  33. #ifndef XFree86Server
  34. #include <assert.h>
  35. #include <stdio.h>
  36. #include <stdlib.h>
  37. #include <string.h>
  38. #else
  39. #include "GL/xf86glx.h"
  40. #endif
  41. #include "accum.h"
  42. #include "api.h"
  43. #include "alpha.h"
  44. #include "attrib.h"
  45. #include "bitmap.h"
  46. #include "bbox.h"
  47. #include "blend.h"
  48. #include "clip.h"
  49. #include "colortab.h"
  50. #include "context.h"
  51. #include "copypix.h"
  52. #include "depth.h"
  53. #include "drawpix.h"
  54. #include "enable.h"
  55. #include "enums.h"
  56. #include "eval.h"
  57. #include "extensions.h"
  58. #include "feedback.h"
  59. #include "fog.h"
  60. #include "get.h"
  61. #include "glmisc.h"
  62. #include "hash.h"
  63. #include "image.h"
  64. #include "light.h"
  65. #include "lines.h"
  66. #include "dlist.h"
  67. #include "logic.h"
  68. #include "macros.h"
  69. #include "masking.h"
  70. #include "matrix.h"
  71. #include "pipeline.h"
  72. #include "pixel.h"
  73. #include "points.h"
  74. #include "polygon.h"
  75. #include "rastpos.h"
  76. #include "readpix.h"
  77. #include "rect.h"
  78. #include "scissor.h"
  79. #include "stencil.h"
  80. #include "texobj.h"
  81. #include "teximage.h"
  82. #include "texstate.h"
  83. #include "types.h"
  84. #include "varray.h"
  85. #include "vb.h"
  86. #include "vbfill.h"
  87. #include "vbxform.h"
  88. #include "winpos.h"
  89. #include "xform.h"
  90. #endif
  91.  
  92.  
  93.  
  94. /*
  95. Functions which aren't compiled but executed immediately:
  96.     glIsList
  97.     glGenLists
  98.     glDeleteLists
  99.     glEndList
  100.     glFeedbackBuffer
  101.     glSelectBuffer
  102.     glRenderMode
  103.     glReadPixels
  104.     glPixelStore
  105.     glFlush
  106.     glFinish
  107.     glIsEnabled
  108.     glGet*
  109.  
  110. Functions which cause errors if called while compiling a display list:
  111.     glNewList
  112. */
  113.  
  114.  
  115.  
  116. /*
  117.  * Display list instructions are stored as sequences of "nodes".  Nodes
  118.  * are allocated in blocks.  Each block has BLOCK_SIZE nodes.  Blocks
  119.  * are linked together with a pointer.
  120.  */
  121.  
  122.  
  123. /* How many nodes to allocate at a time: 
  124.  * - reduced now that we hold vertices etc. elsewhere.
  125.  */
  126. #define BLOCK_SIZE 64
  127.  
  128.  
  129. /*
  130.  * Display list opcodes.
  131.  *
  132.  * The fact that these identifiers are assigned consecutive
  133.  * integer values starting at 0 is very important, see InstSize array usage)
  134.  *
  135.  * KW: Commented out opcodes now handled by vertex-cassettes.
  136.  */
  137. typedef enum {
  138.     OPCODE_ACCUM,
  139.     OPCODE_ALPHA_FUNC,
  140.         OPCODE_BIND_TEXTURE,
  141.     OPCODE_BITMAP,
  142.     OPCODE_BLEND_COLOR,
  143.     OPCODE_BLEND_EQUATION,
  144.     OPCODE_BLEND_FUNC,
  145.     OPCODE_BLEND_FUNC_SEPARATE,
  146.         OPCODE_CALL_LIST,
  147.         OPCODE_CALL_LIST_OFFSET,
  148.     OPCODE_CLEAR,
  149.     OPCODE_CLEAR_ACCUM,
  150.     OPCODE_CLEAR_COLOR,
  151.     OPCODE_CLEAR_DEPTH,
  152.     OPCODE_CLEAR_INDEX,
  153.     OPCODE_CLEAR_STENCIL,
  154.         OPCODE_CLIP_PLANE,
  155.     OPCODE_COLOR_MASK,
  156.     OPCODE_COLOR_MATERIAL,
  157.     OPCODE_COLOR_TABLE,
  158.     OPCODE_COLOR_SUB_TABLE,
  159.     OPCODE_COPY_PIXELS,
  160.         OPCODE_COPY_TEX_IMAGE1D,
  161.         OPCODE_COPY_TEX_IMAGE2D,
  162.         OPCODE_COPY_TEX_IMAGE3D,
  163.         OPCODE_COPY_TEX_SUB_IMAGE1D,
  164.         OPCODE_COPY_TEX_SUB_IMAGE2D,
  165.         OPCODE_COPY_TEX_SUB_IMAGE3D,
  166.     OPCODE_CULL_FACE,
  167.     OPCODE_DEPTH_FUNC,
  168.     OPCODE_DEPTH_MASK,
  169.     OPCODE_DEPTH_RANGE,
  170.     OPCODE_DISABLE,
  171.     OPCODE_DRAW_BUFFER,
  172.     OPCODE_DRAW_PIXELS,
  173.     OPCODE_ENABLE,
  174.     OPCODE_EVALCOORD1,
  175.     OPCODE_EVALCOORD2,
  176.     OPCODE_EVALMESH1,
  177.     OPCODE_EVALMESH2,
  178.     OPCODE_EVALPOINT1,
  179.     OPCODE_EVALPOINT2,
  180.     OPCODE_FOG,
  181.     OPCODE_FRONT_FACE,
  182.     OPCODE_FRUSTUM,
  183.     OPCODE_HINT,
  184.     OPCODE_INDEX_MASK,
  185.     OPCODE_INIT_NAMES,
  186.     OPCODE_LIGHT,
  187.     OPCODE_LIGHT_MODEL,
  188.     OPCODE_LINE_STIPPLE,
  189.     OPCODE_LINE_WIDTH,
  190.     OPCODE_LIST_BASE,
  191.     OPCODE_LOAD_IDENTITY,
  192.     OPCODE_LOAD_MATRIX,
  193.     OPCODE_LOAD_NAME,
  194.     OPCODE_LOGIC_OP,
  195.     OPCODE_MAP1,
  196.     OPCODE_MAP2,
  197.     OPCODE_MAPGRID1,
  198.     OPCODE_MAPGRID2,
  199.     OPCODE_MATRIX_MODE,
  200.     OPCODE_MULT_MATRIX,
  201.     OPCODE_ORTHO,
  202.     OPCODE_PASSTHROUGH,
  203.     OPCODE_PIXEL_MAP,
  204.     OPCODE_PIXEL_TRANSFER,
  205.     OPCODE_PIXEL_ZOOM,
  206.     OPCODE_POINT_SIZE,
  207.         OPCODE_POINT_PARAMETERS,
  208.     OPCODE_POLYGON_MODE,
  209.         OPCODE_POLYGON_STIPPLE,
  210.     OPCODE_POLYGON_OFFSET,
  211.     OPCODE_POP_ATTRIB,
  212.     OPCODE_POP_MATRIX,
  213.     OPCODE_POP_NAME,
  214.     OPCODE_PRIORITIZE_TEXTURE,
  215.     OPCODE_PUSH_ATTRIB,
  216.     OPCODE_PUSH_MATRIX,
  217.     OPCODE_PUSH_NAME,
  218.     OPCODE_RASTER_POS,
  219.     OPCODE_RECTF,
  220.     OPCODE_READ_BUFFER,
  221.         OPCODE_SCALE,
  222.     OPCODE_SCISSOR,
  223.     OPCODE_SELECT_TEXTURE_SGIS,
  224.     OPCODE_SELECT_TEXTURE_COORD_SET,
  225.     OPCODE_SHADE_MODEL,
  226.     OPCODE_STENCIL_FUNC,
  227.     OPCODE_STENCIL_MASK,
  228.     OPCODE_STENCIL_OP,
  229.         OPCODE_TEXENV,
  230.         OPCODE_TEXGEN,
  231.         OPCODE_TEXPARAMETER,
  232.     OPCODE_TEX_IMAGE1D,
  233.     OPCODE_TEX_IMAGE2D,
  234.     OPCODE_TEX_IMAGE3D,
  235.     OPCODE_TEX_SUB_IMAGE1D,
  236.     OPCODE_TEX_SUB_IMAGE2D,
  237.     OPCODE_TEX_SUB_IMAGE3D,
  238.         OPCODE_TRANSLATE,
  239.     OPCODE_VIEWPORT,
  240.     OPCODE_WINDOW_POS,
  241.         /* GL_ARB_multitexture */
  242.         OPCODE_ACTIVE_TEXTURE,
  243.         OPCODE_CLIENT_ACTIVE_TEXTURE,
  244.     /* The following three are meta instructions */
  245.     OPCODE_ERROR,            /* raise compiled-in error */
  246.     OPCODE_VERTEX_CASSETTE,    /* render prebuilt vertex buffer */
  247.     OPCODE_CONTINUE,
  248.     OPCODE_END_OF_LIST
  249. } OpCode;
  250.  
  251.  
  252. /*
  253.  * Each instruction in the display list is stored as a sequence of
  254.  * contiguous nodes in memory.
  255.  * Each node is the union of a variety of datatypes.
  256.  */
  257. union node {
  258.     OpCode        opcode;
  259.     GLboolean    b;
  260.     GLbitfield    bf;
  261.     GLubyte        ub;
  262.     GLshort        s;
  263.     GLushort    us;
  264.     GLint        i;
  265.     GLuint        ui;
  266.     GLenum        e;
  267.     GLfloat        f;
  268.     GLvoid        *data;
  269.     void        *next;    /* If prev node's opcode==OPCODE_CONTINUE */
  270. };
  271.  
  272.  
  273.  
  274. /* Number of nodes of storage needed for each instruction: */
  275. static GLuint InstSize[ OPCODE_END_OF_LIST+1 ];
  276.  
  277. void mesa_print_display_list( GLuint list );
  278.  
  279.  
  280. /**********************************************************************/
  281. /*****                           Private                          *****/
  282. /**********************************************************************/
  283.  
  284.  
  285. /*
  286.  * Allocate space for a display list instruction.
  287.  * Input:  opcode - type of instruction
  288.  *         argcount - number of arguments following the instruction
  289.  * Return: pointer to first node in the instruction
  290.  */
  291. static Node *alloc_instruction( GLcontext *ctx, OpCode opcode, GLint argcount )
  292. {
  293.    Node *n, *newblock;
  294.    GLuint count = InstSize[opcode];
  295.  
  296.    assert( (GLint) count == argcount+1 );
  297.  
  298.    if (ctx->CurrentPos + count + 2 > BLOCK_SIZE) {
  299.       /* This block is full.  Allocate a new block and chain to it */
  300.       n = ctx->CurrentBlock + ctx->CurrentPos;
  301.       n[0].opcode = OPCODE_CONTINUE;
  302.       newblock = (Node *) MALLOC( sizeof(Node) * BLOCK_SIZE );
  303.       if (!newblock) {
  304.          gl_error( ctx, GL_OUT_OF_MEMORY, "Building display list" );
  305.          return NULL;
  306.       }
  307.       n[1].next = (Node *) newblock;
  308.       ctx->CurrentBlock = newblock;
  309.       ctx->CurrentPos = 0;
  310.    }
  311.  
  312.    n = ctx->CurrentBlock + ctx->CurrentPos;
  313.    ctx->CurrentPos += count;
  314.  
  315.    n[0].opcode = opcode;
  316.  
  317.    return n;
  318. }
  319.  
  320.  
  321.  
  322. /*
  323.  * Make an empty display list.  This is used by glGenLists() to
  324.  * reserver display list IDs.
  325.  */
  326. static Node *make_empty_list( void )
  327. {
  328.    Node *n = (Node *) MALLOC( sizeof(Node) );
  329.    n[0].opcode = OPCODE_END_OF_LIST;
  330.    return n;
  331. }
  332.  
  333.  
  334.  
  335. /*
  336.  * Destroy all nodes in a display list.
  337.  * Input:  list - display list number
  338.  */
  339. void gl_destroy_list( GLcontext *ctx, GLuint list )
  340. {
  341.    Node *n, *block;
  342.    GLboolean done;
  343.  
  344.    if (list==0)
  345.       return;
  346.  
  347.    block = (Node *) HashLookup(ctx->Shared->DisplayList, list);
  348.    n = block;
  349.  
  350.    done = block ? GL_FALSE : GL_TRUE;
  351.    while (!done) {
  352.       switch (n[0].opcode) {
  353.      /* special cases first */
  354.          case OPCODE_VERTEX_CASSETTE: 
  355.         if ( ! -- ((struct immediate *) n[1].data)->ref_count )
  356.            gl_immediate_free( (struct immediate *) n[1].data );
  357.         n += InstSize[n[0].opcode];
  358.         break;
  359.      case OPCODE_MAP1:
  360.         gl_free_control_points( ctx, n[1].e, (GLfloat *) n[6].data );
  361.         n += InstSize[n[0].opcode];
  362.         break;
  363.      case OPCODE_MAP2:
  364.         gl_free_control_points( ctx, n[1].e, (GLfloat *) n[10].data );
  365.         n += InstSize[n[0].opcode];
  366.         break;
  367.      case OPCODE_DRAW_PIXELS:
  368.         gl_free_image( (struct gl_image *) n[1].data );
  369.         n += InstSize[n[0].opcode];
  370.         break;
  371.      case OPCODE_BITMAP:
  372.         gl_free_image( (struct gl_image *) n[7].data );
  373.         n += InstSize[n[0].opcode];
  374.         break;
  375.          case OPCODE_COLOR_TABLE:
  376.             gl_free_image( (struct gl_image *) n[3].data );
  377.             n += InstSize[n[0].opcode];
  378.             break;
  379.          case OPCODE_COLOR_SUB_TABLE:
  380.             gl_free_image( (struct gl_image *) n[3].data );
  381.             n += InstSize[n[0].opcode];
  382.             break;
  383.          case OPCODE_POLYGON_STIPPLE:
  384.             FREE( n[1].data );
  385.         n += InstSize[n[0].opcode];
  386.             break;
  387.      case OPCODE_TEX_IMAGE1D:
  388.             FREE( n[8]. data );
  389.             n += InstSize[n[0].opcode];
  390.         break;
  391.      case OPCODE_TEX_IMAGE2D:
  392.             FREE( n[9].data );
  393.             n += InstSize[n[0].opcode];
  394.         break;
  395.      case OPCODE_TEX_IMAGE3D:
  396.             FREE( n[10].data );
  397.             n += InstSize[n[0].opcode];
  398.         break;
  399.          case OPCODE_TEX_SUB_IMAGE1D:
  400.             FREE( n[7].data );
  401.             n += InstSize[n[0].opcode];
  402.             break;
  403.          case OPCODE_TEX_SUB_IMAGE2D:
  404.             FREE( n[9].data );
  405.             n += InstSize[n[0].opcode];
  406.             break;
  407.          case OPCODE_TEX_SUB_IMAGE3D:
  408.             FREE( n[11].data );
  409.             n += InstSize[n[0].opcode];
  410.             break;
  411.      case OPCODE_CONTINUE:
  412.         n = (Node *) n[1].next;
  413.         FREE( block );
  414.         block = n;
  415.         break;
  416.      case OPCODE_END_OF_LIST:
  417.         FREE( block );
  418.         done = GL_TRUE;
  419.         break;
  420.      default:
  421.         /* Most frequent case */
  422.         n += InstSize[n[0].opcode];
  423.         break;
  424.       }
  425.    }
  426.  
  427.    HashRemove(ctx->Shared->DisplayList, list);
  428. }
  429.  
  430.  
  431.  
  432. /*
  433.  * Translate the nth element of list from type to GLuint.
  434.  */
  435. static GLuint translate_id( GLsizei n, GLenum type, const GLvoid *list )
  436. {
  437.    GLbyte *bptr;
  438.    GLubyte *ubptr;
  439.    GLshort *sptr;
  440.    GLushort *usptr;
  441.    GLint *iptr;
  442.    GLuint *uiptr;
  443.    GLfloat *fptr;
  444.  
  445.    switch (type) {
  446.       case GL_BYTE:
  447.          bptr = (GLbyte *) list;
  448.          return (GLuint) *(bptr+n);
  449.       case GL_UNSIGNED_BYTE:
  450.          ubptr = (GLubyte *) list;
  451.          return (GLuint) *(ubptr+n);
  452.       case GL_SHORT:
  453.          sptr = (GLshort *) list;
  454.          return (GLuint) *(sptr+n);
  455.       case GL_UNSIGNED_SHORT:
  456.          usptr = (GLushort *) list;
  457.          return (GLuint) *(usptr+n);
  458.       case GL_INT:
  459.          iptr = (GLint *) list;
  460.          return (GLuint) *(iptr+n);
  461.       case GL_UNSIGNED_INT:
  462.          uiptr = (GLuint *) list;
  463.          return (GLuint) *(uiptr+n);
  464.       case GL_FLOAT:
  465.          fptr = (GLfloat *) list;
  466.          return (GLuint) *(fptr+n);
  467.       case GL_2_BYTES:
  468.          ubptr = ((GLubyte *) list) + 2*n;
  469.          return (GLuint) *ubptr * 256 + (GLuint) *(ubptr+1);
  470.       case GL_3_BYTES:
  471.          ubptr = ((GLubyte *) list) + 3*n;
  472.          return (GLuint) *ubptr * 65536
  473.               + (GLuint) *(ubptr+1) * 256
  474.               + (GLuint) *(ubptr+2);
  475.       case GL_4_BYTES:
  476.          ubptr = ((GLubyte *) list) + 4*n;
  477.          return (GLuint) *ubptr * 16777216
  478.               + (GLuint) *(ubptr+1) * 65536
  479.               + (GLuint) *(ubptr+2) * 256
  480.               + (GLuint) *(ubptr+3);
  481.       default:
  482.          return 0;
  483.    }
  484. }
  485.  
  486.  
  487.  
  488.  
  489. /**********************************************************************/
  490. /*****                        Public                              *****/
  491. /**********************************************************************/
  492.  
  493. void gl_init_lists( void )
  494. {
  495.    static int init_flag = 0;
  496.  
  497.    if (init_flag==0) {
  498.       InstSize[OPCODE_ACCUM] = 3;
  499.       InstSize[OPCODE_ALPHA_FUNC] = 3;
  500.       InstSize[OPCODE_BIND_TEXTURE] = 3;
  501.       InstSize[OPCODE_BITMAP] = 8;
  502.       InstSize[OPCODE_BLEND_COLOR] = 5;
  503.       InstSize[OPCODE_BLEND_EQUATION] = 2;
  504.       InstSize[OPCODE_BLEND_FUNC] = 3;
  505.       InstSize[OPCODE_BLEND_FUNC_SEPARATE] = 5;
  506.       InstSize[OPCODE_CALL_LIST] = 2;
  507.       InstSize[OPCODE_CALL_LIST_OFFSET] = 2;
  508.       InstSize[OPCODE_CLEAR] = 2;
  509.       InstSize[OPCODE_CLEAR_ACCUM] = 5;
  510.       InstSize[OPCODE_CLEAR_COLOR] = 5;
  511.       InstSize[OPCODE_CLEAR_DEPTH] = 2;
  512.       InstSize[OPCODE_CLEAR_INDEX] = 2;
  513.       InstSize[OPCODE_CLEAR_STENCIL] = 2;
  514.       InstSize[OPCODE_CLIP_PLANE] = 6;
  515.       InstSize[OPCODE_COLOR_MASK] = 5;
  516.       InstSize[OPCODE_COLOR_MATERIAL] = 3;
  517.       InstSize[OPCODE_COLOR_TABLE] = 4;
  518.       InstSize[OPCODE_COLOR_SUB_TABLE] = 4;
  519.       InstSize[OPCODE_COPY_PIXELS] = 6;
  520.       InstSize[OPCODE_COPY_TEX_IMAGE1D] = 8;
  521.       InstSize[OPCODE_COPY_TEX_IMAGE2D] = 9;
  522.       InstSize[OPCODE_COPY_TEX_SUB_IMAGE1D] = 7;
  523.       InstSize[OPCODE_COPY_TEX_SUB_IMAGE2D] = 9;
  524.       InstSize[OPCODE_COPY_TEX_SUB_IMAGE3D] = 10;
  525.       InstSize[OPCODE_CULL_FACE] = 2;
  526.       InstSize[OPCODE_DEPTH_FUNC] = 2;
  527.       InstSize[OPCODE_DEPTH_MASK] = 2;
  528.       InstSize[OPCODE_DEPTH_RANGE] = 3;
  529.       InstSize[OPCODE_DISABLE] = 2;
  530.       InstSize[OPCODE_DRAW_BUFFER] = 2;
  531.       InstSize[OPCODE_DRAW_PIXELS] = 2;
  532.       InstSize[OPCODE_ENABLE] = 2;
  533.       InstSize[OPCODE_EVALCOORD1] = 2;
  534.       InstSize[OPCODE_EVALCOORD2] = 3;
  535.       InstSize[OPCODE_EVALMESH1] = 4;
  536.       InstSize[OPCODE_EVALMESH2] = 6;
  537.       InstSize[OPCODE_EVALPOINT1] = 2;
  538.       InstSize[OPCODE_EVALPOINT2] = 3;
  539.       InstSize[OPCODE_FOG] = 6;
  540.       InstSize[OPCODE_FRONT_FACE] = 2;
  541.       InstSize[OPCODE_FRUSTUM] = 7;
  542.       InstSize[OPCODE_HINT] = 3;
  543.       InstSize[OPCODE_INDEX_MASK] = 2;
  544.       InstSize[OPCODE_INIT_NAMES] = 1;
  545.       InstSize[OPCODE_LIGHT] = 7;
  546.       InstSize[OPCODE_LIGHT_MODEL] = 6;
  547.       InstSize[OPCODE_LINE_STIPPLE] = 3;
  548.       InstSize[OPCODE_LINE_WIDTH] = 2;
  549.       InstSize[OPCODE_LIST_BASE] = 2;
  550.       InstSize[OPCODE_LOAD_IDENTITY] = 1;
  551.       InstSize[OPCODE_LOAD_MATRIX] = 17;
  552.       InstSize[OPCODE_LOAD_NAME] = 2;
  553.       InstSize[OPCODE_LOGIC_OP] = 2;
  554.       InstSize[OPCODE_MAP1] = 7;
  555.       InstSize[OPCODE_MAP2] = 11;
  556.       InstSize[OPCODE_MAPGRID1] = 4;
  557.       InstSize[OPCODE_MAPGRID2] = 7;
  558.       InstSize[OPCODE_MATRIX_MODE] = 2;
  559.       InstSize[OPCODE_MULT_MATRIX] = 17;
  560.       InstSize[OPCODE_ORTHO] = 7;
  561.       InstSize[OPCODE_PASSTHROUGH] = 2;
  562.       InstSize[OPCODE_PIXEL_MAP] = 4;
  563.       InstSize[OPCODE_PIXEL_TRANSFER] = 3;
  564.       InstSize[OPCODE_PIXEL_ZOOM] = 3;
  565.       InstSize[OPCODE_POINT_SIZE] = 2;
  566.       InstSize[OPCODE_POINT_PARAMETERS] = 5;
  567.       InstSize[OPCODE_POLYGON_MODE] = 3;
  568.       InstSize[OPCODE_POLYGON_STIPPLE] = 2;
  569.       InstSize[OPCODE_POLYGON_OFFSET] = 3;
  570.       InstSize[OPCODE_POP_ATTRIB] = 1;
  571.       InstSize[OPCODE_POP_MATRIX] = 1;
  572.       InstSize[OPCODE_POP_NAME] = 1;
  573.       InstSize[OPCODE_PRIORITIZE_TEXTURE] = 3;
  574.       InstSize[OPCODE_PUSH_ATTRIB] = 2;
  575.       InstSize[OPCODE_PUSH_MATRIX] = 1;
  576.       InstSize[OPCODE_PUSH_NAME] = 2;
  577.       InstSize[OPCODE_RASTER_POS] = 5;
  578.       InstSize[OPCODE_RECTF] = 5;
  579.       InstSize[OPCODE_READ_BUFFER] = 2;
  580.       InstSize[OPCODE_SCALE] = 4;
  581.       InstSize[OPCODE_SCISSOR] = 5;
  582.       InstSize[OPCODE_STENCIL_FUNC] = 4;
  583.       InstSize[OPCODE_STENCIL_MASK] = 2;
  584.       InstSize[OPCODE_STENCIL_OP] = 4;
  585.       InstSize[OPCODE_SHADE_MODEL] = 2;
  586.       InstSize[OPCODE_TEXENV] = 7;
  587.       InstSize[OPCODE_TEXGEN] = 7;
  588.       InstSize[OPCODE_TEXPARAMETER] = 7;
  589.       InstSize[OPCODE_TEX_IMAGE1D] = 9;
  590.       InstSize[OPCODE_TEX_IMAGE2D] = 10;
  591.       InstSize[OPCODE_TEX_IMAGE3D] = 11;
  592.       InstSize[OPCODE_TEX_SUB_IMAGE1D] = 8;
  593.       InstSize[OPCODE_TEX_SUB_IMAGE2D] = 10;
  594.       InstSize[OPCODE_TEX_SUB_IMAGE3D] = 12;
  595.       InstSize[OPCODE_TRANSLATE] = 4;
  596.       InstSize[OPCODE_VIEWPORT] = 5;
  597.       InstSize[OPCODE_WINDOW_POS] = 5;
  598.       InstSize[OPCODE_CONTINUE] = 2;
  599.       InstSize[OPCODE_ERROR] = 3;
  600.       InstSize[OPCODE_VERTEX_CASSETTE] = 9;
  601.       InstSize[OPCODE_END_OF_LIST] = 1;
  602.       /* GL_ARB_multitexture */
  603.       InstSize[OPCODE_ACTIVE_TEXTURE] = 2;
  604.       InstSize[OPCODE_CLIENT_ACTIVE_TEXTURE] = 2;
  605.    }
  606.    init_flag = 1;
  607. }
  608.  
  609.  
  610. /*
  611.  * Display List compilation functions
  612.  */
  613.  
  614.  
  615.  
  616. static void save_Accum( GLcontext *ctx, GLenum op, GLfloat value )
  617. {
  618.    Node *n;
  619.    FLUSH_VB(ctx, "dlist");
  620.    n = alloc_instruction( ctx, OPCODE_ACCUM, 2 );
  621.    if (n) {
  622.       n[1].e = op;
  623.       n[2].f = value;
  624.    }
  625.    if (ctx->ExecuteFlag) {
  626.       (*ctx->Exec.Accum)( ctx, op, value );
  627.    }
  628. }
  629.  
  630.  
  631. static void save_AlphaFunc( GLcontext *ctx, GLenum func, GLclampf ref )
  632. {
  633.    Node *n;
  634.    FLUSH_VB(ctx, "dlist");
  635.    n = alloc_instruction( ctx, OPCODE_ALPHA_FUNC, 2 );
  636.    if (n) {
  637.       n[1].e = func;
  638.       n[2].f = (GLfloat) ref;
  639.    }
  640.    if (ctx->ExecuteFlag) {
  641.       (*ctx->Exec.AlphaFunc)( ctx, func, ref );
  642.    }
  643. }
  644.  
  645. static void save_BindTexture( GLcontext *ctx, GLenum target, GLuint texture )
  646. {
  647.    Node *n;
  648.    FLUSH_VB(ctx, "dlist");
  649.    n = alloc_instruction( ctx, OPCODE_BIND_TEXTURE, 2 );
  650.    if (n) {
  651.       n[1].e = target;
  652.       n[2].ui = texture;
  653.    }
  654.    if (ctx->ExecuteFlag) {
  655.       (*ctx->Exec.BindTexture)( ctx, target, texture );
  656.    }
  657. }
  658.  
  659.  
  660. static void save_Bitmap( GLcontext *ctx,
  661.                          GLsizei width, GLsizei height,
  662.                          GLfloat xorig, GLfloat yorig,
  663.                          GLfloat xmove, GLfloat ymove,
  664.                          const GLubyte *bitmap,
  665.                          const struct gl_pixelstore_attrib *packing )
  666. {
  667.    Node *n;
  668.    FLUSH_VB(ctx, "dlist");
  669.    n = alloc_instruction( ctx, OPCODE_BITMAP, 7 );
  670.    if (n) {
  671.       struct gl_image *image = gl_unpack_bitmap( ctx, width, height,
  672.                                                  bitmap, packing );
  673.       if (image) {
  674.          image->RefCount = 1;
  675.       }
  676.       n[1].i = (GLint) width;
  677.       n[2].i = (GLint) height;
  678.       n[3].f = xorig;
  679.       n[4].f = yorig;
  680.       n[5].f = xmove;
  681.       n[6].f = ymove;
  682.       n[7].data = (void *) image;
  683.    }
  684.    if (ctx->ExecuteFlag) {
  685.       (*ctx->Exec.Bitmap)( ctx, width, height,
  686.                            xorig, yorig, xmove, ymove, bitmap, packing );
  687.    }
  688. }
  689.  
  690.  
  691. static void save_BlendEquation( GLcontext *ctx, GLenum mode )
  692. {
  693.    Node *n;
  694.    FLUSH_VB(ctx, "dlist");
  695.    n = alloc_instruction( ctx, OPCODE_BLEND_EQUATION, 1 );
  696.    if (n) {
  697.       n[1].e = mode;
  698.    }
  699.    if (ctx->ExecuteFlag) {
  700.       (*ctx->Exec.BlendEquation)( ctx, mode );
  701.    }
  702. }
  703.  
  704.  
  705. static void save_BlendFunc( GLcontext *ctx, GLenum sfactor, GLenum dfactor )
  706. {
  707.    Node *n;
  708.    FLUSH_VB(ctx, "dlist");
  709.    n = alloc_instruction( ctx, OPCODE_BLEND_FUNC, 2 );
  710.    if (n) {
  711.       n[1].e = sfactor;
  712.       n[2].e = dfactor;
  713.    }
  714.    if (ctx->ExecuteFlag) {
  715.       (*ctx->Exec.BlendFunc)( ctx, sfactor, dfactor );
  716.    }
  717. }
  718.  
  719.  
  720. static void save_BlendFuncSeparate( GLcontext *ctx,
  721.                                 GLenum sfactorRGB, GLenum dfactorRGB,
  722.                                 GLenum sfactorA, GLenum dfactorA)
  723. {
  724.    Node *n;
  725.    FLUSH_VB(ctx, "dlist");
  726.    n = alloc_instruction( ctx, OPCODE_BLEND_FUNC_SEPARATE, 4 );
  727.    if (n) {
  728.       n[1].e = sfactorRGB;
  729.       n[2].e = dfactorRGB;
  730.       n[3].e = sfactorA;
  731.       n[4].e = dfactorA;
  732.    }
  733.    if (ctx->ExecuteFlag) {
  734.       (*ctx->Exec.BlendFuncSeparate)( ctx, sfactorRGB, dfactorRGB,
  735.                                       sfactorA, dfactorA);
  736.    }
  737. }
  738.  
  739.  
  740. static void save_BlendColor( GLcontext *ctx, GLfloat red, GLfloat green,
  741.                          GLfloat blue, GLfloat alpha )
  742. {
  743.    Node *n;
  744.    FLUSH_VB(ctx, "dlist");
  745.    n = alloc_instruction( ctx, OPCODE_BLEND_COLOR, 4 );
  746.    if (n) {
  747.       n[1].f = red;
  748.       n[2].f = green;
  749.       n[3].f = blue;
  750.       n[4].f = alpha;
  751.    }
  752.    if (ctx->ExecuteFlag) {
  753.       (*ctx->Exec.BlendColor)( ctx, red, green, blue, alpha );
  754.    }
  755. }
  756.  
  757.  
  758. static void save_CallList( GLcontext *ctx, GLuint list )
  759. {
  760.    Node *n;
  761.    FLUSH_VB(ctx, "dlist");
  762.    n = alloc_instruction( ctx, OPCODE_CALL_LIST, 1 );
  763.    if (n) {
  764.       n[1].ui = list;
  765.    }
  766.    if (ctx->ExecuteFlag) {
  767.       (*ctx->Exec.CallList)( ctx, list );
  768.    }
  769. }
  770.  
  771.  
  772. static void save_CallLists( GLcontext *ctx,
  773.                         GLsizei n, GLenum type, const GLvoid *lists )
  774. {
  775.    GLint i;
  776.    FLUSH_VB(ctx, "dlist");
  777.  
  778.    for (i=0;i<n;i++) {
  779.       GLuint list = translate_id( i, type, lists );
  780.       Node *n = alloc_instruction( ctx, OPCODE_CALL_LIST_OFFSET, 1 );
  781.       if (n) {
  782.          n[1].ui = list;
  783.       }
  784.    }
  785.    if (ctx->ExecuteFlag) {
  786.       (*ctx->Exec.CallLists)( ctx, n, type, lists );
  787.    }
  788. }
  789.  
  790.  
  791. static void save_Clear( GLcontext *ctx, GLbitfield mask )
  792. {
  793.    Node *n;
  794.    FLUSH_VB(ctx, "dlist");
  795.    n = alloc_instruction( ctx, OPCODE_CLEAR, 1 );
  796.    if (n) {
  797.       n[1].bf = mask;
  798.    }
  799.    if (ctx->ExecuteFlag) {
  800.       (*ctx->Exec.Clear)( ctx, mask );
  801.    }
  802. }
  803.  
  804.  
  805. static void save_ClearAccum( GLcontext *ctx, GLfloat red, GLfloat green,
  806.              GLfloat blue, GLfloat alpha )
  807. {
  808.    Node *n;
  809.    FLUSH_VB(ctx, "dlist");
  810.    n = alloc_instruction( ctx, OPCODE_CLEAR_ACCUM, 4 );
  811.    if (n) {
  812.       n[1].f = red;
  813.       n[2].f = green;
  814.       n[3].f = blue;
  815.       n[4].f = alpha;
  816.    }
  817.    if (ctx->ExecuteFlag) {
  818.       (*ctx->Exec.ClearAccum)( ctx, red, green, blue, alpha );
  819.    }
  820. }
  821.  
  822.  
  823. static void save_ClearColor( GLcontext *ctx, GLclampf red, GLclampf green,
  824.              GLclampf blue, GLclampf alpha )
  825. {
  826.    Node *n;
  827.    FLUSH_VB(ctx, "dlist");
  828.    n = alloc_instruction( ctx, OPCODE_CLEAR_COLOR, 4 );
  829.    if (n) {
  830.       n[1].f = red;
  831.       n[2].f = green;
  832.       n[3].f = blue;
  833.       n[4].f = alpha;
  834.    }
  835.    if (ctx->ExecuteFlag) {
  836.       (*ctx->Exec.ClearColor)( ctx, red, green, blue, alpha );
  837.    }
  838. }
  839.  
  840.  
  841. static void save_ClearDepth( GLcontext *ctx, GLclampd depth )
  842. {
  843.    Node *n;
  844.    FLUSH_VB(ctx, "dlist");
  845.    n = alloc_instruction( ctx, OPCODE_CLEAR_DEPTH, 1 );
  846.    if (n) {
  847.       n[1].f = (GLfloat) depth;
  848.    }
  849.    if (ctx->ExecuteFlag) {
  850.       (*ctx->Exec.ClearDepth)( ctx, depth );
  851.    }
  852. }
  853.  
  854.  
  855. static void save_ClearIndex( GLcontext *ctx, GLfloat c )
  856. {
  857.    Node *n;
  858.    FLUSH_VB(ctx, "dlist");
  859.    n = alloc_instruction( ctx, OPCODE_CLEAR_INDEX, 1 );
  860.    if (n) {
  861.       n[1].f = c;
  862.    }
  863.    if (ctx->ExecuteFlag) {
  864.       (*ctx->Exec.ClearIndex)( ctx, c );
  865.    }
  866. }
  867.  
  868.  
  869. static void save_ClearStencil( GLcontext *ctx, GLint s )
  870. {
  871.    Node *n;
  872.    FLUSH_VB(ctx, "dlist");
  873.    n = alloc_instruction( ctx, OPCODE_CLEAR_STENCIL, 1 );
  874.    if (n) {
  875.       n[1].i = s;
  876.    }
  877.    if (ctx->ExecuteFlag) {
  878.       (*ctx->Exec.ClearStencil)( ctx, s );
  879.    }
  880. }
  881.  
  882.  
  883. static void save_ClipPlane( GLcontext *ctx, GLenum plane, const GLfloat *equ )
  884. {
  885.    Node *n;
  886.    FLUSH_VB(ctx, "dlist");
  887.    n = alloc_instruction( ctx, OPCODE_CLIP_PLANE, 5 );
  888.    if (n) {
  889.       n[1].e = plane;
  890.       n[2].f = equ[0];
  891.       n[3].f = equ[1];
  892.       n[4].f = equ[2];
  893.       n[5].f = equ[3];
  894.    }
  895.    if (ctx->ExecuteFlag) {
  896.       (*ctx->Exec.ClipPlane)( ctx, plane, equ );
  897.    }
  898. }
  899.  
  900.  
  901.  
  902. static void save_ColorMask( GLcontext *ctx, GLboolean red, GLboolean green,
  903.                         GLboolean blue, GLboolean alpha )
  904. {
  905.    Node *n;
  906.    FLUSH_VB(ctx, "dlist");
  907.    n = alloc_instruction( ctx, OPCODE_COLOR_MASK, 4 );
  908.    if (n) {
  909.       n[1].b = red;
  910.       n[2].b = green;
  911.       n[3].b = blue;
  912.       n[4].b = alpha;
  913.    }
  914.    if (ctx->ExecuteFlag) {
  915.       (*ctx->Exec.ColorMask)( ctx, red, green, blue, alpha );
  916.    }
  917. }
  918.  
  919.  
  920. static void save_ColorMaterial( GLcontext *ctx, GLenum face, GLenum mode )
  921. {
  922.    Node *n;
  923.    FLUSH_VB(ctx, "dlist");
  924.    n = alloc_instruction( ctx, OPCODE_COLOR_MATERIAL, 2 );
  925.    if (n) {
  926.       n[1].e = face;
  927.       n[2].e = mode;
  928.    }
  929.    if (ctx->ExecuteFlag) {
  930.       (*ctx->Exec.ColorMaterial)( ctx, face, mode );
  931.    }
  932. }
  933.  
  934.  
  935. static void save_ColorTable( GLcontext *ctx, GLenum target, GLenum internalFormat,
  936.                          struct gl_image *table )
  937. {
  938.    Node *n;
  939.    FLUSH_VB(ctx, "dlist");
  940.    n = alloc_instruction( ctx, OPCODE_COLOR_TABLE, 3 );
  941.    if (n) {
  942.       n[1].e = target;
  943.       n[2].e = internalFormat;
  944.       n[3].data = (GLvoid *) table;
  945.       if (table) {
  946.          /* must retain this image */
  947.          table->RefCount = 1;
  948.       }
  949.    }
  950.    if (ctx->ExecuteFlag) {
  951.       (*ctx->Exec.ColorTable)( ctx, target, internalFormat, table );
  952.    }
  953. }
  954.  
  955.  
  956. static void save_ColorSubTable( GLcontext *ctx, GLenum target,
  957.                             GLsizei start, struct gl_image *data )
  958. {
  959.    Node *n;
  960.    FLUSH_VB(ctx, "dlist");
  961.    n = alloc_instruction( ctx, OPCODE_COLOR_SUB_TABLE, 3 );
  962.    if (n) {
  963.       n[1].e = target;
  964.       n[2].i = start;
  965.       n[3].data = (GLvoid *) data;
  966.       if (data) {
  967.          /* must retain this image */
  968.          data->RefCount = 1;
  969.       }
  970.    }
  971.    if (ctx->ExecuteFlag) {
  972.       (*ctx->Exec.ColorSubTable)( ctx, target, start, data );
  973.    }
  974. }
  975.  
  976.  
  977.  
  978. static void save_CopyPixels( GLcontext *ctx, GLint x, GLint y,
  979.              GLsizei width, GLsizei height, GLenum type )
  980. {
  981.    Node *n;
  982.    FLUSH_VB(ctx, "dlist");
  983.    n = alloc_instruction( ctx, OPCODE_COPY_PIXELS, 5 );
  984.    if (n) {
  985.       n[1].i = x;
  986.       n[2].i = y;
  987.       n[3].i = (GLint) width;
  988.       n[4].i = (GLint) height;
  989.       n[5].e = type;
  990.    }
  991.    if (ctx->ExecuteFlag) {
  992.       (*ctx->Exec.CopyPixels)( ctx, x, y, width, height, type );
  993.    }
  994. }
  995.  
  996.  
  997.  
  998. static void save_CopyTexImage1D( GLcontext *ctx,
  999.                              GLenum target, GLint level,
  1000.                              GLenum internalformat,
  1001.                              GLint x, GLint y, GLsizei width,
  1002.                              GLint border )
  1003. {
  1004.    Node *n;
  1005.    FLUSH_VB(ctx, "dlist");
  1006.    n = alloc_instruction( ctx, OPCODE_COPY_TEX_IMAGE1D, 7 );
  1007.    if (n) {
  1008.       n[1].e = target;
  1009.       n[2].i = level;
  1010.       n[3].e = internalformat;
  1011.       n[4].i = x;
  1012.       n[5].i = y;
  1013.       n[6].i = width;
  1014.       n[7].i = border;
  1015.    }
  1016.    if (ctx->ExecuteFlag) {
  1017.       (*ctx->Exec.CopyTexImage1D)( ctx, target, level, internalformat,
  1018.                             x, y, width, border );
  1019.    }
  1020. }
  1021.  
  1022.  
  1023. static void save_CopyTexImage2D( GLcontext *ctx,
  1024.                              GLenum target, GLint level,
  1025.                              GLenum internalformat,
  1026.                              GLint x, GLint y, GLsizei width,
  1027.                              GLsizei height, GLint border )
  1028. {
  1029.    Node *n;
  1030.    FLUSH_VB(ctx, "dlist");
  1031.    n = alloc_instruction( ctx, OPCODE_COPY_TEX_IMAGE2D, 8 );
  1032.    if (n) {
  1033.       n[1].e = target;
  1034.       n[2].i = level;
  1035.       n[3].e = internalformat;
  1036.       n[4].i = x;
  1037.       n[5].i = y;
  1038.       n[6].i = width;
  1039.       n[7].i = height;
  1040.       n[8].i = border;
  1041.    }
  1042.    if (ctx->ExecuteFlag) {
  1043.       (*ctx->Exec.CopyTexImage2D)( ctx, target, level, internalformat,
  1044.                             x, y, width, height, border );
  1045.    }
  1046. }
  1047.  
  1048.  
  1049.  
  1050. static void save_CopyTexSubImage1D( GLcontext *ctx,
  1051.                                 GLenum target, GLint level,
  1052.                                 GLint xoffset, GLint x, GLint y,
  1053.                                 GLsizei width )
  1054. {
  1055.    Node *n;
  1056.    FLUSH_VB(ctx, "dlist");
  1057.    n = alloc_instruction( ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6 );
  1058.    if (n) {
  1059.       n[1].e = target;
  1060.       n[2].i = level;
  1061.       n[3].i = xoffset;
  1062.       n[4].i = x;
  1063.       n[5].i = y;
  1064.       n[6].i = width;
  1065.    }
  1066.    if (ctx->ExecuteFlag) {
  1067.       (*ctx->Exec.CopyTexSubImage1D)( ctx, target, level, xoffset, x, y, width );
  1068.    }
  1069. }
  1070.  
  1071.  
  1072. static void save_CopyTexSubImage2D( GLcontext *ctx,
  1073.                                 GLenum target, GLint level,
  1074.                                 GLint xoffset, GLint yoffset,
  1075.                                 GLint x, GLint y,
  1076.                                 GLsizei width, GLint height )
  1077. {
  1078.    Node *n;
  1079.    FLUSH_VB(ctx, "dlist");
  1080.    n = alloc_instruction( ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8 );
  1081.    if (n) {
  1082.       n[1].e = target;
  1083.       n[2].i = level;
  1084.       n[3].i = xoffset;
  1085.       n[4].i = yoffset;
  1086.       n[5].i = x;
  1087.       n[6].i = y;
  1088.       n[7].i = width;
  1089.       n[8].i = height;
  1090.    }
  1091.    if (ctx->ExecuteFlag) {
  1092.       (*ctx->Exec.CopyTexSubImage2D)( ctx, target, level, xoffset, yoffset,
  1093.                                x, y, width, height );
  1094.    }
  1095. }
  1096.  
  1097.  
  1098. static void save_CopyTexSubImage3D( GLcontext *ctx,
  1099.                                     GLenum target, GLint level,
  1100.                                     GLint xoffset, GLint yoffset,
  1101.                                     GLint zoffset,
  1102.                                     GLint x, GLint y,
  1103.                                     GLsizei width, GLint height )
  1104. {
  1105.    Node *n;
  1106.    FLUSH_VB(ctx, "dlist");
  1107.    n = alloc_instruction( ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9 );
  1108.    if (n) {
  1109.       n[1].e = target;
  1110.       n[2].i = level;
  1111.       n[3].i = xoffset;
  1112.       n[4].i = yoffset;
  1113.       n[5].i = zoffset;
  1114.       n[6].i = x;
  1115.       n[7].i = y;
  1116.       n[8].i = width;
  1117.       n[9].i = height;
  1118.    }
  1119.    if (ctx->ExecuteFlag) {
  1120.       (*ctx->Exec.CopyTexSubImage3D)(ctx, target, level, xoffset, yoffset,
  1121.                                      zoffset, x, y, width, height );
  1122.    }
  1123. }
  1124.  
  1125.  
  1126. static void save_CullFace( GLcontext *ctx, GLenum mode )
  1127. {
  1128.    Node *n;
  1129.    FLUSH_VB(ctx, "dlist");
  1130.    n = alloc_instruction( ctx, OPCODE_CULL_FACE, 1 );
  1131.    if (n) {
  1132.       n[1].e = mode;
  1133.    }
  1134.    if (ctx->ExecuteFlag) {
  1135.       (*ctx->Exec.CullFace)( ctx, mode );
  1136.    }
  1137. }
  1138.  
  1139.  
  1140. static void save_DepthFunc( GLcontext *ctx, GLenum func )
  1141. {
  1142.    Node *n;
  1143.    FLUSH_VB(ctx, "dlist");
  1144.    n = alloc_instruction( ctx, OPCODE_DEPTH_FUNC, 1 );
  1145.    if (n) {
  1146.       n[1].e = func;
  1147.    }
  1148.    if (ctx->ExecuteFlag) {
  1149.       (*ctx->Exec.DepthFunc)( ctx, func );
  1150.    }
  1151. }
  1152.  
  1153.  
  1154. static void save_DepthMask( GLcontext *ctx, GLboolean mask )
  1155. {
  1156.    Node *n;
  1157.    FLUSH_VB(ctx, "dlist");
  1158.    n = alloc_instruction( ctx, OPCODE_DEPTH_MASK, 1 );
  1159.    if (n) {
  1160.       n[1].b = mask;
  1161.    }
  1162.    if (ctx->ExecuteFlag) {
  1163.       (*ctx->Exec.DepthMask)( ctx, mask );
  1164.    }
  1165. }
  1166.  
  1167.  
  1168. static void save_DepthRange( GLcontext *ctx, GLclampd nearval, GLclampd farval )
  1169. {
  1170.    Node *n;
  1171.    FLUSH_VB(ctx, "dlist");
  1172.    n = alloc_instruction( ctx, OPCODE_DEPTH_RANGE, 2 );
  1173.    if (n) {
  1174.       n[1].f = (GLfloat) nearval;
  1175.       n[2].f = (GLfloat) farval;
  1176.    }
  1177.    if (ctx->ExecuteFlag) {
  1178.       (*ctx->Exec.DepthRange)( ctx, nearval, farval );
  1179.    }
  1180. }
  1181.  
  1182.  
  1183. static void save_Disable( GLcontext *ctx, GLenum cap )
  1184. {
  1185.    Node *n;
  1186.    FLUSH_VB(ctx, "dlist");
  1187.    n = alloc_instruction( ctx, OPCODE_DISABLE, 1 );
  1188.    if (n) {
  1189.       n[1].e = cap;
  1190.    }
  1191.    if (ctx->ExecuteFlag) {
  1192.       (*ctx->Exec.Disable)( ctx, cap );
  1193.    }
  1194. }
  1195.  
  1196.  
  1197. static void save_DrawBuffer( GLcontext *ctx, GLenum mode )
  1198. {
  1199.    Node *n;
  1200.    FLUSH_VB(ctx, "dlist");
  1201.    n = alloc_instruction( ctx, OPCODE_DRAW_BUFFER, 1 );
  1202.    if (n) {
  1203.       n[1].e = mode;
  1204.    }
  1205.    if (ctx->ExecuteFlag) {
  1206.       (*ctx->Exec.DrawBuffer)( ctx, mode );
  1207.    }
  1208. }
  1209.  
  1210.  
  1211. static void save_DrawPixels( GLcontext *ctx, struct gl_image *image )
  1212. {
  1213.    Node *n;
  1214.    FLUSH_VB(ctx, "dlist");
  1215.    n = alloc_instruction( ctx, OPCODE_DRAW_PIXELS, 1 );
  1216.    if (n) {
  1217.       n[1].data = (GLvoid *) image;
  1218.    }
  1219.    if (image) {
  1220.       image->RefCount = 1;
  1221.    }
  1222.    if (ctx->ExecuteFlag) {
  1223.       (*ctx->Exec.DrawPixels)( ctx, image );
  1224.    }
  1225. }
  1226.  
  1227.  
  1228.  
  1229. static void save_Enable( GLcontext *ctx, GLenum cap )
  1230. {
  1231.    Node *n;
  1232.    FLUSH_VB(ctx, "dlist");
  1233.    n = alloc_instruction( ctx, OPCODE_ENABLE, 1 );
  1234.    if (n) {
  1235.       n[1].e = cap;
  1236.    }
  1237.    if (ctx->ExecuteFlag) {
  1238.       (*ctx->Exec.Enable)( ctx, cap );
  1239.    }
  1240. }
  1241.  
  1242.  
  1243.  
  1244. static void save_EvalMesh1( GLcontext *ctx,
  1245.                         GLenum mode, GLint i1, GLint i2 )
  1246. {
  1247.    Node *n;
  1248.    FLUSH_VB(ctx, "dlist");
  1249.    n = alloc_instruction( ctx, OPCODE_EVALMESH1, 3 );
  1250.    if (n) {
  1251.       n[1].e = mode;
  1252.       n[2].i = i1;
  1253.       n[3].i = i2;
  1254.    }
  1255.    if (ctx->ExecuteFlag) {
  1256.       (*ctx->Exec.EvalMesh1)( ctx, mode, i1, i2 );
  1257.    }
  1258. }
  1259.  
  1260.  
  1261. static void save_EvalMesh2( GLcontext *ctx, 
  1262.                         GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
  1263. {
  1264.    Node *n;
  1265.    FLUSH_VB(ctx, "dlist");
  1266.    n = alloc_instruction( ctx, OPCODE_EVALMESH2, 5 );
  1267.    if (n) {
  1268.       n[1].e = mode;
  1269.       n[2].i = i1;
  1270.       n[3].i = i2;
  1271.       n[4].i = j1;
  1272.       n[5].i = j2;
  1273.    }
  1274.    if (ctx->ExecuteFlag) {
  1275.       (*ctx->Exec.EvalMesh2)( ctx, mode, i1, i2, j1, j2 );
  1276.    }
  1277. }
  1278.  
  1279.  
  1280.  
  1281.  
  1282. static void save_Fogfv( GLcontext *ctx, GLenum pname, const GLfloat *params )
  1283. {
  1284.    Node *n;
  1285.    FLUSH_VB(ctx, "dlist");
  1286.    n = alloc_instruction( ctx, OPCODE_FOG, 5 );
  1287.    if (n) {
  1288.       n[1].e = pname;
  1289.       n[2].f = params[0];
  1290.       n[3].f = params[1];
  1291.       n[4].f = params[2];
  1292.       n[5].f = params[3];
  1293.    }
  1294.    if (ctx->ExecuteFlag) {
  1295.       (*ctx->Exec.Fogfv)( ctx, pname, params );
  1296.    }
  1297. }
  1298.  
  1299.  
  1300. static void save_FrontFace( GLcontext *ctx, GLenum mode )
  1301. {
  1302.    Node *n;
  1303.    FLUSH_VB(ctx, "dlist");
  1304.    n = alloc_instruction( ctx, OPCODE_FRONT_FACE, 1 );
  1305.    if (n) {
  1306.       n[1].e = mode;
  1307.    }
  1308.    if (ctx->ExecuteFlag) {
  1309.       (*ctx->Exec.FrontFace)( ctx, mode );
  1310.    }
  1311. }
  1312.  
  1313.  
  1314. static void save_Frustum( GLcontext *ctx, GLdouble left, GLdouble right,
  1315.                       GLdouble bottom, GLdouble top,
  1316.                       GLdouble nearval, GLdouble farval )
  1317. {
  1318.    Node *n;
  1319.    FLUSH_VB(ctx, "dlist");
  1320.    n = alloc_instruction( ctx, OPCODE_FRUSTUM, 6 );
  1321.    if (n) {
  1322.       n[1].f = left;
  1323.       n[2].f = right;
  1324.       n[3].f = bottom;
  1325.       n[4].f = top;
  1326.       n[5].f = nearval;
  1327.       n[6].f = farval;
  1328.    }
  1329.    if (ctx->ExecuteFlag) {
  1330.       (*ctx->Exec.Frustum)( ctx, left, right, bottom, top, nearval, farval );
  1331.    }
  1332. }
  1333.  
  1334.  
  1335. static GLboolean save_Hint( GLcontext *ctx, GLenum target, GLenum mode )
  1336. {
  1337.    Node *n;
  1338.    FLUSH_VB(ctx, "dlist");
  1339.    n = alloc_instruction( ctx, OPCODE_HINT, 2 );
  1340.    if (n) {
  1341.       n[1].e = target;
  1342.       n[2].e = mode;
  1343.    }
  1344.    if (ctx->ExecuteFlag) {
  1345.       return (*ctx->Exec.Hint)( ctx, target, mode );
  1346.    }
  1347.    return GL_TRUE;        /* not queried */
  1348. }
  1349.  
  1350.  
  1351.  
  1352. static void save_IndexMask( GLcontext *ctx, GLuint mask )
  1353. {
  1354.    Node *n;
  1355.    FLUSH_VB(ctx, "dlist");
  1356.    n = alloc_instruction( ctx, OPCODE_INDEX_MASK, 1 );
  1357.    if (n) {
  1358.       n[1].ui = mask;
  1359.    }
  1360.    if (ctx->ExecuteFlag) {
  1361.       (*ctx->Exec.IndexMask)( ctx, mask );
  1362.    }
  1363. }
  1364.  
  1365.  
  1366. static void save_InitNames( GLcontext *ctx )
  1367. {
  1368.    FLUSH_VB(ctx, "dlist");
  1369.    (void) alloc_instruction( ctx, OPCODE_INIT_NAMES, 0 );
  1370.    if (ctx->ExecuteFlag) {
  1371.       (*ctx->Exec.InitNames)( ctx );
  1372.    }
  1373. }
  1374.  
  1375.  
  1376. static void save_Lightfv( GLcontext *ctx, GLenum light, GLenum pname,
  1377.                       const GLfloat *params, GLint numparams )
  1378. {
  1379.    Node *n;
  1380.    FLUSH_VB(ctx, "dlist");
  1381.    n = alloc_instruction( ctx, OPCODE_LIGHT, 6 );
  1382.    if (OPCODE_LIGHT) {
  1383.       GLint i;
  1384.       n[1].e = light;
  1385.       n[2].e = pname;
  1386.       for (i=0;i<numparams;i++) {
  1387.      n[3+i].f = params[i];
  1388.       }
  1389.    }
  1390.    if (ctx->ExecuteFlag) {
  1391.       (*ctx->Exec.Lightfv)( ctx, light, pname, params, numparams );
  1392.    }
  1393. }
  1394.  
  1395.  
  1396. static void save_LightModelfv( GLcontext *ctx,
  1397.                            GLenum pname, const GLfloat *params )
  1398. {
  1399.    Node *n;
  1400.    FLUSH_VB(ctx, "dlist");
  1401.    n = alloc_instruction( ctx, OPCODE_LIGHT_MODEL, 5 );
  1402.    if (n) {
  1403.       n[1].e = pname;
  1404.       n[2].f = params[0];
  1405.       n[3].f = params[1];
  1406.       n[4].f = params[2];
  1407.       n[5].f = params[3];
  1408.    }
  1409.    if (ctx->ExecuteFlag) {
  1410.       (*ctx->Exec.LightModelfv)( ctx, pname, params );
  1411.    }
  1412. }
  1413.  
  1414.  
  1415. static void save_LineStipple( GLcontext *ctx, GLint factor, GLushort pattern )
  1416. {
  1417.    Node *n;
  1418.    FLUSH_VB(ctx, "dlist");
  1419.    n = alloc_instruction( ctx, OPCODE_LINE_STIPPLE, 2 );
  1420.    if (n) {
  1421.       n[1].i = factor;
  1422.       n[2].us = pattern;
  1423.    }
  1424.    if (ctx->ExecuteFlag) {
  1425.       (*ctx->Exec.LineStipple)( ctx, factor, pattern );
  1426.    }
  1427. }
  1428.  
  1429.  
  1430. static void save_LineWidth( GLcontext *ctx, GLfloat width )
  1431. {
  1432.    Node *n;
  1433.    FLUSH_VB(ctx, "dlist");
  1434.    n = alloc_instruction( ctx, OPCODE_LINE_WIDTH, 1 );
  1435.    if (n) {
  1436.       n[1].f = width;
  1437.    }
  1438.    if (ctx->ExecuteFlag) {
  1439.       (*ctx->Exec.LineWidth)( ctx, width );
  1440.    }
  1441. }
  1442.  
  1443.  
  1444. static void save_ListBase( GLcontext *ctx, GLuint base )
  1445. {
  1446.    Node *n;
  1447.    FLUSH_VB(ctx, "dlist");
  1448.    n = alloc_instruction( ctx, OPCODE_LIST_BASE, 1 );
  1449.    if (n) {
  1450.       n[1].ui = base;
  1451.    }
  1452.    if (ctx->ExecuteFlag) {
  1453.       (*ctx->Exec.ListBase)( ctx, base );
  1454.    }
  1455. }
  1456.  
  1457.  
  1458. static void save_LoadIdentity( GLcontext *ctx )
  1459. {
  1460.    FLUSH_VB(ctx, "dlist");
  1461.    (void) alloc_instruction( ctx, OPCODE_LOAD_IDENTITY, 0 );
  1462.    if (ctx->ExecuteFlag) {
  1463.       (*ctx->Exec.LoadIdentity)( ctx );
  1464.    }
  1465. }
  1466.  
  1467.  
  1468. static void save_LoadMatrixf( GLcontext *ctx, const GLfloat *m )
  1469. {
  1470.    Node *n;
  1471.    FLUSH_VB(ctx, "dlist");
  1472.    n = alloc_instruction( ctx, OPCODE_LOAD_MATRIX, 16 );
  1473.    if (n) {
  1474.       GLuint i;
  1475.       for (i=0;i<16;i++) {
  1476.      n[1+i].f = m[i];
  1477.       }
  1478.    }
  1479.    if (ctx->ExecuteFlag) {
  1480.       (*ctx->Exec.LoadMatrixf)( ctx, m );
  1481.    }
  1482. }
  1483.  
  1484.  
  1485. static void save_LoadName( GLcontext *ctx, GLuint name )
  1486. {
  1487.    Node *n;
  1488.    FLUSH_VB(ctx, "dlist");
  1489.    n = alloc_instruction( ctx, OPCODE_LOAD_NAME, 1 );
  1490.    if (n) {
  1491.       n[1].ui = name;
  1492.    }
  1493.    if (ctx->ExecuteFlag) {
  1494.       (*ctx->Exec.LoadName)( ctx, name );
  1495.    }
  1496. }
  1497.  
  1498.  
  1499. static void save_LogicOp( GLcontext *ctx, GLenum opcode )
  1500. {
  1501.    Node *n;
  1502.    FLUSH_VB(ctx, "dlist");
  1503.    n = alloc_instruction( ctx, OPCODE_LOGIC_OP, 1 );
  1504.    if (n) {
  1505.       n[1].e = opcode;
  1506.    }
  1507.    if (ctx->ExecuteFlag) {
  1508.       (*ctx->Exec.LogicOp)( ctx, opcode );
  1509.    }
  1510. }
  1511.  
  1512.  
  1513. static void save_Map1f( GLcontext *ctx,
  1514.                    GLenum target, GLfloat u1, GLfloat u2, GLint stride,
  1515.            GLint order, const GLfloat *points, GLboolean retain )
  1516. {
  1517.    Node *n;
  1518.    FLUSH_VB(ctx, "dlist");
  1519.    n = alloc_instruction( ctx, OPCODE_MAP1, 6 );
  1520.    if (n) {
  1521.       n[1].e = target;
  1522.       n[2].f = u1;
  1523.       n[3].f = u2;
  1524.       n[4].i = stride;
  1525.       n[5].i = order;
  1526.       n[6].data = (void *) points;
  1527.    }
  1528.    if (ctx->ExecuteFlag) {
  1529.       (*ctx->Exec.Map1f)( ctx, target, u1, u2, stride, order, points, GL_TRUE );
  1530.    }
  1531.    (void) retain;
  1532. }
  1533.  
  1534.  
  1535. static void save_Map2f( GLcontext *ctx, GLenum target,
  1536.                     GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  1537.                     GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  1538.                     const GLfloat *points, GLboolean retain )
  1539. {
  1540.    Node *n;
  1541.    FLUSH_VB(ctx, "dlist");
  1542.    n = alloc_instruction( ctx, OPCODE_MAP2, 10 );
  1543.    if (n) {
  1544.       n[1].e = target;
  1545.       n[2].f = u1;
  1546.       n[3].f = u2;
  1547.       n[4].f = v1;
  1548.       n[5].f = v2;
  1549.       n[6].i = ustride;
  1550.       n[7].i = vstride;
  1551.       n[8].i = uorder;
  1552.       n[9].i = vorder;
  1553.       n[10].data = (void *) points;
  1554.    }
  1555.    if (ctx->ExecuteFlag) {
  1556.       (*ctx->Exec.Map2f)( ctx, target,
  1557.                         u1, u2, ustride, uorder,
  1558.                         v1, v2, vstride, vorder, points, GL_TRUE );
  1559.    }
  1560.    (void) retain;
  1561. }
  1562.  
  1563.  
  1564. static void save_MapGrid1f( GLcontext *ctx, GLint un, GLfloat u1, GLfloat u2 )
  1565. {
  1566.    Node *n;
  1567.    FLUSH_VB(ctx, "dlist");
  1568.    n = alloc_instruction( ctx, OPCODE_MAPGRID1, 3 );
  1569.    if (n) {
  1570.       n[1].i = un;
  1571.       n[2].f = u1;
  1572.       n[3].f = u2;
  1573.    }
  1574.    if (ctx->ExecuteFlag) {
  1575.       (*ctx->Exec.MapGrid1f)( ctx, un, u1, u2 );
  1576.    }
  1577. }
  1578.  
  1579.  
  1580. static void save_MapGrid2f( GLcontext *ctx, 
  1581.                         GLint un, GLfloat u1, GLfloat u2,
  1582.                 GLint vn, GLfloat v1, GLfloat v2 )
  1583. {
  1584.    Node *n;
  1585.    FLUSH_VB(ctx, "dlist");
  1586.    n = alloc_instruction( ctx, OPCODE_MAPGRID2, 6 );
  1587.    if (n) {
  1588.       n[1].i = un;
  1589.       n[2].f = u1;
  1590.       n[3].f = u2;
  1591.       n[4].i = vn;
  1592.       n[5].f = v1;
  1593.       n[6].f = v2;
  1594.    }
  1595.    if (ctx->ExecuteFlag) {
  1596.       (*ctx->Exec.MapGrid2f)( ctx, un, u1, u2, vn, v1, v2 );
  1597.    }
  1598. }
  1599.  
  1600.  
  1601. static void save_MatrixMode( GLcontext *ctx, GLenum mode )
  1602. {
  1603.    Node *n;
  1604.    FLUSH_VB(ctx, "dlist");
  1605.    n = alloc_instruction( ctx, OPCODE_MATRIX_MODE, 1 );
  1606.    if (n) {
  1607.       n[1].e = mode;
  1608.    }
  1609.    if (ctx->ExecuteFlag) {
  1610.       (*ctx->Exec.MatrixMode)( ctx, mode );
  1611.    }
  1612. }
  1613.  
  1614.  
  1615. static void save_MultMatrixf( GLcontext *ctx, const GLfloat *m )
  1616. {
  1617.    Node *n;
  1618.    FLUSH_VB(ctx, "dlist");
  1619.    n = alloc_instruction( ctx, OPCODE_MULT_MATRIX, 16 );
  1620.    if (n) {
  1621.       GLuint i;
  1622.       for (i=0;i<16;i++) {
  1623.      n[1+i].f = m[i];
  1624.       }
  1625.    }
  1626.    if (ctx->ExecuteFlag) {
  1627.       (*ctx->Exec.MultMatrixf)( ctx, m );
  1628.    }
  1629. }
  1630.  
  1631.  
  1632. static void save_NewList( GLcontext *ctx, GLuint list, GLenum mode )
  1633. {
  1634.    /* It's an error to call this function while building a display list */
  1635.    gl_error( ctx, GL_INVALID_OPERATION, "glNewList" );
  1636.    (void) list;
  1637.    (void) mode;
  1638. }
  1639.  
  1640.  
  1641.  
  1642. static void save_Ortho( GLcontext *ctx, GLdouble left, GLdouble right,
  1643.                     GLdouble bottom, GLdouble top,
  1644.                     GLdouble nearval, GLdouble farval )
  1645. {
  1646.    Node *n;
  1647.    FLUSH_VB(ctx, "dlist");
  1648.    n = alloc_instruction( ctx, OPCODE_ORTHO, 6 );
  1649.    if (n) {
  1650.       n[1].f = left;
  1651.       n[2].f = right;
  1652.       n[3].f = bottom;
  1653.       n[4].f = top;
  1654.       n[5].f = nearval;
  1655.       n[6].f = farval;
  1656.    }
  1657.    if (ctx->ExecuteFlag) {
  1658.       (*ctx->Exec.Ortho)( ctx, left, right, bottom, top, nearval, farval );
  1659.    }
  1660. }
  1661.  
  1662.  
  1663. static void save_PixelMapfv( GLcontext *ctx,
  1664.                          GLenum map, GLint mapsize, const GLfloat *values )
  1665. {
  1666.    Node *n;
  1667.    FLUSH_VB(ctx, "dlist");
  1668.    n = alloc_instruction( ctx, OPCODE_PIXEL_MAP, 3 );
  1669.    if (n) {
  1670.       n[1].e = map;
  1671.       n[2].i = mapsize;
  1672.       n[3].data  = (void *) MALLOC( mapsize * sizeof(GLfloat) );
  1673.       MEMCPY( n[3].data, (void *) values, mapsize * sizeof(GLfloat) );
  1674.    }
  1675.    if (ctx->ExecuteFlag) {
  1676.       (*ctx->Exec.PixelMapfv)( ctx, map, mapsize, values );
  1677.    }
  1678. }
  1679.  
  1680.  
  1681. static void save_PixelTransferf( GLcontext *ctx, GLenum pname, GLfloat param )
  1682. {
  1683.    Node *n;
  1684.    FLUSH_VB(ctx, "dlist");
  1685.    n = alloc_instruction( ctx, OPCODE_PIXEL_TRANSFER, 2 );
  1686.    if (n) {
  1687.       n[1].e = pname;
  1688.       n[2].f = param;
  1689.    }
  1690.    if (ctx->ExecuteFlag) {
  1691.       (*ctx->Exec.PixelTransferf)( ctx, pname, param );
  1692.    }
  1693. }
  1694.  
  1695.  
  1696. static void save_PixelZoom( GLcontext *ctx, GLfloat xfactor, GLfloat yfactor )
  1697. {
  1698.    Node *n;
  1699.    FLUSH_VB(ctx, "dlist");
  1700.    n = alloc_instruction( ctx, OPCODE_PIXEL_ZOOM, 2 );
  1701.    if (n) {
  1702.       n[1].f = xfactor;
  1703.       n[2].f = yfactor;
  1704.    }
  1705.    if (ctx->ExecuteFlag) {
  1706.       (*ctx->Exec.PixelZoom)( ctx, xfactor, yfactor );
  1707.    }
  1708. }
  1709.  
  1710.  
  1711. static void save_PointParameterfvEXT( GLcontext *ctx, GLenum pname,
  1712.                                   const GLfloat *params)
  1713. {
  1714.    Node *n;
  1715.    FLUSH_VB(ctx, "dlist");
  1716.    n = alloc_instruction( ctx, OPCODE_POINT_PARAMETERS, 4 );
  1717.    if (n) {
  1718.       n[1].e = pname;
  1719.       n[2].f = params[0];
  1720.       n[3].f = params[1];
  1721.       n[4].f = params[2];
  1722.    }
  1723.    if (ctx->ExecuteFlag) {
  1724.       (*ctx->Exec.PointParameterfvEXT)( ctx, pname, params );
  1725.    }
  1726. }
  1727.  
  1728.  
  1729. static void save_PointSize( GLcontext *ctx, GLfloat size )
  1730. {
  1731.    Node *n;
  1732.    FLUSH_VB(ctx, "dlist");
  1733.    n = alloc_instruction( ctx, OPCODE_POINT_SIZE, 1 );
  1734.    if (n) {
  1735.       n[1].f = size;
  1736.    }
  1737.    if (ctx->ExecuteFlag) {
  1738.       (*ctx->Exec.PointSize)( ctx, size );
  1739.    }
  1740. }
  1741.  
  1742.  
  1743. static void save_PolygonMode( GLcontext *ctx, GLenum face, GLenum mode )
  1744. {
  1745.    Node *n;
  1746.    FLUSH_VB(ctx, "dlist");
  1747.    n = alloc_instruction( ctx, OPCODE_POLYGON_MODE, 2 );
  1748.    if (n) {
  1749.       n[1].e = face;
  1750.       n[2].e = mode;
  1751.    }
  1752.    if (ctx->ExecuteFlag) {
  1753.       (*ctx->Exec.PolygonMode)( ctx, face, mode );
  1754.    }
  1755. }
  1756.  
  1757.  
  1758. /*
  1759.  * Polygon stipple must have been upacked already!
  1760.  */
  1761. static void save_PolygonStipple( GLcontext *ctx, const GLuint *pattern )
  1762. {
  1763.    Node *n;
  1764.    FLUSH_VB(ctx, "dlist");
  1765.    n = alloc_instruction( ctx, OPCODE_POLYGON_STIPPLE, 1 );
  1766.    if (n) {
  1767.       void *data;
  1768.       n[1].data = MALLOC( 32 * 4 );
  1769.       data = n[1].data;   /* This needed for Acorn compiler */
  1770.       MEMCPY( data, pattern, 32 * 4 );
  1771.    }
  1772.    if (ctx->ExecuteFlag) {
  1773.       (*ctx->Exec.PolygonStipple)( ctx, pattern );
  1774.    }
  1775. }
  1776.  
  1777.  
  1778. static void save_PolygonOffset( GLcontext *ctx, GLfloat factor, GLfloat units )
  1779. {
  1780.    Node *n;
  1781.    FLUSH_VB(ctx, "dlist");
  1782.    n = alloc_instruction( ctx, OPCODE_POLYGON_OFFSET, 2 );
  1783.    if (n) {
  1784.       n[1].f = factor;
  1785.       n[2].f = units;
  1786.    }
  1787.    if (ctx->ExecuteFlag) {
  1788.       (*ctx->Exec.PolygonOffset)( ctx, factor, units );
  1789.    }
  1790. }
  1791.  
  1792.  
  1793. static void save_PopAttrib( GLcontext *ctx )
  1794. {
  1795.    FLUSH_VB(ctx, "dlist");
  1796.    (void) alloc_instruction( ctx, OPCODE_POP_ATTRIB, 0 );
  1797.    if (ctx->ExecuteFlag) {
  1798.       (*ctx->Exec.PopAttrib)( ctx );
  1799.    }
  1800. }
  1801.  
  1802.  
  1803. static void save_PopMatrix( GLcontext *ctx )
  1804. {
  1805.    FLUSH_VB(ctx, "dlist");
  1806.    (void) alloc_instruction( ctx, OPCODE_POP_MATRIX, 0 );
  1807.    if (ctx->ExecuteFlag) {
  1808.       (*ctx->Exec.PopMatrix)( ctx );
  1809.    }
  1810. }
  1811.  
  1812.  
  1813. static void save_PopName( GLcontext *ctx )
  1814. {
  1815.    FLUSH_VB(ctx, "dlist");
  1816.    (void) alloc_instruction( ctx, OPCODE_POP_NAME, 0 );
  1817.    if (ctx->ExecuteFlag) {
  1818.       (*ctx->Exec.PopName)( ctx );
  1819.    }
  1820. }
  1821.  
  1822.  
  1823. static void save_PrioritizeTextures( GLcontext *ctx,
  1824.                                  GLsizei num, const GLuint *textures,
  1825.                                  const GLclampf *priorities )
  1826. {
  1827.    GLint i;
  1828.    FLUSH_VB(ctx, "dlist");
  1829.  
  1830.    for (i=0;i<num;i++) {
  1831.       Node *n;
  1832.       n = alloc_instruction( ctx,  OPCODE_PRIORITIZE_TEXTURE, 2 );
  1833.       if (n) {
  1834.          n[1].ui = textures[i];
  1835.          n[2].f = priorities[i];
  1836.       }
  1837.    }
  1838.    if (ctx->ExecuteFlag) {
  1839.       (*ctx->Exec.PrioritizeTextures)( ctx, num, textures, priorities );
  1840.    }
  1841. }
  1842.  
  1843.  
  1844. static void save_PushAttrib( GLcontext *ctx, GLbitfield mask )
  1845. {
  1846.    Node *n;
  1847.    FLUSH_VB(ctx, "dlist");
  1848.    n = alloc_instruction( ctx, OPCODE_PUSH_ATTRIB, 1 );
  1849.    if (n) {
  1850.       n[1].bf = mask;
  1851.    }
  1852.    if (ctx->ExecuteFlag) {
  1853.       (*ctx->Exec.PushAttrib)( ctx, mask );
  1854.    }
  1855. }
  1856.  
  1857.  
  1858. static void save_PushMatrix( GLcontext *ctx )
  1859. {
  1860.    FLUSH_VB(ctx, "dlist");
  1861.    (void) alloc_instruction( ctx, OPCODE_PUSH_MATRIX, 0 );
  1862.    if (ctx->ExecuteFlag) {
  1863.       (*ctx->Exec.PushMatrix)( ctx );
  1864.    }
  1865. }
  1866.  
  1867.  
  1868. static void save_PushName( GLcontext *ctx, GLuint name )
  1869. {
  1870.    Node *n;
  1871.    FLUSH_VB(ctx, "dlist");
  1872.    n = alloc_instruction( ctx, OPCODE_PUSH_NAME, 1 );
  1873.    if (n) {
  1874.       n[1].ui = name;
  1875.    }
  1876.    if (ctx->ExecuteFlag) {
  1877.       (*ctx->Exec.PushName)( ctx, name );
  1878.    }
  1879. }
  1880.  
  1881.  
  1882. static void save_RasterPos4f( GLcontext *ctx,
  1883.                           GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  1884. {
  1885.    Node *n;
  1886.    FLUSH_VB(ctx, "dlist");
  1887.    n = alloc_instruction( ctx, OPCODE_RASTER_POS, 4 );
  1888.    if (n) {
  1889.       n[1].f = x;
  1890.       n[2].f = y;
  1891.       n[3].f = z;
  1892.       n[4].f = w;
  1893.    }
  1894.    if (ctx->ExecuteFlag) {
  1895.       (*ctx->Exec.RasterPos4f)( ctx, x, y, z, w );
  1896.    }
  1897. }
  1898.  
  1899.  
  1900. static void save_PassThrough( GLcontext *ctx, GLfloat token )
  1901. {
  1902.    Node *n;
  1903.    FLUSH_VB(ctx, "dlist");
  1904.    n = alloc_instruction( ctx, OPCODE_PASSTHROUGH, 1 );
  1905.    if (n) {
  1906.       n[1].f = token;
  1907.    }
  1908.    if (ctx->ExecuteFlag) {
  1909.       (*ctx->Exec.PassThrough)( ctx, token );
  1910.    }
  1911. }
  1912.  
  1913.  
  1914. static void save_ReadBuffer( GLcontext *ctx, GLenum mode )
  1915. {
  1916.    Node *n;
  1917.    FLUSH_VB(ctx, "dlist");
  1918.    n = alloc_instruction( ctx, OPCODE_READ_BUFFER, 1 );
  1919.    if (n) {
  1920.       n[1].e = mode;
  1921.    }
  1922.    if (ctx->ExecuteFlag) {
  1923.       (*ctx->Exec.ReadBuffer)( ctx, mode );
  1924.    }
  1925. }
  1926.  
  1927.  
  1928. static void save_Rectf( GLcontext *ctx,
  1929.                     GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
  1930. {
  1931.    Node *n;
  1932.    FLUSH_VB(ctx, "dlist");
  1933.    n = alloc_instruction( ctx, OPCODE_RECTF, 4 );
  1934.    if (n) {
  1935.       n[1].f = x1;
  1936.       n[2].f = y1;
  1937.       n[3].f = x2;
  1938.       n[4].f = y2;
  1939.    }
  1940.    if (ctx->ExecuteFlag) {
  1941.       (*ctx->Exec.Rectf)( ctx, x1, y1, x2, y2 );
  1942.    }
  1943. }
  1944.  
  1945.  
  1946. static void save_Rotatef( GLcontext *ctx, GLfloat angle,
  1947.                       GLfloat x, GLfloat y, GLfloat z )
  1948. {
  1949.    GLfloat m[16];
  1950.    gl_rotation_matrix( angle, x, y, z, m );
  1951.    save_MultMatrixf( ctx, m );  /* save and maybe execute */
  1952. }
  1953.  
  1954.  
  1955. static void save_Scalef( GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z )
  1956. {
  1957.    Node *n;
  1958.    FLUSH_VB(ctx, "dlist");
  1959.    n = alloc_instruction( ctx, OPCODE_SCALE, 3 );
  1960.    if (n) {
  1961.       n[1].f = x;
  1962.       n[2].f = y;
  1963.       n[3].f = z;
  1964.    }
  1965.    if (ctx->ExecuteFlag) {
  1966.       (*ctx->Exec.Scalef)( ctx, x, y, z );
  1967.    }
  1968. }
  1969.  
  1970.  
  1971. static void save_Scissor( GLcontext *ctx,
  1972.                       GLint x, GLint y, GLsizei width, GLsizei height )
  1973. {
  1974.    Node *n;
  1975.    FLUSH_VB(ctx, "dlist");
  1976.    n = alloc_instruction( ctx, OPCODE_SCISSOR, 4 );
  1977.    if (n) {
  1978.       n[1].i = x;
  1979.       n[2].i = y;
  1980.       n[3].i = width;
  1981.       n[4].i = height;
  1982.    }
  1983.    if (ctx->ExecuteFlag) {
  1984.       (*ctx->Exec.Scissor)( ctx, x, y, width, height );
  1985.    }
  1986. }
  1987.  
  1988.  
  1989. static void save_ShadeModel( GLcontext *ctx, GLenum mode )
  1990. {
  1991.    Node *n;
  1992.    FLUSH_VB(ctx, "dlist");
  1993.    n = alloc_instruction( ctx, OPCODE_SHADE_MODEL, 1 );
  1994.    if (n) {
  1995.       n[1].e = mode;
  1996.    }
  1997.    if (ctx->ExecuteFlag) {
  1998.       (*ctx->Exec.ShadeModel)( ctx, mode );
  1999.    }
  2000. }
  2001.  
  2002.  
  2003. static void save_StencilFunc( GLcontext *ctx, GLenum func, GLint ref, GLuint mask )
  2004. {
  2005.    Node *n;
  2006.    FLUSH_VB(ctx, "dlist");
  2007.    n = alloc_instruction( ctx, OPCODE_STENCIL_FUNC, 3 );
  2008.    if (n) {
  2009.       n[1].e = func;
  2010.       n[2].i = ref;
  2011.       n[3].ui = mask;
  2012.    }
  2013.    if (ctx->ExecuteFlag) {
  2014.       (*ctx->Exec.StencilFunc)( ctx, func, ref, mask );
  2015.    }
  2016. }
  2017.  
  2018.  
  2019. static void save_StencilMask( GLcontext *ctx, GLuint mask )
  2020. {
  2021.    Node *n;
  2022.    FLUSH_VB(ctx, "dlist");
  2023.    n = alloc_instruction( ctx, OPCODE_STENCIL_MASK, 1 );
  2024.    if (n) {
  2025.       n[1].ui = mask;
  2026.    }
  2027.    if (ctx->ExecuteFlag) {
  2028.       (*ctx->Exec.StencilMask)( ctx, mask );
  2029.    }
  2030. }
  2031.  
  2032.  
  2033. static void save_StencilOp( GLcontext *ctx,
  2034.                         GLenum fail, GLenum zfail, GLenum zpass )
  2035. {
  2036.    Node *n;
  2037.    FLUSH_VB(ctx, "dlist");
  2038.    n = alloc_instruction( ctx, OPCODE_STENCIL_OP, 3 );
  2039.    if (n) {
  2040.       n[1].e = fail;
  2041.       n[2].e = zfail;
  2042.       n[3].e = zpass;
  2043.    }
  2044.    if (ctx->ExecuteFlag) {
  2045.       (*ctx->Exec.StencilOp)( ctx, fail, zfail, zpass );
  2046.    }
  2047. }
  2048.  
  2049.  
  2050.  
  2051.  
  2052. static void save_TexEnvfv( GLcontext *ctx,
  2053.                        GLenum target, GLenum pname, const GLfloat *params )
  2054. {
  2055.    Node *n;
  2056.    FLUSH_VB(ctx, "dlist");
  2057.    n = alloc_instruction( ctx, OPCODE_TEXENV, 6 );
  2058.    if (n) {
  2059.       n[1].e = target;
  2060.       n[2].e = pname;
  2061.       n[3].f = params[0];
  2062.       n[4].f = params[1];
  2063.       n[5].f = params[2];
  2064.       n[6].f = params[3];
  2065.    }
  2066.    if (ctx->ExecuteFlag) {
  2067.       (*ctx->Exec.TexEnvfv)( ctx, target, pname, params );
  2068.    }
  2069. }
  2070.  
  2071.  
  2072. static void save_TexGenfv( GLcontext *ctx,
  2073.                        GLenum coord, GLenum pname, const GLfloat *params )
  2074. {
  2075.    Node *n;
  2076.    FLUSH_VB(ctx, "dlist");
  2077.    n = alloc_instruction( ctx, OPCODE_TEXGEN, 6 );
  2078.    if (n) {
  2079.       n[1].e = coord;
  2080.       n[2].e = pname;
  2081.       n[3].f = params[0];
  2082.       n[4].f = params[1];
  2083.       n[5].f = params[2];
  2084.       n[6].f = params[3];
  2085.    }
  2086.    if (ctx->ExecuteFlag) {
  2087.       (*ctx->Exec.TexGenfv)( ctx, coord, pname, params );
  2088.    }
  2089. }
  2090.  
  2091.  
  2092. static void save_TexParameterfv( GLcontext *ctx, GLenum target,
  2093.                              GLenum pname, const GLfloat *params )
  2094. {
  2095.    Node *n;
  2096.    FLUSH_VB(ctx, "dlist");
  2097.    n = alloc_instruction( ctx, OPCODE_TEXPARAMETER, 6 );
  2098.    if (n) {
  2099.       n[1].e = target;
  2100.       n[2].e = pname;
  2101.       n[3].f = params[0];
  2102.       n[4].f = params[1];
  2103.       n[5].f = params[2];
  2104.       n[6].f = params[3];
  2105.    }
  2106.    if (ctx->ExecuteFlag) {
  2107.       (*ctx->Exec.TexParameterfv)( ctx, target, pname, params );
  2108.    }
  2109. }
  2110.  
  2111.  
  2112. static void save_TexImage1D( GLcontext *ctx, GLenum target,
  2113.                              GLint level, GLint components,
  2114.                              GLsizei width, GLint border,
  2115.                              GLenum format, GLenum type,
  2116.                              const GLvoid *pixels )
  2117. {
  2118.    FLUSH_VB(ctx, "dlist");
  2119.    if (target == GL_PROXY_TEXTURE_1D) {
  2120.       (*ctx->Exec.TexImage1D)( ctx, target, level, components, width,
  2121.                                border, format, type, pixels );
  2122.    }
  2123.    else {
  2124.       Node *n;
  2125.       GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type,
  2126.                                          pixels, &ctx->Unpack);
  2127.       n = alloc_instruction( ctx, OPCODE_TEX_IMAGE1D, 8 );
  2128.       if (n) {
  2129.          n[1].e = target;
  2130.          n[2].i = level;
  2131.          n[3].i = components;
  2132.          n[4].i = (GLint) width;
  2133.          n[5].i = border;
  2134.          n[6].e = format;
  2135.          n[7].e = type;
  2136.          n[8].data = image;
  2137.       }
  2138.       else {
  2139.          FREE(image);
  2140.       }
  2141.       if (ctx->ExecuteFlag) {
  2142.          (*ctx->Exec.TexImage1D)( ctx, target, level, components, width,
  2143.                                   border, format, type, pixels );
  2144.       }
  2145.    }
  2146. }
  2147.  
  2148.  
  2149. static void save_TexImage2D( GLcontext *ctx, GLenum target,
  2150.                              GLint level, GLint components,
  2151.                              GLsizei width, GLsizei height, GLint border,
  2152.                              GLenum format, GLenum type,
  2153.                              const GLvoid *pixels )
  2154. {
  2155.    FLUSH_VB(ctx, "dlist");
  2156.    if (target == GL_PROXY_TEXTURE_2D) {
  2157.       (*ctx->Exec.TexImage2D)( ctx, target, level, components, width,
  2158.                                height, border, format, type, pixels );
  2159.    }
  2160.    else {
  2161.       Node *n;
  2162.       GLvoid *image = _mesa_unpack_image(width, height, 1, format, type,
  2163.                                          pixels, &ctx->Unpack);
  2164.       n = alloc_instruction( ctx, OPCODE_TEX_IMAGE2D, 9 );
  2165.       if (n) {
  2166.          n[1].e = target;
  2167.          n[2].i = level;
  2168.          n[3].i = components;
  2169.          n[4].i = (GLint) width;
  2170.          n[5].i = (GLint) height;
  2171.          n[6].i = border;
  2172.          n[7].e = format;
  2173.          n[8].e = type;
  2174.          n[9].data = image;
  2175.       }
  2176.       else {
  2177.          FREE(image);
  2178.       }
  2179.       if (ctx->ExecuteFlag) {
  2180.          (*ctx->Exec.TexImage2D)( ctx, target, level, components, width,
  2181.                                   height, border, format, type, pixels );
  2182.       }
  2183.    }
  2184. }
  2185.  
  2186.  
  2187. static void save_TexImage3D( GLcontext *ctx, GLenum target,
  2188.                              GLint level, GLint components,
  2189.                              GLsizei width, GLsizei height, GLsizei depth,
  2190.                              GLint border,
  2191.                              GLenum format, GLenum type,
  2192.                              const GLvoid *pixels )
  2193. {
  2194.    FLUSH_VB(ctx, "dlist");
  2195.    if (target == GL_PROXY_TEXTURE_3D) {
  2196.       (*ctx->Exec.TexImage3D)( ctx, target, level, components, width,
  2197.                                height, depth, border, format, type, pixels );
  2198.    }
  2199.    else {
  2200.       GLvoid *image = _mesa_unpack_image(width, height, depth, format, type,
  2201.                                          pixels, &ctx->Unpack);
  2202.       Node *n;
  2203.       n = alloc_instruction( ctx, OPCODE_TEX_IMAGE3D, 10 );
  2204.       if (n) {
  2205.          n[1].e = target;
  2206.          n[2].i = level;
  2207.          n[3].i = components;
  2208.          n[4].i = (GLint) width;
  2209.          n[5].i = (GLint) height;
  2210.          n[6].i = (GLint) depth; 
  2211.          n[7].i = border;
  2212.          n[8].e = format;
  2213.          n[9].e = type;
  2214.          n[10].data = image;
  2215.       }
  2216.       else {
  2217.          FREE(image);
  2218.       }
  2219.       if (ctx->ExecuteFlag) {
  2220.          (*ctx->Exec.TexImage3D)( ctx, target, level, components, width,
  2221.                                height, depth, border, format, type, pixels );
  2222.       }
  2223.    }
  2224. }
  2225.  
  2226.  
  2227. static void save_TexSubImage1D( GLcontext *ctx,
  2228.                                 GLenum target, GLint level, GLint xoffset,
  2229.                                 GLsizei width, GLenum format, GLenum type,
  2230.                                 const GLvoid *pixels )
  2231. {
  2232.    Node *n;
  2233.    GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type,
  2234.                                       pixels, &ctx->Unpack);
  2235.    FLUSH_VB(ctx, "dlist");
  2236.    n = alloc_instruction( ctx, OPCODE_TEX_SUB_IMAGE1D, 7 );
  2237.    if (n) {
  2238.       n[1].e = target;
  2239.       n[2].i = level;
  2240.       n[3].i = xoffset;
  2241.       n[4].i = (GLint) width;
  2242.       n[5].e = format;
  2243.       n[6].e = type;
  2244.       n[7].data = image;
  2245.    }
  2246.    else {
  2247.       FREE(image);
  2248.    }
  2249.    if (ctx->ExecuteFlag) {
  2250.       (*ctx->Exec.TexSubImage1D)( ctx, target, level, xoffset, width,
  2251.                                   format, type, pixels );
  2252.    }
  2253. }
  2254.  
  2255.  
  2256. static void save_TexSubImage2D( GLcontext *ctx,
  2257.                                 GLenum target, GLint level,
  2258.                                 GLint xoffset, GLint yoffset,
  2259.                                 GLsizei width, GLsizei height,
  2260.                                 GLenum format, GLenum type,
  2261.                                 const GLvoid *pixels )
  2262. {
  2263.    Node *n;
  2264.    GLvoid *image = _mesa_unpack_image(width, height, 1, format, type,
  2265.                                       pixels, &ctx->Unpack);
  2266.    FLUSH_VB(ctx, "dlist");
  2267.    n = alloc_instruction( ctx, OPCODE_TEX_SUB_IMAGE2D, 9 );
  2268.    if (n) {
  2269.       n[1].e = target;
  2270.       n[2].i = level;
  2271.       n[3].i = xoffset;
  2272.       n[4].i = yoffset;
  2273.       n[5].i = (GLint) width;
  2274.       n[6].i = (GLint) height;
  2275.       n[7].e = format;
  2276.       n[8].e = type;
  2277.       n[9].data = image;
  2278.    }
  2279.    else {
  2280.       FREE(image);
  2281.    }
  2282.    if (ctx->ExecuteFlag) {
  2283.       (*ctx->Exec.TexSubImage2D)( ctx, target, level, xoffset, yoffset,
  2284.                                   width, height, format, type, pixels );
  2285.    }
  2286. }
  2287.  
  2288.  
  2289. static void save_TexSubImage3D( GLcontext *ctx,
  2290.                                 GLenum target, GLint level,
  2291.                                 GLint xoffset, GLint yoffset,GLint zoffset,
  2292.                                 GLsizei width, GLsizei height, GLsizei depth,
  2293.                                 GLenum format, GLenum type,
  2294.                                 const GLvoid *pixels )
  2295. {
  2296.    Node *n;
  2297.    GLvoid *image = _mesa_unpack_image(width, height, depth, format, type,
  2298.                                       pixels, &ctx->Unpack);
  2299.    FLUSH_VB(ctx, "dlist");
  2300.    n = alloc_instruction( ctx, OPCODE_TEX_SUB_IMAGE3D, 11 );
  2301.    if (n) {
  2302.       n[1].e = target;
  2303.       n[2].i = level;
  2304.       n[3].i = xoffset;
  2305.       n[4].i = yoffset;
  2306.       n[5].i = zoffset;
  2307.       n[6].i = (GLint) width;
  2308.       n[7].i = (GLint) height;
  2309.       n[8].i = (GLint) depth;
  2310.       n[9].e = format;
  2311.       n[10].e = type;
  2312.       n[11].data = image;
  2313.    }
  2314.    else {
  2315.       FREE(image);
  2316.    }
  2317.    if (ctx->ExecuteFlag) {
  2318.       (*ctx->Exec.TexSubImage3D)(ctx, target, level, xoffset, yoffset, zoffset,
  2319.                                  width, height, depth, format, type, pixels );
  2320.    }
  2321. }
  2322.  
  2323.  
  2324. static void save_Translatef( GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z )
  2325. {
  2326.    Node *n;
  2327.    FLUSH_VB(ctx, "dlist");
  2328.    n = alloc_instruction( ctx,  OPCODE_TRANSLATE, 3 );
  2329.    if (n) {
  2330.       n[1].f = x;
  2331.       n[2].f = y;
  2332.       n[3].f = z;
  2333.    }
  2334.    if (ctx->ExecuteFlag) {
  2335.       (*ctx->Exec.Translatef)( ctx, x, y, z );
  2336.    }
  2337. }
  2338.  
  2339.  
  2340.  
  2341. static void save_Viewport( GLcontext *ctx,
  2342.                        GLint x, GLint y, GLsizei width, GLsizei height )
  2343. {
  2344.    Node *n;
  2345.    FLUSH_VB(ctx, "dlist");
  2346.    n = alloc_instruction( ctx,  OPCODE_VIEWPORT, 4 );
  2347.    if (n) {
  2348.       n[1].i = x;
  2349.       n[2].i = y;
  2350.       n[3].i = (GLint) width;
  2351.       n[4].i = (GLint) height;
  2352.    }
  2353.    if (ctx->ExecuteFlag) {
  2354.       (*ctx->Exec.Viewport)( ctx, x, y, width, height );
  2355.    }
  2356. }
  2357.  
  2358.  
  2359. static void save_WindowPos4fMESA( GLcontext *ctx,
  2360.                               GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  2361. {
  2362.    Node *n;
  2363.    FLUSH_VB(ctx, "dlist");
  2364.    n = alloc_instruction( ctx,  OPCODE_WINDOW_POS, 4 );
  2365.    if (n) {
  2366.       n[1].f = x;
  2367.       n[2].f = y;
  2368.       n[3].f = z;
  2369.       n[4].f = w;
  2370.    }
  2371.    if (ctx->ExecuteFlag) {
  2372.       (*ctx->Exec.WindowPos4fMESA)( ctx, x, y, z, w );
  2373.    }
  2374. }
  2375.  
  2376.  
  2377.  
  2378.  
  2379.  
  2380.  
  2381. /* GL_ARB_multitexture */
  2382. static void save_ActiveTexture( GLcontext *ctx, GLenum target )
  2383. {
  2384.    Node *n;
  2385.    FLUSH_VB(ctx, "dlist");
  2386.    n = alloc_instruction( ctx, OPCODE_ACTIVE_TEXTURE, 1 );
  2387.    if (n) {
  2388.       n[1].e = target;
  2389.    }
  2390.    if (ctx->ExecuteFlag) {
  2391.       (*ctx->Exec.ActiveTexture)( ctx, target );
  2392.    }
  2393. }
  2394.  
  2395.  
  2396. /* GL_ARB_multitexture */
  2397. static void save_ClientActiveTexture( GLcontext *ctx, GLenum target )
  2398. {
  2399.    Node *n;
  2400.    FLUSH_VB(ctx, "dlist");
  2401.    n = alloc_instruction( ctx, OPCODE_CLIENT_ACTIVE_TEXTURE, 1 );
  2402.    if (n) {
  2403.       n[1].e = target;
  2404.    }
  2405.    if (ctx->ExecuteFlag) {
  2406.       (*ctx->Exec.ClientActiveTexture)( ctx, target );
  2407.    }
  2408. }
  2409.  
  2410.  
  2411.  
  2412. void gl_compile_cassette( GLcontext *ctx )
  2413. {
  2414.    Node *n = alloc_instruction( ctx, OPCODE_VERTEX_CASSETTE, 8 );
  2415.    struct immediate *im = ctx->input;   
  2416.  
  2417.    if (!n) 
  2418.       return;
  2419.    
  2420.  
  2421.    /* Do some easy optimizations of the cassette.  
  2422.     */
  2423. #if 0
  2424.    if (0 && im->v.Obj.size < 4 && im->Count > 15) {
  2425.       im->Bounds = (GLfloat (*)[3]) MALLOC(6 * sizeof(GLfloat));
  2426.       (gl_calc_bound_tab[im->v.Obj.size])( im->Bounds, &im->v.Obj );
  2427.    }
  2428. #endif
  2429.  
  2430.    n[1].data = (void *)im;   
  2431.    n[2].ui = im->Start;
  2432.    n[3].ui = im->Count;
  2433.    n[4].ui = im->BeginState;
  2434.    n[5].ui = im->OrFlag;
  2435.    n[6].ui = im->AndFlag;
  2436.    n[7].ui = im->LastData;
  2437.    n[8].ui = im->LastPrimitive;
  2438.  
  2439.    if (im->Count > VB_MAX - 4) {
  2440.  
  2441.       struct immediate *new_im = gl_immediate_alloc(ctx);      
  2442.       if (!new_im) return;
  2443.       SET_IMMEDIATE( ctx, new_im );
  2444.       gl_reset_input( ctx );
  2445.  
  2446.    } else {
  2447.       im->Count++;;
  2448.       im->Start = im->Count;    /* don't clear anything in reset_input */
  2449.       im->ref_count++;
  2450.  
  2451.       im->Primitive[im->Start] = ctx->Current.Primitive;
  2452.       im->LastPrimitive = im->Start;
  2453.       im->BeginState = VERT_BEGIN_0;
  2454.       im->OrFlag = 0;
  2455.       im->AndFlag = ~0;
  2456.  
  2457.       if (0)
  2458.      fprintf(stderr, "in compile_cassette, BeginState is %x\n", 
  2459.           im->BeginState);
  2460.    }   
  2461. }
  2462.  
  2463. /* KW: Compile commands  
  2464.  * 
  2465.  * Will appear in the list before the vertex buffer containing the
  2466.  * command that provoked the error.  I don't see this as a problem.  
  2467.  */
  2468. void gl_save_error( GLcontext *ctx, GLenum error, const char *s )
  2469. {
  2470.    Node *n;
  2471.    n = alloc_instruction( ctx, OPCODE_ERROR, 2 );
  2472.    if (n) {
  2473.       n[1].e = error;
  2474.       n[2].data = (void *) s;
  2475.    }
  2476.    /* execute already done */
  2477. }
  2478.  
  2479. /**********************************************************************/
  2480. /*                     Display list execution                         */
  2481. /**********************************************************************/
  2482.  
  2483.  
  2484. /*
  2485.  * Execute a display list.  Note that the ListBase offset must have already
  2486.  * been added before calling this function.  I.e. the list argument is
  2487.  * the absolute list number, not relative to ListBase.
  2488.  * Input:  list - display list number
  2489.  */
  2490. static void execute_list( GLcontext *ctx, GLuint list )
  2491. {
  2492.    static struct gl_pixelstore_attrib defaultPacking = {
  2493.       1,            /* Alignment */
  2494.       0,            /* RowLength */
  2495.       0,            /* SkipPixels */
  2496.       0,            /* SkipRows */
  2497.       0,            /* ImageHeight */
  2498.       0,            /* SkipImages */
  2499.       GL_FALSE,     /* SwapBytes */
  2500.       GL_FALSE      /* LsbFirst */
  2501.    };
  2502.    Node *n;
  2503.    GLboolean done;
  2504.    OpCode opcode;
  2505.  
  2506.    if (!gl_IsList(ctx,list))
  2507.       return;
  2508.  
  2509. /*    mesa_print_display_list( list ); */
  2510.  
  2511.    ctx->CallDepth++;
  2512.  
  2513.    n = (Node *) HashLookup(ctx->Shared->DisplayList, list);
  2514.  
  2515.    done = GL_FALSE;
  2516.    while (!done) {
  2517.       opcode = n[0].opcode;
  2518.  
  2519.       switch (opcode) {
  2520.          case OPCODE_ERROR:
  2521.          gl_error( ctx, n[1].e, (const char *) n[2].data ); 
  2522.             break;
  2523.          case OPCODE_VERTEX_CASSETTE: {
  2524.         struct immediate *IM;
  2525.  
  2526.         if (ctx->NewState)
  2527.            gl_update_state(ctx);
  2528.         if (ctx->CompileCVAFlag) {
  2529.            ctx->CompileCVAFlag = 0;
  2530.            ctx->CVA.elt.pipeline_valid = 0;
  2531.         }
  2532.         if (!ctx->CVA.elt.pipeline_valid)
  2533.            gl_build_immediate_pipeline( ctx );
  2534.  
  2535.         
  2536.         IM = (struct immediate *) n[1].data;
  2537.         IM->Start = n[2].ui;
  2538.         IM->Count = n[3].ui;
  2539.         IM->BeginState = n[4].ui;
  2540.         IM->OrFlag = n[5].ui;
  2541.         IM->AndFlag = n[6].ui;
  2542.         IM->LastData = n[7].ui;
  2543.         IM->LastPrimitive = n[8].ui;
  2544.  
  2545.         if ((MESA_VERBOSE & VERBOSE_DISPLAY_LIST) &&
  2546.         (MESA_VERBOSE & VERBOSE_IMMEDIATE))
  2547.            gl_print_cassette( (struct immediate *) n[1].data );
  2548.  
  2549.         if (0)
  2550.            fprintf(stderr, "Run cassette %d, rows %d..%d, beginstate %x\n",
  2551.                IM->id,
  2552.                IM->Start, IM->Count, IM->BeginState);
  2553.  
  2554.         gl_fixup_cassette( ctx, (struct immediate *) n[1].data ); 
  2555.         gl_execute_cassette( ctx, (struct immediate *) n[1].data ); 
  2556.             break;
  2557.      }
  2558.          case OPCODE_ACCUM:
  2559.         gl_Accum( ctx, n[1].e, n[2].f );
  2560.         break;
  2561.          case OPCODE_ALPHA_FUNC:
  2562.         gl_AlphaFunc( ctx, n[1].e, n[2].f );
  2563.         break;
  2564.          case OPCODE_BIND_TEXTURE:
  2565.             gl_BindTexture( ctx, n[1].e, n[2].ui );
  2566.             break;
  2567.      case OPCODE_BITMAP:
  2568.             {
  2569.                const struct gl_image *image = (struct gl_image *) n[7].data;
  2570.                const GLubyte *bitmap = image ? image->Data : NULL;
  2571.                gl_Bitmap( ctx, (GLsizei) n[1].i, (GLsizei) n[2].i,
  2572.                           n[3].f, n[4].f, n[5].f, n[6].f,
  2573.                           bitmap, &defaultPacking );
  2574.             }
  2575.         break;
  2576.      case OPCODE_BLEND_COLOR:
  2577.         gl_BlendColor( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
  2578.         break;
  2579.      case OPCODE_BLEND_EQUATION:
  2580.         gl_BlendEquation( ctx, n[1].e );
  2581.         break;
  2582.      case OPCODE_BLEND_FUNC:
  2583.         gl_BlendFunc( ctx, n[1].e, n[2].e );
  2584.         break;
  2585.      case OPCODE_BLEND_FUNC_SEPARATE:
  2586.         gl_BlendFuncSeparate( ctx, n[1].e, n[2].e, n[3].e, n[4].e );
  2587.         break;
  2588.          case OPCODE_CALL_LIST:
  2589.         /* Generated by glCallList(), don't add ListBase */
  2590.             if (ctx->CallDepth<MAX_LIST_NESTING) {
  2591.                execute_list( ctx, n[1].ui );
  2592.             }
  2593.             break;
  2594.          case OPCODE_CALL_LIST_OFFSET:
  2595.         /* Generated by glCallLists() so we must add ListBase */
  2596.             if (ctx->CallDepth<MAX_LIST_NESTING) {
  2597.                execute_list( ctx, ctx->List.ListBase + n[1].ui );
  2598.             }
  2599.             break;
  2600.      case OPCODE_CLEAR:
  2601.         gl_Clear( ctx, n[1].bf );
  2602.         break;
  2603.      case OPCODE_CLEAR_COLOR:
  2604.         gl_ClearColor( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
  2605.         break;
  2606.      case OPCODE_CLEAR_ACCUM:
  2607.         gl_ClearAccum( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
  2608.         break;
  2609.      case OPCODE_CLEAR_DEPTH:
  2610.         gl_ClearDepth( ctx, (GLclampd) n[1].f );
  2611.         break;
  2612.      case OPCODE_CLEAR_INDEX:
  2613.         gl_ClearIndex( ctx, n[1].ui );
  2614.         break;
  2615.      case OPCODE_CLEAR_STENCIL:
  2616.         gl_ClearStencil( ctx, n[1].i );
  2617.         break;
  2618.          case OPCODE_CLIP_PLANE:
  2619.             {
  2620.                GLfloat equ[4];
  2621.                equ[0] = n[2].f;
  2622.                equ[1] = n[3].f;
  2623.                equ[2] = n[4].f;
  2624.                equ[3] = n[5].f;
  2625.                gl_ClipPlane( ctx, n[1].e, equ );
  2626.             }
  2627.             break;
  2628.      case OPCODE_COLOR_MASK:
  2629.         gl_ColorMask( ctx, n[1].b, n[2].b, n[3].b, n[4].b );
  2630.         break;
  2631.      case OPCODE_COLOR_MATERIAL:
  2632.         gl_ColorMaterial( ctx, n[1].e, n[2].e );
  2633.         break;
  2634.          case OPCODE_COLOR_TABLE:
  2635.             gl_ColorTable( ctx, n[1].e, n[2].e, (struct gl_image *) n[3].data);
  2636.             break;
  2637.          case OPCODE_COLOR_SUB_TABLE:
  2638.             gl_ColorSubTable( ctx, n[1].e, n[2].i,
  2639.                               (struct gl_image *) n[3].data);
  2640.             break;
  2641.      case OPCODE_COPY_PIXELS:
  2642.         gl_CopyPixels( ctx, n[1].i, n[2].i,
  2643.                (GLsizei) n[3].i, (GLsizei) n[4].i, n[5].e );
  2644.         break;
  2645.          case OPCODE_COPY_TEX_IMAGE1D:
  2646.         gl_CopyTexImage1D( ctx, n[1].e, n[2].i, n[3].e, n[4].i,
  2647.                                n[5].i, n[6].i, n[7].i );
  2648.             break;
  2649.          case OPCODE_COPY_TEX_IMAGE2D:
  2650.         gl_CopyTexImage2D( ctx, n[1].e, n[2].i, n[3].e, n[4].i,
  2651.                                n[5].i, n[6].i, n[7].i, n[8].i );
  2652.             break;
  2653.          case OPCODE_COPY_TEX_SUB_IMAGE1D:
  2654.         gl_CopyTexSubImage1D( ctx, n[1].e, n[2].i, n[3].i, n[4].i,
  2655.                                   n[5].i, n[6].i );
  2656.             break;
  2657.          case OPCODE_COPY_TEX_SUB_IMAGE2D:
  2658.         gl_CopyTexSubImage2D( ctx, n[1].e, n[2].i, n[3].i, n[4].i,
  2659.                                   n[5].i, n[6].i, n[7].i, n[8].i );
  2660.             break;
  2661.          case OPCODE_COPY_TEX_SUB_IMAGE3D:
  2662.             gl_CopyTexSubImage3D( ctx, n[1].e, n[2].i, n[3].i, n[4].i,
  2663.                                   n[5].i, n[6].i, n[7].i, n[8].i, n[9].i);
  2664.             break;
  2665.      case OPCODE_CULL_FACE:
  2666.         gl_CullFace( ctx, n[1].e );
  2667.         break;
  2668.      case OPCODE_DEPTH_FUNC:
  2669.         gl_DepthFunc( ctx, n[1].e );
  2670.         break;
  2671.      case OPCODE_DEPTH_MASK:
  2672.         gl_DepthMask( ctx, n[1].b );
  2673.         break;
  2674.      case OPCODE_DEPTH_RANGE:
  2675.         gl_DepthRange( ctx, (GLclampd) n[1].f, (GLclampd) n[2].f );
  2676.         break;
  2677.      case OPCODE_DISABLE:
  2678.         gl_Disable( ctx, n[1].e );
  2679.         break;
  2680.      case OPCODE_DRAW_BUFFER:
  2681.         gl_DrawBuffer( ctx, n[1].e );
  2682.         break;
  2683.      case OPCODE_DRAW_PIXELS:
  2684.         gl_DrawPixels( ctx, (struct gl_image *) n[1].data );
  2685.         break;
  2686.      case OPCODE_ENABLE:
  2687.         gl_Enable( ctx, n[1].e );
  2688.         break;
  2689.      case OPCODE_EVALMESH1:
  2690.         gl_EvalMesh1( ctx, n[1].e, n[2].i, n[3].i );
  2691.         break;
  2692.      case OPCODE_EVALMESH2:
  2693.         gl_EvalMesh2( ctx, n[1].e, n[2].i, n[3].i, n[4].i, n[5].i );
  2694.         break;
  2695.      case OPCODE_FOG:
  2696.         {
  2697.            GLfloat p[4];
  2698.            p[0] = n[2].f;
  2699.            p[1] = n[3].f;
  2700.            p[2] = n[4].f;
  2701.            p[3] = n[5].f;
  2702.            gl_Fogfv( ctx, n[1].e, p );
  2703.         }
  2704.         break;
  2705.      case OPCODE_FRONT_FACE:
  2706.         gl_FrontFace( ctx, n[1].e );
  2707.         break;
  2708.          case OPCODE_FRUSTUM:
  2709.             gl_Frustum( ctx, n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
  2710.             break;
  2711.      case OPCODE_HINT:
  2712.         gl_Hint( ctx, n[1].e, n[2].e );
  2713.         break;
  2714.      case OPCODE_INDEX_MASK:
  2715.         gl_IndexMask( ctx, n[1].ui );
  2716.         break;
  2717.      case OPCODE_INIT_NAMES:
  2718.         gl_InitNames( ctx );
  2719.         break;
  2720.          case OPCODE_LIGHT:
  2721.         {
  2722.            GLfloat p[4];
  2723.            p[0] = n[3].f;
  2724.            p[1] = n[4].f;
  2725.            p[2] = n[5].f;
  2726.            p[3] = n[6].f;
  2727.            gl_Lightfv( ctx, n[1].e, n[2].e, p, 4 );
  2728.         }
  2729.         break;
  2730.          case OPCODE_LIGHT_MODEL:
  2731.         {
  2732.            GLfloat p[4];
  2733.            p[0] = n[2].f;
  2734.            p[1] = n[3].f;
  2735.            p[2] = n[4].f;
  2736.            p[3] = n[5].f;
  2737.            gl_LightModelfv( ctx, n[1].e, p );
  2738.         }
  2739.         break;
  2740.      case OPCODE_LINE_STIPPLE:
  2741.         gl_LineStipple( ctx, n[1].i, n[2].us );
  2742.         break;
  2743.      case OPCODE_LINE_WIDTH:
  2744.         gl_LineWidth( ctx, n[1].f );
  2745.         break;
  2746.      case OPCODE_LIST_BASE:
  2747.         gl_ListBase( ctx, n[1].ui );
  2748.         break;
  2749.      case OPCODE_LOAD_IDENTITY:
  2750.             gl_LoadIdentity( ctx );
  2751.             break;
  2752.      case OPCODE_LOAD_MATRIX:
  2753.         if (sizeof(Node)==sizeof(GLfloat)) {
  2754.            gl_LoadMatrixf( ctx, &n[1].f );
  2755.         }
  2756.         else {
  2757.            GLfloat m[16];
  2758.            GLuint i;
  2759.            for (i=0;i<16;i++) {
  2760.           m[i] = n[1+i].f;
  2761.            }
  2762.            gl_LoadMatrixf( ctx, m );
  2763.         }
  2764.         break;
  2765.      case OPCODE_LOAD_NAME:
  2766.         gl_LoadName( ctx, n[1].ui );
  2767.         break;
  2768.      case OPCODE_LOGIC_OP:
  2769.         gl_LogicOp( ctx, n[1].e );
  2770.         break;
  2771.      case OPCODE_MAP1:
  2772.         gl_Map1f( ctx, n[1].e, n[2].f, n[3].f,
  2773.                       n[4].i, n[5].i, (GLfloat *) n[6].data, GL_TRUE );
  2774.         break;
  2775.      case OPCODE_MAP2:
  2776.         gl_Map2f( ctx, n[1].e,
  2777.                       n[2].f, n[3].f,  /* u1, u2 */
  2778.               n[6].i, n[8].i,  /* ustride, uorder */
  2779.               n[4].f, n[5].f,  /* v1, v2 */
  2780.               n[7].i, n[9].i,  /* vstride, vorder */
  2781.               (GLfloat *) n[10].data,
  2782.                       GL_TRUE);
  2783.         break;
  2784.      case OPCODE_MAPGRID1:
  2785.         gl_MapGrid1f( ctx, n[1].i, n[2].f, n[3].f );
  2786.         break;
  2787.      case OPCODE_MAPGRID2:
  2788.         gl_MapGrid2f( ctx, n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);
  2789.         break;
  2790.          case OPCODE_MATRIX_MODE:
  2791.             gl_MatrixMode( ctx, n[1].e );
  2792.             break;
  2793.      case OPCODE_MULT_MATRIX:
  2794.         if (sizeof(Node)==sizeof(GLfloat)) {
  2795.            gl_MultMatrixf( ctx, &n[1].f );
  2796.         }
  2797.         else {
  2798.            GLfloat m[16];
  2799.            GLuint i;
  2800.            for (i=0;i<16;i++) {
  2801.           m[i] = n[1+i].f;
  2802.            }
  2803.            gl_MultMatrixf( ctx, m );
  2804.         }
  2805.         break;
  2806.          case OPCODE_ORTHO:
  2807.             gl_Ortho( ctx, n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
  2808.             break;
  2809.      case OPCODE_PASSTHROUGH:
  2810.         gl_PassThrough( ctx, n[1].f );
  2811.         break;
  2812.      case OPCODE_PIXEL_MAP:
  2813.         gl_PixelMapfv( ctx, n[1].e, n[2].i, (GLfloat *) n[3].data );
  2814.         break;
  2815.      case OPCODE_PIXEL_TRANSFER:
  2816.         gl_PixelTransferf( ctx, n[1].e, n[2].f );
  2817.         break;
  2818.      case OPCODE_PIXEL_ZOOM:
  2819.         gl_PixelZoom( ctx, n[1].f, n[2].f );
  2820.         break;
  2821.      case OPCODE_POINT_SIZE:
  2822.         gl_PointSize( ctx, n[1].f );
  2823.         break;
  2824.      case OPCODE_POINT_PARAMETERS:
  2825.         {
  2826.         GLfloat params[3];
  2827.         params[0] = n[2].f;
  2828.         params[1] = n[3].f;
  2829.         params[2] = n[4].f;
  2830.         gl_PointParameterfvEXT( ctx, n[1].e, params ); 
  2831.         }
  2832.         break;
  2833.      case OPCODE_POLYGON_MODE:
  2834.         gl_PolygonMode( ctx, n[1].e, n[2].e );
  2835.         break;
  2836.      case OPCODE_POLYGON_STIPPLE:
  2837.         gl_PolygonStipple( ctx, (GLuint *) n[1].data );
  2838.         break;
  2839.      case OPCODE_POLYGON_OFFSET:
  2840.         gl_PolygonOffset( ctx, n[1].f, n[2].f );
  2841.         break;
  2842.      case OPCODE_POP_ATTRIB:
  2843.         gl_PopAttrib( ctx );
  2844.         break;
  2845.      case OPCODE_POP_MATRIX:
  2846.         gl_PopMatrix( ctx );
  2847.         break;
  2848.      case OPCODE_POP_NAME:
  2849.         gl_PopName( ctx );
  2850.         break;
  2851.      case OPCODE_PRIORITIZE_TEXTURE:
  2852.             gl_PrioritizeTextures( ctx, 1, &n[1].ui, &n[2].f );
  2853.         break;
  2854.      case OPCODE_PUSH_ATTRIB:
  2855.         gl_PushAttrib( ctx, n[1].bf );
  2856.         break;
  2857.      case OPCODE_PUSH_MATRIX:
  2858.         gl_PushMatrix( ctx );
  2859.         break;
  2860.      case OPCODE_PUSH_NAME:
  2861.         gl_PushName( ctx, n[1].ui );
  2862.         break;
  2863.      case OPCODE_RASTER_POS:
  2864.             gl_RasterPos4f( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
  2865.         break;
  2866.      case OPCODE_READ_BUFFER:
  2867.         gl_ReadBuffer( ctx, n[1].e );
  2868.         break;
  2869.          case OPCODE_RECTF:
  2870.             gl_Rectf( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
  2871.             break;
  2872.          case OPCODE_SCALE:
  2873.             gl_Scalef( ctx, n[1].f, n[2].f, n[3].f );
  2874.             break;
  2875.      case OPCODE_SCISSOR:
  2876.         gl_Scissor( ctx, n[1].i, n[2].i, n[3].i, n[4].i );
  2877.         break;
  2878.      case OPCODE_SHADE_MODEL:
  2879.         gl_ShadeModel( ctx, n[1].e );
  2880.         break;
  2881.      case OPCODE_STENCIL_FUNC:
  2882.         gl_StencilFunc( ctx, n[1].e, n[2].i, n[3].ui );
  2883.         break;
  2884.      case OPCODE_STENCIL_MASK:
  2885.         gl_StencilMask( ctx, n[1].ui );
  2886.         break;
  2887.      case OPCODE_STENCIL_OP:
  2888.         gl_StencilOp( ctx, n[1].e, n[2].e, n[3].e );
  2889.         break;
  2890.          case OPCODE_TEXENV:
  2891.             {
  2892.                GLfloat params[4];
  2893.                params[0] = n[3].f;
  2894.                params[1] = n[4].f;
  2895.                params[2] = n[5].f;
  2896.                params[3] = n[6].f;
  2897.                gl_TexEnvfv( ctx, n[1].e, n[2].e, params );
  2898.             }
  2899.             break;
  2900.          case OPCODE_TEXGEN:
  2901.             {
  2902.                GLfloat params[4];
  2903.                params[0] = n[3].f;
  2904.                params[1] = n[4].f;
  2905.                params[2] = n[5].f;
  2906.                params[3] = n[6].f;
  2907.                gl_TexGenfv( ctx, n[1].e, n[2].e, params );
  2908.             }
  2909.             break;
  2910.          case OPCODE_TEXPARAMETER:
  2911.             {
  2912.                GLfloat params[4];
  2913.                params[0] = n[3].f;
  2914.                params[1] = n[4].f;
  2915.                params[2] = n[5].f;
  2916.                params[3] = n[6].f;
  2917.                gl_TexParameterfv( ctx, n[1].e, n[2].e, params );
  2918.             }
  2919.             break;
  2920.      case OPCODE_TEX_IMAGE1D:
  2921.             {
  2922.                struct gl_pixelstore_attrib save = ctx->Unpack;
  2923.                ctx->Unpack = defaultPacking;
  2924.                gl_TexImage1D( ctx,
  2925.                               n[1].e, /* target */
  2926.                               n[2].i, /* level */
  2927.                               n[3].i, /* components */
  2928.                               n[4].i, /* width */
  2929.                               n[5].e, /* border */
  2930.                               n[6].e, /* format */
  2931.                               n[7].e, /* type */
  2932.                               n[8].data );
  2933.                ctx->Unpack = save;  /* restore */
  2934.             }
  2935.         break;
  2936.      case OPCODE_TEX_IMAGE2D:
  2937.             {
  2938.                struct gl_pixelstore_attrib save = ctx->Unpack;
  2939.                ctx->Unpack = defaultPacking;
  2940.                gl_TexImage2D( ctx,
  2941.                               n[1].e, /* target */
  2942.                               n[2].i, /* level */
  2943.                               n[3].i, /* components */
  2944.                               n[4].i, /* width */
  2945.                               n[5].i, /* height */
  2946.                               n[6].e, /* border */
  2947.                               n[7].e, /* format */
  2948.                               n[8].e, /* type */
  2949.                               n[9].data );
  2950.                ctx->Unpack = save;  /* restore */
  2951.             }
  2952.         break;
  2953.          case OPCODE_TEX_IMAGE3D:
  2954.             {
  2955.                struct gl_pixelstore_attrib save = ctx->Unpack;
  2956.                ctx->Unpack = defaultPacking;
  2957.                gl_TexImage3D( ctx,
  2958.                               n[1].e, /* target */
  2959.                               n[2].i, /* level */
  2960.                               n[3].i, /* components */
  2961.                               n[4].i, /* width */
  2962.                               n[5].i, /* height */
  2963.                               n[6].i, /* depth  */
  2964.                               n[7].e, /* border */
  2965.                               n[8].e, /* format */
  2966.                               n[9].e, /* type */
  2967.                               n[10].data );
  2968.                ctx->Unpack = save;  /* restore */
  2969.             }
  2970.             break;
  2971.          case OPCODE_TEX_SUB_IMAGE1D:
  2972.             {
  2973.                struct gl_pixelstore_attrib save = ctx->Unpack;
  2974.                ctx->Unpack = defaultPacking;
  2975.                gl_TexSubImage1D( ctx, n[1].e, n[2].i, n[3].i, n[4].i, n[5].e,
  2976.                                  n[6].e, n[7].data );
  2977.                ctx->Unpack = save;  /* restore */
  2978.             }
  2979.             break;
  2980.          case OPCODE_TEX_SUB_IMAGE2D:
  2981.             {
  2982.                struct gl_pixelstore_attrib save = ctx->Unpack;
  2983.                ctx->Unpack = defaultPacking;
  2984.                (*ctx->Exec.TexSubImage2D)( ctx, n[1].e, n[2].i, n[3].i,
  2985.                                            n[4].i, n[5].e,
  2986.                                            n[6].i, n[7].e, n[8].e, n[9].data );
  2987.                ctx->Unpack = save;  /* restore */
  2988.             }
  2989.             break;
  2990.          case OPCODE_TEX_SUB_IMAGE3D:
  2991.             {
  2992.                struct gl_pixelstore_attrib save = ctx->Unpack;
  2993.                ctx->Unpack = defaultPacking;
  2994.                gl_TexSubImage3D( ctx, n[1].e, n[2].i, n[3].i, n[4].i, n[5].i,
  2995.                                  n[6].i, n[7].i, n[8].i, n[9].e, n[10].e,
  2996.                                  n[11].data );
  2997.                ctx->Unpack = save;  /* restore */
  2998.             }
  2999.             break;
  3000.          case OPCODE_TRANSLATE:
  3001.             gl_Translatef( ctx, n[1].f, n[2].f, n[3].f );
  3002.             break;
  3003.      case OPCODE_VIEWPORT:
  3004.         gl_Viewport( ctx,
  3005.                          n[1].i, n[2].i, (GLsizei) n[3].i, (GLsizei) n[4].i );
  3006.         break;
  3007.      case OPCODE_WINDOW_POS:
  3008.             gl_WindowPos4fMESA( ctx, n[1].f, n[2].f, n[3].f, n[4].f );
  3009.         break;
  3010.          case OPCODE_ACTIVE_TEXTURE:  /* GL_ARB_multitexture */
  3011.             gl_ActiveTexture( ctx, n[1].e );
  3012.             break;
  3013.          case OPCODE_CLIENT_ACTIVE_TEXTURE:  /* GL_ARB_multitexture */
  3014.             gl_ClientActiveTexture( ctx, n[1].e );
  3015.             break;
  3016.      case OPCODE_CONTINUE:
  3017.         n = (Node *) n[1].next;
  3018.         break;
  3019.      case OPCODE_END_OF_LIST:
  3020.         done = GL_TRUE;
  3021.         break;
  3022.      default:
  3023.             {
  3024.                char msg[1000];
  3025.                sprintf(msg, "Error in execute_list: opcode=%d", (int) opcode);
  3026.                gl_problem( ctx, msg );
  3027.             }
  3028.             done = GL_TRUE;
  3029.       }
  3030.  
  3031.       /* increment n to point to next compiled command */
  3032.       if (opcode!=OPCODE_CONTINUE) {
  3033.      n += InstSize[opcode];
  3034.       }
  3035.  
  3036.    }
  3037.    ctx->CallDepth--;
  3038. }
  3039.  
  3040.  
  3041.  
  3042.  
  3043.  
  3044. /**********************************************************************/
  3045. /*                           GL functions                             */
  3046. /**********************************************************************/
  3047.  
  3048.  
  3049.  
  3050.  
  3051. /*
  3052.  * Test if a display list number is valid.
  3053.  */
  3054. GLboolean gl_IsList( GLcontext *ctx, GLuint list )
  3055. {
  3056.    if (list > 0 && HashLookup(ctx->Shared->DisplayList, list)) {
  3057.       return GL_TRUE;
  3058.    }
  3059.    else {
  3060.       return GL_FALSE;
  3061.    }
  3062. }
  3063.  
  3064.  
  3065.  
  3066. /*
  3067.  * Delete a sequence of consecutive display lists.
  3068.  */
  3069. void gl_DeleteLists( GLcontext *ctx, GLuint list, GLsizei range )
  3070. {
  3071.    GLuint i;
  3072.  
  3073.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDeleteLists");
  3074.    if (range<0) {
  3075.       gl_error( ctx, GL_INVALID_VALUE, "glDeleteLists" );
  3076.       return;
  3077.    }
  3078.    for (i=list;i<list+range;i++) {
  3079.       gl_destroy_list( ctx, i );
  3080.    }
  3081. }
  3082.  
  3083.  
  3084.  
  3085. /*
  3086.  * Return a display list number, n, such that lists n through n+range-1
  3087.  * are free.
  3088.  */
  3089. GLuint gl_GenLists( GLcontext *ctx, GLsizei range )
  3090. {
  3091.    GLuint base;
  3092.  
  3093.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glGenLists", 0);
  3094.    if (range<0) {
  3095.       gl_error( ctx, GL_INVALID_VALUE, "glGenLists" );
  3096.       return 0;
  3097.    }
  3098.    if (range==0) {
  3099.       return 0;
  3100.    }
  3101.  
  3102.    base = HashFindFreeKeyBlock(ctx->Shared->DisplayList, range);
  3103.    if (base) {
  3104.       /* reserve the list IDs by with empty/dummy lists */
  3105.       GLint i;
  3106.       for (i=0; i<range; i++) {
  3107.          HashInsert(ctx->Shared->DisplayList, base+i, make_empty_list());
  3108.       }
  3109.    }
  3110.    return base;
  3111. }
  3112.  
  3113.  
  3114.  
  3115. /*
  3116.  * Begin a new display list.
  3117.  */
  3118. void gl_NewList( GLcontext *ctx, GLuint list, GLenum mode )
  3119. {
  3120.    struct immediate *IM;
  3121.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glNewList");
  3122.  
  3123.    if (MESA_VERBOSE&VERBOSE_API)
  3124.       fprintf(stderr, "glNewList %u %s\n", list, gl_lookup_enum_by_nr(mode));
  3125.  
  3126.    if (list==0) {
  3127.       gl_error( ctx, GL_INVALID_VALUE, "glNewList" );
  3128.       return;
  3129.    }
  3130.  
  3131.    if (mode!=GL_COMPILE && mode!=GL_COMPILE_AND_EXECUTE) {
  3132.       gl_error( ctx, GL_INVALID_ENUM, "glNewList" );
  3133.       return;
  3134.    }
  3135.  
  3136.    if (ctx->CurrentListPtr) {
  3137.       /* already compiling a display list */
  3138.       gl_error( ctx, GL_INVALID_OPERATION, "glNewList" );
  3139.       return;
  3140.    }
  3141.  
  3142.    /* Allocate new display list */
  3143.    ctx->CurrentListNum = list;
  3144.    ctx->CurrentBlock = (Node *) MALLOC( sizeof(Node) * BLOCK_SIZE );
  3145.    ctx->CurrentListPtr = ctx->CurrentBlock;
  3146.    ctx->CurrentPos = 0;
  3147.  
  3148.    IM = gl_immediate_alloc( ctx );
  3149.    SET_IMMEDIATE( ctx, IM );
  3150.    gl_reset_input( ctx );
  3151.  
  3152.    ctx->CompileFlag = GL_TRUE;
  3153.    ctx->CompileCVAFlag = GL_FALSE;
  3154.    ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE);
  3155.    ctx->API = ctx->Save;  /* Switch the API function pointers */
  3156. }
  3157.  
  3158.  
  3159.  
  3160. /*
  3161.  * End definition of current display list.
  3162.  */
  3163. void gl_EndList( GLcontext *ctx )
  3164. {
  3165.    if (MESA_VERBOSE&VERBOSE_API)
  3166.       fprintf(stderr, "glEndList\n");
  3167.  
  3168.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "glEndList" );
  3169.  
  3170.    /* Check that a list is under construction */
  3171.    if (!ctx->CurrentListPtr) {
  3172.       gl_error( ctx, GL_INVALID_OPERATION, "glEndList" );
  3173.       return;
  3174.    }
  3175.  
  3176.    (void) alloc_instruction( ctx, OPCODE_END_OF_LIST, 0 );
  3177.  
  3178.  
  3179.  
  3180.    /* Destroy old list, if any */
  3181.    gl_destroy_list(ctx, ctx->CurrentListNum);
  3182.    /* Install the list */
  3183.    HashInsert(ctx->Shared->DisplayList, ctx->CurrentListNum, ctx->CurrentListPtr);
  3184.  
  3185.  
  3186.    if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST)
  3187.       mesa_print_display_list(ctx->CurrentListNum);
  3188.  
  3189.    ctx->CurrentListNum = 0;
  3190.    ctx->CurrentListPtr = NULL;
  3191.    ctx->ExecuteFlag = GL_TRUE;
  3192.    ctx->CompileFlag = GL_FALSE;
  3193.    /* ctx->CompileCVAFlag = ...; */
  3194.  
  3195.    /* KW: Put back the old input pointer.
  3196.     */
  3197.    if (--ctx->input->ref_count == 0)
  3198.       gl_immediate_free( ctx->input );
  3199.  
  3200.    SET_IMMEDIATE( ctx, ctx->VB->IM );
  3201.    gl_reset_input( ctx );
  3202.  
  3203.    /* Haven't tracked down why this is needed.
  3204.     */
  3205.    ctx->NewState = ~0;
  3206.  
  3207.    ctx->API = ctx->Exec;   /* Switch the API function pointers */
  3208. }
  3209.  
  3210.  
  3211.  
  3212. void gl_CallList( GLcontext *ctx, GLuint list )
  3213. {
  3214.    /* VERY IMPORTANT:  Save the CompileFlag status, turn it off, */
  3215.    /* execute the display list, and restore the CompileFlag. */
  3216.    GLboolean save_compile_flag;
  3217.  
  3218.    if (MESA_VERBOSE&VERBOSE_API) {
  3219.       fprintf(stderr, "glCallList %u\n", list);
  3220.       mesa_print_display_list( list ); 
  3221.    }
  3222.  
  3223.    save_compile_flag = ctx->CompileFlag;   
  3224.    ctx->CompileFlag = GL_FALSE;
  3225.    
  3226.    FLUSH_VB( ctx, "call list" );
  3227.    execute_list( ctx, list );
  3228.    ctx->CompileFlag = save_compile_flag;
  3229.  
  3230.    /* also restore API function pointers to point to "save" versions */
  3231.    if (save_compile_flag)
  3232.            ctx->API = ctx->Save;
  3233. }
  3234.  
  3235.  
  3236.  
  3237. /*
  3238.  * Execute glCallLists:  call multiple display lists.
  3239.  */
  3240. void gl_CallLists( GLcontext *ctx,
  3241.                    GLsizei n, GLenum type, const GLvoid *lists )
  3242. {
  3243.    GLuint list;
  3244.    GLint i;
  3245.    GLboolean save_compile_flag;
  3246.  
  3247.    /* Save the CompileFlag status, turn it off, execute display list,
  3248.     * and restore the CompileFlag.
  3249.     */
  3250.    save_compile_flag = ctx->CompileFlag;
  3251.    ctx->CompileFlag = GL_FALSE;
  3252.  
  3253.    FLUSH_VB( ctx, "call lists" );
  3254.  
  3255.    for (i=0;i<n;i++) {
  3256.       list = translate_id( i, type, lists );
  3257.       execute_list( ctx, ctx->List.ListBase + list );
  3258.    }
  3259.  
  3260.    ctx->CompileFlag = save_compile_flag;
  3261.  
  3262.    /* also restore API function pointers to point to "save" versions */
  3263.    if (save_compile_flag)
  3264.            ctx->API = ctx->Save;
  3265.  
  3266.  
  3267. /*    RESET_IMMEDIATE( ctx ); */
  3268. }
  3269.  
  3270.  
  3271.  
  3272. /*
  3273.  * Set the offset added to list numbers in glCallLists.
  3274.  */
  3275. void gl_ListBase( GLcontext *ctx, GLuint base )
  3276. {
  3277.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glListBase");
  3278.    ctx->List.ListBase = base;
  3279. }
  3280.  
  3281.  
  3282.  
  3283.  
  3284.  
  3285.  
  3286. /*
  3287.  * Assign all the pointers in 'table' to point to Mesa's display list
  3288.  * building functions.
  3289.  */
  3290. void gl_init_dlist_pointers( struct gl_api_table *table )
  3291. {
  3292.    table->Accum = save_Accum;
  3293.    table->AlphaFunc = save_AlphaFunc;
  3294.    table->AreTexturesResident = gl_AreTexturesResident;
  3295.    table->BindTexture = save_BindTexture;
  3296.    table->Bitmap = save_Bitmap;
  3297.    table->BlendColor = save_BlendColor;
  3298.    table->BlendEquation = save_BlendEquation;
  3299.    table->BlendFunc = save_BlendFunc;
  3300.    table->BlendFuncSeparate = save_BlendFuncSeparate;
  3301.    table->CallList = save_CallList;
  3302.    table->CallLists = save_CallLists;
  3303.    table->Clear = save_Clear;
  3304.    table->ClearAccum = save_ClearAccum;
  3305.    table->ClearColor = save_ClearColor;
  3306.    table->ClearDepth = save_ClearDepth;
  3307.    table->ClearIndex = save_ClearIndex;
  3308.    table->ClearStencil = save_ClearStencil;
  3309.    table->ClipPlane = save_ClipPlane;
  3310.    table->ColorMask = save_ColorMask;
  3311.    table->ColorMaterial = save_ColorMaterial;
  3312.    table->ColorTable = save_ColorTable;
  3313.    table->ColorSubTable = save_ColorSubTable;
  3314.    table->CopyPixels = save_CopyPixels;
  3315.    table->CopyTexImage1D = save_CopyTexImage1D;
  3316.    table->CopyTexImage2D = save_CopyTexImage2D;
  3317.    table->CopyTexSubImage1D = save_CopyTexSubImage1D;
  3318.    table->CopyTexSubImage2D = save_CopyTexSubImage2D;
  3319.    table->CopyTexSubImage3D = save_CopyTexSubImage3D;
  3320.    table->CullFace = save_CullFace;
  3321.    table->DeleteLists = gl_DeleteLists;   /* NOT SAVED */
  3322.    table->DeleteTextures = gl_DeleteTextures;  /* NOT SAVED */
  3323.    table->DepthFunc = save_DepthFunc;
  3324.    table->DepthMask = save_DepthMask;
  3325.    table->DepthRange = save_DepthRange;
  3326.    table->Disable = save_Disable;
  3327.    table->DisableClientState = gl_DisableClientState;  /* NOT SAVED */
  3328.    table->DrawBuffer = save_DrawBuffer;
  3329.    table->DrawPixels = save_DrawPixels;
  3330.    table->Enable = save_Enable;
  3331.    table->Error = gl_save_error;
  3332.    table->EnableClientState = gl_EnableClientState;   /* NOT SAVED */
  3333.    table->EndList = gl_EndList;   /* NOT SAVED */
  3334.    table->EvalMesh1 = save_EvalMesh1;
  3335.    table->EvalMesh2 = save_EvalMesh2;
  3336.    table->FeedbackBuffer = gl_FeedbackBuffer;   /* NOT SAVED */
  3337.    table->Finish = gl_Finish;   /* NOT SAVED */
  3338.    table->Flush = gl_Flush;   /* NOT SAVED */
  3339.    table->Fogfv = save_Fogfv;
  3340.    table->FrontFace = save_FrontFace;
  3341.    table->Frustum = save_Frustum;
  3342.    table->GenLists = gl_GenLists;   /* NOT SAVED */
  3343.    table->GenTextures = gl_GenTextures;   /* NOT SAVED */
  3344.  
  3345.    /* NONE OF THESE COMMANDS ARE COMPILED INTO DISPLAY LISTS */
  3346.    table->GetBooleanv = gl_GetBooleanv;
  3347.    table->GetClipPlane = gl_GetClipPlane;
  3348.    table->GetColorTable = gl_GetColorTable;
  3349.    table->GetColorTableParameteriv = gl_GetColorTableParameteriv;
  3350.    table->GetDoublev = gl_GetDoublev;
  3351.    table->GetError = gl_GetError;
  3352.    table->GetFloatv = gl_GetFloatv;
  3353.    table->GetIntegerv = gl_GetIntegerv;
  3354.    table->GetString = gl_GetString;
  3355.    table->GetLightfv = gl_GetLightfv;
  3356.    table->GetLightiv = gl_GetLightiv;
  3357.    table->GetMapdv = gl_GetMapdv;
  3358.    table->GetMapfv = gl_GetMapfv;
  3359.    table->GetMapiv = gl_GetMapiv;
  3360.    table->GetMaterialfv = gl_GetMaterialfv;
  3361.    table->GetMaterialiv = gl_GetMaterialiv;
  3362.    table->GetPixelMapfv = gl_GetPixelMapfv;
  3363.    table->GetPixelMapuiv = gl_GetPixelMapuiv;
  3364.    table->GetPixelMapusv = gl_GetPixelMapusv;
  3365.    table->GetPointerv = gl_GetPointerv;
  3366.    table->GetPolygonStipple = gl_GetPolygonStipple;
  3367.    table->GetTexEnvfv = gl_GetTexEnvfv;
  3368.    table->GetTexEnviv = gl_GetTexEnviv;
  3369.    table->GetTexGendv = gl_GetTexGendv;
  3370.    table->GetTexGenfv = gl_GetTexGenfv;
  3371.    table->GetTexGeniv = gl_GetTexGeniv;
  3372.    table->GetTexImage = gl_GetTexImage;
  3373.    table->GetTexLevelParameterfv = gl_GetTexLevelParameterfv;
  3374.    table->GetTexLevelParameteriv = gl_GetTexLevelParameteriv;
  3375.    table->GetTexParameterfv = gl_GetTexParameterfv;
  3376.    table->GetTexParameteriv = gl_GetTexParameteriv;
  3377.  
  3378.    table->Hint = save_Hint;
  3379.    table->IndexMask = save_IndexMask;
  3380.    table->InitNames = save_InitNames;
  3381.    table->IsEnabled = gl_IsEnabled;   /* NOT SAVED */
  3382.    table->IsTexture = gl_IsTexture;   /* NOT SAVED */
  3383.    table->IsList = gl_IsList;   /* NOT SAVED */
  3384.    table->LightModelfv = save_LightModelfv;
  3385.    table->Lightfv = save_Lightfv;
  3386.    table->LineStipple = save_LineStipple;
  3387.    table->LineWidth = save_LineWidth;
  3388.    table->ListBase = save_ListBase;
  3389.    table->LoadIdentity = save_LoadIdentity;
  3390.    table->LoadMatrixf = save_LoadMatrixf;
  3391.    table->LoadName = save_LoadName;
  3392.    table->LogicOp = save_LogicOp;
  3393.    table->Map1f = save_Map1f;
  3394.    table->Map2f = save_Map2f;
  3395.    table->MapGrid1f = save_MapGrid1f;
  3396.    table->MapGrid2f = save_MapGrid2f;
  3397.    table->MatrixMode = save_MatrixMode;
  3398.    table->MultMatrixf = save_MultMatrixf;
  3399.    table->NewList = save_NewList;
  3400.    table->Ortho = save_Ortho;
  3401.    table->PointParameterfvEXT = save_PointParameterfvEXT;
  3402.    table->PassThrough = save_PassThrough;
  3403.    table->PixelMapfv = save_PixelMapfv;
  3404.    table->PixelStorei = gl_PixelStorei;   /* NOT SAVED */
  3405.    table->PixelTransferf = save_PixelTransferf;
  3406.    table->PixelZoom = save_PixelZoom;
  3407.    table->PointSize = save_PointSize;
  3408.    table->PolygonMode = save_PolygonMode;
  3409.    table->PolygonOffset = save_PolygonOffset;
  3410.    table->PolygonStipple = save_PolygonStipple;
  3411.    table->PopAttrib = save_PopAttrib;
  3412.    table->PopClientAttrib = gl_PopClientAttrib;  /* NOT SAVED */
  3413.    table->PopMatrix = save_PopMatrix;
  3414.    table->PopName = save_PopName;
  3415.    table->PrioritizeTextures = save_PrioritizeTextures;
  3416.    table->PushAttrib = save_PushAttrib;
  3417.    table->PushClientAttrib = gl_PushClientAttrib;  /* NOT SAVED */
  3418.    table->PushMatrix = save_PushMatrix;
  3419.    table->PushName = save_PushName;
  3420.    table->RasterPos4f = save_RasterPos4f;
  3421.    table->ReadBuffer = save_ReadBuffer;
  3422.    table->ReadPixels = gl_ReadPixels;   /* NOT SAVED */
  3423.    table->Rectf = save_Rectf;
  3424.    table->RenderMode = gl_RenderMode;   /* NOT SAVED */
  3425.    table->Rotatef = save_Rotatef;
  3426.    table->Scalef = save_Scalef;
  3427.    table->Scissor = save_Scissor;
  3428.    table->SelectBuffer = gl_SelectBuffer;   /* NOT SAVED */
  3429.    table->ShadeModel = save_ShadeModel;
  3430.    table->StencilFunc = save_StencilFunc;
  3431.    table->StencilMask = save_StencilMask;
  3432.    table->StencilOp = save_StencilOp;
  3433.    table->TexEnvfv = save_TexEnvfv;
  3434.    table->TexGenfv = save_TexGenfv;
  3435.    table->TexImage1D = save_TexImage1D;
  3436.    table->TexImage2D = save_TexImage2D;
  3437.    table->TexImage3D = save_TexImage3D;
  3438.    table->TexSubImage1D = save_TexSubImage1D;
  3439.    table->TexSubImage2D = save_TexSubImage2D;
  3440.    table->TexSubImage3D = save_TexSubImage3D;
  3441.    table->TexParameterfv = save_TexParameterfv;
  3442.    table->Translatef = save_Translatef;
  3443.    table->Viewport = save_Viewport;
  3444.  
  3445.    /* GL_MESA_window_pos extension */
  3446.    table->WindowPos4fMESA = save_WindowPos4fMESA;
  3447.  
  3448.    /* GL_MESA_resize_buffers extension */
  3449.    table->ResizeBuffersMESA = gl_ResizeBuffersMESA;
  3450.  
  3451.    /* GL_ARB_multitexture */
  3452.    table->ActiveTexture = save_ActiveTexture;
  3453.    table->ClientActiveTexture = save_ClientActiveTexture;
  3454. }
  3455.  
  3456.  
  3457.  
  3458. /***
  3459.  *** Debugging code
  3460.  ***/
  3461. static const char *enum_string( GLenum k )
  3462. {
  3463.    return gl_lookup_enum_by_nr( k );
  3464. }
  3465.  
  3466.  
  3467. /*
  3468.  * Print the commands in a display list.  For debugging only.
  3469.  * TODO: many commands aren't handled yet.
  3470.  */
  3471. static void print_list( GLcontext *ctx, FILE *f, GLuint list )
  3472. {
  3473.    Node *n;
  3474.    GLboolean done;
  3475.    OpCode opcode;
  3476.  
  3477.    if (!glIsList(list)) {
  3478.       fprintf(f,"%u is not a display list ID\n",list);
  3479.       return;
  3480.    }
  3481.  
  3482.    n = (Node *) HashLookup(ctx->Shared->DisplayList, list);
  3483.  
  3484.    fprintf( f, "START-LIST %u, address %p\n", list, (void*)n );
  3485.  
  3486.    done = n ? GL_FALSE : GL_TRUE;
  3487.    while (!done) {
  3488.       opcode = n[0].opcode;
  3489.  
  3490.       switch (opcode) {
  3491.          case OPCODE_ACCUM:
  3492.             fprintf(f,"accum %s %g\n", enum_string(n[1].e), n[2].f );
  3493.         break;
  3494.      case OPCODE_BITMAP:
  3495.             fprintf(f,"Bitmap %d %d %g %g %g %g %p\n", n[1].i, n[2].i,
  3496.                n[3].f, n[4].f, n[5].f, n[6].f, (void *) n[7].data );
  3497.         break;
  3498.          case OPCODE_CALL_LIST:
  3499.             fprintf(f,"CallList %d\n", (int) n[1].ui );
  3500.             break;
  3501.          case OPCODE_CALL_LIST_OFFSET:
  3502.             fprintf(f,"CallList %d + offset %u = %u\n", (int) n[1].ui,
  3503.                     ctx->List.ListBase, ctx->List.ListBase + n[1].ui );
  3504.             break;
  3505.      case OPCODE_DISABLE:
  3506.             fprintf(f,"Disable %s\n", enum_string(n[1].e));
  3507.         break;
  3508.      case OPCODE_ENABLE:
  3509.             fprintf(f,"Enable %s\n", enum_string(n[1].e));
  3510.         break;
  3511.          case OPCODE_FRUSTUM:
  3512.             fprintf(f,"Frustum %g %g %g %g %g %g\n",
  3513.                     n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
  3514.             break;
  3515.      case OPCODE_LINE_STIPPLE:
  3516.         fprintf(f,"LineStipple %d %x\n", n[1].i, (int) n[2].us );
  3517.         break;
  3518.      case OPCODE_LOAD_IDENTITY:
  3519.             fprintf(f,"LoadIdentity\n");
  3520.         break;
  3521.      case OPCODE_LOAD_MATRIX:
  3522.             fprintf(f,"LoadMatrix\n");
  3523.             fprintf(f,"  %8f %8f %8f %8f\n", n[1].f, n[5].f,  n[9].f, n[13].f);
  3524.             fprintf(f,"  %8f %8f %8f %8f\n", n[2].f, n[6].f, n[10].f, n[14].f);
  3525.             fprintf(f,"  %8f %8f %8f %8f\n", n[3].f, n[7].f, n[11].f, n[15].f);
  3526.             fprintf(f,"  %8f %8f %8f %8f\n", n[4].f, n[8].f, n[12].f, n[16].f);
  3527.         break;
  3528.      case OPCODE_MULT_MATRIX:
  3529.             fprintf(f,"MultMatrix (or Rotate)\n");
  3530.             fprintf(f,"  %8f %8f %8f %8f\n", n[1].f, n[5].f,  n[9].f, n[13].f);
  3531.             fprintf(f,"  %8f %8f %8f %8f\n", n[2].f, n[6].f, n[10].f, n[14].f);
  3532.             fprintf(f,"  %8f %8f %8f %8f\n", n[3].f, n[7].f, n[11].f, n[15].f);
  3533.             fprintf(f,"  %8f %8f %8f %8f\n", n[4].f, n[8].f, n[12].f, n[16].f);
  3534.         break;
  3535.          case OPCODE_ORTHO:
  3536.             fprintf(f,"Ortho %g %g %g %g %g %g\n",
  3537.                     n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
  3538.             break;
  3539.      case OPCODE_POP_ATTRIB:
  3540.             fprintf(f,"PopAttrib\n");
  3541.         break;
  3542.      case OPCODE_POP_MATRIX:
  3543.             fprintf(f,"PopMatrix\n");
  3544.         break;
  3545.      case OPCODE_POP_NAME:
  3546.             fprintf(f,"PopName\n");
  3547.         break;
  3548.      case OPCODE_PUSH_ATTRIB:
  3549.             fprintf(f,"PushAttrib %x\n", n[1].bf );
  3550.         break;
  3551.      case OPCODE_PUSH_MATRIX:
  3552.             fprintf(f,"PushMatrix\n");
  3553.         break;
  3554.      case OPCODE_PUSH_NAME:
  3555.             fprintf(f,"PushName %d\n", (int) n[1].ui );
  3556.         break;
  3557.      case OPCODE_RASTER_POS:
  3558.             fprintf(f,"RasterPos %g %g %g %g\n", n[1].f, n[2].f,n[3].f,n[4].f);
  3559.         break;
  3560.          case OPCODE_RECTF:
  3561.             fprintf( f, "Rectf %g %g %g %g\n", n[1].f, n[2].f, n[3].f, n[4].f);
  3562.             break;
  3563.          case OPCODE_SCALE:
  3564.             fprintf(f,"Scale %g %g %g\n", n[1].f, n[2].f, n[3].f );
  3565.             break;
  3566.          case OPCODE_TRANSLATE:
  3567.             fprintf(f,"Translate %g %g %g\n", n[1].f, n[2].f, n[3].f );
  3568.             break;
  3569.          case OPCODE_BIND_TEXTURE:
  3570.         fprintf(f,"BindTexture %s %d\n", gl_lookup_enum_by_nr(n[1].ui), 
  3571.             n[2].ui);
  3572.         break;
  3573.          case OPCODE_SHADE_MODEL:
  3574.         fprintf(f,"ShadeModel %s\n", gl_lookup_enum_by_nr(n[1].ui)); 
  3575.         break;
  3576.  
  3577.      /*
  3578.       * meta opcodes/commands
  3579.       */
  3580.          case OPCODE_ERROR:
  3581.             fprintf(f,"Error: %s %s\n", enum_string(n[1].e), (const char *)n[2].data );
  3582.             break;
  3583.      case OPCODE_VERTEX_CASSETTE:
  3584.             fprintf(f,"VERTEX-CASSETTE, id %u, rows %u..%u\n", 
  3585.             ((struct immediate *) n[1].data)->id,
  3586.             n[2].ui,
  3587.             n[3].ui);
  3588.         break;
  3589.      case OPCODE_CONTINUE:
  3590.             fprintf(f,"DISPLAY-LIST-CONTINUE\n");
  3591.         n = (Node *) n[1].next;
  3592.         break;
  3593.      case OPCODE_END_OF_LIST:
  3594.             fprintf(f,"END-LIST %u\n", list);
  3595.         done = GL_TRUE;
  3596.         break;
  3597.          default:
  3598.             if (opcode < 0 || opcode > OPCODE_END_OF_LIST) {
  3599.                fprintf(f,"ERROR IN DISPLAY LIST: opcode = %d, address = %p\n",
  3600.                        opcode, (void*) n);
  3601.                return;
  3602.             }
  3603.             else {
  3604.                fprintf(f,"command %d, %u operands\n",opcode,InstSize[opcode]);
  3605.             }
  3606.       }
  3607.  
  3608.       /* increment n to point to next compiled command */
  3609.       if (opcode!=OPCODE_CONTINUE) {
  3610.      n += InstSize[opcode];
  3611.       }
  3612.    }
  3613. }
  3614.  
  3615.  
  3616.  
  3617.  
  3618.  
  3619.  
  3620.  
  3621.  
  3622. /*
  3623.  * Clients may call this function to help debug display list problems.
  3624.  * This function is _ONLY_FOR_DEBUGGING_PURPOSES_.  It may be removed,
  3625.  * changed, or break in the future without notice.
  3626.  */
  3627. void mesa_print_display_list( GLuint list )
  3628. {
  3629.    GET_CONTEXT;
  3630.    print_list( CC, stderr, list );
  3631. }
  3632.