home *** CD-ROM | disk | FTP | other *** search
/ Amiga Magazin: Amiga-CD 2000 April & May / AMIGA_2000_04.iso / patches / mesa3.1 / mesa-3_1.lha / src / get.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-07  |  118.2 KB  |  3,814 lines
  1. /* $Id: get.c,v 1.5.2.1 1999/12/13 21:58:42 brianp 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/get.c,v 1.3 1999/04/04 00:20:25 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 <string.h>
  37. #else
  38. #include "GL/xf86glx.h"
  39. #endif
  40. #include "context.h"
  41. #include "enable.h"
  42. #include "enums.h"
  43. #include "extensions.h"
  44. #include "get.h"
  45. #include "macros.h"
  46. #include "mmath.h"
  47. #include "types.h"
  48. #include "vb.h"
  49. #endif
  50.  
  51.  
  52.  
  53. #define FLOAT_TO_BOOL(X)    ( (X)==0.0F ? GL_FALSE : GL_TRUE )
  54. #define INT_TO_BOOL(I)        ( (I)==0 ? GL_FALSE : GL_TRUE )
  55. #define ENUM_TO_BOOL(E)        ( (E)==0 ? GL_FALSE : GL_TRUE )
  56.  
  57. #ifdef SPECIALCAST
  58. /* Needed for an Amiga compiler */
  59. #define ENUM_TO_FLOAT(X) ((GLfloat)(GLint)(X))
  60. #define ENUM_TO_DOUBLE(X) ((GLdouble)(GLint)(X))
  61. #else
  62. /* all other compilers */
  63. #define ENUM_TO_FLOAT(X) ((GLfloat)(X))
  64. #define ENUM_TO_DOUBLE(X) ((GLdouble)(X))
  65. #endif
  66.  
  67.  
  68.  
  69. void gl_GetBooleanv( GLcontext *ctx, GLenum pname, GLboolean *params )
  70. {
  71.    GLuint i;
  72.    GLuint texUnit = ctx->Texture.CurrentUnit;
  73.    GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
  74.    const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
  75.  
  76.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetBooleanv");
  77.  
  78.    if (MESA_VERBOSE & VERBOSE_API) 
  79.       fprintf(stderr, "glGetBooleanv %s\n", gl_lookup_enum_by_nr(pname));
  80.  
  81.    switch (pname) {
  82.       case GL_ACCUM_RED_BITS:
  83.       case GL_ACCUM_GREEN_BITS:
  84.       case GL_ACCUM_BLUE_BITS:
  85.       case GL_ACCUM_ALPHA_BITS:
  86.          *params = INT_TO_BOOL(ctx->Visual->AccumBits);
  87.          break;
  88.       case GL_ACCUM_CLEAR_VALUE:
  89.          params[0] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[0]);
  90.          params[1] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[1]);
  91.          params[2] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[2]);
  92.          params[3] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[3]);
  93.          break;
  94.       case GL_ALPHA_BIAS:
  95.          *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaBias);
  96.          break;
  97.       case GL_ALPHA_BITS:
  98.          *params = INT_TO_BOOL(ctx->Visual->AlphaBits);
  99.          break;
  100.       case GL_ALPHA_SCALE:
  101.          *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaScale);
  102.          break;
  103.       case GL_ALPHA_TEST:
  104.          *params = ctx->Color.AlphaEnabled;
  105.          break;
  106.       case GL_ALPHA_TEST_FUNC:
  107.          *params = ENUM_TO_BOOL(ctx->Color.AlphaFunc);
  108.          break;
  109.       case GL_ALPHA_TEST_REF:
  110.          *params = FLOAT_TO_BOOL((GLfloat) ctx->Color.AlphaRef / 255.0);
  111.          break;
  112.       case GL_ATTRIB_STACK_DEPTH:
  113.          *params = INT_TO_BOOL(ctx->AttribStackDepth);
  114.          break;
  115.       case GL_AUTO_NORMAL:
  116.          *params = ctx->Eval.AutoNormal;
  117.          break;
  118.       case GL_AUX_BUFFERS:
  119.          *params = (NUM_AUX_BUFFERS) ? GL_TRUE : GL_FALSE;
  120.          break;
  121.       case GL_BLEND:
  122.          *params = ctx->Color.BlendEnabled;
  123.          break;
  124.       case GL_BLEND_DST:
  125.          *params = ENUM_TO_BOOL(ctx->Color.BlendDstRGB);
  126.          break;
  127.       case GL_BLEND_SRC:
  128.          *params = ENUM_TO_BOOL(ctx->Color.BlendSrcRGB);
  129.          break;
  130.       case GL_BLEND_SRC_RGB_INGR:
  131.          *params = ENUM_TO_BOOL(ctx->Color.BlendSrcRGB);
  132.          break;
  133.       case GL_BLEND_DST_RGB_INGR:
  134.          *params = ENUM_TO_BOOL(ctx->Color.BlendDstRGB);
  135.          break;
  136.       case GL_BLEND_SRC_ALPHA_INGR:
  137.          *params = ENUM_TO_BOOL(ctx->Color.BlendSrcA);
  138.          break;
  139.       case GL_BLEND_DST_ALPHA_INGR:
  140.          *params = ENUM_TO_BOOL(ctx->Color.BlendDstA);
  141.          break;
  142.       case GL_BLEND_EQUATION_EXT:
  143.      *params = ENUM_TO_BOOL( ctx->Color.BlendEquation );
  144.      break;
  145.       case GL_BLEND_COLOR_EXT:
  146.      params[0] = FLOAT_TO_BOOL( ctx->Color.BlendColor[0] );
  147.      params[1] = FLOAT_TO_BOOL( ctx->Color.BlendColor[1] );
  148.      params[2] = FLOAT_TO_BOOL( ctx->Color.BlendColor[2] );
  149.      params[3] = FLOAT_TO_BOOL( ctx->Color.BlendColor[3] );
  150.      break;
  151.       case GL_BLUE_BIAS:
  152.          *params = FLOAT_TO_BOOL(ctx->Pixel.BlueBias);
  153.          break;
  154.       case GL_BLUE_BITS:
  155.          *params = INT_TO_BOOL( ctx->Visual->BlueBits );
  156.          break;
  157.       case GL_BLUE_SCALE:
  158.          *params = FLOAT_TO_BOOL(ctx->Pixel.BlueScale);
  159.          break;
  160.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  161.          *params = INT_TO_BOOL(ctx->ClientAttribStackDepth);
  162.          break;
  163.       case GL_CLIP_PLANE0:
  164.       case GL_CLIP_PLANE1:
  165.       case GL_CLIP_PLANE2:
  166.       case GL_CLIP_PLANE3:
  167.       case GL_CLIP_PLANE4:
  168.       case GL_CLIP_PLANE5:
  169.          *params = ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  170.          break;
  171.       case GL_COLOR_CLEAR_VALUE:
  172.          params[0] = FLOAT_TO_BOOL(ctx->Color.ClearColor[0]);
  173.          params[1] = FLOAT_TO_BOOL(ctx->Color.ClearColor[1]);
  174.          params[2] = FLOAT_TO_BOOL(ctx->Color.ClearColor[2]);
  175.          params[3] = FLOAT_TO_BOOL(ctx->Color.ClearColor[3]);
  176.          break;
  177.       case GL_COLOR_MATERIAL:
  178.          *params = ctx->Light.ColorMaterialEnabled;
  179.          break;
  180.       case GL_COLOR_MATERIAL_FACE:
  181.          *params = ENUM_TO_BOOL(ctx->Light.ColorMaterialFace);
  182.          break;
  183.       case GL_COLOR_MATERIAL_PARAMETER:
  184.          *params = ENUM_TO_BOOL(ctx->Light.ColorMaterialMode);
  185.          break;
  186.       case GL_COLOR_WRITEMASK:
  187.          params[0] = ctx->Color.ColorMask[RCOMP] ? GL_TRUE : GL_FALSE;
  188.          params[1] = ctx->Color.ColorMask[GCOMP] ? GL_TRUE : GL_FALSE;
  189.          params[2] = ctx->Color.ColorMask[BCOMP] ? GL_TRUE : GL_FALSE;
  190.          params[3] = ctx->Color.ColorMask[ACOMP] ? GL_TRUE : GL_FALSE;
  191.          break;
  192.       case GL_CULL_FACE:
  193.          *params = ctx->Polygon.CullFlag;
  194.          break;
  195.       case GL_CULL_FACE_MODE:
  196.          *params = ENUM_TO_BOOL(ctx->Polygon.CullFaceMode);
  197.          break;
  198.       case GL_CURRENT_COLOR:
  199.          params[0] = INT_TO_BOOL(ctx->Current.ByteColor[0]);
  200.          params[1] = INT_TO_BOOL(ctx->Current.ByteColor[1]);
  201.          params[2] = INT_TO_BOOL(ctx->Current.ByteColor[2]);
  202.          params[3] = INT_TO_BOOL(ctx->Current.ByteColor[3]);
  203.          break;
  204.       case GL_CURRENT_INDEX:
  205.          *params = INT_TO_BOOL(ctx->Current.Index);
  206.          break;
  207.       case GL_CURRENT_NORMAL:
  208.          params[0] = FLOAT_TO_BOOL(ctx->Current.Normal[0]);
  209.          params[1] = FLOAT_TO_BOOL(ctx->Current.Normal[1]);
  210.          params[2] = FLOAT_TO_BOOL(ctx->Current.Normal[2]);
  211.          break;
  212.       case GL_CURRENT_RASTER_COLOR:
  213.      params[0] = FLOAT_TO_BOOL(ctx->Current.RasterColor[0]);
  214.      params[1] = FLOAT_TO_BOOL(ctx->Current.RasterColor[1]);
  215.      params[2] = FLOAT_TO_BOOL(ctx->Current.RasterColor[2]);
  216.      params[3] = FLOAT_TO_BOOL(ctx->Current.RasterColor[3]);
  217.      break;
  218.       case GL_CURRENT_RASTER_DISTANCE:
  219.      *params = FLOAT_TO_BOOL(ctx->Current.RasterDistance);
  220.      break;
  221.       case GL_CURRENT_RASTER_INDEX:
  222.      *params = FLOAT_TO_BOOL(ctx->Current.RasterIndex);
  223.      break;
  224.       case GL_CURRENT_RASTER_POSITION:
  225.      params[0] = FLOAT_TO_BOOL(ctx->Current.RasterPos[0]);
  226.      params[1] = FLOAT_TO_BOOL(ctx->Current.RasterPos[1]);
  227.      params[2] = FLOAT_TO_BOOL(ctx->Current.RasterPos[2]);
  228.      params[3] = FLOAT_TO_BOOL(ctx->Current.RasterPos[3]);
  229.      break;
  230.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  231.          params[0] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformUnit][0]);
  232.          params[1] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformUnit][1]);
  233.          params[2] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformUnit][2]);
  234.          params[3] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformUnit][3]);
  235.      break;
  236.       case GL_CURRENT_RASTER_POSITION_VALID:
  237.          *params = ctx->Current.RasterPosValid;
  238.      break;
  239.       case GL_CURRENT_TEXTURE_COORDS:
  240.          params[0] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texTransformUnit][0]);
  241.          params[1] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texTransformUnit][1]);
  242.          params[2] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texTransformUnit][2]);
  243.          params[3] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texTransformUnit][3]);
  244.      break;
  245.       case GL_DEPTH_BIAS:
  246.          *params = FLOAT_TO_BOOL(ctx->Pixel.DepthBias);
  247.      break;
  248.       case GL_DEPTH_BITS:
  249.      *params = INT_TO_BOOL(ctx->Visual->DepthBits);
  250.      break;
  251.       case GL_DEPTH_CLEAR_VALUE:
  252.          *params = FLOAT_TO_BOOL(ctx->Depth.Clear);
  253.      break;
  254.       case GL_DEPTH_FUNC:
  255.          *params = ENUM_TO_BOOL(ctx->Depth.Func);
  256.      break;
  257.       case GL_DEPTH_RANGE:
  258.          params[0] = FLOAT_TO_BOOL(ctx->Viewport.Near);
  259.          params[1] = FLOAT_TO_BOOL(ctx->Viewport.Far);
  260.      break;
  261.       case GL_DEPTH_SCALE:
  262.          *params = FLOAT_TO_BOOL(ctx->Pixel.DepthScale);
  263.      break;
  264.       case GL_DEPTH_TEST:
  265.          *params = ctx->Depth.Test;
  266.      break;
  267.       case GL_DEPTH_WRITEMASK:
  268.      *params = ctx->Depth.Mask;
  269.      break;
  270.       case GL_DITHER:
  271.      *params = ctx->Color.DitherFlag;
  272.      break;
  273.       case GL_DOUBLEBUFFER:
  274.      *params = ctx->Visual->DBflag;
  275.      break;
  276.       case GL_DRAW_BUFFER:
  277.      *params = ENUM_TO_BOOL(ctx->Color.DrawBuffer);
  278.      break;
  279.       case GL_EDGE_FLAG:
  280.      *params = ctx->Current.EdgeFlag;
  281.      break;
  282.       case GL_FEEDBACK_BUFFER_SIZE:
  283.          /* TODO: is this right?  Or, return number of entries in buffer? */
  284.          *params = INT_TO_BOOL(ctx->Feedback.BufferSize);
  285.          break;
  286.       case GL_FEEDBACK_BUFFER_TYPE:
  287.          *params = INT_TO_BOOL(ctx->Feedback.Type);
  288.          break;
  289.       case GL_FOG:
  290.      *params = ctx->Fog.Enabled;
  291.      break;
  292.       case GL_FOG_COLOR:
  293.          params[0] = FLOAT_TO_BOOL(ctx->Fog.Color[0]);
  294.          params[1] = FLOAT_TO_BOOL(ctx->Fog.Color[1]);
  295.          params[2] = FLOAT_TO_BOOL(ctx->Fog.Color[2]);
  296.          params[3] = FLOAT_TO_BOOL(ctx->Fog.Color[3]);
  297.      break;
  298.       case GL_FOG_DENSITY:
  299.          *params = FLOAT_TO_BOOL(ctx->Fog.Density);
  300.      break;
  301.       case GL_FOG_END:
  302.          *params = FLOAT_TO_BOOL(ctx->Fog.End);
  303.      break;
  304.       case GL_FOG_HINT:
  305.      *params = ENUM_TO_BOOL(ctx->Hint.Fog);
  306.      break;
  307.       case GL_FOG_INDEX:
  308.      *params = FLOAT_TO_BOOL(ctx->Fog.Index);
  309.      break;
  310.       case GL_FOG_MODE:
  311.      *params = ENUM_TO_BOOL(ctx->Fog.Mode);
  312.      break;
  313.       case GL_FOG_START:
  314.          *params = FLOAT_TO_BOOL(ctx->Fog.End);
  315.      break;
  316.       case GL_FRONT_FACE:
  317.      *params = ENUM_TO_BOOL(ctx->Polygon.FrontFace);
  318.      break;
  319.       case GL_GREEN_BIAS:
  320.          *params = FLOAT_TO_BOOL(ctx->Pixel.GreenBias);
  321.      break;
  322.       case GL_GREEN_BITS:
  323.          *params = INT_TO_BOOL( ctx->Visual->GreenBits );
  324.      break;
  325.       case GL_GREEN_SCALE:
  326.          *params = FLOAT_TO_BOOL(ctx->Pixel.GreenScale);
  327.      break;
  328.       case GL_INDEX_BITS:
  329.          *params = INT_TO_BOOL( ctx->Visual->IndexBits );
  330.      break;
  331.       case GL_INDEX_CLEAR_VALUE:
  332.      *params = INT_TO_BOOL(ctx->Color.ClearIndex);
  333.      break;
  334.       case GL_INDEX_MODE:
  335.      *params = ctx->Visual->RGBAflag ? GL_FALSE : GL_TRUE;
  336.      break;
  337.       case GL_INDEX_OFFSET:
  338.      *params = INT_TO_BOOL(ctx->Pixel.IndexOffset);
  339.      break;
  340.       case GL_INDEX_SHIFT:
  341.      *params = INT_TO_BOOL(ctx->Pixel.IndexShift);
  342.      break;
  343.       case GL_INDEX_WRITEMASK:
  344.      *params = INT_TO_BOOL(ctx->Color.IndexMask);
  345.      break;
  346.       case GL_LIGHT0:
  347.       case GL_LIGHT1:
  348.       case GL_LIGHT2:
  349.       case GL_LIGHT3:
  350.       case GL_LIGHT4:
  351.       case GL_LIGHT5:
  352.       case GL_LIGHT6:
  353.       case GL_LIGHT7:
  354.      *params = ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  355.      break;
  356.       case GL_LIGHTING:
  357.      *params = ctx->Light.Enabled;
  358.      break;
  359.       case GL_LIGHT_MODEL_AMBIENT:
  360.      params[0] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[0]);
  361.      params[1] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[1]);
  362.      params[2] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[2]);
  363.      params[3] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[3]);
  364.      break;
  365.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  366.          params[0] = ENUM_TO_BOOL(ctx->Light.Model.ColorControl);
  367.          break;
  368.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  369.      *params = ctx->Light.Model.LocalViewer;
  370.      break;
  371.       case GL_LIGHT_MODEL_TWO_SIDE:
  372.      *params = ctx->Light.Model.TwoSide;
  373.      break;
  374.       case GL_LINE_SMOOTH:
  375.      *params = ctx->Line.SmoothFlag;
  376.      break;
  377.       case GL_LINE_SMOOTH_HINT:
  378.      *params = ENUM_TO_BOOL(ctx->Hint.LineSmooth);
  379.      break;
  380.       case GL_LINE_STIPPLE:
  381.      *params = ctx->Line.StippleFlag;
  382.      break;
  383.       case GL_LINE_STIPPLE_PATTERN:
  384.      *params = INT_TO_BOOL(ctx->Line.StipplePattern);
  385.      break;
  386.       case GL_LINE_STIPPLE_REPEAT:
  387.      *params = INT_TO_BOOL(ctx->Line.StippleFactor);
  388.      break;
  389.       case GL_LINE_WIDTH:
  390.      *params = FLOAT_TO_BOOL(ctx->Line.Width);
  391.      break;
  392.       case GL_LINE_WIDTH_GRANULARITY:
  393.      *params = FLOAT_TO_BOOL(LINE_WIDTH_GRANULARITY);
  394.      break;
  395.       case GL_LINE_WIDTH_RANGE:
  396.      params[0] = FLOAT_TO_BOOL(MIN_LINE_WIDTH);
  397.      params[1] = FLOAT_TO_BOOL(MAX_LINE_WIDTH);
  398.      break;
  399.       case GL_LIST_BASE:
  400.      *params = INT_TO_BOOL(ctx->List.ListBase);
  401.      break;
  402.       case GL_LIST_INDEX:
  403.      *params = INT_TO_BOOL( ctx->CurrentListNum );
  404.      break;
  405.       case GL_LIST_MODE:
  406.      *params = ENUM_TO_BOOL( ctx->ExecuteFlag
  407.                   ? GL_COMPILE_AND_EXECUTE : GL_COMPILE );
  408.      break;
  409.       case GL_INDEX_LOGIC_OP:
  410.      *params = ctx->Color.IndexLogicOpEnabled;
  411.      break;
  412.       case GL_COLOR_LOGIC_OP:
  413.      *params = ctx->Color.ColorLogicOpEnabled;
  414.      break;
  415.       case GL_LOGIC_OP_MODE:
  416.      *params = ENUM_TO_BOOL(ctx->Color.LogicOp);
  417.      break;
  418.       case GL_MAP1_COLOR_4:
  419.      *params = ctx->Eval.Map1Color4;
  420.      break;
  421.       case GL_MAP1_GRID_DOMAIN:
  422.      params[0] = FLOAT_TO_BOOL(ctx->Eval.MapGrid1u1);
  423.      params[1] = FLOAT_TO_BOOL(ctx->Eval.MapGrid1u2);
  424.      break;
  425.       case GL_MAP1_GRID_SEGMENTS:
  426.      *params = INT_TO_BOOL(ctx->Eval.MapGrid1un);
  427.      break;
  428.       case GL_MAP1_INDEX:
  429.      *params = ctx->Eval.Map1Index;
  430.      break;
  431.       case GL_MAP1_NORMAL:
  432.      *params = ctx->Eval.Map1Normal;
  433.      break;
  434.       case GL_MAP1_TEXTURE_COORD_1:
  435.      *params = ctx->Eval.Map1TextureCoord1;
  436.      break;
  437.       case GL_MAP1_TEXTURE_COORD_2:
  438.      *params = ctx->Eval.Map1TextureCoord2;
  439.      break;
  440.       case GL_MAP1_TEXTURE_COORD_3:
  441.      *params = ctx->Eval.Map1TextureCoord3;
  442.      break;
  443.       case GL_MAP1_TEXTURE_COORD_4:
  444.      *params = ctx->Eval.Map1TextureCoord4;
  445.      break;
  446.       case GL_MAP1_VERTEX_3:
  447.      *params = ctx->Eval.Map1Vertex3;
  448.      break;
  449.       case GL_MAP1_VERTEX_4:
  450.      *params = ctx->Eval.Map1Vertex4;
  451.      break;
  452.       case GL_MAP2_COLOR_4:
  453.      *params = ctx->Eval.Map2Color4;
  454.      break;
  455.       case GL_MAP2_GRID_DOMAIN:
  456.      params[0] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2u1);
  457.      params[1] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2u2);
  458.      params[2] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2v1);
  459.      params[3] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2v2);
  460.      break;
  461.       case GL_MAP2_GRID_SEGMENTS:
  462.      params[0] = INT_TO_BOOL(ctx->Eval.MapGrid2un);
  463.      params[1] = INT_TO_BOOL(ctx->Eval.MapGrid2vn);
  464.      break;
  465.       case GL_MAP2_INDEX:
  466.      *params = ctx->Eval.Map2Index;
  467.      break;
  468.       case GL_MAP2_NORMAL:
  469.      *params = ctx->Eval.Map2Normal;
  470.      break;
  471.       case GL_MAP2_TEXTURE_COORD_1:
  472.      *params = ctx->Eval.Map2TextureCoord1;
  473.      break;
  474.       case GL_MAP2_TEXTURE_COORD_2:
  475.      *params = ctx->Eval.Map2TextureCoord2;
  476.      break;
  477.       case GL_MAP2_TEXTURE_COORD_3:
  478.      *params = ctx->Eval.Map2TextureCoord3;
  479.      break;
  480.       case GL_MAP2_TEXTURE_COORD_4:
  481.      *params = ctx->Eval.Map2TextureCoord4;
  482.      break;
  483.       case GL_MAP2_VERTEX_3:
  484.      *params = ctx->Eval.Map2Vertex3;
  485.      break;
  486.       case GL_MAP2_VERTEX_4:
  487.      *params = ctx->Eval.Map2Vertex4;
  488.      break;
  489.       case GL_MAP_COLOR:
  490.      *params = ctx->Pixel.MapColorFlag;
  491.      break;
  492.       case GL_MAP_STENCIL:
  493.      *params = ctx->Pixel.MapStencilFlag;
  494.      break;
  495.       case GL_MATRIX_MODE:
  496.      *params = ENUM_TO_BOOL( ctx->Transform.MatrixMode );
  497.      break;
  498.       case GL_MAX_ATTRIB_STACK_DEPTH:
  499.      *params = INT_TO_BOOL(MAX_ATTRIB_STACK_DEPTH);
  500.      break;
  501.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  502.          *params = INT_TO_BOOL( MAX_CLIENT_ATTRIB_STACK_DEPTH);
  503.          break;
  504.       case GL_MAX_CLIP_PLANES:
  505.      *params = INT_TO_BOOL(MAX_CLIP_PLANES);
  506.      break;
  507.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  508.          *params = INT_TO_BOOL(VB_MAX);
  509.          break;
  510.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  511.          *params = INT_TO_BOOL(VB_MAX);
  512.          break;
  513.       case GL_MAX_EVAL_ORDER:
  514.      *params = INT_TO_BOOL(MAX_EVAL_ORDER);
  515.      break;
  516.       case GL_MAX_LIGHTS:
  517.      *params = INT_TO_BOOL(MAX_LIGHTS);
  518.      break;
  519.       case GL_MAX_LIST_NESTING:
  520.      *params = INT_TO_BOOL(MAX_LIST_NESTING);
  521.      break;
  522.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  523.      *params = INT_TO_BOOL(MAX_MODELVIEW_STACK_DEPTH);
  524.      break;
  525.       case GL_MAX_NAME_STACK_DEPTH:
  526.      *params = INT_TO_BOOL(MAX_NAME_STACK_DEPTH);
  527.      break;
  528.       case GL_MAX_PIXEL_MAP_TABLE:
  529.      *params = INT_TO_BOOL(MAX_PIXEL_MAP_TABLE);
  530.      break;
  531.       case GL_MAX_PROJECTION_STACK_DEPTH:
  532.      *params = INT_TO_BOOL(MAX_PROJECTION_STACK_DEPTH);
  533.      break;
  534.       case GL_MAX_TEXTURE_SIZE:
  535.       case GL_MAX_3D_TEXTURE_SIZE:
  536.          *params = INT_TO_BOOL(ctx->Const.MaxTextureSize);
  537.      break;
  538.       case GL_MAX_TEXTURE_STACK_DEPTH:
  539.      *params = INT_TO_BOOL(MAX_TEXTURE_STACK_DEPTH);
  540.      break;
  541.       case GL_MAX_VIEWPORT_DIMS:
  542.      params[0] = INT_TO_BOOL(MAX_WIDTH);
  543.      params[1] = INT_TO_BOOL(MAX_HEIGHT);
  544.      break;
  545.       case GL_MODELVIEW_MATRIX:
  546.      for (i=0;i<16;i++) {
  547.         params[i] = FLOAT_TO_BOOL(ctx->ModelView.m[i]);
  548.      }
  549.      break;
  550.       case GL_MODELVIEW_STACK_DEPTH:
  551.      *params = INT_TO_BOOL(ctx->ModelViewStackDepth + 1);
  552.      break;
  553.       case GL_NAME_STACK_DEPTH:
  554.      *params = INT_TO_BOOL(ctx->Select.NameStackDepth);
  555.      break;
  556.       case GL_NORMALIZE:
  557.      *params = ctx->Transform.Normalize;
  558.      break;
  559.       case GL_PACK_ALIGNMENT:
  560.      *params = INT_TO_BOOL(ctx->Pack.Alignment);
  561.      break;
  562.       case GL_PACK_LSB_FIRST:
  563.      *params = ctx->Pack.LsbFirst;
  564.      break;
  565.       case GL_PACK_ROW_LENGTH:
  566.      *params = INT_TO_BOOL(ctx->Pack.RowLength);
  567.      break;
  568.       case GL_PACK_SKIP_PIXELS:
  569.      *params = INT_TO_BOOL(ctx->Pack.SkipPixels);
  570.      break;
  571.       case GL_PACK_SKIP_ROWS:
  572.      *params = INT_TO_BOOL(ctx->Pack.SkipRows);
  573.      break;
  574.       case GL_PACK_SWAP_BYTES:
  575.      *params = ctx->Pack.SwapBytes;
  576.      break;
  577.       case GL_PACK_SKIP_IMAGES_EXT:
  578.          *params = ctx->Pack.SkipImages;
  579.          break;
  580.       case GL_PACK_IMAGE_HEIGHT_EXT:
  581.          *params = ctx->Pack.ImageHeight;
  582.          break;
  583.       case GL_PERSPECTIVE_CORRECTION_HINT:
  584.      *params = ENUM_TO_BOOL(ctx->Hint.PerspectiveCorrection);
  585.      break;
  586.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  587.      *params = INT_TO_BOOL(ctx->Pixel.MapAtoAsize);
  588.      break;
  589.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  590.      *params = INT_TO_BOOL(ctx->Pixel.MapBtoBsize);
  591.      break;
  592.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  593.      *params = INT_TO_BOOL(ctx->Pixel.MapGtoGsize);
  594.      break;
  595.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  596.      *params = INT_TO_BOOL(ctx->Pixel.MapItoAsize);
  597.      break;
  598.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  599.      *params = INT_TO_BOOL(ctx->Pixel.MapItoBsize);
  600.      break;
  601.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  602.      *params = INT_TO_BOOL(ctx->Pixel.MapItoGsize);
  603.      break;
  604.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  605.      *params = INT_TO_BOOL(ctx->Pixel.MapItoIsize);
  606.      break;
  607.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  608.      *params = INT_TO_BOOL(ctx->Pixel.MapItoRsize);
  609.      break;
  610.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  611.      *params = INT_TO_BOOL(ctx->Pixel.MapRtoRsize);
  612.      break;
  613.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  614.      *params = INT_TO_BOOL(ctx->Pixel.MapStoSsize);
  615.      break;
  616.       case GL_POINT_SIZE:
  617.      *params = FLOAT_TO_BOOL(ctx->Point.Size );
  618.      break;
  619.       case GL_POINT_SIZE_GRANULARITY:
  620.      *params = FLOAT_TO_BOOL(POINT_SIZE_GRANULARITY );
  621.      break;
  622.       case GL_POINT_SIZE_RANGE:
  623.      params[0] = FLOAT_TO_BOOL(MIN_POINT_SIZE );
  624.      params[1] = FLOAT_TO_BOOL(MAX_POINT_SIZE );
  625.      break;
  626.       case GL_POINT_SMOOTH:
  627.      *params = ctx->Point.SmoothFlag;
  628.      break;
  629.       case GL_POINT_SMOOTH_HINT:
  630.      *params = ENUM_TO_BOOL(ctx->Hint.PointSmooth);
  631.      break;
  632.       case GL_POINT_SIZE_MIN_EXT:
  633.      *params = FLOAT_TO_BOOL(ctx->Point.MinSize);
  634.      break;
  635.       case GL_POINT_SIZE_MAX_EXT:
  636.      *params = FLOAT_TO_BOOL(ctx->Point.MaxSize);
  637.      break;
  638.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  639.      *params = FLOAT_TO_BOOL(ctx->Point.Threshold);
  640.      break;
  641.       case GL_DISTANCE_ATTENUATION_EXT:
  642.      params[0] = FLOAT_TO_BOOL(ctx->Point.Params[0]);
  643.      params[1] = FLOAT_TO_BOOL(ctx->Point.Params[1]);
  644.      params[2] = FLOAT_TO_BOOL(ctx->Point.Params[2]);
  645.      break;
  646.       case GL_POLYGON_MODE:
  647.      params[0] = ENUM_TO_BOOL(ctx->Polygon.FrontMode);
  648.      params[1] = ENUM_TO_BOOL(ctx->Polygon.BackMode);
  649.      break;
  650. #ifdef GL_EXT_polygon_offset
  651.       case GL_POLYGON_OFFSET_BIAS_EXT:
  652.          *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetUnits );
  653.          break;
  654. #endif
  655.       case GL_POLYGON_OFFSET_FACTOR:
  656.          *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetFactor );
  657.          break;
  658.       case GL_POLYGON_OFFSET_UNITS:
  659.          *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetUnits );
  660.          break;
  661.       case GL_POLYGON_SMOOTH:
  662.      *params = ctx->Polygon.SmoothFlag;
  663.      break;
  664.       case GL_POLYGON_SMOOTH_HINT:
  665.      *params = ENUM_TO_BOOL(ctx->Hint.PolygonSmooth);
  666.      break;
  667.       case GL_POLYGON_STIPPLE:
  668.      *params = ctx->Polygon.StippleFlag;
  669.      break;
  670.       case GL_PROJECTION_MATRIX:
  671.      for (i=0;i<16;i++) {
  672.         params[i] = FLOAT_TO_BOOL(ctx->ProjectionMatrix.m[i]);
  673.      }
  674.      break;
  675.       case GL_PROJECTION_STACK_DEPTH:
  676.      *params = INT_TO_BOOL(ctx->ProjectionStackDepth + 1);
  677.      break;
  678.       case GL_READ_BUFFER:
  679.      *params = ENUM_TO_BOOL(ctx->Pixel.ReadBuffer);
  680.      break;
  681.       case GL_RED_BIAS:
  682.          *params = FLOAT_TO_BOOL(ctx->Pixel.RedBias);
  683.      break;
  684.       case GL_RED_BITS:
  685.          *params = INT_TO_BOOL( ctx->Visual->RedBits );
  686.      break;
  687.       case GL_RED_SCALE:
  688.          *params = FLOAT_TO_BOOL(ctx->Pixel.RedScale);
  689.      break;
  690.       case GL_RENDER_MODE:
  691.      *params = ENUM_TO_BOOL(ctx->RenderMode);
  692.      break;
  693.       case GL_RGBA_MODE:
  694.          *params = ctx->Visual->RGBAflag;
  695.      break;
  696.       case GL_SCISSOR_BOX:
  697.      params[0] = INT_TO_BOOL(ctx->Scissor.X);
  698.      params[1] = INT_TO_BOOL(ctx->Scissor.Y);
  699.      params[2] = INT_TO_BOOL(ctx->Scissor.Width);
  700.      params[3] = INT_TO_BOOL(ctx->Scissor.Height);
  701.      break;
  702.       case GL_SCISSOR_TEST:
  703.      *params = ctx->Scissor.Enabled;
  704.      break;
  705.       case GL_SELECTION_BUFFER_SIZE:
  706.          *params = INT_TO_BOOL(ctx->Select.BufferSize);
  707.          break;
  708.       case GL_SHADE_MODEL:
  709.      *params = ENUM_TO_BOOL(ctx->Light.ShadeModel);
  710.      break;
  711.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  712.          *params = ctx->Texture.SharedPalette;
  713.          break;
  714.       case GL_STENCIL_BITS:
  715.      *params = INT_TO_BOOL(ctx->Visual->StencilBits);
  716.      break;
  717.       case GL_STENCIL_CLEAR_VALUE:
  718.      *params = INT_TO_BOOL(ctx->Stencil.Clear);
  719.      break;
  720.       case GL_STENCIL_FAIL:
  721.      *params = ENUM_TO_BOOL(ctx->Stencil.FailFunc);
  722.      break;
  723.       case GL_STENCIL_FUNC:
  724.      *params = ENUM_TO_BOOL(ctx->Stencil.Function);
  725.      break;
  726.       case GL_STENCIL_PASS_DEPTH_FAIL:
  727.      *params = ENUM_TO_BOOL(ctx->Stencil.ZFailFunc);
  728.      break;
  729.       case GL_STENCIL_PASS_DEPTH_PASS:
  730.      *params = ENUM_TO_BOOL(ctx->Stencil.ZPassFunc);
  731.      break;
  732.       case GL_STENCIL_REF:
  733.      *params = INT_TO_BOOL(ctx->Stencil.Ref);
  734.      break;
  735.       case GL_STENCIL_TEST:
  736.      *params = ctx->Stencil.Enabled;
  737.      break;
  738.       case GL_STENCIL_VALUE_MASK:
  739.      *params = INT_TO_BOOL(ctx->Stencil.ValueMask);
  740.      break;
  741.       case GL_STENCIL_WRITEMASK:
  742.      *params = INT_TO_BOOL(ctx->Stencil.WriteMask);
  743.      break;
  744.       case GL_STEREO:
  745.      *params = ctx->Visual->StereoFlag;
  746.      break;
  747.       case GL_SUBPIXEL_BITS:
  748.      *params = INT_TO_BOOL(0);  /* TODO */
  749.      break;
  750.       case GL_TEXTURE_1D:
  751.          *params = gl_IsEnabled( ctx, GL_TEXTURE_1D );
  752.      break;
  753.       case GL_TEXTURE_2D:
  754.          *params = gl_IsEnabled( ctx, GL_TEXTURE_2D );
  755.      break;
  756.       case GL_TEXTURE_3D:
  757.          *params = gl_IsEnabled( ctx, GL_TEXTURE_3D );
  758.      break;
  759.       case GL_TEXTURE_BINDING_1D:
  760.          *params = INT_TO_BOOL(textureUnit->CurrentD[1]->Name);
  761.           break;
  762.       case GL_TEXTURE_BINDING_2D:
  763.          *params = INT_TO_BOOL(textureUnit->CurrentD[2]->Name);
  764.           break;
  765.       case GL_TEXTURE_BINDING_3D:
  766.          *params = INT_TO_BOOL(textureUnit->CurrentD[3]->Name);
  767.           break;
  768.       case GL_TEXTURE_ENV_COLOR:
  769.          {
  770.             params[0] = FLOAT_TO_BOOL(textureUnit->EnvColor[0]);
  771.             params[1] = FLOAT_TO_BOOL(textureUnit->EnvColor[1]);
  772.             params[2] = FLOAT_TO_BOOL(textureUnit->EnvColor[2]);
  773.             params[3] = FLOAT_TO_BOOL(textureUnit->EnvColor[3]);
  774.          }
  775.      break;
  776.       case GL_TEXTURE_ENV_MODE:
  777.      *params = ENUM_TO_BOOL(textureUnit->EnvMode);
  778.      break;
  779.       case GL_TEXTURE_GEN_S:
  780.      *params = (textureUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
  781.      break;
  782.       case GL_TEXTURE_GEN_T:
  783.      *params = (textureUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
  784.      break;
  785.       case GL_TEXTURE_GEN_R:
  786.      *params = (textureUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
  787.      break;
  788.       case GL_TEXTURE_GEN_Q:
  789.      *params = (textureUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
  790.      break;
  791.       case GL_TEXTURE_MATRIX:
  792.      for (i=0;i<16;i++) {
  793.         params[i] = 
  794.            FLOAT_TO_BOOL(ctx->TextureMatrix[texTransformUnit].m[i]);
  795.      }
  796.      break;
  797.       case GL_TEXTURE_STACK_DEPTH:
  798.      *params = INT_TO_BOOL(ctx->TextureStackDepth[texTransformUnit] + 1);
  799.      break;
  800.       case GL_UNPACK_ALIGNMENT:
  801.      *params = INT_TO_BOOL(ctx->Unpack.Alignment);
  802.      break;
  803.       case GL_UNPACK_LSB_FIRST:
  804.      *params = ctx->Unpack.LsbFirst;
  805.      break;
  806.       case GL_UNPACK_ROW_LENGTH:
  807.      *params = INT_TO_BOOL(ctx->Unpack.RowLength);
  808.      break;
  809.       case GL_UNPACK_SKIP_PIXELS:
  810.      *params = INT_TO_BOOL(ctx->Unpack.SkipPixels);
  811.      break;
  812.       case GL_UNPACK_SKIP_ROWS:
  813.      *params = INT_TO_BOOL(ctx->Unpack.SkipRows);
  814.      break;
  815.       case GL_UNPACK_SWAP_BYTES:
  816.      *params = ctx->Unpack.SwapBytes;
  817.      break;
  818.       case GL_UNPACK_SKIP_IMAGES_EXT:
  819.          *params = ctx->Unpack.SkipImages;
  820.          break;
  821.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  822.          *params = ctx->Unpack.ImageHeight;
  823.          break;
  824.       case GL_VIEWPORT:
  825.      params[0] = INT_TO_BOOL(ctx->Viewport.X);
  826.      params[1] = INT_TO_BOOL(ctx->Viewport.Y);
  827.      params[2] = INT_TO_BOOL(ctx->Viewport.Width);
  828.      params[3] = INT_TO_BOOL(ctx->Viewport.Height);
  829.      break;
  830.       case GL_ZOOM_X:
  831.      *params = FLOAT_TO_BOOL(ctx->Pixel.ZoomX);
  832.      break;
  833.       case GL_ZOOM_Y:
  834.      *params = FLOAT_TO_BOOL(ctx->Pixel.ZoomY);
  835.      break;
  836.       case GL_VERTEX_ARRAY:
  837.          *params = ctx->Array.Vertex.Enabled;
  838.          break;
  839.       case GL_VERTEX_ARRAY_SIZE:
  840.          *params = INT_TO_BOOL(ctx->Array.Vertex.Size);
  841.          break;
  842.       case GL_VERTEX_ARRAY_TYPE:
  843.          *params = ENUM_TO_BOOL(ctx->Array.Vertex.Type);
  844.          break;
  845.       case GL_VERTEX_ARRAY_STRIDE:
  846.          *params = INT_TO_BOOL(ctx->Array.Vertex.Stride);
  847.          break;
  848.       case GL_VERTEX_ARRAY_COUNT_EXT:
  849.          *params = INT_TO_BOOL(0);
  850.          break;
  851.       case GL_NORMAL_ARRAY:
  852.          *params = ctx->Array.Normal.Enabled;
  853.          break;
  854.       case GL_NORMAL_ARRAY_TYPE:
  855.          *params = ENUM_TO_BOOL(ctx->Array.Normal.Type);
  856.          break;
  857.       case GL_NORMAL_ARRAY_STRIDE:
  858.          *params = INT_TO_BOOL(ctx->Array.Normal.Stride);
  859.          break;
  860.       case GL_NORMAL_ARRAY_COUNT_EXT:
  861.          *params = INT_TO_BOOL(0);
  862.          break;
  863.       case GL_COLOR_ARRAY:
  864.          *params = ctx->Array.Color.Enabled;
  865.          break;
  866.       case GL_COLOR_ARRAY_SIZE:
  867.          *params = INT_TO_BOOL(ctx->Array.Color.Size);
  868.          break;
  869.       case GL_COLOR_ARRAY_TYPE:
  870.          *params = ENUM_TO_BOOL(ctx->Array.Color.Type);
  871.          break;
  872.       case GL_COLOR_ARRAY_STRIDE:
  873.          *params = INT_TO_BOOL(ctx->Array.Color.Stride);
  874.          break;
  875.       case GL_COLOR_ARRAY_COUNT_EXT:
  876.          *params = INT_TO_BOOL(0);
  877.          break;
  878.       case GL_INDEX_ARRAY:
  879.          *params = ctx->Array.Index.Enabled;
  880.          break;
  881.       case GL_INDEX_ARRAY_TYPE:
  882.          *params = ENUM_TO_BOOL(ctx->Array.Index.Type);
  883.          break;
  884.       case GL_INDEX_ARRAY_STRIDE:
  885.          *params = INT_TO_BOOL(ctx->Array.Index.Stride);
  886.          break;
  887.       case GL_INDEX_ARRAY_COUNT_EXT:
  888.          *params = INT_TO_BOOL(0);
  889.          break;
  890.       case GL_TEXTURE_COORD_ARRAY:
  891.          *params = ctx->Array.TexCoord[texUnit].Enabled;
  892.          break;
  893.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  894.          *params = INT_TO_BOOL(ctx->Array.TexCoord[texUnit].Size);
  895.          break;
  896.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  897.          *params = ENUM_TO_BOOL(ctx->Array.TexCoord[texUnit].Type);
  898.          break;
  899.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  900.          *params = INT_TO_BOOL(ctx->Array.TexCoord[texUnit].Stride);
  901.          break;
  902.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  903.          *params = INT_TO_BOOL(0);
  904.          break;
  905.       case GL_EDGE_FLAG_ARRAY:
  906.          *params = ctx->Array.EdgeFlag.Enabled;
  907.          break;
  908.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  909.          *params = INT_TO_BOOL(ctx->Array.EdgeFlag.Stride);
  910.          break;
  911.  
  912.       case GL_MAX_TEXTURE_UNITS_ARB:
  913.          *params = ctx->Const.MaxTextureUnits;
  914.          break;
  915.       case GL_ACTIVE_TEXTURE_ARB:
  916.          *params = INT_TO_BOOL(GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
  917.          break;
  918.       case GL_CLIENT_ACTIVE_TEXTURE_ARB:
  919.          *params = INT_TO_BOOL(GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
  920.          break;
  921.  
  922.  
  923.       /* GL_PGI_misc_hints */
  924.       case GL_STRICT_DEPTHFUNC_HINT_PGI:
  925.      *params = ENUM_TO_BOOL(GL_NICEST);
  926.          break;
  927.       case GL_STRICT_LIGHTING_HINT_PGI:
  928.      *params = ENUM_TO_BOOL(ctx->Hint.StrictLighting);
  929.      break;
  930.       case GL_STRICT_SCISSOR_HINT_PGI:
  931.       case GL_FULL_STIPPLE_HINT_PGI:
  932.      *params = ENUM_TO_BOOL(GL_TRUE);
  933.      break;
  934.       case GL_CONSERVE_MEMORY_HINT_PGI:
  935.      *params = ENUM_TO_BOOL(GL_FALSE);
  936.      break;
  937.       case GL_ALWAYS_FAST_HINT_PGI:
  938.      *params = (GLboolean) (ctx->Hint.AllowDrawWin == GL_TRUE &&
  939.                   ctx->Hint.AllowDrawSpn == GL_FALSE && 
  940.                   ctx->Hint.AllowDrawMem == GL_FALSE);
  941.      break;
  942.       case GL_ALWAYS_SOFT_HINT_PGI:
  943.      *params = (GLboolean) (ctx->Hint.AllowDrawWin == GL_TRUE &&
  944.                   ctx->Hint.AllowDrawSpn == GL_TRUE && 
  945.                   ctx->Hint.AllowDrawMem == GL_TRUE);
  946.      break;
  947.       case GL_ALLOW_DRAW_OBJ_HINT_PGI:
  948.      *params = (GLboolean) GL_TRUE;
  949.      break;
  950.       case GL_ALLOW_DRAW_WIN_HINT_PGI:
  951.      *params = (GLboolean) ctx->Hint.AllowDrawWin;
  952.      break;
  953.       case GL_ALLOW_DRAW_SPN_HINT_PGI:
  954.      *params = (GLboolean) ctx->Hint.AllowDrawSpn;
  955.      break;
  956.       case GL_ALLOW_DRAW_MEM_HINT_PGI:
  957.      *params = (GLboolean) ctx->Hint.AllowDrawMem;
  958.      break;
  959.       case GL_CLIP_NEAR_HINT_PGI:
  960.       case GL_CLIP_FAR_HINT_PGI:
  961.      *params = ENUM_TO_BOOL(GL_TRUE);
  962.      break;
  963.       case GL_WIDE_LINE_HINT_PGI:
  964.      *params = ENUM_TO_BOOL(GL_DONT_CARE);
  965.      break;
  966.       case GL_BACK_NORMALS_HINT_PGI:
  967.      *params = ENUM_TO_BOOL(GL_TRUE);
  968.      break;
  969.       case GL_NATIVE_GRAPHICS_HANDLE_PGI:
  970.      *params = 0;
  971.      break;
  972.       default:
  973.      printf("invalid enum: %x\n", pname);
  974.          gl_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
  975.    }
  976. }
  977.  
  978.  
  979.  
  980.  
  981. void gl_GetDoublev( GLcontext *ctx, GLenum pname, GLdouble *params )
  982. {
  983.    GLuint i;
  984.    GLuint texUnit = ctx->Texture.CurrentUnit;
  985.    GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
  986.    const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
  987.  
  988.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetDoublev");
  989.  
  990.    if (MESA_VERBOSE & VERBOSE_API) 
  991.       fprintf(stderr, "glGetDoublev %s\n", gl_lookup_enum_by_nr(pname));
  992.  
  993.    switch (pname) {
  994.       case GL_ACCUM_RED_BITS:
  995.       case GL_ACCUM_GREEN_BITS:
  996.       case GL_ACCUM_BLUE_BITS:
  997.       case GL_ACCUM_ALPHA_BITS:
  998.          *params = (GLdouble) ctx->Visual->AccumBits;
  999.          break;
  1000.       case GL_ACCUM_CLEAR_VALUE:
  1001.          params[0] = (GLdouble) ctx->Accum.ClearColor[0];
  1002.          params[1] = (GLdouble) ctx->Accum.ClearColor[1];
  1003.          params[2] = (GLdouble) ctx->Accum.ClearColor[2];
  1004.          params[3] = (GLdouble) ctx->Accum.ClearColor[3];
  1005.          break;
  1006.       case GL_ALPHA_BIAS:
  1007.          *params = (GLdouble) ctx->Pixel.AlphaBias;
  1008.          break;
  1009.       case GL_ALPHA_BITS:
  1010.          *params = (GLdouble) ctx->Visual->AlphaBits;
  1011.          break;
  1012.       case GL_ALPHA_SCALE:
  1013.          *params = (GLdouble) ctx->Pixel.AlphaScale;
  1014.          break;
  1015.       case GL_ALPHA_TEST:
  1016.          *params = (GLdouble) ctx->Color.AlphaEnabled;
  1017.          break;
  1018.       case GL_ALPHA_TEST_FUNC:
  1019.          *params = ENUM_TO_DOUBLE(ctx->Color.AlphaFunc);
  1020.          break;
  1021.       case GL_ALPHA_TEST_REF:
  1022.          *params = (GLdouble) ctx->Color.AlphaRef / 255.0;
  1023.          break;
  1024.       case GL_ATTRIB_STACK_DEPTH:
  1025.          *params = (GLdouble ) (ctx->AttribStackDepth);
  1026.          break;
  1027.       case GL_AUTO_NORMAL:
  1028.          *params = (GLdouble) ctx->Eval.AutoNormal;
  1029.          break;
  1030.       case GL_AUX_BUFFERS:
  1031.          *params = (GLdouble) NUM_AUX_BUFFERS;
  1032.          break;
  1033.       case GL_BLEND:
  1034.          *params = (GLdouble) ctx->Color.BlendEnabled;
  1035.          break;
  1036.       case GL_BLEND_DST:
  1037.          *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstRGB);
  1038.          break;
  1039.       case GL_BLEND_SRC:
  1040.          *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB);
  1041.          break;
  1042.       case GL_BLEND_SRC_RGB_INGR:
  1043.          *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB);
  1044.          break;
  1045.       case GL_BLEND_DST_RGB_INGR:
  1046.          *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstRGB);
  1047.          break;
  1048.       case GL_BLEND_SRC_ALPHA_INGR:
  1049.          *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcA);
  1050.          break;
  1051.       case GL_BLEND_DST_ALPHA_INGR:
  1052.          *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstA);
  1053.          break;
  1054.       case GL_BLEND_EQUATION_EXT:
  1055.      *params = ENUM_TO_DOUBLE(ctx->Color.BlendEquation);
  1056.      break;
  1057.       case GL_BLEND_COLOR_EXT:
  1058.      params[0] = (GLdouble) ctx->Color.BlendColor[0];
  1059.      params[1] = (GLdouble) ctx->Color.BlendColor[1];
  1060.      params[2] = (GLdouble) ctx->Color.BlendColor[2];
  1061.      params[3] = (GLdouble) ctx->Color.BlendColor[3];
  1062.      break;
  1063.       case GL_BLUE_BIAS:
  1064.          *params = (GLdouble) ctx->Pixel.BlueBias;
  1065.          break;
  1066.       case GL_BLUE_BITS:
  1067.          *params = (GLdouble) ctx->Visual->BlueBits;
  1068.          break;
  1069.       case GL_BLUE_SCALE:
  1070.          *params = (GLdouble) ctx->Pixel.BlueScale;
  1071.          break;
  1072.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  1073.          *params = (GLdouble) (ctx->ClientAttribStackDepth);
  1074.          break;
  1075.       case GL_CLIP_PLANE0:
  1076.       case GL_CLIP_PLANE1:
  1077.       case GL_CLIP_PLANE2:
  1078.       case GL_CLIP_PLANE3:
  1079.       case GL_CLIP_PLANE4:
  1080.       case GL_CLIP_PLANE5:
  1081.          *params = (GLdouble) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  1082.          break;
  1083.       case GL_COLOR_CLEAR_VALUE:
  1084.          params[0] = (GLdouble) ctx->Color.ClearColor[0];
  1085.          params[1] = (GLdouble) ctx->Color.ClearColor[1];
  1086.          params[2] = (GLdouble) ctx->Color.ClearColor[2];
  1087.          params[3] = (GLdouble) ctx->Color.ClearColor[3];
  1088.          break;
  1089.       case GL_COLOR_MATERIAL:
  1090.          *params = (GLdouble) ctx->Light.ColorMaterialEnabled;
  1091.          break;
  1092.       case GL_COLOR_MATERIAL_FACE:
  1093.          *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialFace);
  1094.          break;
  1095.       case GL_COLOR_MATERIAL_PARAMETER:
  1096.          *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialMode);
  1097.          break;
  1098.       case GL_COLOR_WRITEMASK:
  1099.          params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0 : 0.0;
  1100.          params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0 : 0.0;
  1101.          params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0 : 0.0;
  1102.          params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0 : 0.0;
  1103.          break;
  1104.       case GL_CULL_FACE:
  1105.          *params = (GLdouble) ctx->Polygon.CullFlag;
  1106.          break;
  1107.       case GL_CULL_FACE_MODE:
  1108.          *params = ENUM_TO_DOUBLE(ctx->Polygon.CullFaceMode);
  1109.          break;
  1110.       case GL_CURRENT_COLOR:
  1111.          params[0] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[0]);
  1112.          params[1] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[1]);
  1113.          params[2] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[2]);
  1114.          params[3] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[3]);
  1115.          break;
  1116.       case GL_CURRENT_INDEX:
  1117.          *params = (GLdouble) ctx->Current.Index;
  1118.          break;
  1119.       case GL_CURRENT_NORMAL:
  1120.          params[0] = (GLdouble) ctx->Current.Normal[0];
  1121.          params[1] = (GLdouble) ctx->Current.Normal[1];
  1122.          params[2] = (GLdouble) ctx->Current.Normal[2];
  1123.          break;
  1124.       case GL_CURRENT_RASTER_COLOR:
  1125.      params[0] = (GLdouble) ctx->Current.RasterColor[0];
  1126.      params[1] = (GLdouble) ctx->Current.RasterColor[1];
  1127.      params[2] = (GLdouble) ctx->Current.RasterColor[2];
  1128.      params[3] = (GLdouble) ctx->Current.RasterColor[3];
  1129.      break;
  1130.       case GL_CURRENT_RASTER_DISTANCE:
  1131.      params[0] = (GLdouble) ctx->Current.RasterDistance;
  1132.      break;
  1133.       case GL_CURRENT_RASTER_INDEX:
  1134.      *params = (GLdouble) ctx->Current.RasterIndex;
  1135.      break;
  1136.       case GL_CURRENT_RASTER_POSITION:
  1137.      params[0] = (GLdouble) ctx->Current.RasterPos[0];
  1138.      params[1] = (GLdouble) ctx->Current.RasterPos[1];
  1139.      params[2] = (GLdouble) ctx->Current.RasterPos[2];
  1140.      params[3] = (GLdouble) ctx->Current.RasterPos[3];
  1141.      break;
  1142.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  1143.      params[0] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
  1144.      params[1] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
  1145.      params[2] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
  1146.      params[3] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
  1147.      break;
  1148.       case GL_CURRENT_RASTER_POSITION_VALID:
  1149.      *params = (GLdouble) ctx->Current.RasterPosValid;
  1150.      break;
  1151.       case GL_CURRENT_TEXTURE_COORDS:
  1152.      params[0] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][0];
  1153.      params[1] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][1];
  1154.      params[2] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][2];
  1155.      params[3] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][3];
  1156.      break;
  1157.       case GL_DEPTH_BIAS:
  1158.      *params = (GLdouble) ctx->Pixel.DepthBias;
  1159.      break;
  1160.       case GL_DEPTH_BITS:
  1161.      *params = (GLdouble) ctx->Visual->DepthBits;
  1162.      break;
  1163.       case GL_DEPTH_CLEAR_VALUE:
  1164.      *params = (GLdouble) ctx->Depth.Clear;
  1165.      break;
  1166.       case GL_DEPTH_FUNC:
  1167.      *params = ENUM_TO_DOUBLE(ctx->Depth.Func);
  1168.      break;
  1169.       case GL_DEPTH_RANGE:
  1170.          params[0] = (GLdouble) ctx->Viewport.Near;
  1171.          params[1] = (GLdouble) ctx->Viewport.Far;
  1172.      break;
  1173.       case GL_DEPTH_SCALE:
  1174.      *params = (GLdouble) ctx->Pixel.DepthScale;
  1175.      break;
  1176.       case GL_DEPTH_TEST:
  1177.      *params = (GLdouble) ctx->Depth.Test;
  1178.      break;
  1179.       case GL_DEPTH_WRITEMASK:
  1180.      *params = (GLdouble) ctx->Depth.Mask;
  1181.      break;
  1182.       case GL_DITHER:
  1183.      *params = (GLdouble) ctx->Color.DitherFlag;
  1184.      break;
  1185.       case GL_DOUBLEBUFFER:
  1186.      *params = (GLdouble) ctx->Visual->DBflag;
  1187.      break;
  1188.       case GL_DRAW_BUFFER:
  1189.      *params = ENUM_TO_DOUBLE(ctx->Color.DrawBuffer);
  1190.      break;
  1191.       case GL_EDGE_FLAG:
  1192.      *params = (GLdouble) ctx->Current.EdgeFlag;
  1193.      break;
  1194.       case GL_FEEDBACK_BUFFER_SIZE:
  1195.          /* TODO: is this right?  Or, return number of entries in buffer? */
  1196.          *params = (GLdouble) ctx->Feedback.BufferSize;
  1197.          break;
  1198.       case GL_FEEDBACK_BUFFER_TYPE:
  1199.          *params = ENUM_TO_DOUBLE(ctx->Feedback.Type);
  1200.          break;
  1201.       case GL_FOG:
  1202.      *params = (GLdouble) ctx->Fog.Enabled;
  1203.      break;
  1204.       case GL_FOG_COLOR:
  1205.      params[0] = (GLdouble) ctx->Fog.Color[0];
  1206.      params[1] = (GLdouble) ctx->Fog.Color[1];
  1207.      params[2] = (GLdouble) ctx->Fog.Color[2];
  1208.      params[3] = (GLdouble) ctx->Fog.Color[3];
  1209.      break;
  1210.       case GL_FOG_DENSITY:
  1211.      *params = (GLdouble) ctx->Fog.Density;
  1212.      break;
  1213.       case GL_FOG_END:
  1214.      *params = (GLdouble) ctx->Fog.End;
  1215.      break;
  1216.       case GL_FOG_HINT:
  1217.      *params = ENUM_TO_DOUBLE(ctx->Hint.Fog);
  1218.      break;
  1219.       case GL_FOG_INDEX:
  1220.      *params = (GLdouble) ctx->Fog.Index;
  1221.      break;
  1222.       case GL_FOG_MODE:
  1223.      *params = ENUM_TO_DOUBLE(ctx->Fog.Mode);
  1224.      break;
  1225.       case GL_FOG_START:
  1226.      *params = (GLdouble) ctx->Fog.Start;
  1227.      break;
  1228.       case GL_FRONT_FACE:
  1229.      *params = ENUM_TO_DOUBLE(ctx->Polygon.FrontFace);
  1230.      break;
  1231.       case GL_GREEN_BIAS:
  1232.          *params = (GLdouble) ctx->Pixel.GreenBias;
  1233.          break;
  1234.       case GL_GREEN_BITS:
  1235.          *params = (GLdouble) ctx->Visual->GreenBits;
  1236.          break;
  1237.       case GL_GREEN_SCALE:
  1238.          *params = (GLdouble) ctx->Pixel.GreenScale;
  1239.          break;
  1240.       case GL_INDEX_BITS:
  1241.          *params = (GLdouble) ctx->Visual->IndexBits;
  1242.      break;
  1243.       case GL_INDEX_CLEAR_VALUE:
  1244.          *params = (GLdouble) ctx->Color.ClearIndex;
  1245.      break;
  1246.       case GL_INDEX_MODE:
  1247.      *params = ctx->Visual->RGBAflag ? 0.0 : 1.0;
  1248.      break;
  1249.       case GL_INDEX_OFFSET:
  1250.      *params = (GLdouble) ctx->Pixel.IndexOffset;
  1251.      break;
  1252.       case GL_INDEX_SHIFT:
  1253.      *params = (GLdouble) ctx->Pixel.IndexShift;
  1254.      break;
  1255.       case GL_INDEX_WRITEMASK:
  1256.      *params = (GLdouble) ctx->Color.IndexMask;
  1257.      break;
  1258.       case GL_LIGHT0:
  1259.       case GL_LIGHT1:
  1260.       case GL_LIGHT2:
  1261.       case GL_LIGHT3:
  1262.       case GL_LIGHT4:
  1263.       case GL_LIGHT5:
  1264.       case GL_LIGHT6:
  1265.       case GL_LIGHT7:
  1266.      *params = (GLdouble) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  1267.      break;
  1268.       case GL_LIGHTING:
  1269.      *params = (GLdouble) ctx->Light.Enabled;
  1270.      break;
  1271.       case GL_LIGHT_MODEL_AMBIENT:
  1272.      params[0] = (GLdouble) ctx->Light.Model.Ambient[0];
  1273.      params[1] = (GLdouble) ctx->Light.Model.Ambient[1];
  1274.      params[2] = (GLdouble) ctx->Light.Model.Ambient[2];
  1275.      params[3] = (GLdouble) ctx->Light.Model.Ambient[3];
  1276.      break;
  1277.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  1278.          params[0] = (GLdouble) ctx->Light.Model.ColorControl;
  1279.          break;
  1280.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  1281.      *params = (GLdouble) ctx->Light.Model.LocalViewer;
  1282.      break;
  1283.       case GL_LIGHT_MODEL_TWO_SIDE:
  1284.      *params = (GLdouble) ctx->Light.Model.TwoSide;
  1285.      break;
  1286.       case GL_LINE_SMOOTH:
  1287.      *params = (GLdouble) ctx->Line.SmoothFlag;
  1288.      break;
  1289.       case GL_LINE_SMOOTH_HINT:
  1290.      *params = ENUM_TO_DOUBLE(ctx->Hint.LineSmooth);
  1291.      break;
  1292.       case GL_LINE_STIPPLE:
  1293.      *params = (GLdouble) ctx->Line.StippleFlag;
  1294.      break;
  1295.       case GL_LINE_STIPPLE_PATTERN:
  1296.          *params = (GLdouble) ctx->Line.StipplePattern;
  1297.          break;
  1298.       case GL_LINE_STIPPLE_REPEAT:
  1299.          *params = (GLdouble) ctx->Line.StippleFactor;
  1300.          break;
  1301.       case GL_LINE_WIDTH:
  1302.      *params = (GLdouble) ctx->Line.Width;
  1303.      break;
  1304.       case GL_LINE_WIDTH_GRANULARITY:
  1305.      *params = (GLdouble) LINE_WIDTH_GRANULARITY;
  1306.      break;
  1307.       case GL_LINE_WIDTH_RANGE:
  1308.      params[0] = (GLdouble) MIN_LINE_WIDTH;
  1309.      params[1] = (GLdouble) MAX_LINE_WIDTH;
  1310.      break;
  1311.       case GL_LIST_BASE:
  1312.      *params = (GLdouble) ctx->List.ListBase;
  1313.      break;
  1314.       case GL_LIST_INDEX:
  1315.      *params = (GLdouble) ctx->CurrentListNum;
  1316.      break;
  1317.       case GL_LIST_MODE:
  1318.      *params = ctx->ExecuteFlag ? ENUM_TO_DOUBLE(GL_COMPILE_AND_EXECUTE)
  1319.                      : ENUM_TO_DOUBLE(GL_COMPILE);
  1320.      break;
  1321.       case GL_INDEX_LOGIC_OP:
  1322.      *params = (GLdouble) ctx->Color.IndexLogicOpEnabled;
  1323.      break;
  1324.       case GL_COLOR_LOGIC_OP:
  1325.      *params = (GLdouble) ctx->Color.ColorLogicOpEnabled;
  1326.      break;
  1327.       case GL_LOGIC_OP_MODE:
  1328.          *params = ENUM_TO_DOUBLE(ctx->Color.LogicOp);
  1329.      break;
  1330.       case GL_MAP1_COLOR_4:
  1331.      *params = (GLdouble) ctx->Eval.Map1Color4;
  1332.      break;
  1333.       case GL_MAP1_GRID_DOMAIN:
  1334.      params[0] = (GLdouble) ctx->Eval.MapGrid1u1;
  1335.      params[1] = (GLdouble) ctx->Eval.MapGrid1u2;
  1336.      break;
  1337.       case GL_MAP1_GRID_SEGMENTS:
  1338.      *params = (GLdouble) ctx->Eval.MapGrid1un;
  1339.      break;
  1340.       case GL_MAP1_INDEX:
  1341.      *params = (GLdouble) ctx->Eval.Map1Index;
  1342.      break;
  1343.       case GL_MAP1_NORMAL:
  1344.      *params = (GLdouble) ctx->Eval.Map1Normal;
  1345.      break;
  1346.       case GL_MAP1_TEXTURE_COORD_1:
  1347.      *params = (GLdouble) ctx->Eval.Map1TextureCoord1;
  1348.      break;
  1349.       case GL_MAP1_TEXTURE_COORD_2:
  1350.      *params = (GLdouble) ctx->Eval.Map1TextureCoord2;
  1351.      break;
  1352.       case GL_MAP1_TEXTURE_COORD_3:
  1353.      *params = (GLdouble) ctx->Eval.Map1TextureCoord3;
  1354.      break;
  1355.       case GL_MAP1_TEXTURE_COORD_4:
  1356.      *params = (GLdouble) ctx->Eval.Map1TextureCoord4;
  1357.      break;
  1358.       case GL_MAP1_VERTEX_3:
  1359.      *params = (GLdouble) ctx->Eval.Map1Vertex3;
  1360.      break;
  1361.       case GL_MAP1_VERTEX_4:
  1362.      *params = (GLdouble) ctx->Eval.Map1Vertex4;
  1363.      break;
  1364.       case GL_MAP2_COLOR_4:
  1365.      *params = (GLdouble) ctx->Eval.Map2Color4;
  1366.      break;
  1367.       case GL_MAP2_GRID_DOMAIN:
  1368.      params[0] = (GLdouble) ctx->Eval.MapGrid2u1;
  1369.      params[1] = (GLdouble) ctx->Eval.MapGrid2u2;
  1370.      params[2] = (GLdouble) ctx->Eval.MapGrid2v1;
  1371.      params[3] = (GLdouble) ctx->Eval.MapGrid2v2;
  1372.      break;
  1373.       case GL_MAP2_GRID_SEGMENTS:
  1374.      params[0] = (GLdouble) ctx->Eval.MapGrid2un;
  1375.      params[1] = (GLdouble) ctx->Eval.MapGrid2vn;
  1376.      break;
  1377.       case GL_MAP2_INDEX:
  1378.      *params = (GLdouble) ctx->Eval.Map2Index;
  1379.      break;
  1380.       case GL_MAP2_NORMAL:
  1381.      *params = (GLdouble) ctx->Eval.Map2Normal;
  1382.      break;
  1383.       case GL_MAP2_TEXTURE_COORD_1:
  1384.      *params = (GLdouble) ctx->Eval.Map2TextureCoord1;
  1385.      break;
  1386.       case GL_MAP2_TEXTURE_COORD_2:
  1387.      *params = (GLdouble) ctx->Eval.Map2TextureCoord2;
  1388.      break;
  1389.       case GL_MAP2_TEXTURE_COORD_3:
  1390.      *params = (GLdouble) ctx->Eval.Map2TextureCoord3;
  1391.      break;
  1392.       case GL_MAP2_TEXTURE_COORD_4:
  1393.      *params = (GLdouble) ctx->Eval.Map2TextureCoord4;
  1394.      break;
  1395.       case GL_MAP2_VERTEX_3:
  1396.      *params = (GLdouble) ctx->Eval.Map2Vertex3;
  1397.      break;
  1398.       case GL_MAP2_VERTEX_4:
  1399.      *params = (GLdouble) ctx->Eval.Map2Vertex4;
  1400.      break;
  1401.       case GL_MAP_COLOR:
  1402.      *params = (GLdouble) ctx->Pixel.MapColorFlag;
  1403.      break;
  1404.       case GL_MAP_STENCIL:
  1405.      *params = (GLdouble) ctx->Pixel.MapStencilFlag;
  1406.      break;
  1407.       case GL_MATRIX_MODE:
  1408.      *params = ENUM_TO_DOUBLE(ctx->Transform.MatrixMode);
  1409.      break;
  1410.       case GL_MAX_ATTRIB_STACK_DEPTH:
  1411.      *params = (GLdouble) MAX_ATTRIB_STACK_DEPTH;
  1412.      break;
  1413.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  1414.          *params = (GLdouble) MAX_CLIENT_ATTRIB_STACK_DEPTH;
  1415.          break;
  1416.       case GL_MAX_CLIP_PLANES:
  1417.      *params = (GLdouble) MAX_CLIP_PLANES;
  1418.      break;
  1419.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  1420.          *params = (GLdouble) VB_MAX;
  1421.          break;
  1422.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  1423.          *params = (GLdouble) VB_MAX;
  1424.          break;
  1425.       case GL_MAX_EVAL_ORDER:
  1426.      *params = (GLdouble) MAX_EVAL_ORDER;
  1427.      break;
  1428.       case GL_MAX_LIGHTS:
  1429.      *params = (GLdouble) MAX_LIGHTS;
  1430.      break;
  1431.       case GL_MAX_LIST_NESTING:
  1432.      *params = (GLdouble) MAX_LIST_NESTING;
  1433.      break;
  1434.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  1435.      *params = (GLdouble) MAX_MODELVIEW_STACK_DEPTH;
  1436.      break;
  1437.       case GL_MAX_NAME_STACK_DEPTH:
  1438.      *params = (GLdouble) MAX_NAME_STACK_DEPTH;
  1439.      break;
  1440.       case GL_MAX_PIXEL_MAP_TABLE:
  1441.      *params = (GLdouble) MAX_PIXEL_MAP_TABLE;
  1442.      break;
  1443.       case GL_MAX_PROJECTION_STACK_DEPTH:
  1444.      *params = (GLdouble) MAX_PROJECTION_STACK_DEPTH;
  1445.      break;
  1446.       case GL_MAX_TEXTURE_SIZE:
  1447.       case GL_MAX_3D_TEXTURE_SIZE:
  1448.          *params = (GLdouble) ctx->Const.MaxTextureSize;
  1449.      break;
  1450.       case GL_MAX_TEXTURE_STACK_DEPTH:
  1451.      *params = (GLdouble) MAX_TEXTURE_STACK_DEPTH;
  1452.      break;
  1453.       case GL_MAX_VIEWPORT_DIMS:
  1454.          params[0] = (GLdouble) MAX_WIDTH;
  1455.          params[1] = (GLdouble) MAX_HEIGHT;
  1456.          break;
  1457.       case GL_MODELVIEW_MATRIX:
  1458.      for (i=0;i<16;i++) {
  1459.         params[i] = (GLdouble) ctx->ModelView.m[i];
  1460.      }
  1461.      break;
  1462.       case GL_MODELVIEW_STACK_DEPTH:
  1463.      *params = (GLdouble) (ctx->ModelViewStackDepth + 1);
  1464.      break;
  1465.       case GL_NAME_STACK_DEPTH:
  1466.      *params = (GLdouble) ctx->Select.NameStackDepth;
  1467.      break;
  1468.       case GL_NORMALIZE:
  1469.      *params = (GLdouble) ctx->Transform.Normalize;
  1470.      break;
  1471.       case GL_PACK_ALIGNMENT:
  1472.      *params = (GLdouble) ctx->Pack.Alignment;
  1473.      break;
  1474.       case GL_PACK_LSB_FIRST:
  1475.      *params = (GLdouble) ctx->Pack.LsbFirst;
  1476.      break;
  1477.       case GL_PACK_ROW_LENGTH:
  1478.      *params = (GLdouble) ctx->Pack.RowLength;
  1479.      break;
  1480.       case GL_PACK_SKIP_PIXELS:
  1481.      *params = (GLdouble) ctx->Pack.SkipPixels;
  1482.      break;
  1483.       case GL_PACK_SKIP_ROWS:
  1484.      *params = (GLdouble) ctx->Pack.SkipRows;
  1485.      break;
  1486.       case GL_PACK_SWAP_BYTES:
  1487.      *params = (GLdouble) ctx->Pack.SwapBytes;
  1488.      break;
  1489.       case GL_PACK_SKIP_IMAGES_EXT:
  1490.          *params = (GLdouble) ctx->Pack.SkipImages;
  1491.          break;
  1492.       case GL_PACK_IMAGE_HEIGHT_EXT:
  1493.          *params = (GLdouble) ctx->Pack.ImageHeight;
  1494.          break;
  1495.       case GL_PERSPECTIVE_CORRECTION_HINT:
  1496.      *params = ENUM_TO_DOUBLE(ctx->Hint.PerspectiveCorrection);
  1497.      break;
  1498.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  1499.      *params = (GLdouble) ctx->Pixel.MapAtoAsize;
  1500.      break;
  1501.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  1502.      *params = (GLdouble) ctx->Pixel.MapBtoBsize;
  1503.      break;
  1504.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  1505.      *params = (GLdouble) ctx->Pixel.MapGtoGsize;
  1506.      break;
  1507.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  1508.      *params = (GLdouble) ctx->Pixel.MapItoAsize;
  1509.      break;
  1510.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  1511.      *params = (GLdouble) ctx->Pixel.MapItoBsize;
  1512.      break;
  1513.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  1514.      *params = (GLdouble) ctx->Pixel.MapItoGsize;
  1515.      break;
  1516.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  1517.      *params = (GLdouble) ctx->Pixel.MapItoIsize;
  1518.      break;
  1519.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  1520.      *params = (GLdouble) ctx->Pixel.MapItoRsize;
  1521.      break;
  1522.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  1523.      *params = (GLdouble) ctx->Pixel.MapRtoRsize;
  1524.      break;
  1525.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  1526.      *params = (GLdouble) ctx->Pixel.MapStoSsize;
  1527.      break;
  1528.       case GL_POINT_SIZE:
  1529.          *params = (GLdouble) ctx->Point.Size;
  1530.          break;
  1531.       case GL_POINT_SIZE_GRANULARITY:
  1532.      *params = (GLdouble) POINT_SIZE_GRANULARITY;
  1533.      break;
  1534.       case GL_POINT_SIZE_RANGE:
  1535.      params[0] = (GLdouble) MIN_POINT_SIZE;
  1536.      params[1] = (GLdouble) MAX_POINT_SIZE;
  1537.      break;
  1538.       case GL_POINT_SMOOTH:
  1539.      *params = (GLdouble) ctx->Point.SmoothFlag;
  1540.      break;
  1541.       case GL_POINT_SMOOTH_HINT:
  1542.      *params = ENUM_TO_DOUBLE(ctx->Hint.PointSmooth);
  1543.      break;
  1544.       case GL_POINT_SIZE_MIN_EXT:
  1545.      *params = (GLdouble) (ctx->Point.MinSize);
  1546.      break;
  1547.       case GL_POINT_SIZE_MAX_EXT:
  1548.      *params = (GLdouble) (ctx->Point.MaxSize);
  1549.      break;
  1550.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  1551.      *params = (GLdouble) (ctx->Point.Threshold);
  1552.      break;
  1553.       case GL_DISTANCE_ATTENUATION_EXT:
  1554.      params[0] = (GLdouble) (ctx->Point.Params[0]);
  1555.      params[1] = (GLdouble) (ctx->Point.Params[1]);
  1556.      params[2] = (GLdouble) (ctx->Point.Params[2]);
  1557.      break;
  1558.       case GL_POLYGON_MODE:
  1559.      params[0] = ENUM_TO_DOUBLE(ctx->Polygon.FrontMode);
  1560.      params[1] = ENUM_TO_DOUBLE(ctx->Polygon.BackMode);
  1561.      break;
  1562. #ifdef GL_EXT_polygon_offset
  1563.       case GL_POLYGON_OFFSET_BIAS_EXT:
  1564.          *params = (GLdouble) ctx->Polygon.OffsetUnits;
  1565.          break;
  1566. #endif
  1567.       case GL_POLYGON_OFFSET_FACTOR:
  1568.          *params = (GLdouble) ctx->Polygon.OffsetFactor;
  1569.          break;
  1570.       case GL_POLYGON_OFFSET_UNITS:
  1571.          *params = (GLdouble) ctx->Polygon.OffsetUnits;
  1572.          break;
  1573.       case GL_POLYGON_SMOOTH:
  1574.      *params = (GLdouble) ctx->Polygon.SmoothFlag;
  1575.      break;
  1576.       case GL_POLYGON_SMOOTH_HINT:
  1577.      *params = ENUM_TO_DOUBLE(ctx->Hint.PolygonSmooth);
  1578.      break;
  1579.       case GL_POLYGON_STIPPLE:
  1580.          *params = (GLdouble) ctx->Polygon.StippleFlag;
  1581.      break;
  1582.       case GL_PROJECTION_MATRIX:
  1583.      for (i=0;i<16;i++) {
  1584.         params[i] = (GLdouble) ctx->ProjectionMatrix.m[i];
  1585.      }
  1586.      break;
  1587.       case GL_PROJECTION_STACK_DEPTH:
  1588.      *params = (GLdouble) (ctx->ProjectionStackDepth + 1);
  1589.      break;
  1590.       case GL_READ_BUFFER:
  1591.      *params = ENUM_TO_DOUBLE(ctx->Pixel.ReadBuffer);
  1592.      break;
  1593.       case GL_RED_BIAS:
  1594.          *params = (GLdouble) ctx->Pixel.RedBias;
  1595.          break;
  1596.       case GL_RED_BITS:
  1597.          *params = (GLdouble) ctx->Visual->RedBits;
  1598.          break;
  1599.       case GL_RED_SCALE:
  1600.          *params = (GLdouble) ctx->Pixel.RedScale;
  1601.          break;
  1602.       case GL_RENDER_MODE:
  1603.      *params = ENUM_TO_DOUBLE(ctx->RenderMode);
  1604.      break;
  1605.       case GL_RGBA_MODE:
  1606.      *params = (GLdouble) ctx->Visual->RGBAflag;
  1607.      break;
  1608.       case GL_SCISSOR_BOX:
  1609.      params[0] = (GLdouble) ctx->Scissor.X;
  1610.      params[1] = (GLdouble) ctx->Scissor.Y;
  1611.      params[2] = (GLdouble) ctx->Scissor.Width;
  1612.      params[3] = (GLdouble) ctx->Scissor.Height;
  1613.      break;
  1614.       case GL_SCISSOR_TEST:
  1615.      *params = (GLdouble) ctx->Scissor.Enabled;
  1616.      break;
  1617.       case GL_SELECTION_BUFFER_SIZE:
  1618.          *params = (GLdouble) ctx->Select.BufferSize;
  1619.          break;
  1620.       case GL_SHADE_MODEL:
  1621.      *params = ENUM_TO_DOUBLE(ctx->Light.ShadeModel);
  1622.      break;
  1623.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  1624.          *params = (GLdouble) ctx->Texture.SharedPalette;
  1625.          break;
  1626.       case GL_STENCIL_BITS:
  1627.          *params = (GLdouble) ctx->Visual->StencilBits;
  1628.          break;
  1629.       case GL_STENCIL_CLEAR_VALUE:
  1630.      *params = (GLdouble) ctx->Stencil.Clear;
  1631.      break;
  1632.       case GL_STENCIL_FAIL:
  1633.      *params = ENUM_TO_DOUBLE(ctx->Stencil.FailFunc);
  1634.      break;
  1635.       case GL_STENCIL_FUNC:
  1636.      *params = ENUM_TO_DOUBLE(ctx->Stencil.Function);
  1637.      break;
  1638.       case GL_STENCIL_PASS_DEPTH_FAIL:
  1639.      *params = ENUM_TO_DOUBLE(ctx->Stencil.ZFailFunc);
  1640.      break;
  1641.       case GL_STENCIL_PASS_DEPTH_PASS:
  1642.      *params = ENUM_TO_DOUBLE(ctx->Stencil.ZPassFunc);
  1643.      break;
  1644.       case GL_STENCIL_REF:
  1645.      *params = (GLdouble) ctx->Stencil.Ref;
  1646.      break;
  1647.       case GL_STENCIL_TEST:
  1648.      *params = (GLdouble) ctx->Stencil.Enabled;
  1649.      break;
  1650.       case GL_STENCIL_VALUE_MASK:
  1651.      *params = (GLdouble) ctx->Stencil.ValueMask;
  1652.      break;
  1653.       case GL_STENCIL_WRITEMASK:
  1654.      *params = (GLdouble) ctx->Stencil.WriteMask;
  1655.      break;
  1656.       case GL_STEREO:
  1657.      *params = (GLdouble) ctx->Visual->StereoFlag;
  1658.      break;
  1659.       case GL_SUBPIXEL_BITS:
  1660.      *params = 0.0;   /* TODO */
  1661.      break;
  1662.       case GL_TEXTURE_1D:
  1663.          *params = gl_IsEnabled(ctx, GL_TEXTURE_1D) ? 1.0 : 0.0;
  1664.      break;
  1665.       case GL_TEXTURE_2D:
  1666.          *params = gl_IsEnabled(ctx, GL_TEXTURE_2D) ? 1.0 : 0.0;
  1667.      break;
  1668.       case GL_TEXTURE_3D:
  1669.          *params = gl_IsEnabled(ctx, GL_TEXTURE_3D) ? 1.0 : 0.0;
  1670.      break;
  1671.       case GL_TEXTURE_BINDING_1D:
  1672.          *params = (GLdouble) textureUnit->CurrentD[1]->Name;
  1673.           break;
  1674.       case GL_TEXTURE_BINDING_2D:
  1675.          *params = (GLdouble) textureUnit->CurrentD[2]->Name;
  1676.           break;
  1677.       case GL_TEXTURE_BINDING_3D:
  1678.          *params = (GLdouble) textureUnit->CurrentD[3]->Name;
  1679.           break;
  1680.       case GL_TEXTURE_ENV_COLOR:
  1681.      params[0] = (GLdouble) textureUnit->EnvColor[0];
  1682.      params[1] = (GLdouble) textureUnit->EnvColor[1];
  1683.      params[2] = (GLdouble) textureUnit->EnvColor[2];
  1684.      params[3] = (GLdouble) textureUnit->EnvColor[3];
  1685.      break;
  1686.       case GL_TEXTURE_ENV_MODE:
  1687.      *params = ENUM_TO_DOUBLE(textureUnit->EnvMode);
  1688.      break;
  1689.       case GL_TEXTURE_GEN_S:
  1690.      *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
  1691.      break;
  1692.       case GL_TEXTURE_GEN_T:
  1693.      *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
  1694.      break;
  1695.       case GL_TEXTURE_GEN_R:
  1696.      *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
  1697.      break;
  1698.       case GL_TEXTURE_GEN_Q:
  1699.      *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
  1700.      break;
  1701.       case GL_TEXTURE_MATRIX:
  1702.          for (i=0;i<16;i++) {
  1703.         params[i] = (GLdouble) ctx->TextureMatrix[texTransformUnit].m[i];
  1704.      }
  1705.      break;
  1706.       case GL_TEXTURE_STACK_DEPTH:
  1707.      *params = (GLdouble) (ctx->TextureStackDepth[texTransformUnit] + 1);
  1708.      break;
  1709.       case GL_UNPACK_ALIGNMENT:
  1710.      *params = (GLdouble) ctx->Unpack.Alignment;
  1711.      break;
  1712.       case GL_UNPACK_LSB_FIRST:
  1713.      *params = (GLdouble) ctx->Unpack.LsbFirst;
  1714.      break;
  1715.       case GL_UNPACK_ROW_LENGTH:
  1716.      *params = (GLdouble) ctx->Unpack.RowLength;
  1717.      break;
  1718.       case GL_UNPACK_SKIP_PIXELS:
  1719.      *params = (GLdouble) ctx->Unpack.SkipPixels;
  1720.      break;
  1721.       case GL_UNPACK_SKIP_ROWS:
  1722.      *params = (GLdouble) ctx->Unpack.SkipRows;
  1723.      break;
  1724.       case GL_UNPACK_SWAP_BYTES:
  1725.      *params = (GLdouble) ctx->Unpack.SwapBytes;
  1726.      break;
  1727.       case GL_UNPACK_SKIP_IMAGES_EXT:
  1728.          *params = (GLdouble) ctx->Unpack.SkipImages;
  1729.          break;
  1730.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  1731.          *params = (GLdouble) ctx->Unpack.ImageHeight;
  1732.          break;
  1733.       case GL_VIEWPORT:
  1734.      params[0] = (GLdouble) ctx->Viewport.X;
  1735.      params[1] = (GLdouble) ctx->Viewport.Y;
  1736.      params[2] = (GLdouble) ctx->Viewport.Width;
  1737.      params[3] = (GLdouble) ctx->Viewport.Height;
  1738.      break;
  1739.       case GL_ZOOM_X:
  1740.      *params = (GLdouble) ctx->Pixel.ZoomX;
  1741.      break;
  1742.       case GL_ZOOM_Y:
  1743.      *params = (GLdouble) ctx->Pixel.ZoomY;
  1744.      break;
  1745.       case GL_VERTEX_ARRAY:
  1746.          *params = (GLdouble) ctx->Array.Vertex.Enabled;
  1747.          break;
  1748.       case GL_VERTEX_ARRAY_SIZE:
  1749.          *params = (GLdouble) ctx->Array.Vertex.Size;
  1750.          break;
  1751.       case GL_VERTEX_ARRAY_TYPE:
  1752.          *params = ENUM_TO_DOUBLE(ctx->Array.Vertex.Type);
  1753.          break;
  1754.       case GL_VERTEX_ARRAY_STRIDE:
  1755.          *params = (GLdouble) ctx->Array.Vertex.Stride;
  1756.          break;
  1757.       case GL_VERTEX_ARRAY_COUNT_EXT:
  1758.          *params = 0.0;
  1759.          break;
  1760.       case GL_NORMAL_ARRAY:
  1761.          *params = (GLdouble) ctx->Array.Normal.Enabled;
  1762.          break;
  1763.       case GL_NORMAL_ARRAY_TYPE:
  1764.          *params = ENUM_TO_DOUBLE(ctx->Array.Normal.Type);
  1765.          break;
  1766.       case GL_NORMAL_ARRAY_STRIDE:
  1767.          *params = (GLdouble) ctx->Array.Normal.Stride;
  1768.          break;
  1769.       case GL_NORMAL_ARRAY_COUNT_EXT:
  1770.          *params = 0.0;
  1771.          break;
  1772.       case GL_COLOR_ARRAY:
  1773.          *params = (GLdouble) ctx->Array.Color.Enabled;
  1774.          break;
  1775.       case GL_COLOR_ARRAY_SIZE:
  1776.          *params = (GLdouble) ctx->Array.Color.Size;
  1777.          break;
  1778.       case GL_COLOR_ARRAY_TYPE:
  1779.          *params = ENUM_TO_DOUBLE(ctx->Array.Color.Type);
  1780.          break;
  1781.       case GL_COLOR_ARRAY_STRIDE:
  1782.          *params = (GLdouble) ctx->Array.Color.Stride;
  1783.          break;
  1784.       case GL_COLOR_ARRAY_COUNT_EXT:
  1785.          *params = 0.0;
  1786.          break;
  1787.       case GL_INDEX_ARRAY:
  1788.          *params = (GLdouble) ctx->Array.Index.Enabled;
  1789.          break;
  1790.       case GL_INDEX_ARRAY_TYPE:
  1791.          *params = ENUM_TO_DOUBLE(ctx->Array.Index.Type);
  1792.          break;
  1793.       case GL_INDEX_ARRAY_STRIDE:
  1794.          *params = (GLdouble) ctx->Array.Index.Stride;
  1795.          break;
  1796.       case GL_INDEX_ARRAY_COUNT_EXT:
  1797.          *params = 0.0;
  1798.          break;
  1799.       case GL_TEXTURE_COORD_ARRAY:
  1800.          *params = (GLdouble) ctx->Array.TexCoord[texUnit].Enabled;
  1801.          break;
  1802.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  1803.          *params = (GLdouble) ctx->Array.TexCoord[texUnit].Size;
  1804.          break;
  1805.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  1806.          *params = ENUM_TO_DOUBLE(ctx->Array.TexCoord[texUnit].Type);
  1807.          break;
  1808.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  1809.          *params = (GLdouble) ctx->Array.TexCoord[texUnit].Stride;
  1810.          break;
  1811.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  1812.          *params = 0.0;
  1813.          break;
  1814.       case GL_EDGE_FLAG_ARRAY:
  1815.          *params = (GLdouble) ctx->Array.EdgeFlag.Enabled;
  1816.          break;
  1817.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  1818.          *params = (GLdouble) ctx->Array.EdgeFlag.Stride;
  1819.          break;
  1820.       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
  1821.          *params = 0.0;
  1822.          break;
  1823.  
  1824.       case GL_MAX_TEXTURE_UNITS_ARB:
  1825.          *params = (GLdouble) ctx->Const.MaxTextureUnits;
  1826.          break;
  1827.       case GL_ACTIVE_TEXTURE_ARB:
  1828.          *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
  1829.          break;
  1830.       case GL_CLIENT_ACTIVE_TEXTURE_ARB:
  1831.          *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
  1832.          break;
  1833.  
  1834.  
  1835.       /* GL_PGI_misc_hints */
  1836.       case GL_STRICT_DEPTHFUNC_HINT_PGI:
  1837.      *params = ENUM_TO_DOUBLE(GL_NICEST);
  1838.          break;
  1839.       case GL_STRICT_LIGHTING_HINT_PGI:
  1840.      *params = ENUM_TO_DOUBLE(ctx->Hint.StrictLighting);
  1841.      break;
  1842.       case GL_STRICT_SCISSOR_HINT_PGI:
  1843.       case GL_FULL_STIPPLE_HINT_PGI:
  1844.      *params = ENUM_TO_DOUBLE(GL_TRUE);
  1845.      break;
  1846.       case GL_CONSERVE_MEMORY_HINT_PGI:
  1847.      *params = ENUM_TO_DOUBLE(GL_FALSE);
  1848.      break;
  1849.       case GL_ALWAYS_FAST_HINT_PGI:
  1850.      *params = (GLdouble) (ctx->Hint.AllowDrawWin == GL_TRUE &&
  1851.                   ctx->Hint.AllowDrawSpn == GL_FALSE && 
  1852.                   ctx->Hint.AllowDrawMem == GL_FALSE);
  1853.      break;
  1854.       case GL_ALWAYS_SOFT_HINT_PGI:
  1855.      *params = (GLdouble) (ctx->Hint.AllowDrawWin == GL_TRUE &&
  1856.                   ctx->Hint.AllowDrawSpn == GL_TRUE && 
  1857.                   ctx->Hint.AllowDrawMem == GL_TRUE);
  1858.      break;
  1859.       case GL_ALLOW_DRAW_OBJ_HINT_PGI:
  1860.      *params = (GLdouble) GL_TRUE;
  1861.      break;
  1862.       case GL_ALLOW_DRAW_WIN_HINT_PGI:
  1863.      *params = (GLdouble) ctx->Hint.AllowDrawWin;
  1864.      break;
  1865.       case GL_ALLOW_DRAW_SPN_HINT_PGI:
  1866.      *params = (GLdouble) ctx->Hint.AllowDrawSpn;
  1867.      break;
  1868.       case GL_ALLOW_DRAW_MEM_HINT_PGI:
  1869.      *params = (GLdouble) ctx->Hint.AllowDrawMem;
  1870.      break;
  1871.       case GL_CLIP_NEAR_HINT_PGI:
  1872.       case GL_CLIP_FAR_HINT_PGI:
  1873.      *params = ENUM_TO_DOUBLE(GL_TRUE);
  1874.      break;
  1875.       case GL_WIDE_LINE_HINT_PGI:
  1876.      *params = ENUM_TO_DOUBLE(GL_DONT_CARE);
  1877.      break;
  1878.       case GL_BACK_NORMALS_HINT_PGI:
  1879.      *params = ENUM_TO_DOUBLE(GL_TRUE);
  1880.      break;
  1881.       case GL_NATIVE_GRAPHICS_HANDLE_PGI:
  1882.      *params = 0;
  1883.      break;
  1884.  
  1885.  
  1886.  
  1887.       default:
  1888.      printf("invalid enum: %x\n", pname);
  1889.          gl_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
  1890.    }
  1891. }
  1892.  
  1893.  
  1894.  
  1895.  
  1896. void gl_GetFloatv( GLcontext *ctx, GLenum pname, GLfloat *params )
  1897. {
  1898.    GLuint i;
  1899.    GLuint texUnit = ctx->Texture.CurrentUnit;
  1900.    GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
  1901.    const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
  1902.  
  1903.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetFloatv");
  1904.  
  1905.    if (MESA_VERBOSE & VERBOSE_API) 
  1906.       fprintf(stderr, "glGetFloatv %s\n", gl_lookup_enum_by_nr(pname));
  1907.  
  1908.    switch (pname) {
  1909.       case GL_ACCUM_RED_BITS:
  1910.       case GL_ACCUM_GREEN_BITS:
  1911.       case GL_ACCUM_BLUE_BITS:
  1912.       case GL_ACCUM_ALPHA_BITS:
  1913.          *params = (GLfloat) ctx->Visual->AccumBits;
  1914.          break;
  1915.       case GL_ACCUM_CLEAR_VALUE:
  1916.          params[0] = ctx->Accum.ClearColor[0];
  1917.          params[1] = ctx->Accum.ClearColor[1];
  1918.          params[2] = ctx->Accum.ClearColor[2];
  1919.          params[3] = ctx->Accum.ClearColor[3];
  1920.          break;
  1921.       case GL_ALPHA_BIAS:
  1922.          *params = ctx->Pixel.AlphaBias;
  1923.          break;
  1924.       case GL_ALPHA_BITS:
  1925.          *params = (GLfloat) ctx->Visual->AlphaBits;
  1926.          break;
  1927.       case GL_ALPHA_SCALE:
  1928.          *params = ctx->Pixel.AlphaScale;
  1929.          break;
  1930.       case GL_ALPHA_TEST:
  1931.          *params = (GLfloat) ctx->Color.AlphaEnabled;
  1932.          break;
  1933.       case GL_ALPHA_TEST_FUNC:
  1934.          *params = ENUM_TO_FLOAT(ctx->Color.AlphaFunc);
  1935.          break;
  1936.       case GL_ALPHA_TEST_REF:
  1937.          *params = (GLfloat) ctx->Color.AlphaRef / 255.0;
  1938.          break;
  1939.       case GL_ATTRIB_STACK_DEPTH:
  1940.          *params = (GLfloat) (ctx->AttribStackDepth);
  1941.          break;
  1942.       case GL_AUTO_NORMAL:
  1943.          *params = (GLfloat) ctx->Eval.AutoNormal;
  1944.          break;
  1945.       case GL_AUX_BUFFERS:
  1946.          *params = (GLfloat) NUM_AUX_BUFFERS;
  1947.          break;
  1948.       case GL_BLEND:
  1949.          *params = (GLfloat) ctx->Color.BlendEnabled;
  1950.          break;
  1951.       case GL_BLEND_DST:
  1952.          *params = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
  1953.          break;
  1954.       case GL_BLEND_SRC:
  1955.          *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
  1956.          break;
  1957.       case GL_BLEND_SRC_RGB_INGR:
  1958.          *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
  1959.          break;
  1960.       case GL_BLEND_DST_RGB_INGR:
  1961.          *params = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
  1962.          break;
  1963.       case GL_BLEND_SRC_ALPHA_INGR:
  1964.          *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcA);
  1965.          break;
  1966.       case GL_BLEND_DST_ALPHA_INGR:
  1967.          *params = ENUM_TO_FLOAT(ctx->Color.BlendDstA);
  1968.          break;
  1969.       case GL_BLEND_EQUATION_EXT:
  1970.      *params = ENUM_TO_FLOAT(ctx->Color.BlendEquation);
  1971.      break;
  1972.       case GL_BLEND_COLOR_EXT:
  1973.      params[0] = ctx->Color.BlendColor[0];
  1974.      params[1] = ctx->Color.BlendColor[1];
  1975.      params[2] = ctx->Color.BlendColor[2];
  1976.      params[3] = ctx->Color.BlendColor[3];
  1977.      break;
  1978.       case GL_BLUE_BIAS:
  1979.          *params = ctx->Pixel.BlueBias;
  1980.          break;
  1981.       case GL_BLUE_BITS:
  1982.          *params = (GLfloat) ctx->Visual->BlueBits;
  1983.          break;
  1984.       case GL_BLUE_SCALE:
  1985.          *params = ctx->Pixel.BlueScale;
  1986.          break;
  1987.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  1988.          *params = (GLfloat) (ctx->ClientAttribStackDepth);
  1989.          break;
  1990.       case GL_CLIP_PLANE0:
  1991.       case GL_CLIP_PLANE1:
  1992.       case GL_CLIP_PLANE2:
  1993.       case GL_CLIP_PLANE3:
  1994.       case GL_CLIP_PLANE4:
  1995.       case GL_CLIP_PLANE5:
  1996.          *params = (GLfloat) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
  1997.          break;
  1998.       case GL_COLOR_CLEAR_VALUE:
  1999.          params[0] = (GLfloat) ctx->Color.ClearColor[0];
  2000.          params[1] = (GLfloat) ctx->Color.ClearColor[1];
  2001.          params[2] = (GLfloat) ctx->Color.ClearColor[2];
  2002.          params[3] = (GLfloat) ctx->Color.ClearColor[3];
  2003.          break;
  2004.       case GL_COLOR_MATERIAL:
  2005.          *params = (GLfloat) ctx->Light.ColorMaterialEnabled;
  2006.          break;
  2007.       case GL_COLOR_MATERIAL_FACE:
  2008.          *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialFace);
  2009.          break;
  2010.       case GL_COLOR_MATERIAL_PARAMETER:
  2011.          *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialMode);
  2012.          break;
  2013.       case GL_COLOR_WRITEMASK:
  2014.          params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0F : 0.0F;
  2015.          params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0F : 0.0F;
  2016.          params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0F : 0.0F;
  2017.          params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0F : 0.0F;
  2018.          break;
  2019.       case GL_CULL_FACE:
  2020.          *params = (GLfloat) ctx->Polygon.CullFlag;
  2021.          break;
  2022.       case GL_CULL_FACE_MODE:
  2023.          *params = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode);
  2024.          break;
  2025.       case GL_CURRENT_COLOR:
  2026.      UBYTE_RGBA_TO_FLOAT_RGBA(params, ctx->Current.ByteColor);
  2027.          break;
  2028.       case GL_CURRENT_INDEX:
  2029.          *params = (GLfloat) ctx->Current.Index;
  2030.          break;
  2031.       case GL_CURRENT_NORMAL:
  2032.          params[0] = ctx->Current.Normal[0];
  2033.          params[1] = ctx->Current.Normal[1];
  2034.          params[2] = ctx->Current.Normal[2];
  2035.          break;
  2036.       case GL_CURRENT_RASTER_COLOR:
  2037.      params[0] = ctx->Current.RasterColor[0];
  2038.      params[1] = ctx->Current.RasterColor[1];
  2039.      params[2] = ctx->Current.RasterColor[2];
  2040.      params[3] = ctx->Current.RasterColor[3];
  2041.      break;
  2042.       case GL_CURRENT_RASTER_DISTANCE:
  2043.      params[0] = ctx->Current.RasterDistance;
  2044.      break;
  2045.       case GL_CURRENT_RASTER_INDEX:
  2046.      *params = (GLfloat) ctx->Current.RasterIndex;
  2047.      break;
  2048.       case GL_CURRENT_RASTER_POSITION:
  2049.      params[0] = ctx->Current.RasterPos[0];
  2050.      params[1] = ctx->Current.RasterPos[1];
  2051.      params[2] = ctx->Current.RasterPos[2];
  2052.      params[3] = ctx->Current.RasterPos[3];
  2053.      break;
  2054.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  2055.      params[0] = ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
  2056.      params[1] = ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
  2057.      params[2] = ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
  2058.      params[3] = ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
  2059.      break;
  2060.       case GL_CURRENT_RASTER_POSITION_VALID:
  2061.      *params = (GLfloat) ctx->Current.RasterPosValid;
  2062.      break;
  2063.       case GL_CURRENT_TEXTURE_COORDS:
  2064.      params[0] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][0];
  2065.      params[1] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][1];
  2066.      params[2] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][2];
  2067.      params[3] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][3];
  2068.      break;
  2069.       case GL_DEPTH_BIAS:
  2070.      *params = (GLfloat) ctx->Pixel.DepthBias;
  2071.      break;
  2072.       case GL_DEPTH_BITS:
  2073.      *params = (GLfloat) ctx->Visual->DepthBits;
  2074.      break;
  2075.       case GL_DEPTH_CLEAR_VALUE:
  2076.      *params = (GLfloat) ctx->Depth.Clear;
  2077.      break;
  2078.       case GL_DEPTH_FUNC:
  2079.      *params = ENUM_TO_FLOAT(ctx->Depth.Func);
  2080.      break;
  2081.       case GL_DEPTH_RANGE:
  2082.          params[0] = (GLfloat) ctx->Viewport.Near;
  2083.          params[1] = (GLfloat) ctx->Viewport.Far;
  2084.      break;
  2085.       case GL_DEPTH_SCALE:
  2086.      *params = (GLfloat) ctx->Pixel.DepthScale;
  2087.      break;
  2088.       case GL_DEPTH_TEST:
  2089.      *params = (GLfloat) ctx->Depth.Test;
  2090.      break;
  2091.       case GL_DEPTH_WRITEMASK:
  2092.      *params = (GLfloat) ctx->Depth.Mask;
  2093.      break;
  2094.       case GL_DITHER:
  2095.      *params = (GLfloat) ctx->Color.DitherFlag;
  2096.      break;
  2097.       case GL_DOUBLEBUFFER:
  2098.      *params = (GLfloat) ctx->Visual->DBflag;
  2099.      break;
  2100.       case GL_DRAW_BUFFER:
  2101.      *params = ENUM_TO_FLOAT(ctx->Color.DrawBuffer);
  2102.      break;
  2103.       case GL_EDGE_FLAG:
  2104.      *params = (GLfloat) ctx->Current.EdgeFlag;
  2105.      break;
  2106.       case GL_FEEDBACK_BUFFER_SIZE:
  2107.          /* TODO: is this right?  Or, return number of entries in buffer? */
  2108.          *params = (GLfloat) ctx->Feedback.BufferSize;
  2109.          break;
  2110.       case GL_FEEDBACK_BUFFER_TYPE:
  2111.          *params = ENUM_TO_FLOAT(ctx->Feedback.Type);
  2112.          break;
  2113.       case GL_FOG:
  2114.      *params = (GLfloat) ctx->Fog.Enabled;
  2115.      break;
  2116.       case GL_FOG_COLOR:
  2117.      params[0] = ctx->Fog.Color[0];
  2118.      params[1] = ctx->Fog.Color[1];
  2119.      params[2] = ctx->Fog.Color[2];
  2120.      params[3] = ctx->Fog.Color[3];
  2121.      break;
  2122.       case GL_FOG_DENSITY:
  2123.      *params = ctx->Fog.Density;
  2124.      break;
  2125.       case GL_FOG_END:
  2126.      *params = ctx->Fog.End;
  2127.      break;
  2128.       case GL_FOG_HINT:
  2129.      *params = ENUM_TO_FLOAT(ctx->Hint.Fog);
  2130.      break;
  2131.       case GL_FOG_INDEX:
  2132.      *params = ctx->Fog.Index;
  2133.      break;
  2134.       case GL_FOG_MODE:
  2135.      *params = ENUM_TO_FLOAT(ctx->Fog.Mode);
  2136.      break;
  2137.       case GL_FOG_START:
  2138.      *params = ctx->Fog.Start;
  2139.      break;
  2140.       case GL_FRONT_FACE:
  2141.      *params = ENUM_TO_FLOAT(ctx->Polygon.FrontFace);
  2142.      break;
  2143.       case GL_GREEN_BIAS:
  2144.          *params = (GLfloat) ctx->Pixel.GreenBias;
  2145.          break;
  2146.       case GL_GREEN_BITS:
  2147.          *params = (GLfloat) ctx->Visual->GreenBits;
  2148.          break;
  2149.       case GL_GREEN_SCALE:
  2150.          *params = (GLfloat) ctx->Pixel.GreenScale;
  2151.          break;
  2152.       case GL_INDEX_BITS:
  2153.          *params = (GLfloat) ctx->Visual->IndexBits;
  2154.      break;
  2155.       case GL_INDEX_CLEAR_VALUE:
  2156.          *params = (GLfloat) ctx->Color.ClearIndex;
  2157.      break;
  2158.       case GL_INDEX_MODE:
  2159.      *params = ctx->Visual->RGBAflag ? 0.0F : 1.0F;
  2160.      break;
  2161.       case GL_INDEX_OFFSET:
  2162.      *params = (GLfloat) ctx->Pixel.IndexOffset;
  2163.      break;
  2164.       case GL_INDEX_SHIFT:
  2165.      *params = (GLfloat) ctx->Pixel.IndexShift;
  2166.      break;
  2167.       case GL_INDEX_WRITEMASK:
  2168.      *params = (GLfloat) ctx->Color.IndexMask;
  2169.      break;
  2170.       case GL_LIGHT0:
  2171.       case GL_LIGHT1:
  2172.       case GL_LIGHT2:
  2173.       case GL_LIGHT3:
  2174.       case GL_LIGHT4:
  2175.       case GL_LIGHT5:
  2176.       case GL_LIGHT6:
  2177.       case GL_LIGHT7:
  2178.      *params = (GLfloat) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  2179.      break;
  2180.       case GL_LIGHTING:
  2181.      *params = (GLfloat) ctx->Light.Enabled;
  2182.      break;
  2183.       case GL_LIGHT_MODEL_AMBIENT:
  2184.      params[0] = ctx->Light.Model.Ambient[0];
  2185.      params[1] = ctx->Light.Model.Ambient[1];
  2186.      params[2] = ctx->Light.Model.Ambient[2];
  2187.      params[3] = ctx->Light.Model.Ambient[3];
  2188.      break;
  2189.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  2190.          params[0] = ENUM_TO_FLOAT(ctx->Light.Model.ColorControl);
  2191.          break;
  2192.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  2193.      *params = (GLfloat) ctx->Light.Model.LocalViewer;
  2194.      break;
  2195.       case GL_LIGHT_MODEL_TWO_SIDE:
  2196.      *params = (GLfloat) ctx->Light.Model.TwoSide;
  2197.      break;
  2198.       case GL_LINE_SMOOTH:
  2199.      *params = (GLfloat) ctx->Line.SmoothFlag;
  2200.      break;
  2201.       case GL_LINE_SMOOTH_HINT:
  2202.      *params = ENUM_TO_FLOAT(ctx->Hint.LineSmooth);
  2203.      break;
  2204.       case GL_LINE_STIPPLE:
  2205.      *params = (GLfloat) ctx->Line.StippleFlag;
  2206.      break;
  2207.       case GL_LINE_STIPPLE_PATTERN:
  2208.          *params = (GLfloat) ctx->Line.StipplePattern;
  2209.          break;
  2210.       case GL_LINE_STIPPLE_REPEAT:
  2211.          *params = (GLfloat) ctx->Line.StippleFactor;
  2212.          break;
  2213.       case GL_LINE_WIDTH:
  2214.      *params = (GLfloat) ctx->Line.Width;
  2215.      break;
  2216.       case GL_LINE_WIDTH_GRANULARITY:
  2217.      *params = (GLfloat) LINE_WIDTH_GRANULARITY;
  2218.      break;
  2219.       case GL_LINE_WIDTH_RANGE:
  2220.      params[0] = (GLfloat) MIN_LINE_WIDTH;
  2221.      params[1] = (GLfloat) MAX_LINE_WIDTH;
  2222.      break;
  2223.       case GL_LIST_BASE:
  2224.      *params = (GLfloat) ctx->List.ListBase;
  2225.      break;
  2226.       case GL_LIST_INDEX:
  2227.      *params = (GLfloat) ctx->CurrentListNum;
  2228.      break;
  2229.       case GL_LIST_MODE:
  2230.      *params = ctx->ExecuteFlag ? ENUM_TO_FLOAT(GL_COMPILE_AND_EXECUTE)
  2231.                      : ENUM_TO_FLOAT(GL_COMPILE);
  2232.      break;
  2233.       case GL_INDEX_LOGIC_OP:
  2234.      *params = (GLfloat) ctx->Color.IndexLogicOpEnabled;
  2235.      break;
  2236.       case GL_COLOR_LOGIC_OP:
  2237.      *params = (GLfloat) ctx->Color.ColorLogicOpEnabled;
  2238.      break;
  2239.       case GL_LOGIC_OP_MODE:
  2240.          *params = ENUM_TO_FLOAT(ctx->Color.LogicOp);
  2241.      break;
  2242.       case GL_MAP1_COLOR_4:
  2243.      *params = (GLfloat) ctx->Eval.Map1Color4;
  2244.      break;
  2245.       case GL_MAP1_GRID_DOMAIN:
  2246.      params[0] = ctx->Eval.MapGrid1u1;
  2247.      params[1] = ctx->Eval.MapGrid1u2;
  2248.      break;
  2249.       case GL_MAP1_GRID_SEGMENTS:
  2250.      *params = (GLfloat) ctx->Eval.MapGrid1un;
  2251.      break;
  2252.       case GL_MAP1_INDEX:
  2253.      *params = (GLfloat) ctx->Eval.Map1Index;
  2254.      break;
  2255.       case GL_MAP1_NORMAL:
  2256.      *params = (GLfloat) ctx->Eval.Map1Normal;
  2257.      break;
  2258.       case GL_MAP1_TEXTURE_COORD_1:
  2259.      *params = (GLfloat) ctx->Eval.Map1TextureCoord1;
  2260.      break;
  2261.       case GL_MAP1_TEXTURE_COORD_2:
  2262.      *params = (GLfloat) ctx->Eval.Map1TextureCoord2;
  2263.      break;
  2264.       case GL_MAP1_TEXTURE_COORD_3:
  2265.      *params = (GLfloat) ctx->Eval.Map1TextureCoord3;
  2266.      break;
  2267.       case GL_MAP1_TEXTURE_COORD_4:
  2268.      *params = (GLfloat) ctx->Eval.Map1TextureCoord4;
  2269.      break;
  2270.       case GL_MAP1_VERTEX_3:
  2271.      *params = (GLfloat) ctx->Eval.Map1Vertex3;
  2272.      break;
  2273.       case GL_MAP1_VERTEX_4:
  2274.      *params = (GLfloat) ctx->Eval.Map1Vertex4;
  2275.      break;
  2276.       case GL_MAP2_COLOR_4:
  2277.      *params = (GLfloat) ctx->Eval.Map2Color4;
  2278.      break;
  2279.       case GL_MAP2_GRID_DOMAIN:
  2280.      params[0] = ctx->Eval.MapGrid2u1;
  2281.      params[1] = ctx->Eval.MapGrid2u2;
  2282.      params[2] = ctx->Eval.MapGrid2v1;
  2283.      params[3] = ctx->Eval.MapGrid2v2;
  2284.      break;
  2285.       case GL_MAP2_GRID_SEGMENTS:
  2286.      params[0] = (GLfloat) ctx->Eval.MapGrid2un;
  2287.      params[1] = (GLfloat) ctx->Eval.MapGrid2vn;
  2288.      break;
  2289.       case GL_MAP2_INDEX:
  2290.      *params = (GLfloat) ctx->Eval.Map2Index;
  2291.      break;
  2292.       case GL_MAP2_NORMAL:
  2293.      *params = (GLfloat) ctx->Eval.Map2Normal;
  2294.      break;
  2295.       case GL_MAP2_TEXTURE_COORD_1:
  2296.      *params = ctx->Eval.Map2TextureCoord1;
  2297.      break;
  2298.       case GL_MAP2_TEXTURE_COORD_2:
  2299.      *params = ctx->Eval.Map2TextureCoord2;
  2300.      break;
  2301.       case GL_MAP2_TEXTURE_COORD_3:
  2302.      *params = ctx->Eval.Map2TextureCoord3;
  2303.      break;
  2304.       case GL_MAP2_TEXTURE_COORD_4:
  2305.      *params = ctx->Eval.Map2TextureCoord4;
  2306.      break;
  2307.       case GL_MAP2_VERTEX_3:
  2308.      *params = (GLfloat) ctx->Eval.Map2Vertex3;
  2309.      break;
  2310.       case GL_MAP2_VERTEX_4:
  2311.      *params = (GLfloat) ctx->Eval.Map2Vertex4;
  2312.      break;
  2313.       case GL_MAP_COLOR:
  2314.      *params = (GLfloat) ctx->Pixel.MapColorFlag;
  2315.      break;
  2316.       case GL_MAP_STENCIL:
  2317.      *params = (GLfloat) ctx->Pixel.MapStencilFlag;
  2318.      break;
  2319.       case GL_MATRIX_MODE:
  2320.      *params = ENUM_TO_FLOAT(ctx->Transform.MatrixMode);
  2321.      break;
  2322.       case GL_MAX_ATTRIB_STACK_DEPTH:
  2323.      *params = (GLfloat) MAX_ATTRIB_STACK_DEPTH;
  2324.      break;
  2325.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  2326.          *params = (GLfloat) MAX_CLIENT_ATTRIB_STACK_DEPTH;
  2327.          break;
  2328.       case GL_MAX_CLIP_PLANES:
  2329.      *params = (GLfloat) MAX_CLIP_PLANES;
  2330.      break;
  2331.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  2332.          *params = (GLfloat) VB_MAX;
  2333.          break;
  2334.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  2335.          *params = (GLfloat) VB_MAX;
  2336.          break;
  2337.       case GL_MAX_EVAL_ORDER:
  2338.      *params = (GLfloat) MAX_EVAL_ORDER;
  2339.      break;
  2340.       case GL_MAX_LIGHTS:
  2341.      *params = (GLfloat) MAX_LIGHTS;
  2342.      break;
  2343.       case GL_MAX_LIST_NESTING:
  2344.      *params = (GLfloat) MAX_LIST_NESTING;
  2345.      break;
  2346.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  2347.      *params = (GLfloat) MAX_MODELVIEW_STACK_DEPTH;
  2348.      break;
  2349.       case GL_MAX_NAME_STACK_DEPTH:
  2350.      *params = (GLfloat) MAX_NAME_STACK_DEPTH;
  2351.      break;
  2352.       case GL_MAX_PIXEL_MAP_TABLE:
  2353.      *params = (GLfloat) MAX_PIXEL_MAP_TABLE;
  2354.      break;
  2355.       case GL_MAX_PROJECTION_STACK_DEPTH:
  2356.      *params = (GLfloat) MAX_PROJECTION_STACK_DEPTH;
  2357.      break;
  2358.       case GL_MAX_TEXTURE_SIZE:
  2359.       case GL_MAX_3D_TEXTURE_SIZE:
  2360.          *params = (GLfloat) ctx->Const.MaxTextureSize;
  2361.      break;
  2362.       case GL_MAX_TEXTURE_STACK_DEPTH:
  2363.      *params = (GLfloat) MAX_TEXTURE_STACK_DEPTH;
  2364.      break;
  2365.       case GL_MAX_VIEWPORT_DIMS:
  2366.          params[0] = (GLfloat) MAX_WIDTH;
  2367.          params[1] = (GLfloat) MAX_HEIGHT;
  2368.          break;
  2369.       case GL_MODELVIEW_MATRIX:
  2370.      for (i=0;i<16;i++) {
  2371.         params[i] = ctx->ModelView.m[i];
  2372.      }
  2373.      break;
  2374.       case GL_MODELVIEW_STACK_DEPTH:
  2375.      *params = (GLfloat) (ctx->ModelViewStackDepth + 1);
  2376.      break;
  2377.       case GL_NAME_STACK_DEPTH:
  2378.      *params = (GLfloat) ctx->Select.NameStackDepth;
  2379.      break;
  2380.       case GL_NORMALIZE:
  2381.      *params = (GLfloat) ctx->Transform.Normalize;
  2382.      break;
  2383.       case GL_PACK_ALIGNMENT:
  2384.      *params = (GLfloat) ctx->Pack.Alignment;
  2385.      break;
  2386.       case GL_PACK_LSB_FIRST:
  2387.      *params = (GLfloat) ctx->Pack.LsbFirst;
  2388.      break;
  2389.       case GL_PACK_ROW_LENGTH:
  2390.      *params = (GLfloat) ctx->Pack.RowLength;
  2391.      break;
  2392.       case GL_PACK_SKIP_PIXELS:
  2393.      *params = (GLfloat) ctx->Pack.SkipPixels;
  2394.      break;
  2395.       case GL_PACK_SKIP_ROWS:
  2396.      *params = (GLfloat) ctx->Pack.SkipRows;
  2397.      break;
  2398.       case GL_PACK_SWAP_BYTES:
  2399.      *params = (GLfloat) ctx->Pack.SwapBytes;
  2400.      break;
  2401.       case GL_PACK_SKIP_IMAGES_EXT:
  2402.          *params = (GLfloat) ctx->Pack.SkipImages;
  2403.          break;
  2404.       case GL_PACK_IMAGE_HEIGHT_EXT:
  2405.          *params = (GLfloat) ctx->Pack.ImageHeight;
  2406.          break;
  2407.       case GL_PERSPECTIVE_CORRECTION_HINT:
  2408.      *params = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection);
  2409.      break;
  2410.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  2411.      *params = (GLfloat) ctx->Pixel.MapAtoAsize;
  2412.      break;
  2413.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  2414.      *params = (GLfloat) ctx->Pixel.MapBtoBsize;
  2415.      break;
  2416.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  2417.      *params = (GLfloat) ctx->Pixel.MapGtoGsize;
  2418.      break;
  2419.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  2420.      *params = (GLfloat) ctx->Pixel.MapItoAsize;
  2421.      break;
  2422.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  2423.      *params = (GLfloat) ctx->Pixel.MapItoBsize;
  2424.      break;
  2425.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  2426.      *params = (GLfloat) ctx->Pixel.MapItoGsize;
  2427.      break;
  2428.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  2429.      *params = (GLfloat) ctx->Pixel.MapItoIsize;
  2430.      break;
  2431.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  2432.      *params = (GLfloat) ctx->Pixel.MapItoRsize;
  2433.      break;
  2434.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  2435.      *params = (GLfloat) ctx->Pixel.MapRtoRsize;
  2436.      break;
  2437.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  2438.      *params = (GLfloat) ctx->Pixel.MapStoSsize;
  2439.      break;
  2440.       case GL_POINT_SIZE:
  2441.          *params = (GLfloat) ctx->Point.Size;
  2442.          break;
  2443.       case GL_POINT_SIZE_GRANULARITY:
  2444.      *params = (GLfloat) POINT_SIZE_GRANULARITY;
  2445.      break;
  2446.       case GL_POINT_SIZE_RANGE:
  2447.      params[0] = (GLfloat) MIN_POINT_SIZE;
  2448.      params[1] = (GLfloat) MAX_POINT_SIZE;
  2449.      break;
  2450.       case GL_POINT_SMOOTH:
  2451.      *params = (GLfloat) ctx->Point.SmoothFlag;
  2452.      break;
  2453.       case GL_POINT_SMOOTH_HINT:
  2454.      *params = ENUM_TO_FLOAT(ctx->Hint.PointSmooth);
  2455.      break;
  2456.       case GL_POINT_SIZE_MIN_EXT:
  2457.      *params = (GLfloat) (ctx->Point.MinSize);
  2458.      break;
  2459.       case GL_POINT_SIZE_MAX_EXT:
  2460.      *params = (GLfloat) (ctx->Point.MaxSize);
  2461.      break;
  2462.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  2463.      *params = (GLfloat) (ctx->Point.Threshold);
  2464.      break;
  2465.       case GL_DISTANCE_ATTENUATION_EXT:
  2466.      params[0] = (GLfloat) (ctx->Point.Params[0]);
  2467.      params[1] = (GLfloat) (ctx->Point.Params[1]);
  2468.      params[2] = (GLfloat) (ctx->Point.Params[2]);
  2469.      break;
  2470.       case GL_POLYGON_MODE:
  2471.      params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontMode);
  2472.      params[1] = ENUM_TO_FLOAT(ctx->Polygon.BackMode);
  2473.      break;
  2474. #ifdef GL_EXT_polygon_offset
  2475.       case GL_POLYGON_OFFSET_BIAS_EXT:
  2476.          *params = ctx->Polygon.OffsetUnits;
  2477.          break;
  2478. #endif
  2479.       case GL_POLYGON_OFFSET_FACTOR:
  2480.          *params = ctx->Polygon.OffsetFactor;
  2481.          break;
  2482.       case GL_POLYGON_OFFSET_UNITS:
  2483.          *params = ctx->Polygon.OffsetUnits;
  2484.          break;
  2485.       case GL_POLYGON_SMOOTH:
  2486.      *params = (GLfloat) ctx->Polygon.SmoothFlag;
  2487.      break;
  2488.       case GL_POLYGON_SMOOTH_HINT:
  2489.      *params = ENUM_TO_FLOAT(ctx->Hint.PolygonSmooth);
  2490.      break;
  2491.       case GL_POLYGON_STIPPLE:
  2492.          *params = (GLfloat) ctx->Polygon.StippleFlag;
  2493.      break;
  2494.       case GL_PROJECTION_MATRIX:
  2495.      for (i=0;i<16;i++) {
  2496.         params[i] = ctx->ProjectionMatrix.m[i];
  2497.      }
  2498.      break;
  2499.       case GL_PROJECTION_STACK_DEPTH:
  2500.      *params = (GLfloat) (ctx->ProjectionStackDepth + 1);
  2501.      break;
  2502.       case GL_READ_BUFFER:
  2503.      *params = ENUM_TO_FLOAT(ctx->Pixel.ReadBuffer);
  2504.      break;
  2505.       case GL_RED_BIAS:
  2506.          *params = ctx->Pixel.RedBias;
  2507.          break;
  2508.       case GL_RED_BITS:
  2509.          *params = (GLfloat) ctx->Visual->RedBits;
  2510.          break;
  2511.       case GL_RED_SCALE:
  2512.          *params = ctx->Pixel.RedScale;
  2513.          break;
  2514.       case GL_RENDER_MODE:
  2515.      *params = ENUM_TO_FLOAT(ctx->RenderMode);
  2516.      break;
  2517.       case GL_RGBA_MODE:
  2518.      *params = (GLfloat) ctx->Visual->RGBAflag;
  2519.      break;
  2520.       case GL_SCISSOR_BOX:
  2521.      params[0] = (GLfloat) ctx->Scissor.X;
  2522.      params[1] = (GLfloat) ctx->Scissor.Y;
  2523.      params[2] = (GLfloat) ctx->Scissor.Width;
  2524.      params[3] = (GLfloat) ctx->Scissor.Height;
  2525.      break;
  2526.       case GL_SCISSOR_TEST:
  2527.      *params = (GLfloat) ctx->Scissor.Enabled;
  2528.      break;
  2529.       case GL_SELECTION_BUFFER_SIZE:
  2530.          *params = (GLfloat) ctx->Select.BufferSize;
  2531.          break;
  2532.       case GL_SHADE_MODEL:
  2533.      *params = ENUM_TO_FLOAT(ctx->Light.ShadeModel);
  2534.      break;
  2535.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  2536.          *params = (GLfloat) ctx->Texture.SharedPalette;
  2537.          break;
  2538.       case GL_STENCIL_BITS:
  2539.          *params = (GLfloat) ctx->Visual->StencilBits;
  2540.          break;
  2541.       case GL_STENCIL_CLEAR_VALUE:
  2542.      *params = (GLfloat) ctx->Stencil.Clear;
  2543.      break;
  2544.       case GL_STENCIL_FAIL:
  2545.      *params = ENUM_TO_FLOAT(ctx->Stencil.FailFunc);
  2546.      break;
  2547.       case GL_STENCIL_FUNC:
  2548.      *params = ENUM_TO_FLOAT(ctx->Stencil.Function);
  2549.      break;
  2550.       case GL_STENCIL_PASS_DEPTH_FAIL:
  2551.      *params = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc);
  2552.      break;
  2553.       case GL_STENCIL_PASS_DEPTH_PASS:
  2554.      *params = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc);
  2555.      break;
  2556.       case GL_STENCIL_REF:
  2557.      *params = (GLfloat) ctx->Stencil.Ref;
  2558.      break;
  2559.       case GL_STENCIL_TEST:
  2560.      *params = (GLfloat) ctx->Stencil.Enabled;
  2561.      break;
  2562.       case GL_STENCIL_VALUE_MASK:
  2563.      *params = (GLfloat) ctx->Stencil.ValueMask;
  2564.      break;
  2565.       case GL_STENCIL_WRITEMASK:
  2566.      *params = (GLfloat) ctx->Stencil.WriteMask;
  2567.      break;
  2568.       case GL_STEREO:
  2569.      *params = (GLfloat) ctx->Visual->StereoFlag;
  2570.      break;
  2571.       case GL_SUBPIXEL_BITS:
  2572.      *params = 0.0F;  /* TODO */
  2573.      break;
  2574.       case GL_TEXTURE_1D:
  2575.          *params = gl_IsEnabled(ctx, GL_TEXTURE_1D) ? 1.0 : 0.0;
  2576.      break;
  2577.       case GL_TEXTURE_2D:
  2578.          *params = gl_IsEnabled(ctx, GL_TEXTURE_2D) ? 1.0 : 0.0;
  2579.      break;
  2580.       case GL_TEXTURE_3D:
  2581.          *params = gl_IsEnabled(ctx, GL_TEXTURE_3D) ? 1.0 : 0.0;
  2582.      break;
  2583.       case GL_TEXTURE_BINDING_1D:
  2584.          *params = (GLfloat) textureUnit->CurrentD[1]->Name;
  2585.           break;
  2586.       case GL_TEXTURE_BINDING_2D:
  2587.          *params = (GLfloat) textureUnit->CurrentD[2]->Name;
  2588.           break;
  2589.       case GL_TEXTURE_BINDING_3D:
  2590.          *params = (GLfloat) textureUnit->CurrentD[2]->Name;
  2591.           break;
  2592.       case GL_TEXTURE_ENV_COLOR:
  2593.      params[0] = textureUnit->EnvColor[0];
  2594.      params[1] = textureUnit->EnvColor[1];
  2595.      params[2] = textureUnit->EnvColor[2];
  2596.      params[3] = textureUnit->EnvColor[3];
  2597.      break;
  2598.       case GL_TEXTURE_ENV_MODE:
  2599.      *params = ENUM_TO_FLOAT(textureUnit->EnvMode);
  2600.      break;
  2601.       case GL_TEXTURE_GEN_S:
  2602.      *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
  2603.      break;
  2604.       case GL_TEXTURE_GEN_T:
  2605.      *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
  2606.      break;
  2607.       case GL_TEXTURE_GEN_R:
  2608.      *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
  2609.      break;
  2610.       case GL_TEXTURE_GEN_Q:
  2611.      *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
  2612.      break;
  2613.       case GL_TEXTURE_MATRIX:
  2614.          for (i=0;i<16;i++) {
  2615.         params[i] = ctx->TextureMatrix[texTransformUnit].m[i];
  2616.      }
  2617.      break;
  2618.       case GL_TEXTURE_STACK_DEPTH:
  2619.      *params = (GLfloat) (ctx->TextureStackDepth[texTransformUnit] + 1);
  2620.      break;
  2621.       case GL_UNPACK_ALIGNMENT:
  2622.      *params = (GLfloat) ctx->Unpack.Alignment;
  2623.      break;
  2624.       case GL_UNPACK_LSB_FIRST:
  2625.      *params = (GLfloat) ctx->Unpack.LsbFirst;
  2626.      break;
  2627.       case GL_UNPACK_ROW_LENGTH:
  2628.      *params = (GLfloat) ctx->Unpack.RowLength;
  2629.      break;
  2630.       case GL_UNPACK_SKIP_PIXELS:
  2631.      *params = (GLfloat) ctx->Unpack.SkipPixels;
  2632.      break;
  2633.       case GL_UNPACK_SKIP_ROWS:
  2634.      *params = (GLfloat) ctx->Unpack.SkipRows;
  2635.      break;
  2636.       case GL_UNPACK_SWAP_BYTES:
  2637.      *params = (GLfloat) ctx->Unpack.SwapBytes;
  2638.      break;
  2639.       case GL_UNPACK_SKIP_IMAGES_EXT:
  2640.          *params = (GLfloat) ctx->Unpack.SkipImages;
  2641.          break;
  2642.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  2643.          *params = (GLfloat) ctx->Unpack.ImageHeight;
  2644.          break;
  2645.       case GL_VIEWPORT:
  2646.      params[0] = (GLfloat) ctx->Viewport.X;
  2647.      params[1] = (GLfloat) ctx->Viewport.Y;
  2648.      params[2] = (GLfloat) ctx->Viewport.Width;
  2649.      params[3] = (GLfloat) ctx->Viewport.Height;
  2650.      break;
  2651.       case GL_ZOOM_X:
  2652.      *params = (GLfloat) ctx->Pixel.ZoomX;
  2653.      break;
  2654.       case GL_ZOOM_Y:
  2655.      *params = (GLfloat) ctx->Pixel.ZoomY;
  2656.      break;
  2657.       case GL_VERTEX_ARRAY:
  2658.          *params = (GLfloat) ctx->Array.Vertex.Enabled;
  2659.          break;
  2660.       case GL_VERTEX_ARRAY_SIZE:
  2661.          *params = (GLfloat) ctx->Array.Vertex.Size;
  2662.          break;
  2663.       case GL_VERTEX_ARRAY_TYPE:
  2664.          *params = ENUM_TO_FLOAT(ctx->Array.Vertex.Type);
  2665.          break;
  2666.       case GL_VERTEX_ARRAY_STRIDE:
  2667.          *params = (GLfloat) ctx->Array.Vertex.Stride;
  2668.          break;
  2669.       case GL_VERTEX_ARRAY_COUNT_EXT:
  2670.          *params = 0.0;
  2671.          break;
  2672.       case GL_NORMAL_ARRAY:
  2673.          *params = (GLfloat) ctx->Array.Normal.Enabled;
  2674.          break;
  2675.       case GL_NORMAL_ARRAY_TYPE:
  2676.          *params = ENUM_TO_FLOAT(ctx->Array.Normal.Type);
  2677.          break;
  2678.       case GL_NORMAL_ARRAY_STRIDE:
  2679.          *params = (GLfloat) ctx->Array.Normal.Stride;
  2680.          break;
  2681.       case GL_NORMAL_ARRAY_COUNT_EXT:
  2682.          *params = 0.0;
  2683.          break;
  2684.       case GL_COLOR_ARRAY:
  2685.          *params = (GLfloat) ctx->Array.Color.Enabled;
  2686.          break;
  2687.       case GL_COLOR_ARRAY_SIZE:
  2688.          *params = (GLfloat) ctx->Array.Color.Size;
  2689.          break;
  2690.       case GL_COLOR_ARRAY_TYPE:
  2691.          *params = ENUM_TO_FLOAT(ctx->Array.Color.Type);
  2692.          break;
  2693.       case GL_COLOR_ARRAY_STRIDE:
  2694.          *params = (GLfloat) ctx->Array.Color.Stride;
  2695.          break;
  2696.       case GL_COLOR_ARRAY_COUNT_EXT:
  2697.          *params = 0.0;
  2698.          break;
  2699.       case GL_INDEX_ARRAY:
  2700.          *params = (GLfloat) ctx->Array.Index.Enabled;
  2701.          break;
  2702.       case GL_INDEX_ARRAY_TYPE:
  2703.          *params = ENUM_TO_FLOAT(ctx->Array.Index.Type);
  2704.          break;
  2705.       case GL_INDEX_ARRAY_STRIDE:
  2706.          *params = (GLfloat) ctx->Array.Index.Stride;
  2707.          break;
  2708.       case GL_INDEX_ARRAY_COUNT_EXT:
  2709.          *params = 0.0;
  2710.          break;
  2711.       case GL_TEXTURE_COORD_ARRAY:
  2712.          *params = (GLfloat) ctx->Array.TexCoord[texUnit].Enabled;
  2713.          break;
  2714.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  2715.          *params = (GLfloat) ctx->Array.TexCoord[texUnit].Size;
  2716.          break;
  2717.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  2718.          *params = ENUM_TO_FLOAT(ctx->Array.TexCoord[texUnit].Type);
  2719.          break;
  2720.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  2721.          *params = (GLfloat) ctx->Array.TexCoord[texUnit].Stride;
  2722.          break;
  2723.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  2724.          *params = 0.0;
  2725.          break;
  2726.       case GL_EDGE_FLAG_ARRAY:
  2727.          *params = (GLfloat) ctx->Array.EdgeFlag.Enabled;
  2728.          break;
  2729.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  2730.          *params = (GLfloat) ctx->Array.EdgeFlag.Stride;
  2731.          break;
  2732.       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
  2733.          *params = 0.0;
  2734.          break;
  2735.  
  2736.       case GL_MAX_TEXTURE_UNITS_ARB:
  2737.          *params = (GLfloat) ctx->Const.MaxTextureUnits;
  2738.          break;
  2739.       case GL_ACTIVE_TEXTURE_ARB:
  2740.          *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
  2741.          break;
  2742.       case GL_CLIENT_ACTIVE_TEXTURE_ARB:
  2743.          *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
  2744.          break;
  2745.  
  2746.       /* GL_PGI_misc_hints */
  2747.       case GL_STRICT_DEPTHFUNC_HINT_PGI:
  2748.      *params = ENUM_TO_FLOAT(GL_NICEST);
  2749.          break;
  2750.       case GL_STRICT_LIGHTING_HINT_PGI:
  2751.      *params = ENUM_TO_FLOAT(ctx->Hint.StrictLighting);
  2752.      break;
  2753.       case GL_STRICT_SCISSOR_HINT_PGI:
  2754.       case GL_FULL_STIPPLE_HINT_PGI:
  2755.      *params = ENUM_TO_FLOAT(GL_TRUE);
  2756.      break;
  2757.       case GL_CONSERVE_MEMORY_HINT_PGI:
  2758.      *params = ENUM_TO_FLOAT(GL_FALSE);
  2759.      break;
  2760.       case GL_ALWAYS_FAST_HINT_PGI:
  2761.      *params = (GLfloat) (ctx->Hint.AllowDrawWin == GL_TRUE &&
  2762.                   ctx->Hint.AllowDrawSpn == GL_FALSE && 
  2763.                   ctx->Hint.AllowDrawMem == GL_FALSE);
  2764.      break;
  2765.       case GL_ALWAYS_SOFT_HINT_PGI:
  2766.      *params = (GLfloat) (ctx->Hint.AllowDrawWin == GL_TRUE &&
  2767.                   ctx->Hint.AllowDrawSpn == GL_TRUE && 
  2768.                   ctx->Hint.AllowDrawMem == GL_TRUE);
  2769.      break;
  2770.       case GL_ALLOW_DRAW_OBJ_HINT_PGI:
  2771.      *params = (GLfloat) GL_TRUE;
  2772.      break;
  2773.       case GL_ALLOW_DRAW_WIN_HINT_PGI:
  2774.      *params = (GLfloat) ctx->Hint.AllowDrawWin;
  2775.      break;
  2776.       case GL_ALLOW_DRAW_SPN_HINT_PGI:
  2777.      *params = (GLfloat) ctx->Hint.AllowDrawSpn;
  2778.      break;
  2779.       case GL_ALLOW_DRAW_MEM_HINT_PGI:
  2780.      *params = (GLfloat) ctx->Hint.AllowDrawMem;
  2781.      break;
  2782.       case GL_CLIP_NEAR_HINT_PGI:
  2783.       case GL_CLIP_FAR_HINT_PGI:
  2784.      *params = ENUM_TO_FLOAT(GL_TRUE);
  2785.      break;
  2786.       case GL_WIDE_LINE_HINT_PGI:
  2787.      *params = ENUM_TO_FLOAT(GL_DONT_CARE);
  2788.      break;
  2789.       case GL_BACK_NORMALS_HINT_PGI:
  2790.      *params = ENUM_TO_FLOAT(GL_TRUE);
  2791.      break;
  2792.       case GL_NATIVE_GRAPHICS_HANDLE_PGI:
  2793.      *params = 0;
  2794.      break;
  2795.  
  2796.       default:
  2797.      printf("invalid enum: %x\n", pname);
  2798.          gl_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
  2799.    }
  2800. }
  2801.  
  2802.  
  2803.  
  2804.  
  2805. void gl_GetIntegerv( GLcontext *ctx, GLenum pname, GLint *params )
  2806. {
  2807.    GLuint i;
  2808.    GLuint texUnit = ctx->Texture.CurrentUnit;
  2809.    GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
  2810.    const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
  2811.  
  2812.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetIntegerv");
  2813.  
  2814.    if (MESA_VERBOSE & VERBOSE_API) 
  2815.       fprintf(stderr, "glGetIntegerv %s\n", gl_lookup_enum_by_nr(pname));
  2816.  
  2817.    switch (pname) {
  2818.       case GL_ACCUM_RED_BITS:
  2819.       case GL_ACCUM_GREEN_BITS:
  2820.       case GL_ACCUM_BLUE_BITS:
  2821.       case GL_ACCUM_ALPHA_BITS:
  2822.          *params = (GLint) ctx->Visual->AccumBits;
  2823.          break;
  2824.       case GL_ACCUM_CLEAR_VALUE:
  2825.          params[0] = FLOAT_TO_INT( ctx->Accum.ClearColor[0] );
  2826.          params[1] = FLOAT_TO_INT( ctx->Accum.ClearColor[1] );
  2827.          params[2] = FLOAT_TO_INT( ctx->Accum.ClearColor[2] );
  2828.          params[3] = FLOAT_TO_INT( ctx->Accum.ClearColor[3] );
  2829.          break;
  2830.       case GL_ALPHA_BIAS:
  2831.          *params = (GLint) ctx->Pixel.AlphaBias;
  2832.          break;
  2833.       case GL_ALPHA_BITS:
  2834.          *params = ctx->Visual->AlphaBits;
  2835.          break;
  2836.       case GL_ALPHA_SCALE:
  2837.          *params = (GLint) ctx->Pixel.AlphaScale;
  2838.          break;
  2839.       case GL_ALPHA_TEST:
  2840.          *params = (GLint) ctx->Color.AlphaEnabled;
  2841.          break;
  2842.       case GL_ALPHA_TEST_REF:
  2843.          *params = FLOAT_TO_INT( (GLfloat) ctx->Color.AlphaRef / 255.0 );
  2844.          break;
  2845.       case GL_ALPHA_TEST_FUNC:
  2846.          *params = (GLint) ctx->Color.AlphaFunc;
  2847.          break;
  2848.       case GL_ATTRIB_STACK_DEPTH:
  2849.          *params = (GLint) (ctx->AttribStackDepth);
  2850.          break;
  2851.       case GL_AUTO_NORMAL:
  2852.          *params = (GLint) ctx->Eval.AutoNormal;
  2853.          break;
  2854.       case GL_AUX_BUFFERS:
  2855.          *params = (GLint) NUM_AUX_BUFFERS;
  2856.          break;
  2857.       case GL_BLEND:
  2858.          *params = (GLint) ctx->Color.BlendEnabled;
  2859.          break;
  2860.       case GL_BLEND_DST:
  2861.          *params = (GLint) ctx->Color.BlendDstRGB;
  2862.          break;
  2863.       case GL_BLEND_SRC:
  2864.          *params = (GLint) ctx->Color.BlendSrcRGB;
  2865.          break;
  2866.       case GL_BLEND_SRC_RGB_INGR:
  2867.          *params = (GLint) ctx->Color.BlendSrcRGB;
  2868.          break;
  2869.       case GL_BLEND_DST_RGB_INGR:
  2870.          *params = (GLint) ctx->Color.BlendDstRGB;
  2871.          break;
  2872.       case GL_BLEND_SRC_ALPHA_INGR:
  2873.          *params = (GLint) ctx->Color.BlendSrcA;
  2874.          break;
  2875.       case GL_BLEND_DST_ALPHA_INGR:
  2876.          *params = (GLint) ctx->Color.BlendDstA;
  2877.          break;
  2878.       case GL_BLEND_EQUATION_EXT:
  2879.      *params = (GLint) ctx->Color.BlendEquation;
  2880.      break;
  2881.       case GL_BLEND_COLOR_EXT:
  2882.      params[0] = FLOAT_TO_INT( ctx->Color.BlendColor[0] );
  2883.      params[1] = FLOAT_TO_INT( ctx->Color.BlendColor[1] );
  2884.      params[2] = FLOAT_TO_INT( ctx->Color.BlendColor[2] );
  2885.      params[3] = FLOAT_TO_INT( ctx->Color.BlendColor[3] );
  2886.      break;
  2887.       case GL_BLUE_BIAS:
  2888.          *params = (GLint) ctx->Pixel.BlueBias;
  2889.          break;
  2890.       case GL_BLUE_BITS:
  2891.          *params = (GLint) ctx->Visual->BlueBits;
  2892.          break;
  2893.       case GL_BLUE_SCALE:
  2894.          *params = (GLint) ctx->Pixel.BlueScale;
  2895.          break;
  2896.       case GL_CLIENT_ATTRIB_STACK_DEPTH:
  2897.          *params = (GLint) (ctx->ClientAttribStackDepth);
  2898.          break;
  2899.       case GL_CLIP_PLANE0:
  2900.       case GL_CLIP_PLANE1:
  2901.       case GL_CLIP_PLANE2:
  2902.       case GL_CLIP_PLANE3:
  2903.       case GL_CLIP_PLANE4:
  2904.       case GL_CLIP_PLANE5:
  2905.          i = (GLint) (pname - GL_CLIP_PLANE0);
  2906.          *params = (GLint) ctx->Transform.ClipEnabled[i];
  2907.          break;
  2908.       case GL_COLOR_CLEAR_VALUE:
  2909.          params[0] = FLOAT_TO_INT( ctx->Color.ClearColor[0] );
  2910.          params[1] = FLOAT_TO_INT( ctx->Color.ClearColor[1] );
  2911.          params[2] = FLOAT_TO_INT( ctx->Color.ClearColor[2] );
  2912.          params[3] = FLOAT_TO_INT( ctx->Color.ClearColor[3] );
  2913.          break;
  2914.       case GL_COLOR_MATERIAL:
  2915.          *params = (GLint) ctx->Light.ColorMaterialEnabled;
  2916.          break;
  2917.       case GL_COLOR_MATERIAL_FACE:
  2918.          *params = (GLint) ctx->Light.ColorMaterialFace;
  2919.          break;
  2920.       case GL_COLOR_MATERIAL_PARAMETER:
  2921.          *params = (GLint) ctx->Light.ColorMaterialMode;
  2922.          break;
  2923.       case GL_COLOR_WRITEMASK:
  2924.          params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0;
  2925.          params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0;
  2926.          params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0;
  2927.          params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0;
  2928.          break;
  2929.       case GL_CULL_FACE:
  2930.          *params = (GLint) ctx->Polygon.CullFlag;
  2931.          break;
  2932.       case GL_CULL_FACE_MODE:
  2933.          *params = (GLint) ctx->Polygon.CullFaceMode;
  2934.          break;
  2935.       case GL_CURRENT_COLOR:
  2936.          params[0] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[0] ) );
  2937.          params[1] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[1] ) );
  2938.          params[2] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[2] ) );
  2939.          params[3] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[3] ) );
  2940.          break;
  2941.       case GL_CURRENT_INDEX:
  2942.          *params = (GLint) ctx->Current.Index;
  2943.          break;
  2944.       case GL_CURRENT_NORMAL:
  2945.          params[0] = FLOAT_TO_INT( ctx->Current.Normal[0] );
  2946.          params[1] = FLOAT_TO_INT( ctx->Current.Normal[1] );
  2947.          params[2] = FLOAT_TO_INT( ctx->Current.Normal[2] );
  2948.          break;
  2949.       case GL_CURRENT_RASTER_COLOR:
  2950.      params[0] = FLOAT_TO_INT( ctx->Current.RasterColor[0] );
  2951.      params[1] = FLOAT_TO_INT( ctx->Current.RasterColor[1] );
  2952.      params[2] = FLOAT_TO_INT( ctx->Current.RasterColor[2] );
  2953.      params[3] = FLOAT_TO_INT( ctx->Current.RasterColor[3] );
  2954.      break;
  2955.       case GL_CURRENT_RASTER_DISTANCE:
  2956.      params[0] = (GLint) ctx->Current.RasterDistance;
  2957.      break;
  2958.       case GL_CURRENT_RASTER_INDEX:
  2959.      *params = (GLint) ctx->Current.RasterIndex;
  2960.      break;
  2961.       case GL_CURRENT_RASTER_POSITION:
  2962.      params[0] = (GLint) ctx->Current.RasterPos[0];
  2963.      params[1] = (GLint) ctx->Current.RasterPos[1];
  2964.      params[2] = (GLint) ctx->Current.RasterPos[2];
  2965.      params[3] = (GLint) ctx->Current.RasterPos[3];
  2966.      break;
  2967.       case GL_CURRENT_RASTER_TEXTURE_COORDS:
  2968.      params[0] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
  2969.      params[1] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
  2970.      params[2] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
  2971.      params[3] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
  2972.      break;
  2973.       case GL_CURRENT_RASTER_POSITION_VALID:
  2974.      *params = (GLint) ctx->Current.RasterPosValid;
  2975.      break;
  2976.       case GL_CURRENT_TEXTURE_COORDS:
  2977.          params[0] = (GLint) ctx->Current.Texcoord[texTransformUnit][0];
  2978.          params[1] = (GLint) ctx->Current.Texcoord[texTransformUnit][1];
  2979.          params[2] = (GLint) ctx->Current.Texcoord[texTransformUnit][2];
  2980.          params[3] = (GLint) ctx->Current.Texcoord[texTransformUnit][3];
  2981.      break;
  2982.       case GL_DEPTH_BIAS:
  2983.          *params = (GLint) ctx->Pixel.DepthBias;
  2984.      break;
  2985.       case GL_DEPTH_BITS:
  2986.      *params = ctx->Visual->DepthBits;
  2987.      break;
  2988.       case GL_DEPTH_CLEAR_VALUE:
  2989.          *params = (GLint) ctx->Depth.Clear;
  2990.      break;
  2991.       case GL_DEPTH_FUNC:
  2992.          *params = (GLint) ctx->Depth.Func;
  2993.      break;
  2994.       case GL_DEPTH_RANGE:
  2995.          params[0] = (GLint) ctx->Viewport.Near;
  2996.          params[1] = (GLint) ctx->Viewport.Far;
  2997.      break;
  2998.       case GL_DEPTH_SCALE:
  2999.          *params = (GLint) ctx->Pixel.DepthScale;
  3000.      break;
  3001.       case GL_DEPTH_TEST:
  3002.          *params = (GLint) ctx->Depth.Test;
  3003.      break;
  3004.       case GL_DEPTH_WRITEMASK:
  3005.      *params = (GLint) ctx->Depth.Mask;
  3006.      break;
  3007.       case GL_DITHER:
  3008.      *params = (GLint) ctx->Color.DitherFlag;
  3009.      break;
  3010.       case GL_DOUBLEBUFFER:
  3011.      *params = (GLint) ctx->Visual->DBflag;
  3012.      break;
  3013.       case GL_DRAW_BUFFER:
  3014.      *params = (GLint) ctx->Color.DrawBuffer;
  3015.      break;
  3016.       case GL_EDGE_FLAG:
  3017.      *params = (GLint) ctx->Current.EdgeFlag;
  3018.      break;
  3019.       case GL_FEEDBACK_BUFFER_SIZE:
  3020.          /* TODO: is this right?  Or, return number of entries in buffer? */
  3021.          *params = ctx->Feedback.BufferSize;
  3022.          break;
  3023.       case GL_FEEDBACK_BUFFER_TYPE:
  3024.          *params = ctx->Feedback.Type;
  3025.          break;
  3026.       case GL_FOG:
  3027.      *params = (GLint) ctx->Fog.Enabled;
  3028.      break;
  3029.       case GL_FOG_COLOR:
  3030.      params[0] = FLOAT_TO_INT( ctx->Fog.Color[0] );
  3031.      params[1] = FLOAT_TO_INT( ctx->Fog.Color[1] );
  3032.      params[2] = FLOAT_TO_INT( ctx->Fog.Color[2] );
  3033.      params[3] = FLOAT_TO_INT( ctx->Fog.Color[3] );
  3034.      break;
  3035.       case GL_FOG_DENSITY:
  3036.      *params = (GLint) ctx->Fog.Density;
  3037.      break;
  3038.       case GL_FOG_END:
  3039.      *params = (GLint) ctx->Fog.End;
  3040.      break;
  3041.       case GL_FOG_HINT:
  3042.      *params = (GLint) ctx->Hint.Fog;
  3043.      break;
  3044.       case GL_FOG_INDEX:
  3045.      *params = (GLint) ctx->Fog.Index;
  3046.      break;
  3047.       case GL_FOG_MODE:
  3048.      *params = (GLint) ctx->Fog.Mode;
  3049.      break;
  3050.       case GL_FOG_START:
  3051.      *params = (GLint) ctx->Fog.Start;
  3052.      break;
  3053.       case GL_FRONT_FACE:
  3054.      *params = (GLint) ctx->Polygon.FrontFace;
  3055.      break;
  3056.       case GL_GREEN_BIAS:
  3057.          *params = (GLint) ctx->Pixel.GreenBias;
  3058.          break;
  3059.       case GL_GREEN_BITS:
  3060.          *params = (GLint) ctx->Visual->GreenBits;
  3061.          break;
  3062.       case GL_GREEN_SCALE:
  3063.          *params = (GLint) ctx->Pixel.GreenScale;
  3064.          break;
  3065.       case GL_INDEX_BITS:
  3066.          *params = (GLint) ctx->Visual->IndexBits;
  3067.          break;
  3068.       case GL_INDEX_CLEAR_VALUE:
  3069.          *params = (GLint) ctx->Color.ClearIndex;
  3070.          break;
  3071.       case GL_INDEX_MODE:
  3072.      *params = ctx->Visual->RGBAflag ? 0 : 1;
  3073.      break;
  3074.       case GL_INDEX_OFFSET:
  3075.      *params = ctx->Pixel.IndexOffset;
  3076.      break;
  3077.       case GL_INDEX_SHIFT:
  3078.      *params = ctx->Pixel.IndexShift;
  3079.      break;
  3080.       case GL_INDEX_WRITEMASK:
  3081.      *params = (GLint) ctx->Color.IndexMask;
  3082.      break;
  3083.       case GL_LIGHT0:
  3084.       case GL_LIGHT1:
  3085.       case GL_LIGHT2:
  3086.       case GL_LIGHT3:
  3087.       case GL_LIGHT4:
  3088.       case GL_LIGHT5:
  3089.       case GL_LIGHT6:
  3090.       case GL_LIGHT7:
  3091.      *params = (GLint) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
  3092.      break;
  3093.       case GL_LIGHTING:
  3094.      *params = (GLint) ctx->Light.Enabled;
  3095.      break;
  3096.       case GL_LIGHT_MODEL_AMBIENT:
  3097.      params[0] = FLOAT_TO_INT( ctx->Light.Model.Ambient[0] );
  3098.      params[1] = FLOAT_TO_INT( ctx->Light.Model.Ambient[1] );
  3099.      params[2] = FLOAT_TO_INT( ctx->Light.Model.Ambient[2] );
  3100.      params[3] = FLOAT_TO_INT( ctx->Light.Model.Ambient[3] );
  3101.      break;
  3102.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  3103.          params[0] = (GLint) ctx->Light.Model.ColorControl;
  3104.          break;
  3105.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  3106.      *params = (GLint) ctx->Light.Model.LocalViewer;
  3107.      break;
  3108.       case GL_LIGHT_MODEL_TWO_SIDE:
  3109.      *params = (GLint) ctx->Light.Model.TwoSide;
  3110.      break;
  3111.       case GL_LINE_SMOOTH:
  3112.      *params = (GLint) ctx->Line.SmoothFlag;
  3113.      break;
  3114.       case GL_LINE_SMOOTH_HINT:
  3115.      *params = (GLint) ctx->Hint.LineSmooth;
  3116.      break;
  3117.       case GL_LINE_STIPPLE:
  3118.      *params = (GLint) ctx->Line.StippleFlag;
  3119.      break;
  3120.       case GL_LINE_STIPPLE_PATTERN:
  3121.          *params = (GLint) ctx->Line.StipplePattern;
  3122.          break;
  3123.       case GL_LINE_STIPPLE_REPEAT:
  3124.          *params = (GLint) ctx->Line.StippleFactor;
  3125.          break;
  3126.       case GL_LINE_WIDTH:
  3127.      *params = (GLint) ctx->Line.Width;
  3128.      break;
  3129.       case GL_LINE_WIDTH_GRANULARITY:
  3130.      *params = (GLint) LINE_WIDTH_GRANULARITY;
  3131.      break;
  3132.       case GL_LINE_WIDTH_RANGE:
  3133.      params[0] = (GLint) MIN_LINE_WIDTH;
  3134.      params[1] = (GLint) MAX_LINE_WIDTH;
  3135.      break;
  3136.       case GL_LIST_BASE:
  3137.      *params = (GLint) ctx->List.ListBase;
  3138.      break;
  3139.       case GL_LIST_INDEX:
  3140.      *params = (GLint) ctx->CurrentListNum;
  3141.      break;
  3142.       case GL_LIST_MODE:
  3143.      *params = ctx->ExecuteFlag ? (GLint) GL_COMPILE_AND_EXECUTE
  3144.                      : (GLint) GL_COMPILE;
  3145.      break;
  3146.       case GL_INDEX_LOGIC_OP:
  3147.      *params = (GLint) ctx->Color.IndexLogicOpEnabled;
  3148.      break;
  3149.       case GL_COLOR_LOGIC_OP:
  3150.      *params = (GLint) ctx->Color.ColorLogicOpEnabled;
  3151.      break;
  3152.       case GL_LOGIC_OP_MODE:
  3153.          *params = (GLint) ctx->Color.LogicOp;
  3154.          break;
  3155.       case GL_MAP1_COLOR_4:
  3156.      *params = (GLint) ctx->Eval.Map1Color4;
  3157.      break;
  3158.       case GL_MAP1_GRID_DOMAIN:
  3159.      params[0] = (GLint) ctx->Eval.MapGrid1u1;
  3160.      params[1] = (GLint) ctx->Eval.MapGrid1u2;
  3161.      break;
  3162.       case GL_MAP1_GRID_SEGMENTS:
  3163.      *params = (GLint) ctx->Eval.MapGrid1un;
  3164.      break;
  3165.       case GL_MAP1_INDEX:
  3166.      *params = (GLint) ctx->Eval.Map1Index;
  3167.      break;
  3168.       case GL_MAP1_NORMAL:
  3169.      *params = (GLint) ctx->Eval.Map1Normal;
  3170.      break;
  3171.       case GL_MAP1_TEXTURE_COORD_1:
  3172.      *params = (GLint) ctx->Eval.Map1TextureCoord1;
  3173.      break;
  3174.       case GL_MAP1_TEXTURE_COORD_2:
  3175.      *params = (GLint) ctx->Eval.Map1TextureCoord2;
  3176.      break;
  3177.       case GL_MAP1_TEXTURE_COORD_3:
  3178.      *params = (GLint) ctx->Eval.Map1TextureCoord3;
  3179.      break;
  3180.       case GL_MAP1_TEXTURE_COORD_4:
  3181.      *params = (GLint) ctx->Eval.Map1TextureCoord4;
  3182.      break;
  3183.       case GL_MAP1_VERTEX_3:
  3184.      *params = (GLint) ctx->Eval.Map1Vertex3;
  3185.      break;
  3186.       case GL_MAP1_VERTEX_4:
  3187.      *params = (GLint) ctx->Eval.Map1Vertex4;
  3188.      break;
  3189.       case GL_MAP2_COLOR_4:
  3190.      *params = (GLint) ctx->Eval.Map2Color4;
  3191.      break;
  3192.       case GL_MAP2_GRID_DOMAIN:
  3193.      params[0] = (GLint) ctx->Eval.MapGrid2u1;
  3194.      params[1] = (GLint) ctx->Eval.MapGrid2u2;
  3195.      params[2] = (GLint) ctx->Eval.MapGrid2v1;
  3196.      params[3] = (GLint) ctx->Eval.MapGrid2v2;
  3197.      break;
  3198.       case GL_MAP2_GRID_SEGMENTS:
  3199.      params[0] = (GLint) ctx->Eval.MapGrid2un;
  3200.      params[1] = (GLint) ctx->Eval.MapGrid2vn;
  3201.      break;
  3202.       case GL_MAP2_INDEX:
  3203.      *params = (GLint) ctx->Eval.Map2Index;
  3204.      break;
  3205.       case GL_MAP2_NORMAL:
  3206.      *params = (GLint) ctx->Eval.Map2Normal;
  3207.      break;
  3208.       case GL_MAP2_TEXTURE_COORD_1:
  3209.      *params = (GLint) ctx->Eval.Map2TextureCoord1;
  3210.      break;
  3211.       case GL_MAP2_TEXTURE_COORD_2:
  3212.      *params = (GLint) ctx->Eval.Map2TextureCoord2;
  3213.      break;
  3214.       case GL_MAP2_TEXTURE_COORD_3:
  3215.      *params = (GLint) ctx->Eval.Map2TextureCoord3;
  3216.      break;
  3217.       case GL_MAP2_TEXTURE_COORD_4:
  3218.      *params = (GLint) ctx->Eval.Map2TextureCoord4;
  3219.      break;
  3220.       case GL_MAP2_VERTEX_3:
  3221.      *params = (GLint) ctx->Eval.Map2Vertex3;
  3222.      break;
  3223.       case GL_MAP2_VERTEX_4:
  3224.      *params = (GLint) ctx->Eval.Map2Vertex4;
  3225.      break;
  3226.       case GL_MAP_COLOR:
  3227.      *params = (GLint) ctx->Pixel.MapColorFlag;
  3228.      break;
  3229.       case GL_MAP_STENCIL:
  3230.      *params = (GLint) ctx->Pixel.MapStencilFlag;
  3231.      break;
  3232.       case GL_MATRIX_MODE:
  3233.      *params = (GLint) ctx->Transform.MatrixMode;
  3234.      break;
  3235.       case GL_MAX_ATTRIB_STACK_DEPTH:
  3236.          *params = (GLint) MAX_ATTRIB_STACK_DEPTH;
  3237.          break;
  3238.       case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
  3239.          *params = (GLint) MAX_CLIENT_ATTRIB_STACK_DEPTH;
  3240.          break;
  3241.       case GL_MAX_CLIP_PLANES:
  3242.          *params = (GLint) MAX_CLIP_PLANES;
  3243.          break;
  3244.       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
  3245.          *params = VB_MAX;
  3246.          break;
  3247.       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
  3248.          *params = VB_MAX;
  3249.          break;
  3250.       case GL_MAX_EVAL_ORDER:
  3251.      *params = (GLint) MAX_EVAL_ORDER;
  3252.      break;
  3253.       case GL_MAX_LIGHTS:
  3254.          *params = (GLint) MAX_LIGHTS;
  3255.          break;
  3256.       case GL_MAX_LIST_NESTING:
  3257.          *params = (GLint) MAX_LIST_NESTING;
  3258.          break;
  3259.       case GL_MAX_MODELVIEW_STACK_DEPTH:
  3260.          *params = (GLint) MAX_MODELVIEW_STACK_DEPTH;
  3261.          break;
  3262.       case GL_MAX_NAME_STACK_DEPTH:
  3263.      *params = (GLint) MAX_NAME_STACK_DEPTH;
  3264.      break;
  3265.       case GL_MAX_PIXEL_MAP_TABLE:
  3266.      *params = (GLint) MAX_PIXEL_MAP_TABLE;
  3267.      break;
  3268.       case GL_MAX_PROJECTION_STACK_DEPTH:
  3269.          *params = (GLint) MAX_PROJECTION_STACK_DEPTH;
  3270.          break;
  3271.       case GL_MAX_TEXTURE_SIZE:
  3272.       case GL_MAX_3D_TEXTURE_SIZE:
  3273.          *params = ctx->Const.MaxTextureSize;
  3274.      break;
  3275.       case GL_MAX_TEXTURE_STACK_DEPTH:
  3276.      *params = (GLint) MAX_TEXTURE_STACK_DEPTH;
  3277.      break;
  3278.       case GL_MAX_VIEWPORT_DIMS:
  3279.          params[0] = (GLint) MAX_WIDTH;
  3280.          params[1] = (GLint) MAX_HEIGHT;
  3281.          break;
  3282.       case GL_MODELVIEW_MATRIX:
  3283.      for (i=0;i<16;i++) {
  3284.         params[i] = (GLint) ctx->ModelView.m[i];
  3285.      }
  3286.      break;
  3287.       case GL_MODELVIEW_STACK_DEPTH:
  3288.      *params = (GLint) (ctx->ModelViewStackDepth + 1);
  3289.      break;
  3290.       case GL_NAME_STACK_DEPTH:
  3291.      *params = (GLint) ctx->Select.NameStackDepth;
  3292.      break;
  3293.       case GL_NORMALIZE:
  3294.      *params = (GLint) ctx->Transform.Normalize;
  3295.      break;
  3296.       case GL_PACK_ALIGNMENT:
  3297.      *params = ctx->Pack.Alignment;
  3298.      break;
  3299.       case GL_PACK_LSB_FIRST:
  3300.      *params = (GLint) ctx->Pack.LsbFirst;
  3301.      break;
  3302.       case GL_PACK_ROW_LENGTH:
  3303.      *params = ctx->Pack.RowLength;
  3304.      break;
  3305.       case GL_PACK_SKIP_PIXELS:
  3306.      *params = ctx->Pack.SkipPixels;
  3307.      break;
  3308.       case GL_PACK_SKIP_ROWS:
  3309.      *params = ctx->Pack.SkipRows;
  3310.      break;
  3311.       case GL_PACK_SWAP_BYTES:
  3312.      *params = (GLint) ctx->Pack.SwapBytes;
  3313.      break;
  3314.       case GL_PACK_SKIP_IMAGES_EXT:
  3315.          *params = ctx->Pack.SkipImages;
  3316.          break;
  3317.       case GL_PACK_IMAGE_HEIGHT_EXT:
  3318.          *params = ctx->Pack.ImageHeight;
  3319.          break;
  3320.       case GL_PERSPECTIVE_CORRECTION_HINT:
  3321.      *params = (GLint) ctx->Hint.PerspectiveCorrection;
  3322.      break;
  3323.       case GL_PIXEL_MAP_A_TO_A_SIZE:
  3324.      *params = ctx->Pixel.MapAtoAsize;
  3325.      break;
  3326.       case GL_PIXEL_MAP_B_TO_B_SIZE:
  3327.      *params = ctx->Pixel.MapBtoBsize;
  3328.      break;
  3329.       case GL_PIXEL_MAP_G_TO_G_SIZE:
  3330.      *params = ctx->Pixel.MapGtoGsize;
  3331.      break;
  3332.       case GL_PIXEL_MAP_I_TO_A_SIZE:
  3333.      *params = ctx->Pixel.MapItoAsize;
  3334.      break;
  3335.       case GL_PIXEL_MAP_I_TO_B_SIZE:
  3336.      *params = ctx->Pixel.MapItoBsize;
  3337.      break;
  3338.       case GL_PIXEL_MAP_I_TO_G_SIZE:
  3339.      *params = ctx->Pixel.MapItoGsize;
  3340.      break;
  3341.       case GL_PIXEL_MAP_I_TO_I_SIZE:
  3342.      *params = ctx->Pixel.MapItoIsize;
  3343.      break;
  3344.       case GL_PIXEL_MAP_I_TO_R_SIZE:
  3345.      *params = ctx->Pixel.MapItoRsize;
  3346.      break;
  3347.       case GL_PIXEL_MAP_R_TO_R_SIZE:
  3348.      *params = ctx->Pixel.MapRtoRsize;
  3349.      break;
  3350.       case GL_PIXEL_MAP_S_TO_S_SIZE:
  3351.      *params = ctx->Pixel.MapStoSsize;
  3352.      break;
  3353.       case GL_POINT_SIZE:
  3354.          *params = (GLint) ctx->Point.Size;
  3355.          break;
  3356.       case GL_POINT_SIZE_GRANULARITY:
  3357.      *params = (GLint) POINT_SIZE_GRANULARITY;
  3358.      break;
  3359.       case GL_POINT_SIZE_RANGE:
  3360.      params[0] = (GLint) MIN_POINT_SIZE;
  3361.      params[1] = (GLint) MAX_POINT_SIZE;
  3362.      break;
  3363.       case GL_POINT_SMOOTH:
  3364.      *params = (GLint) ctx->Point.SmoothFlag;
  3365.      break;
  3366.       case GL_POINT_SMOOTH_HINT:
  3367.      *params = (GLint) ctx->Hint.PointSmooth;
  3368.      break;
  3369.       case GL_POINT_SIZE_MIN_EXT:
  3370.      *params = (GLint) (ctx->Point.MinSize);
  3371.      break;
  3372.       case GL_POINT_SIZE_MAX_EXT:
  3373.      *params = (GLint) (ctx->Point.MaxSize);
  3374.      break;
  3375.       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
  3376.      *params = (GLint) (ctx->Point.Threshold);
  3377.      break;
  3378.       case GL_DISTANCE_ATTENUATION_EXT:
  3379.      params[0] = (GLint) (ctx->Point.Params[0]);
  3380.      params[1] = (GLint) (ctx->Point.Params[1]);
  3381.      params[2] = (GLint) (ctx->Point.Params[2]);
  3382.      break;
  3383.       case GL_POLYGON_MODE:
  3384.      params[0] = (GLint) ctx->Polygon.FrontMode;
  3385.      params[1] = (GLint) ctx->Polygon.BackMode;
  3386.      break;
  3387. #ifdef GL_EXT_polygon_offset
  3388.       case GL_POLYGON_OFFSET_BIAS_EXT:
  3389.          *params = (GLint) ctx->Polygon.OffsetUnits;
  3390.          break;
  3391. #endif
  3392.       case GL_POLYGON_OFFSET_FACTOR:
  3393.          *params = (GLint) ctx->Polygon.OffsetFactor;
  3394.          break;
  3395.       case GL_POLYGON_OFFSET_UNITS:
  3396.          *params = (GLint) ctx->Polygon.OffsetUnits;
  3397.          break;
  3398.       case GL_POLYGON_SMOOTH:
  3399.      *params = (GLint) ctx->Polygon.SmoothFlag;
  3400.      break;
  3401.       case GL_POLYGON_SMOOTH_HINT:
  3402.      *params = (GLint) ctx->Hint.PolygonSmooth;
  3403.      break;
  3404.       case GL_POLYGON_STIPPLE:
  3405.          *params = (GLint) ctx->Polygon.StippleFlag;
  3406.      break;
  3407.       case GL_PROJECTION_MATRIX:
  3408.      for (i=0;i<16;i++) {
  3409.         params[i] = (GLint) ctx->ProjectionMatrix.m[i];
  3410.      }
  3411.      break;
  3412.       case GL_PROJECTION_STACK_DEPTH:
  3413.      *params = (GLint) (ctx->ProjectionStackDepth + 1);
  3414.      break;
  3415.       case GL_READ_BUFFER:
  3416.      *params = (GLint) ctx->Pixel.ReadBuffer;
  3417.      break;
  3418.       case GL_RED_BIAS:
  3419.          *params = (GLint) ctx->Pixel.RedBias;
  3420.          break;
  3421.       case GL_RED_BITS:
  3422.          *params = (GLint) ctx->Visual->RedBits;
  3423.          break;
  3424.       case GL_RED_SCALE:
  3425.          *params = (GLint) ctx->Pixel.RedScale;
  3426.          break;
  3427.       case GL_RENDER_MODE:
  3428.      *params = (GLint) ctx->RenderMode;
  3429.      break;
  3430.       case GL_RGBA_MODE:
  3431.      *params = (GLint) ctx->Visual->RGBAflag;
  3432.      break;
  3433.       case GL_SCISSOR_BOX:
  3434.      params[0] = (GLint) ctx->Scissor.X;
  3435.      params[1] = (GLint) ctx->Scissor.Y;
  3436.      params[2] = (GLint) ctx->Scissor.Width;
  3437.      params[3] = (GLint) ctx->Scissor.Height;
  3438.      break;
  3439.       case GL_SCISSOR_TEST:
  3440.      *params = (GLint) ctx->Scissor.Enabled;
  3441.      break;
  3442.       case GL_SELECTION_BUFFER_SIZE:
  3443.          *params = (GLint) ctx->Select.BufferSize;
  3444.          break;
  3445.       case GL_SHADE_MODEL:
  3446.      *params = (GLint) ctx->Light.ShadeModel;
  3447.      break;
  3448.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  3449.          *params = (GLint) ctx->Texture.SharedPalette;
  3450.          break;
  3451.       case GL_STENCIL_BITS:
  3452.          *params = ctx->Visual->StencilBits;
  3453.          break;
  3454.       case GL_STENCIL_CLEAR_VALUE:
  3455.      *params = (GLint) ctx->Stencil.Clear;
  3456.      break;
  3457.       case GL_STENCIL_FAIL:
  3458.      *params = (GLint) ctx->Stencil.FailFunc;
  3459.      break;
  3460.       case GL_STENCIL_FUNC:
  3461.      *params = (GLint) ctx->Stencil.Function;
  3462.      break;
  3463.       case GL_STENCIL_PASS_DEPTH_FAIL:
  3464.      *params = (GLint) ctx->Stencil.ZFailFunc;
  3465.      break;
  3466.       case GL_STENCIL_PASS_DEPTH_PASS:
  3467.      *params = (GLint) ctx->Stencil.ZPassFunc;
  3468.      break;
  3469.       case GL_STENCIL_REF:
  3470.      *params = (GLint) ctx->Stencil.Ref;
  3471.      break;
  3472.       case GL_STENCIL_TEST:
  3473.      *params = (GLint) ctx->Stencil.Enabled;
  3474.      break;
  3475.       case GL_STENCIL_VALUE_MASK:
  3476.      *params = (GLint) ctx->Stencil.ValueMask;
  3477.      break;
  3478.       case GL_STENCIL_WRITEMASK:
  3479.      *params = (GLint) ctx->Stencil.WriteMask;
  3480.      break;
  3481.       case GL_STEREO:
  3482.      *params = (GLint) ctx->Visual->StereoFlag;
  3483.      break;
  3484.       case GL_SUBPIXEL_BITS:
  3485.      *params = 0;  /* TODO */
  3486.      break;
  3487.       case GL_TEXTURE_1D:
  3488.          *params = gl_IsEnabled(ctx, GL_TEXTURE_1D) ? 1 : 0;
  3489.      break;
  3490.       case GL_TEXTURE_2D:
  3491.          *params = gl_IsEnabled(ctx, GL_TEXTURE_2D) ? 1 : 0;
  3492.      break;
  3493.       case GL_TEXTURE_3D:
  3494.          *params = gl_IsEnabled(ctx, GL_TEXTURE_3D) ? 1 : 0;
  3495.      break;
  3496.       case GL_TEXTURE_BINDING_1D:
  3497.          *params = textureUnit->CurrentD[1]->Name;
  3498.           break;
  3499.       case GL_TEXTURE_BINDING_2D:
  3500.          *params = textureUnit->CurrentD[2]->Name;
  3501.           break;
  3502.       case GL_TEXTURE_BINDING_3D:
  3503.          *params = textureUnit->CurrentD[3]->Name;
  3504.           break;
  3505.       case GL_TEXTURE_ENV_COLOR:
  3506.      params[0] = FLOAT_TO_INT( textureUnit->EnvColor[0] );
  3507.      params[1] = FLOAT_TO_INT( textureUnit->EnvColor[1] );
  3508.      params[2] = FLOAT_TO_INT( textureUnit->EnvColor[2] );
  3509.      params[3] = FLOAT_TO_INT( textureUnit->EnvColor[3] );
  3510.      break;
  3511.       case GL_TEXTURE_ENV_MODE:
  3512.      *params = (GLint) textureUnit->EnvMode;
  3513.      break;
  3514.       case GL_TEXTURE_GEN_S:
  3515.      *params = (textureUnit->TexGenEnabled & S_BIT) ? 1 : 0;
  3516.      break;
  3517.       case GL_TEXTURE_GEN_T:
  3518.      *params = (textureUnit->TexGenEnabled & T_BIT) ? 1 : 0;
  3519.      break;
  3520.       case GL_TEXTURE_GEN_R:
  3521.      *params = (textureUnit->TexGenEnabled & R_BIT) ? 1 : 0;
  3522.      break;
  3523.       case GL_TEXTURE_GEN_Q:
  3524.      *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1 : 0;
  3525.      break;
  3526.       case GL_TEXTURE_MATRIX:
  3527.          for (i=0;i<16;i++) {
  3528.         params[i] = (GLint) ctx->TextureMatrix[texTransformUnit].m[i];
  3529.      }
  3530.      break;
  3531.       case GL_TEXTURE_STACK_DEPTH:
  3532.      *params = (GLint) (ctx->TextureStackDepth[texTransformUnit] + 1);
  3533.      break;
  3534.       case GL_UNPACK_ALIGNMENT:
  3535.      *params = ctx->Unpack.Alignment;
  3536.      break;
  3537.       case GL_UNPACK_LSB_FIRST:
  3538.      *params = (GLint) ctx->Unpack.LsbFirst;
  3539.      break;
  3540.       case GL_UNPACK_ROW_LENGTH:
  3541.      *params = ctx->Unpack.RowLength;
  3542.      break;
  3543.       case GL_UNPACK_SKIP_PIXELS:
  3544.      *params = ctx->Unpack.SkipPixels;
  3545.      break;
  3546.       case GL_UNPACK_SKIP_ROWS:
  3547.      *params = ctx->Unpack.SkipRows;
  3548.      break;
  3549.       case GL_UNPACK_SWAP_BYTES:
  3550.      *params = (GLint) ctx->Unpack.SwapBytes;
  3551.      break;
  3552.       case GL_UNPACK_SKIP_IMAGES_EXT:
  3553.          *params = ctx->Unpack.SkipImages;
  3554.          break;
  3555.       case GL_UNPACK_IMAGE_HEIGHT_EXT:
  3556.          *params = ctx->Unpack.ImageHeight;
  3557.          break;
  3558.       case GL_VIEWPORT:
  3559.          params[0] = (GLint) ctx->Viewport.X;
  3560.          params[1] = (GLint) ctx->Viewport.Y;
  3561.          params[2] = (GLint) ctx->Viewport.Width;
  3562.          params[3] = (GLint) ctx->Viewport.Height;
  3563.          break;
  3564.       case GL_ZOOM_X:
  3565.      *params = (GLint) ctx->Pixel.ZoomX;
  3566.      break;
  3567.       case GL_ZOOM_Y:
  3568.      *params = (GLint) ctx->Pixel.ZoomY;
  3569.      break;
  3570.       case GL_VERTEX_ARRAY:
  3571.          *params = (GLint) ctx->Array.Vertex.Enabled;
  3572.          break;
  3573.       case GL_VERTEX_ARRAY_SIZE:
  3574.          *params = ctx->Array.Vertex.Size;
  3575.          break;
  3576.       case GL_VERTEX_ARRAY_TYPE:
  3577.          *params = ctx->Array.Vertex.Type;
  3578.          break;
  3579.       case GL_VERTEX_ARRAY_STRIDE:
  3580.          *params = ctx->Array.Vertex.Stride;
  3581.          break;
  3582.       case GL_VERTEX_ARRAY_COUNT_EXT:
  3583.          *params = 0;
  3584.          break;
  3585.       case GL_NORMAL_ARRAY:
  3586.          *params = (GLint) ctx->Array.Normal.Enabled;
  3587.          break;
  3588.       case GL_NORMAL_ARRAY_TYPE:
  3589.          *params = ctx->Array.Normal.Type;
  3590.          break;
  3591.       case GL_NORMAL_ARRAY_STRIDE:
  3592.          *params = ctx->Array.Normal.Stride;
  3593.          break;
  3594.       case GL_NORMAL_ARRAY_COUNT_EXT:
  3595.          *params = 0;
  3596.          break;
  3597.       case GL_COLOR_ARRAY:
  3598.          *params = (GLint) ctx->Array.Color.Enabled;
  3599.          break;
  3600.       case GL_COLOR_ARRAY_SIZE:
  3601.          *params = ctx->Array.Color.Size;
  3602.          break;
  3603.       case GL_COLOR_ARRAY_TYPE:
  3604.          *params = ctx->Array.Color.Type;
  3605.          break;
  3606.       case GL_COLOR_ARRAY_STRIDE:
  3607.          *params = ctx->Array.Color.Stride;
  3608.          break;
  3609.       case GL_COLOR_ARRAY_COUNT_EXT:
  3610.          *params = 0;
  3611.          break;
  3612.       case GL_INDEX_ARRAY:
  3613.          *params = (GLint) ctx->Array.Index.Enabled;
  3614.          break;
  3615.       case GL_INDEX_ARRAY_TYPE:
  3616.          *params = ctx->Array.Index.Type;
  3617.          break;
  3618.       case GL_INDEX_ARRAY_STRIDE:
  3619.          *params = ctx->Array.Index.Stride;
  3620.          break;
  3621.       case GL_INDEX_ARRAY_COUNT_EXT:
  3622.          *params = 0;
  3623.          break;
  3624.       case GL_TEXTURE_COORD_ARRAY:
  3625.          *params = (GLint) ctx->Array.TexCoord[texUnit].Enabled;
  3626.          break;
  3627.       case GL_TEXTURE_COORD_ARRAY_SIZE:
  3628.          *params = ctx->Array.TexCoord[texUnit].Size;
  3629.          break;
  3630.       case GL_TEXTURE_COORD_ARRAY_TYPE:
  3631.          *params = ctx->Array.TexCoord[texUnit].Type;
  3632.          break;
  3633.       case GL_TEXTURE_COORD_ARRAY_STRIDE:
  3634.          *params = ctx->Array.TexCoord[texUnit].Stride;
  3635.          break;
  3636.       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
  3637.          *params = 0;
  3638.          break;
  3639.       case GL_EDGE_FLAG_ARRAY:
  3640.          *params = (GLint) ctx->Array.EdgeFlag.Enabled;
  3641.          break;
  3642.       case GL_EDGE_FLAG_ARRAY_STRIDE:
  3643.          *params = ctx->Array.EdgeFlag.Stride;
  3644.          break;
  3645.       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
  3646.          *params = 0;
  3647.          break;
  3648.  
  3649.       case GL_MAX_TEXTURE_UNITS_ARB:
  3650.          *params = ctx->Const.MaxTextureUnits;
  3651.          break;
  3652.       case GL_ACTIVE_TEXTURE_ARB:
  3653.          *params = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
  3654.          break;
  3655.       case GL_CLIENT_ACTIVE_TEXTURE_ARB:
  3656.          *params = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
  3657.          break;
  3658.  
  3659.  
  3660.       /* GL_PGI_misc_hints */
  3661.       case GL_STRICT_DEPTHFUNC_HINT_PGI:
  3662.      *params = (GL_NICEST);
  3663.          break;
  3664.       case GL_STRICT_LIGHTING_HINT_PGI:
  3665.      *params = (ctx->Hint.StrictLighting);
  3666.      break;
  3667.       case GL_STRICT_SCISSOR_HINT_PGI:
  3668.       case GL_FULL_STIPPLE_HINT_PGI:
  3669.      *params = (GL_TRUE);
  3670.      break;
  3671.       case GL_CONSERVE_MEMORY_HINT_PGI:
  3672.      *params = (GL_FALSE);
  3673.      break;
  3674.       case GL_ALWAYS_FAST_HINT_PGI:
  3675.      *params = (ctx->Hint.AllowDrawWin == GL_TRUE &&
  3676.             ctx->Hint.AllowDrawSpn == GL_FALSE && 
  3677.             ctx->Hint.AllowDrawMem == GL_FALSE);
  3678.      break;
  3679.       case GL_ALWAYS_SOFT_HINT_PGI:
  3680.      *params =  (ctx->Hint.AllowDrawWin == GL_TRUE &&
  3681.              ctx->Hint.AllowDrawSpn == GL_TRUE && 
  3682.              ctx->Hint.AllowDrawMem == GL_TRUE);
  3683.      break;
  3684.       case GL_ALLOW_DRAW_OBJ_HINT_PGI:
  3685.      *params = GL_TRUE;
  3686.      break;
  3687.       case GL_ALLOW_DRAW_WIN_HINT_PGI:
  3688.      *params = ctx->Hint.AllowDrawWin;
  3689.      break;
  3690.       case GL_ALLOW_DRAW_SPN_HINT_PGI:
  3691.      *params = ctx->Hint.AllowDrawSpn;
  3692.      break;
  3693.       case GL_ALLOW_DRAW_MEM_HINT_PGI:
  3694.      *params = ctx->Hint.AllowDrawMem;
  3695.      break;
  3696.       case GL_CLIP_NEAR_HINT_PGI:
  3697.       case GL_CLIP_FAR_HINT_PGI:
  3698.      *params = GL_TRUE;
  3699.      break;
  3700.       case GL_WIDE_LINE_HINT_PGI:
  3701.      *params = GL_DONT_CARE;
  3702.      break;
  3703.       case GL_BACK_NORMALS_HINT_PGI:
  3704.      *params = (GL_TRUE);
  3705.      break;
  3706.       case GL_NATIVE_GRAPHICS_HANDLE_PGI:
  3707.      *params = 0;
  3708.      break;
  3709.  
  3710.       /* GL_EXT_compiled_vertex_array
  3711.        */
  3712.       case GL_ARRAY_ELEMENT_LOCK_FIRST_SGI:
  3713.      *params = ctx->Array.LockFirst;
  3714.      break;
  3715.  
  3716.       case GL_ARRAY_ELEMENT_LOCK_COUNT_SGI:
  3717.      *params = ctx->Array.LockCount;
  3718.      break;
  3719.      
  3720.       default:
  3721.      printf("invalid enum: %x\n", pname);
  3722.          gl_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
  3723.    }
  3724. }
  3725.  
  3726.  
  3727.  
  3728. void gl_GetPointerv( GLcontext *ctx, GLenum pname, GLvoid **params )
  3729. {
  3730.    GLuint texUnit = ctx->Texture.CurrentUnit;
  3731.    /*GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;*/
  3732.  
  3733.    if (MESA_VERBOSE & VERBOSE_API) 
  3734.       fprintf(stderr, "glGetPointerv %s\n", gl_lookup_enum_by_nr(pname));
  3735.  
  3736.    switch (pname) {
  3737.       case GL_VERTEX_ARRAY_POINTER:
  3738.          *params = ctx->Array.Vertex.Ptr;
  3739.          break;
  3740.       case GL_NORMAL_ARRAY_POINTER:
  3741.          *params = ctx->Array.Normal.Ptr;
  3742.          break;
  3743.       case GL_COLOR_ARRAY_POINTER:
  3744.          *params = ctx->Array.Color.Ptr;
  3745.          break;
  3746.       case GL_INDEX_ARRAY_POINTER:
  3747.          *params = ctx->Array.Index.Ptr;
  3748.          break;
  3749.       case GL_TEXTURE_COORD_ARRAY_POINTER:
  3750.          *params = ctx->Array.TexCoord[texUnit].Ptr;
  3751.          break;
  3752.       case GL_EDGE_FLAG_ARRAY_POINTER:
  3753.          *params = ctx->Array.EdgeFlag.Ptr;
  3754.          break;
  3755.       case GL_FEEDBACK_BUFFER_POINTER:
  3756.          *params = ctx->Feedback.Buffer;
  3757.          break;
  3758.       case GL_SELECTION_BUFFER_POINTER:
  3759.          *params = ctx->Select.Buffer;
  3760.          break;
  3761.       default:
  3762.          gl_error( ctx, GL_INVALID_ENUM, "glGetPointerv" );
  3763.          return;
  3764.    }
  3765. }
  3766.  
  3767.  
  3768.  
  3769. const GLubyte *gl_GetString( GLcontext *ctx, GLenum name )
  3770. {
  3771.    static char result[1000];
  3772.    static char *vendor = "Brian Paul";
  3773.    static char *version = "1.2 Mesa 3.1";
  3774.  
  3775.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glGetString", 0);
  3776.  
  3777.    /* First see if device driver can satisfy this call */
  3778.    switch (name) {
  3779.       case GL_VENDOR:
  3780.       case GL_RENDERER:
  3781.       case GL_VERSION:
  3782.          if (ctx->Driver.GetString) {
  3783.             const GLubyte *str = (*ctx->Driver.GetString)(ctx, name);
  3784.             if (str && str[0])
  3785.                return str;
  3786.          }
  3787.          break;
  3788.       /* Extensions always handled by extensions.c */
  3789.       case GL_EXTENSIONS:
  3790.      return (GLubyte *) gl_extensions_get_string( ctx );
  3791.       default:
  3792.          gl_error( ctx, GL_INVALID_ENUM, "glGetString" );
  3793.          return (GLubyte *) 0;
  3794.    }
  3795.  
  3796.    /* If we get here, device driver didn't return a string */
  3797.    switch (name) {
  3798.       case GL_VENDOR:
  3799.          return (GLubyte *) vendor;
  3800.       case GL_RENDERER:
  3801.          strcpy(result, "Mesa");
  3802.          if (ctx->Driver.RendererString) {
  3803.             strcat(result, " ");
  3804.             strcat(result, (*ctx->Driver.RendererString)());
  3805.          }
  3806.          return (GLubyte *) result;
  3807.       case GL_VERSION:
  3808.          return (GLubyte *) version;
  3809.       default:
  3810.          /* caught above */
  3811.          return NULL;
  3812.    }
  3813. }
  3814.