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 / enable.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-07  |  20.6 KB  |  706 lines
  1. /* $Id: enable.c,v 1.9 1999/11/10 06:29:44 keithw Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.1
  6.  * 
  7.  * Copyright (C) 1999  Brian Paul   All Rights Reserved.
  8.  * 
  9.  * Permission is hereby granted, free of charge, to any person obtaining a
  10.  * copy of this software and associated documentation files (the "Software"),
  11.  * to deal in the Software without restriction, including without limitation
  12.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13.  * and/or sell copies of the Software, and to permit persons to whom the
  14.  * Software is furnished to do so, subject to the following conditions:
  15.  * 
  16.  * The above copyright notice and this permission notice shall be included
  17.  * in all copies or substantial portions of the Software.
  18.  * 
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  */
  26.  
  27.  
  28. /* $XFree86: xc/lib/GL/mesa/src/enable.c,v 1.3 1999/04/04 00:20:23 dawes Exp $ */
  29.  
  30. #ifdef PC_HEADER
  31. #include "all.h"
  32. #else
  33. #ifndef XFree86Server
  34. #include <stdio.h>
  35. #include <string.h>
  36. #else
  37. #include "GL/xf86glx.h"
  38. #endif
  39. #include "context.h"
  40. #include "enable.h"
  41. #include "light.h"
  42. #include "macros.h"
  43. #include "matrix.h"
  44. #include "mmath.h"
  45. #include "simple_list.h"
  46. #include "types.h"
  47. #include "vbfill.h"
  48. #include "xform.h"
  49. #include "enums.h"
  50. #endif
  51.  
  52.  
  53.  
  54. /*
  55.  * Perform glEnable and glDisable calls.
  56.  */
  57. void gl_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
  58. {
  59.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "gl_enable/disable" );
  60.  
  61.    if (MESA_VERBOSE & VERBOSE_API) 
  62.       fprintf(stderr, "%s %s (newstate is %x)\n", 
  63.           state ? "glEnable" : "glDisable",
  64.           gl_lookup_enum_by_nr(cap),
  65.           ctx->NewState);
  66.  
  67.    switch (cap) {
  68.       case GL_ALPHA_TEST:
  69.          if (ctx->Color.AlphaEnabled!=state) {
  70.             ctx->Color.AlphaEnabled = state;
  71.             ctx->NewState |= NEW_RASTER_OPS;
  72.          }
  73.      break;
  74.       case GL_AUTO_NORMAL:
  75.      ctx->Eval.AutoNormal = state;
  76.      break;
  77.       case GL_BLEND:
  78.          if (ctx->Color.BlendEnabled!=state) {
  79.             ctx->Color.BlendEnabled = state;
  80.             /* The following needed to accomodate 1.0 RGB logic op blending */
  81.             if (ctx->Color.BlendEquation==GL_LOGIC_OP && state) {
  82.                ctx->Color.ColorLogicOpEnabled = GL_TRUE;
  83.             }
  84.             else {
  85.                ctx->Color.ColorLogicOpEnabled = GL_FALSE;
  86.             }
  87.             ctx->NewState |= NEW_RASTER_OPS;
  88.          }
  89.      break;
  90.       case GL_CLIP_PLANE0:
  91.       case GL_CLIP_PLANE1:
  92.       case GL_CLIP_PLANE2:
  93.       case GL_CLIP_PLANE3:
  94.       case GL_CLIP_PLANE4:
  95.       case GL_CLIP_PLANE5:
  96.      if (cap >= GL_CLIP_PLANE0 && 
  97.          cap <= GL_CLIP_PLANE5 &&
  98.          ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0] != state) 
  99.      {
  100.         GLuint p = cap-GL_CLIP_PLANE0;
  101.  
  102.         ctx->Transform.ClipEnabled[p] = state;
  103.         ctx->NewState |= NEW_USER_CLIP;
  104.  
  105.         if (state) {
  106.            ctx->Enabled |= ENABLE_USERCLIP;
  107.            ctx->Transform.AnyClip++;
  108.            
  109.            if (ctx->ProjectionMatrix.flags & MAT_DIRTY_ALL_OVER) {
  110.           gl_matrix_analyze( &ctx->ProjectionMatrix );
  111.            }
  112.            
  113.            gl_transform_vector( ctx->Transform.ClipUserPlane[p],
  114.                     ctx->Transform.EyeUserPlane[p],
  115.                     ctx->ProjectionMatrix.inv );
  116.         } else {
  117.            if (--ctx->Transform.AnyClip == 0)
  118.           ctx->Enabled &= ~ENABLE_USERCLIP;           
  119.         }        
  120.      }
  121.      break;
  122.       case GL_COLOR_MATERIAL:
  123.          if (ctx->Light.ColorMaterialEnabled!=state) {
  124.             ctx->Light.ColorMaterialEnabled = state;
  125.         ctx->NewState |= NEW_LIGHTING;
  126.         if (state) 
  127.            gl_update_color_material( ctx, ctx->Current.ByteColor );
  128.          }
  129.      break;
  130.       case GL_CULL_FACE:
  131.          if (ctx->Polygon.CullFlag!=state) {
  132.             ctx->Polygon.CullFlag = state;
  133.         ctx->TriangleCaps ^= DD_TRI_CULL;
  134.             ctx->NewState |= NEW_POLYGON;
  135.          }
  136.      break;
  137.       case GL_DEPTH_TEST:
  138.          if (state && ctx->Visual->DepthBits==0) {
  139.             gl_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
  140.             return;
  141.          }
  142.      if (ctx->Depth.Test!=state) {
  143.             ctx->Depth.Test = state;
  144.             ctx->NewState |= NEW_RASTER_OPS;
  145.          }
  146.          break;
  147.       case GL_DITHER:
  148.          if (ctx->NoDither) {
  149.             /* MESA_NO_DITHER env var */
  150.             state = GL_FALSE;
  151.          }
  152.          if (ctx->Color.DitherFlag!=state) {
  153.             ctx->Color.DitherFlag = state;
  154.             ctx->NewState |= NEW_RASTER_OPS;
  155.          }
  156.      break;
  157.       case GL_FOG:
  158.      if (ctx->Fog.Enabled!=state) {
  159.             ctx->Fog.Enabled = state;
  160.         ctx->Enabled ^= ENABLE_FOG;
  161.             ctx->NewState |= NEW_FOG|NEW_RASTER_OPS;
  162.          }
  163.      break;
  164.       case GL_LIGHT0:
  165.       case GL_LIGHT1:
  166.       case GL_LIGHT2:
  167.       case GL_LIGHT3:
  168.       case GL_LIGHT4:
  169.       case GL_LIGHT5:
  170.       case GL_LIGHT6:
  171.       case GL_LIGHT7:
  172.      if (ctx->Light.Light[cap-GL_LIGHT0].Enabled != state) 
  173.      {
  174.         ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
  175.  
  176.         if (state) {
  177.            insert_at_tail(&ctx->Light.EnabledList, 
  178.                   &ctx->Light.Light[cap-GL_LIGHT0]);
  179.            if (ctx->Light.Enabled)
  180.           ctx->Enabled |= ENABLE_LIGHT;
  181.         } else {
  182.            remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
  183.            if (is_empty_list(&ctx->Light.EnabledList))
  184.           ctx->Enabled &= ~ENABLE_LIGHT;
  185.         }
  186.  
  187.         ctx->NewState |= NEW_LIGHTING;
  188.      }
  189.          break;
  190.       case GL_LIGHTING:
  191.          if (ctx->Light.Enabled!=state) {
  192.             ctx->Light.Enabled = state;
  193.         ctx->Enabled &= ~ENABLE_LIGHT;
  194.             if (state)
  195.            ctx->Enabled |= ENABLE_LIGHT;
  196.             ctx->NewState |= NEW_LIGHTING;
  197.          }
  198.          break;
  199.       case GL_LINE_SMOOTH:
  200.      if (ctx->Line.SmoothFlag!=state) {
  201.             ctx->Line.SmoothFlag = state;
  202.             ctx->NewState |= NEW_RASTER_OPS;
  203.          }
  204.      break;
  205.       case GL_LINE_STIPPLE:
  206.      if (ctx->Line.StippleFlag!=state) {
  207.             ctx->Line.StippleFlag = state;
  208.         ctx->TriangleCaps ^= DD_LINE_STIPPLE;
  209.             ctx->NewState |= NEW_RASTER_OPS;
  210.          }
  211.      break;
  212.       case GL_INDEX_LOGIC_OP:
  213.          if (ctx->Color.IndexLogicOpEnabled!=state) {
  214.         ctx->Color.IndexLogicOpEnabled = state;
  215.             ctx->NewState |= NEW_RASTER_OPS;
  216.          }
  217.      break;
  218.       case GL_COLOR_LOGIC_OP:
  219.          if (ctx->Color.ColorLogicOpEnabled!=state) {
  220.         ctx->Color.ColorLogicOpEnabled = state;
  221.             ctx->NewState |= NEW_RASTER_OPS;
  222.          }
  223.      break;
  224.       case GL_MAP1_COLOR_4:
  225.      ctx->Eval.Map1Color4 = state;
  226.      break;
  227.       case GL_MAP1_INDEX:
  228.      ctx->Eval.Map1Index = state;
  229.      break;
  230.       case GL_MAP1_NORMAL:
  231.      ctx->Eval.Map1Normal = state;
  232.      break;
  233.       case GL_MAP1_TEXTURE_COORD_1:
  234.      ctx->Eval.Map1TextureCoord1 = state;
  235.      break;
  236.       case GL_MAP1_TEXTURE_COORD_2:
  237.      ctx->Eval.Map1TextureCoord2 = state;
  238.      break;
  239.       case GL_MAP1_TEXTURE_COORD_3:
  240.      ctx->Eval.Map1TextureCoord3 = state;
  241.      break;
  242.       case GL_MAP1_TEXTURE_COORD_4:
  243.      ctx->Eval.Map1TextureCoord4 = state;
  244.      break;
  245.       case GL_MAP1_VERTEX_3:
  246.      ctx->Eval.Map1Vertex3 = state;
  247.      break;
  248.       case GL_MAP1_VERTEX_4:
  249.      ctx->Eval.Map1Vertex4 = state;
  250.      break;
  251.       case GL_MAP2_COLOR_4:
  252.      ctx->Eval.Map2Color4 = state;
  253.      break;
  254.       case GL_MAP2_INDEX:
  255.      ctx->Eval.Map2Index = state;
  256.      break;
  257.       case GL_MAP2_NORMAL:
  258.      ctx->Eval.Map2Normal = state;
  259.      break;
  260.       case GL_MAP2_TEXTURE_COORD_1: 
  261.      ctx->Eval.Map2TextureCoord1 = state;
  262.      break;
  263.       case GL_MAP2_TEXTURE_COORD_2:
  264.      ctx->Eval.Map2TextureCoord2 = state;
  265.      break;
  266.       case GL_MAP2_TEXTURE_COORD_3:
  267.      ctx->Eval.Map2TextureCoord3 = state;
  268.      break;
  269.       case GL_MAP2_TEXTURE_COORD_4:
  270.      ctx->Eval.Map2TextureCoord4 = state;
  271.      break;
  272.       case GL_MAP2_VERTEX_3:
  273.      ctx->Eval.Map2Vertex3 = state;
  274.      break;
  275.       case GL_MAP2_VERTEX_4:
  276.      ctx->Eval.Map2Vertex4 = state;
  277.      break;
  278.       case GL_NORMALIZE:
  279.      if (ctx->Transform.Normalize != state) {
  280.         ctx->Transform.Normalize = state;
  281.         ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
  282.         ctx->Enabled ^= ENABLE_NORMALIZE;
  283.      }
  284.      break;
  285.       case GL_POINT_SMOOTH:
  286.      if (ctx->Point.SmoothFlag!=state) {
  287.             ctx->Point.SmoothFlag = state;
  288.             ctx->NewState |= NEW_RASTER_OPS;
  289.          }
  290.      break;
  291.       case GL_POLYGON_SMOOTH:
  292.      if (ctx->Polygon.SmoothFlag!=state) {
  293.             ctx->Polygon.SmoothFlag = state;
  294.             ctx->NewState |= NEW_RASTER_OPS;
  295.          }
  296.      break;
  297.       case GL_POLYGON_STIPPLE:
  298.      if (ctx->Polygon.StippleFlag!=state) {
  299.             ctx->Polygon.StippleFlag = state;
  300.         ctx->TriangleCaps ^= DD_TRI_STIPPLE;
  301.             ctx->NewState |= NEW_RASTER_OPS;
  302.          }
  303.      break;
  304.       case GL_POLYGON_OFFSET_POINT:
  305.          if (ctx->Polygon.OffsetPoint!=state) {
  306.             ctx->Polygon.OffsetPoint = state;
  307.             ctx->NewState |= NEW_POLYGON;
  308.          }
  309.          break;
  310.       case GL_POLYGON_OFFSET_LINE:
  311.          if (ctx->Polygon.OffsetLine!=state) {
  312.             ctx->Polygon.OffsetLine = state;
  313.             ctx->NewState |= NEW_POLYGON;
  314.          }
  315.          break;
  316.       case GL_POLYGON_OFFSET_FILL:
  317.       /*case GL_POLYGON_OFFSET_EXT:*/
  318.          if (ctx->Polygon.OffsetFill!=state) {
  319.             ctx->Polygon.OffsetFill = state;
  320.             ctx->NewState |= NEW_POLYGON;
  321.          }
  322.          break;
  323.       case GL_RESCALE_NORMAL_EXT:
  324.      if (ctx->Transform.RescaleNormals != state) {
  325.         ctx->Transform.RescaleNormals = state;
  326.         ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
  327.         ctx->Enabled ^= ENABLE_RESCALE;
  328.      }
  329.          break;
  330.       case GL_SCISSOR_TEST:
  331.          if (ctx->Scissor.Enabled!=state) {
  332.             ctx->Scissor.Enabled = state;
  333.             ctx->NewState |= NEW_RASTER_OPS;
  334.          }
  335.      break;
  336.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  337.          ctx->Texture.SharedPalette = state;
  338.          if (ctx->Driver.UseGlobalTexturePalette)
  339.             (*ctx->Driver.UseGlobalTexturePalette)( ctx, state );
  340.          break;
  341.       case GL_STENCIL_TEST:
  342.      if (state && ctx->Visual->StencilBits==0) {
  343.             gl_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
  344.             return;
  345.      }
  346.      if (ctx->Stencil.Enabled!=state) {
  347.             ctx->Stencil.Enabled = state;
  348.             ctx->NewState |= NEW_RASTER_OPS;
  349.         ctx->TriangleCaps ^= DD_STENCIL;
  350.          }
  351.      break;
  352.       case GL_TEXTURE_1D:
  353.          if (ctx->Visual->RGBAflag) {
  354.         const GLuint curr = ctx->Texture.CurrentUnit;
  355.         const GLuint flag = TEXTURE0_1D << (curr * 4);
  356.             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
  357.         ctx->NewState |= NEW_TEXTURE_ENABLE;
  358.             if (state) {
  359.            texUnit->Enabled |= TEXTURE0_1D;
  360.            ctx->Enabled |= flag;
  361.         }
  362.             else {
  363.                texUnit->Enabled &= ~TEXTURE0_1D;
  364.                ctx->Enabled &= ~flag;
  365.             }
  366.          }
  367.          break;
  368.       case GL_TEXTURE_2D:
  369.          if (ctx->Visual->RGBAflag) {
  370.         const GLuint curr = ctx->Texture.CurrentUnit;
  371.         const GLuint flag = TEXTURE0_2D << (curr * 4);
  372.             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
  373.         ctx->NewState |= NEW_TEXTURE_ENABLE;
  374.             if (state) {
  375.            texUnit->Enabled |= TEXTURE0_2D;
  376.            ctx->Enabled |= flag;
  377.         }
  378.             else {
  379.                texUnit->Enabled &= ~TEXTURE0_2D;
  380.                ctx->Enabled &= ~flag;
  381.             }
  382.          }
  383.      break;
  384.       case GL_TEXTURE_3D:
  385.          if (ctx->Visual->RGBAflag) {
  386.         const GLuint curr = ctx->Texture.CurrentUnit;
  387.         const GLuint flag = TEXTURE0_3D << (curr * 4);
  388.             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
  389.         ctx->NewState |= NEW_TEXTURE_ENABLE;
  390.             if (state) {
  391.            texUnit->Enabled |= TEXTURE0_3D;
  392.            ctx->Enabled |= flag;
  393.         }
  394.             else {
  395.                texUnit->Enabled &= ~TEXTURE0_3D;
  396.                ctx->Enabled &= ~flag;
  397.             }
  398.          }
  399.          break;
  400.       case GL_TEXTURE_GEN_Q:
  401.          {
  402.             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  403.             if (state)
  404.                texUnit->TexGenEnabled |= Q_BIT;
  405.             else
  406.                texUnit->TexGenEnabled &= ~Q_BIT;
  407.             ctx->NewState |= NEW_TEXTURING;
  408.          }
  409.      break;
  410.       case GL_TEXTURE_GEN_R:
  411.          {
  412.             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  413.             if (state)
  414.                texUnit->TexGenEnabled |= R_BIT;
  415.             else
  416.                texUnit->TexGenEnabled &= ~R_BIT;
  417.             ctx->NewState |= NEW_TEXTURING;
  418.          }
  419.      break;
  420.       case GL_TEXTURE_GEN_S:
  421.          {
  422.             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  423.             if (state)
  424.                texUnit->TexGenEnabled |= S_BIT;
  425.             else
  426.                texUnit->TexGenEnabled &= ~S_BIT;
  427.             ctx->NewState |= NEW_TEXTURING;
  428.          }
  429.      break;
  430.       case GL_TEXTURE_GEN_T:
  431.          {
  432.             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  433.             if (state)
  434.                texUnit->TexGenEnabled |= T_BIT;
  435.             else
  436.                texUnit->TexGenEnabled &= ~T_BIT;
  437.             ctx->NewState |= NEW_TEXTURING;
  438.          }
  439.      break;
  440.  
  441.       /*
  442.        * CLIENT STATE!!!
  443.        */
  444.       case GL_VERTEX_ARRAY:
  445.          ctx->Array.Vertex.Enabled = state;
  446.          break;
  447.       case GL_NORMAL_ARRAY:
  448.          ctx->Array.Normal.Enabled = state;
  449.          break;
  450.       case GL_COLOR_ARRAY:
  451.          ctx->Array.Color.Enabled = state;
  452.          break;
  453.       case GL_INDEX_ARRAY:
  454.          ctx->Array.Index.Enabled = state;
  455.          break;
  456.       case GL_TEXTURE_COORD_ARRAY:
  457.          ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled = state;
  458.          break;
  459.       case GL_EDGE_FLAG_ARRAY:
  460.          ctx->Array.EdgeFlag.Enabled = state;
  461.          break;
  462.  
  463.       default:
  464.      if (state) {
  465.         gl_error( ctx, GL_INVALID_ENUM, "glEnable" );
  466.      }
  467.      else {
  468.         gl_error( ctx, GL_INVALID_ENUM, "glDisable" );
  469.      }
  470.          return;
  471.    }
  472.  
  473.    if (ctx->Driver.Enable) {
  474.       (*ctx->Driver.Enable)( ctx, cap, state );
  475.    }
  476. }
  477.  
  478.  
  479.  
  480.  
  481. void gl_Enable( GLcontext* ctx, GLenum cap )
  482. {
  483.    gl_set_enable( ctx, cap, GL_TRUE );
  484. }
  485.  
  486.  
  487.  
  488. void gl_Disable( GLcontext* ctx, GLenum cap )
  489. {
  490.    gl_set_enable( ctx, cap, GL_FALSE );
  491. }
  492.  
  493.  
  494.  
  495. GLboolean gl_IsEnabled( GLcontext* ctx, GLenum cap )
  496. {
  497.    switch (cap) {
  498.       case GL_ALPHA_TEST:
  499.          return ctx->Color.AlphaEnabled;
  500.       case GL_AUTO_NORMAL:
  501.      return ctx->Eval.AutoNormal;
  502.       case GL_BLEND:
  503.          return ctx->Color.BlendEnabled;
  504.       case GL_CLIP_PLANE0:
  505.       case GL_CLIP_PLANE1:
  506.       case GL_CLIP_PLANE2:
  507.       case GL_CLIP_PLANE3:
  508.       case GL_CLIP_PLANE4:
  509.       case GL_CLIP_PLANE5:
  510.      return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
  511.       case GL_COLOR_MATERIAL:
  512.      return ctx->Light.ColorMaterialEnabled;
  513.       case GL_CULL_FACE:
  514.          return ctx->Polygon.CullFlag;
  515.       case GL_DEPTH_TEST:
  516.          return ctx->Depth.Test;
  517.       case GL_DITHER:
  518.      return ctx->Color.DitherFlag;
  519.       case GL_FOG:
  520.      return ctx->Fog.Enabled;
  521.       case GL_LIGHTING:
  522.          return ctx->Light.Enabled;
  523.       case GL_LIGHT0:
  524.       case GL_LIGHT1:
  525.       case GL_LIGHT2:
  526.       case GL_LIGHT3:
  527.       case GL_LIGHT4:
  528.       case GL_LIGHT5:
  529.       case GL_LIGHT6:
  530.       case GL_LIGHT7:
  531.          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
  532.       case GL_LINE_SMOOTH:
  533.      return ctx->Line.SmoothFlag;
  534.       case GL_LINE_STIPPLE:
  535.      return ctx->Line.StippleFlag;
  536.       case GL_INDEX_LOGIC_OP:
  537.      return ctx->Color.IndexLogicOpEnabled;
  538.       case GL_COLOR_LOGIC_OP:
  539.      return ctx->Color.ColorLogicOpEnabled;
  540.       case GL_MAP1_COLOR_4:
  541.      return ctx->Eval.Map1Color4;
  542.       case GL_MAP1_INDEX:
  543.      return ctx->Eval.Map1Index;
  544.       case GL_MAP1_NORMAL:
  545.      return ctx->Eval.Map1Normal;
  546.       case GL_MAP1_TEXTURE_COORD_1:
  547.      return ctx->Eval.Map1TextureCoord1;
  548.       case GL_MAP1_TEXTURE_COORD_2:
  549.      return ctx->Eval.Map1TextureCoord2;
  550.       case GL_MAP1_TEXTURE_COORD_3:
  551.      return ctx->Eval.Map1TextureCoord3;
  552.       case GL_MAP1_TEXTURE_COORD_4:
  553.      return ctx->Eval.Map1TextureCoord4;
  554.       case GL_MAP1_VERTEX_3:
  555.      return ctx->Eval.Map1Vertex3;
  556.       case GL_MAP1_VERTEX_4:
  557.      return ctx->Eval.Map1Vertex4;
  558.       case GL_MAP2_COLOR_4:
  559.      return ctx->Eval.Map2Color4;
  560.       case GL_MAP2_INDEX:
  561.      return ctx->Eval.Map2Index;
  562.       case GL_MAP2_NORMAL:
  563.      return ctx->Eval.Map2Normal;
  564.       case GL_MAP2_TEXTURE_COORD_1: 
  565.      return ctx->Eval.Map2TextureCoord1;
  566.       case GL_MAP2_TEXTURE_COORD_2:
  567.      return ctx->Eval.Map2TextureCoord2;
  568.       case GL_MAP2_TEXTURE_COORD_3:
  569.      return ctx->Eval.Map2TextureCoord3;
  570.       case GL_MAP2_TEXTURE_COORD_4:
  571.      return ctx->Eval.Map2TextureCoord4;
  572.       case GL_MAP2_VERTEX_3:
  573.      return ctx->Eval.Map2Vertex3;
  574.       case GL_MAP2_VERTEX_4:
  575.      return ctx->Eval.Map2Vertex4;
  576.       case GL_NORMALIZE:
  577.      return ctx->Transform.Normalize;
  578.       case GL_POINT_SMOOTH:
  579.      return ctx->Point.SmoothFlag;
  580.       case GL_POLYGON_SMOOTH:
  581.      return ctx->Polygon.SmoothFlag;
  582.       case GL_POLYGON_STIPPLE:
  583.      return ctx->Polygon.StippleFlag;
  584.       case GL_POLYGON_OFFSET_POINT:
  585.      return ctx->Polygon.OffsetPoint;
  586.       case GL_POLYGON_OFFSET_LINE:
  587.      return ctx->Polygon.OffsetLine;
  588.       case GL_POLYGON_OFFSET_FILL:
  589.       /*case GL_POLYGON_OFFSET_EXT:*/
  590.      return ctx->Polygon.OffsetFill;
  591.       case GL_RESCALE_NORMAL_EXT:
  592.          return ctx->Transform.RescaleNormals;
  593.       case GL_SCISSOR_TEST:
  594.      return ctx->Scissor.Enabled;
  595.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  596.          return ctx->Texture.SharedPalette;
  597.       case GL_STENCIL_TEST:
  598.      return ctx->Stencil.Enabled;
  599.       case GL_TEXTURE_1D:
  600.          {
  601.             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  602.             return (texUnit->Enabled & TEXTURE0_1D) ? GL_TRUE : GL_FALSE;
  603.          }
  604.       case GL_TEXTURE_2D:
  605.          {
  606.             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  607.             return (texUnit->Enabled & TEXTURE0_2D) ? GL_TRUE : GL_FALSE;
  608.          }
  609.       case GL_TEXTURE_3D:
  610.          {
  611.             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  612.             return (texUnit->Enabled & TEXTURE0_3D) ? GL_TRUE : GL_FALSE;
  613.          }
  614.       case GL_TEXTURE_GEN_Q:
  615.          {
  616.             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  617.             return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
  618.          }
  619.       case GL_TEXTURE_GEN_R:
  620.          {
  621.             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  622.             return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
  623.          }
  624.       case GL_TEXTURE_GEN_S:
  625.          {
  626.             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  627.             return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
  628.          }
  629.       case GL_TEXTURE_GEN_T:
  630.          {
  631.             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  632.             return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
  633.          }
  634.  
  635.       /*
  636.        * CLIENT STATE!!!
  637.        */
  638.       case GL_VERTEX_ARRAY:
  639.          return ctx->Array.Vertex.Enabled;
  640.       case GL_NORMAL_ARRAY:
  641.          return ctx->Array.Normal.Enabled;
  642.       case GL_COLOR_ARRAY:
  643.          return ctx->Array.Color.Enabled;
  644.       case GL_INDEX_ARRAY:
  645.          return ctx->Array.Index.Enabled;
  646.       case GL_TEXTURE_COORD_ARRAY:
  647.          return ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
  648.       case GL_EDGE_FLAG_ARRAY:
  649.          return ctx->Array.EdgeFlag.Enabled;
  650.       default:
  651.      gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
  652.      return GL_FALSE;
  653.    }
  654. }
  655.  
  656.  
  657.  
  658.  
  659. static void gl_client_state( GLcontext *ctx, GLenum cap, GLboolean state )
  660. {
  661.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, 
  662.                        (state 
  663.                     ? "glEnableClientState" 
  664.                     : "glDisableClientState") );
  665.  
  666.    switch (cap) {
  667.       case GL_VERTEX_ARRAY:
  668.          ctx->Array.Vertex.Enabled = state;
  669.          break;
  670.       case GL_NORMAL_ARRAY:
  671.          ctx->Array.Normal.Enabled = state;
  672.          break;
  673.       case GL_COLOR_ARRAY:
  674.          ctx->Array.Color.Enabled = state;
  675.          break;
  676.       case GL_INDEX_ARRAY:
  677.          ctx->Array.Index.Enabled = state;
  678.          break;
  679.       case GL_TEXTURE_COORD_ARRAY:
  680.          ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled = state;
  681.          break;
  682.       case GL_EDGE_FLAG_ARRAY:
  683.          ctx->Array.EdgeFlag.Enabled = state;
  684.          break;
  685.       default:
  686.          gl_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
  687.    }
  688.  
  689.    ctx->NewState |= NEW_CLIENT_STATE;
  690. }
  691.  
  692.  
  693.  
  694. void gl_EnableClientState( GLcontext *ctx, GLenum cap )
  695. {
  696.    gl_client_state( ctx, cap, GL_TRUE );
  697. }
  698.  
  699.  
  700.  
  701. void gl_DisableClientState( GLcontext *ctx, GLenum cap )
  702. {
  703.    gl_client_state( ctx, cap, GL_FALSE );
  704. }
  705.  
  706.