Subversion Repositories Kolibri OS

Rev

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

  1. /**
  2.  * \file enable.c
  3.  * Enable/disable/query GL capabilities.
  4.  */
  5.  
  6. /*
  7.  * Mesa 3-D graphics library
  8.  * Version:  7.0.3
  9.  *
  10.  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  11.  *
  12.  * Permission is hereby granted, free of charge, to any person obtaining a
  13.  * copy of this software and associated documentation files (the "Software"),
  14.  * to deal in the Software without restriction, including without limitation
  15.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  16.  * and/or sell copies of the Software, and to permit persons to whom the
  17.  * Software is furnished to do so, subject to the following conditions:
  18.  *
  19.  * The above copyright notice and this permission notice shall be included
  20.  * in all copies or substantial portions of the Software.
  21.  *
  22.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  23.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  24.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  25.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  26.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  27.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28.  */
  29.  
  30.  
  31. #include "glheader.h"
  32. #include "context.h"
  33. #include "enable.h"
  34. #include "light.h"
  35. #include "simple_list.h"
  36. #include "mtypes.h"
  37. #include "enums.h"
  38. #include "api_arrayelt.h"
  39. #include "texstate.h"
  40.  
  41.  
  42.  
  43. #define CHECK_EXTENSION(EXTNAME, CAP)                                   \
  44.    if (!ctx->Extensions.EXTNAME) {                                      \
  45.       goto invalid_enum_error;                                          \
  46.    }
  47.  
  48.  
  49. /**
  50.  * Helper to enable/disable client-side state.
  51.  */
  52. static void
  53. client_state(struct gl_context *ctx, GLenum cap, GLboolean state)
  54. {
  55.    struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
  56.    GLuint flag;
  57.    GLboolean *var;
  58.  
  59.    switch (cap) {
  60.       case GL_VERTEX_ARRAY:
  61.          var = &arrayObj->Vertex.Enabled;
  62.          flag = _NEW_ARRAY_VERTEX;
  63.          break;
  64.       case GL_NORMAL_ARRAY:
  65.          var = &arrayObj->Normal.Enabled;
  66.          flag = _NEW_ARRAY_NORMAL;
  67.          break;
  68.       case GL_COLOR_ARRAY:
  69.          var = &arrayObj->Color.Enabled;
  70.          flag = _NEW_ARRAY_COLOR0;
  71.          break;
  72.       case GL_INDEX_ARRAY:
  73.          var = &arrayObj->Index.Enabled;
  74.          flag = _NEW_ARRAY_INDEX;
  75.          break;
  76.       case GL_TEXTURE_COORD_ARRAY:
  77.          var = &arrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled;
  78.          flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
  79.          break;
  80.       case GL_EDGE_FLAG_ARRAY:
  81.          var = &arrayObj->EdgeFlag.Enabled;
  82.          flag = _NEW_ARRAY_EDGEFLAG;
  83.          break;
  84.       case GL_FOG_COORDINATE_ARRAY_EXT:
  85.          var = &arrayObj->FogCoord.Enabled;
  86.          flag = _NEW_ARRAY_FOGCOORD;
  87.          break;
  88.       case GL_SECONDARY_COLOR_ARRAY_EXT:
  89.          var = &arrayObj->SecondaryColor.Enabled;
  90.          flag = _NEW_ARRAY_COLOR1;
  91.          break;
  92.  
  93. #if FEATURE_point_size_array
  94.       case GL_POINT_SIZE_ARRAY_OES:
  95.          var = &arrayObj->PointSize.Enabled;
  96.          flag = _NEW_ARRAY_POINT_SIZE;
  97.          break;
  98. #endif
  99.  
  100. #if FEATURE_NV_vertex_program
  101.       case GL_VERTEX_ATTRIB_ARRAY0_NV:
  102.       case GL_VERTEX_ATTRIB_ARRAY1_NV:
  103.       case GL_VERTEX_ATTRIB_ARRAY2_NV:
  104.       case GL_VERTEX_ATTRIB_ARRAY3_NV:
  105.       case GL_VERTEX_ATTRIB_ARRAY4_NV:
  106.       case GL_VERTEX_ATTRIB_ARRAY5_NV:
  107.       case GL_VERTEX_ATTRIB_ARRAY6_NV:
  108.       case GL_VERTEX_ATTRIB_ARRAY7_NV:
  109.       case GL_VERTEX_ATTRIB_ARRAY8_NV:
  110.       case GL_VERTEX_ATTRIB_ARRAY9_NV:
  111.       case GL_VERTEX_ATTRIB_ARRAY10_NV:
  112.       case GL_VERTEX_ATTRIB_ARRAY11_NV:
  113.       case GL_VERTEX_ATTRIB_ARRAY12_NV:
  114.       case GL_VERTEX_ATTRIB_ARRAY13_NV:
  115.       case GL_VERTEX_ATTRIB_ARRAY14_NV:
  116.       case GL_VERTEX_ATTRIB_ARRAY15_NV:
  117.          CHECK_EXTENSION(NV_vertex_program, cap);
  118.          {
  119.             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
  120.             ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
  121.             var = &arrayObj->VertexAttrib[n].Enabled;
  122.             flag = _NEW_ARRAY_ATTRIB(n);
  123.          }
  124.          break;
  125. #endif /* FEATURE_NV_vertex_program */
  126.  
  127.       /* GL_NV_primitive_restart */
  128.       case GL_PRIMITIVE_RESTART_NV:
  129.          if (!ctx->Extensions.NV_primitive_restart) {
  130.             goto invalid_enum_error;
  131.          }
  132.          var = &ctx->Array.PrimitiveRestart;
  133.          flag = 0;
  134.          break;
  135.  
  136.       default:
  137.          goto invalid_enum_error;
  138.    }
  139.  
  140.    if (*var == state)
  141.       return;
  142.  
  143.    FLUSH_VERTICES(ctx, _NEW_ARRAY);
  144.    ctx->Array.NewState |= flag;
  145.  
  146.    _ae_invalidate_state(ctx, _NEW_ARRAY);
  147.  
  148.    *var = state;
  149.  
  150.    if (state)
  151.       ctx->Array.ArrayObj->_Enabled |= flag;
  152.    else
  153.       ctx->Array.ArrayObj->_Enabled &= ~flag;
  154.  
  155.    if (ctx->Driver.Enable) {
  156.       ctx->Driver.Enable( ctx, cap, state );
  157.    }
  158.  
  159.    return;
  160.  
  161. invalid_enum_error:
  162.    _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(0x%x)",
  163.                state ? "Enable" : "Disable", cap);
  164. }
  165.  
  166.  
  167. /**
  168.  * Enable GL capability.
  169.  * \param cap  state to enable/disable.
  170.  *
  171.  * Get's the current context, assures that we're outside glBegin()/glEnd() and
  172.  * calls client_state().
  173.  */
  174. void GLAPIENTRY
  175. _mesa_EnableClientState( GLenum cap )
  176. {
  177.    GET_CURRENT_CONTEXT(ctx);
  178.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  179.    client_state( ctx, cap, GL_TRUE );
  180. }
  181.  
  182.  
  183. /**
  184.  * Disable GL capability.
  185.  * \param cap  state to enable/disable.
  186.  *
  187.  * Get's the current context, assures that we're outside glBegin()/glEnd() and
  188.  * calls client_state().
  189.  */
  190. void GLAPIENTRY
  191. _mesa_DisableClientState( GLenum cap )
  192. {
  193.    GET_CURRENT_CONTEXT(ctx);
  194.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  195.    client_state( ctx, cap, GL_FALSE );
  196. }
  197.  
  198.  
  199. #undef CHECK_EXTENSION
  200. #define CHECK_EXTENSION(EXTNAME, CAP)                                   \
  201.    if (!ctx->Extensions.EXTNAME) {                                      \
  202.       goto invalid_enum_error;                                          \
  203.    }
  204.  
  205. #define CHECK_EXTENSION2(EXT1, EXT2, CAP)                               \
  206.    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {                \
  207.       goto invalid_enum_error;                                          \
  208.    }
  209.  
  210.  
  211.  
  212. /**
  213.  * Return pointer to current texture unit for setting/getting coordinate
  214.  * state.
  215.  * Note that we'll set GL_INVALID_OPERATION if the active texture unit is
  216.  * higher than the number of supported coordinate units.  And we'll return NULL.
  217.  */
  218. static struct gl_texture_unit *
  219. get_texcoord_unit(struct gl_context *ctx)
  220. {
  221.    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
  222.       _mesa_error(ctx, GL_INVALID_OPERATION, "glEnable/Disable(texcoord unit)");
  223.       return NULL;
  224.    }
  225.    else {
  226.       return &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  227.    }
  228. }
  229.  
  230.  
  231. /**
  232.  * Helper function to enable or disable a texture target.
  233.  * \param bit  one of the TEXTURE_x_BIT values
  234.  * \return GL_TRUE if state is changing or GL_FALSE if no change
  235.  */
  236. static GLboolean
  237. enable_texture(struct gl_context *ctx, GLboolean state, GLbitfield texBit)
  238. {
  239.    struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
  240.    const GLbitfield newenabled = state
  241.       ? (texUnit->Enabled | texBit) : (texUnit->Enabled & ~texBit);
  242.  
  243.    if (texUnit->Enabled == newenabled)
  244.        return GL_FALSE;
  245.  
  246.    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  247.    texUnit->Enabled = newenabled;
  248.    return GL_TRUE;
  249. }
  250.  
  251.  
  252. /**
  253.  * Helper function to enable or disable state.
  254.  *
  255.  * \param ctx GL context.
  256.  * \param cap  the state to enable/disable
  257.  * \param state whether to enable or disable the specified capability.
  258.  *
  259.  * Updates the current context and flushes the vertices as needed. For
  260.  * capabilities associated with extensions it verifies that those extensions
  261.  * are effectivly present before updating. Notifies the driver via
  262.  * dd_function_table::Enable.
  263.  */
  264. void
  265. _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state)
  266. {
  267.    if (MESA_VERBOSE & VERBOSE_API)
  268.       _mesa_debug(ctx, "%s %s (newstate is %x)\n",
  269.                   state ? "glEnable" : "glDisable",
  270.                   _mesa_lookup_enum_by_nr(cap),
  271.                   ctx->NewState);
  272.  
  273.    switch (cap) {
  274.       case GL_ALPHA_TEST:
  275.          if (ctx->Color.AlphaEnabled == state)
  276.             return;
  277.          FLUSH_VERTICES(ctx, _NEW_COLOR);
  278.          ctx->Color.AlphaEnabled = state;
  279.          break;
  280.       case GL_AUTO_NORMAL:
  281.          if (ctx->Eval.AutoNormal == state)
  282.             return;
  283.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  284.          ctx->Eval.AutoNormal = state;
  285.          break;
  286.       case GL_BLEND:
  287.          {
  288.             GLbitfield newEnabled = state * ((1 << ctx->Const.MaxDrawBuffers) - 1);
  289.             if (newEnabled != ctx->Color.BlendEnabled) {
  290.                FLUSH_VERTICES(ctx, _NEW_COLOR);
  291.                ctx->Color.BlendEnabled = newEnabled;
  292.             }
  293.          }
  294.          break;
  295. #if FEATURE_userclip
  296.       case GL_CLIP_PLANE0:
  297.       case GL_CLIP_PLANE1:
  298.       case GL_CLIP_PLANE2:
  299.       case GL_CLIP_PLANE3:
  300.       case GL_CLIP_PLANE4:
  301.       case GL_CLIP_PLANE5:
  302.          {
  303.             const GLuint p = cap - GL_CLIP_PLANE0;
  304.  
  305.             if ((ctx->Transform.ClipPlanesEnabled & (1 << p)) == ((GLuint) state << p))
  306.                return;
  307.  
  308.             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
  309.  
  310.             if (state) {
  311.                ctx->Transform.ClipPlanesEnabled |= (1 << p);
  312.  
  313.                if (_math_matrix_is_dirty(ctx->ProjectionMatrixStack.Top))
  314.                   _math_matrix_analyse( ctx->ProjectionMatrixStack.Top );
  315.  
  316.                /* This derived state also calculated in clip.c and
  317.                 * from _mesa_update_state() on changes to EyeUserPlane
  318.                 * and ctx->ProjectionMatrix respectively.
  319.                 */
  320.                _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
  321.                                     ctx->Transform.EyeUserPlane[p],
  322.                                     ctx->ProjectionMatrixStack.Top->inv );
  323.             }
  324.             else {
  325.                ctx->Transform.ClipPlanesEnabled &= ~(1 << p);
  326.             }              
  327.          }
  328.          break;
  329. #endif
  330.       case GL_COLOR_MATERIAL:
  331.          if (ctx->Light.ColorMaterialEnabled == state)
  332.             return;
  333.          FLUSH_VERTICES(ctx, _NEW_LIGHT);
  334.          FLUSH_CURRENT(ctx, 0);
  335.          ctx->Light.ColorMaterialEnabled = state;
  336.          if (state) {
  337.             _mesa_update_color_material( ctx,
  338.                                   ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
  339.          }
  340.          break;
  341.       case GL_CULL_FACE:
  342.          if (ctx->Polygon.CullFlag == state)
  343.             return;
  344.          FLUSH_VERTICES(ctx, _NEW_POLYGON);
  345.          ctx->Polygon.CullFlag = state;
  346.          break;
  347.       case GL_DEPTH_TEST:
  348.          if (ctx->Depth.Test == state)
  349.             return;
  350.          FLUSH_VERTICES(ctx, _NEW_DEPTH);
  351.          ctx->Depth.Test = state;
  352.          break;
  353.       case GL_DITHER:
  354.          if (ctx->NoDither) {
  355.             state = GL_FALSE; /* MESA_NO_DITHER env var */
  356.          }
  357.          if (ctx->Color.DitherFlag == state)
  358.             return;
  359.          FLUSH_VERTICES(ctx, _NEW_COLOR);
  360.          ctx->Color.DitherFlag = state;
  361.          break;
  362.       case GL_FOG:
  363.          if (ctx->Fog.Enabled == state)
  364.             return;
  365.          FLUSH_VERTICES(ctx, _NEW_FOG);
  366.          ctx->Fog.Enabled = state;
  367.          break;
  368.       case GL_LIGHT0:
  369.       case GL_LIGHT1:
  370.       case GL_LIGHT2:
  371.       case GL_LIGHT3:
  372.       case GL_LIGHT4:
  373.       case GL_LIGHT5:
  374.       case GL_LIGHT6:
  375.       case GL_LIGHT7:
  376.          if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
  377.             return;
  378.          FLUSH_VERTICES(ctx, _NEW_LIGHT);
  379.          ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
  380.          if (state) {
  381.             insert_at_tail(&ctx->Light.EnabledList,
  382.                            &ctx->Light.Light[cap-GL_LIGHT0]);
  383.          }
  384.          else {
  385.             remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
  386.          }
  387.          break;
  388.       case GL_LIGHTING:
  389.          if (ctx->Light.Enabled == state)
  390.             return;
  391.          FLUSH_VERTICES(ctx, _NEW_LIGHT);
  392.          ctx->Light.Enabled = state;
  393.          if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)
  394.             ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;
  395.          else
  396.             ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE;
  397.          break;
  398.       case GL_LINE_SMOOTH:
  399.          if (ctx->Line.SmoothFlag == state)
  400.             return;
  401.          FLUSH_VERTICES(ctx, _NEW_LINE);
  402.          ctx->Line.SmoothFlag = state;
  403.          ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
  404.          break;
  405.       case GL_LINE_STIPPLE:
  406.          if (ctx->Line.StippleFlag == state)
  407.             return;
  408.          FLUSH_VERTICES(ctx, _NEW_LINE);
  409.          ctx->Line.StippleFlag = state;
  410.          ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
  411.          break;
  412.       case GL_INDEX_LOGIC_OP:
  413.          if (ctx->Color.IndexLogicOpEnabled == state)
  414.             return;
  415.          FLUSH_VERTICES(ctx, _NEW_COLOR);
  416.          ctx->Color.IndexLogicOpEnabled = state;
  417.          break;
  418.       case GL_COLOR_LOGIC_OP:
  419.          if (ctx->Color.ColorLogicOpEnabled == state)
  420.             return;
  421.          FLUSH_VERTICES(ctx, _NEW_COLOR);
  422.          ctx->Color.ColorLogicOpEnabled = state;
  423.          break;
  424.       case GL_MAP1_COLOR_4:
  425.          if (ctx->Eval.Map1Color4 == state)
  426.             return;
  427.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  428.          ctx->Eval.Map1Color4 = state;
  429.          break;
  430.       case GL_MAP1_INDEX:
  431.          if (ctx->Eval.Map1Index == state)
  432.             return;
  433.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  434.          ctx->Eval.Map1Index = state;
  435.          break;
  436.       case GL_MAP1_NORMAL:
  437.          if (ctx->Eval.Map1Normal == state)
  438.             return;
  439.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  440.          ctx->Eval.Map1Normal = state;
  441.          break;
  442.       case GL_MAP1_TEXTURE_COORD_1:
  443.          if (ctx->Eval.Map1TextureCoord1 == state)
  444.             return;
  445.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  446.          ctx->Eval.Map1TextureCoord1 = state;
  447.          break;
  448.       case GL_MAP1_TEXTURE_COORD_2:
  449.          if (ctx->Eval.Map1TextureCoord2 == state)
  450.             return;
  451.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  452.          ctx->Eval.Map1TextureCoord2 = state;
  453.          break;
  454.       case GL_MAP1_TEXTURE_COORD_3:
  455.          if (ctx->Eval.Map1TextureCoord3 == state)
  456.             return;
  457.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  458.          ctx->Eval.Map1TextureCoord3 = state;
  459.          break;
  460.       case GL_MAP1_TEXTURE_COORD_4:
  461.          if (ctx->Eval.Map1TextureCoord4 == state)
  462.             return;
  463.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  464.          ctx->Eval.Map1TextureCoord4 = state;
  465.          break;
  466.       case GL_MAP1_VERTEX_3:
  467.          if (ctx->Eval.Map1Vertex3 == state)
  468.             return;
  469.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  470.          ctx->Eval.Map1Vertex3 = state;
  471.          break;
  472.       case GL_MAP1_VERTEX_4:
  473.          if (ctx->Eval.Map1Vertex4 == state)
  474.             return;
  475.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  476.          ctx->Eval.Map1Vertex4 = state;
  477.          break;
  478.       case GL_MAP2_COLOR_4:
  479.          if (ctx->Eval.Map2Color4 == state)
  480.             return;
  481.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  482.          ctx->Eval.Map2Color4 = state;
  483.          break;
  484.       case GL_MAP2_INDEX:
  485.          if (ctx->Eval.Map2Index == state)
  486.             return;
  487.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  488.          ctx->Eval.Map2Index = state;
  489.          break;
  490.       case GL_MAP2_NORMAL:
  491.          if (ctx->Eval.Map2Normal == state)
  492.             return;
  493.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  494.          ctx->Eval.Map2Normal = state;
  495.          break;
  496.       case GL_MAP2_TEXTURE_COORD_1:
  497.          if (ctx->Eval.Map2TextureCoord1 == state)
  498.             return;
  499.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  500.          ctx->Eval.Map2TextureCoord1 = state;
  501.          break;
  502.       case GL_MAP2_TEXTURE_COORD_2:
  503.          if (ctx->Eval.Map2TextureCoord2 == state)
  504.             return;
  505.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  506.          ctx->Eval.Map2TextureCoord2 = state;
  507.          break;
  508.       case GL_MAP2_TEXTURE_COORD_3:
  509.          if (ctx->Eval.Map2TextureCoord3 == state)
  510.             return;
  511.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  512.          ctx->Eval.Map2TextureCoord3 = state;
  513.          break;
  514.       case GL_MAP2_TEXTURE_COORD_4:
  515.          if (ctx->Eval.Map2TextureCoord4 == state)
  516.             return;
  517.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  518.          ctx->Eval.Map2TextureCoord4 = state;
  519.          break;
  520.       case GL_MAP2_VERTEX_3:
  521.          if (ctx->Eval.Map2Vertex3 == state)
  522.             return;
  523.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  524.          ctx->Eval.Map2Vertex3 = state;
  525.          break;
  526.       case GL_MAP2_VERTEX_4:
  527.          if (ctx->Eval.Map2Vertex4 == state)
  528.             return;
  529.          FLUSH_VERTICES(ctx, _NEW_EVAL);
  530.          ctx->Eval.Map2Vertex4 = state;
  531.          break;
  532.       case GL_NORMALIZE:
  533.          if (ctx->Transform.Normalize == state)
  534.             return;
  535.          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
  536.          ctx->Transform.Normalize = state;
  537.          break;
  538.       case GL_POINT_SMOOTH:
  539.          if (ctx->Point.SmoothFlag == state)
  540.             return;
  541.          FLUSH_VERTICES(ctx, _NEW_POINT);
  542.          ctx->Point.SmoothFlag = state;
  543.          ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
  544.          break;
  545.       case GL_POLYGON_SMOOTH:
  546.          if (ctx->Polygon.SmoothFlag == state)
  547.             return;
  548.          FLUSH_VERTICES(ctx, _NEW_POLYGON);
  549.          ctx->Polygon.SmoothFlag = state;
  550.          ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
  551.          break;
  552.       case GL_POLYGON_STIPPLE:
  553.          if (ctx->Polygon.StippleFlag == state)
  554.             return;
  555.          FLUSH_VERTICES(ctx, _NEW_POLYGON);
  556.          ctx->Polygon.StippleFlag = state;
  557.          ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
  558.          break;
  559.       case GL_POLYGON_OFFSET_POINT:
  560.          if (ctx->Polygon.OffsetPoint == state)
  561.             return;
  562.          FLUSH_VERTICES(ctx, _NEW_POLYGON);
  563.          ctx->Polygon.OffsetPoint = state;
  564.          break;
  565.       case GL_POLYGON_OFFSET_LINE:
  566.          if (ctx->Polygon.OffsetLine == state)
  567.             return;
  568.          FLUSH_VERTICES(ctx, _NEW_POLYGON);
  569.          ctx->Polygon.OffsetLine = state;
  570.          break;
  571.       case GL_POLYGON_OFFSET_FILL:
  572.          /*case GL_POLYGON_OFFSET_EXT:*/
  573.          if (ctx->Polygon.OffsetFill == state)
  574.             return;
  575.          FLUSH_VERTICES(ctx, _NEW_POLYGON);
  576.          ctx->Polygon.OffsetFill = state;
  577.          break;
  578.       case GL_RESCALE_NORMAL_EXT:
  579.          if (ctx->Transform.RescaleNormals == state)
  580.             return;
  581.          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
  582.          ctx->Transform.RescaleNormals = state;
  583.          break;
  584.       case GL_SCISSOR_TEST:
  585.          if (ctx->Scissor.Enabled == state)
  586.             return;
  587.          FLUSH_VERTICES(ctx, _NEW_SCISSOR);
  588.          ctx->Scissor.Enabled = state;
  589.          break;
  590.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  591.          if (ctx->Texture.SharedPalette == state)
  592.             return;
  593.          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  594.          ctx->Texture.SharedPalette = state;
  595.          break;
  596.       case GL_STENCIL_TEST:
  597.          if (ctx->Stencil.Enabled == state)
  598.             return;
  599.          FLUSH_VERTICES(ctx, _NEW_STENCIL);
  600.          ctx->Stencil.Enabled = state;
  601.          break;
  602.       case GL_TEXTURE_1D:
  603.          if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) {
  604.             return;
  605.          }
  606.          break;
  607.       case GL_TEXTURE_2D:
  608.          if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) {
  609.             return;
  610.          }
  611.          break;
  612.       case GL_TEXTURE_3D:
  613.          if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) {
  614.             return;
  615.          }
  616.          break;
  617.       case GL_TEXTURE_GEN_Q:
  618.          {
  619.             struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
  620.             if (texUnit) {
  621.                GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
  622.                if (state)
  623.                   newenabled |= Q_BIT;
  624.                if (texUnit->TexGenEnabled == newenabled)
  625.                   return;
  626.                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  627.                texUnit->TexGenEnabled = newenabled;
  628.             }
  629.          }
  630.          break;
  631.       case GL_TEXTURE_GEN_R:
  632.          {
  633.             struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
  634.             if (texUnit) {
  635.                GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
  636.                if (state)
  637.                   newenabled |= R_BIT;
  638.                if (texUnit->TexGenEnabled == newenabled)
  639.                   return;
  640.                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  641.                texUnit->TexGenEnabled = newenabled;
  642.             }
  643.          }
  644.          break;
  645.       case GL_TEXTURE_GEN_S:
  646.          {
  647.             struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
  648.             if (texUnit) {
  649.                GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
  650.                if (state)
  651.                   newenabled |= S_BIT;
  652.                if (texUnit->TexGenEnabled == newenabled)
  653.                   return;
  654.                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  655.                texUnit->TexGenEnabled = newenabled;
  656.             }
  657.          }
  658.          break;
  659.       case GL_TEXTURE_GEN_T:
  660.          {
  661.             struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
  662.             if (texUnit) {
  663.                GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
  664.                if (state)
  665.                   newenabled |= T_BIT;
  666.                if (texUnit->TexGenEnabled == newenabled)
  667.                   return;
  668.                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  669.                texUnit->TexGenEnabled = newenabled;
  670.             }
  671.          }
  672.          break;
  673.  
  674. #if FEATURE_ES1
  675.       case GL_TEXTURE_GEN_STR_OES:
  676.          /* disable S, T, and R at the same time */
  677.          {
  678.             struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
  679.             if (texUnit) {
  680.                GLuint newenabled =
  681.                   texUnit->TexGenEnabled & ~STR_BITS;
  682.                if (state)
  683.                   newenabled |= STR_BITS;
  684.                if (texUnit->TexGenEnabled == newenabled)
  685.                   return;
  686.                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  687.                texUnit->TexGenEnabled = newenabled;
  688.             }
  689.          }
  690.          break;
  691. #endif
  692.  
  693.       /*
  694.        * CLIENT STATE!!!
  695.        */
  696.       case GL_VERTEX_ARRAY:
  697.       case GL_NORMAL_ARRAY:
  698.       case GL_COLOR_ARRAY:
  699.       case GL_INDEX_ARRAY:
  700.       case GL_TEXTURE_COORD_ARRAY:
  701.       case GL_EDGE_FLAG_ARRAY:
  702.       case GL_FOG_COORDINATE_ARRAY_EXT:
  703.       case GL_SECONDARY_COLOR_ARRAY_EXT:
  704.       case GL_POINT_SIZE_ARRAY_OES:
  705.          client_state( ctx, cap, state );
  706.          return;
  707.  
  708.       /* GL_SGI_texture_color_table */
  709.       case GL_TEXTURE_COLOR_TABLE_SGI:
  710.          CHECK_EXTENSION(SGI_texture_color_table, cap);
  711.          if (ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled == state)
  712.             return;
  713.          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  714.          ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled = state;
  715.          break;
  716.  
  717.       /* GL_ARB_texture_cube_map */
  718.       case GL_TEXTURE_CUBE_MAP_ARB:
  719.          CHECK_EXTENSION(ARB_texture_cube_map, cap);
  720.          if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) {
  721.             return;
  722.          }
  723.          break;
  724.  
  725.       /* GL_EXT_secondary_color */
  726.       case GL_COLOR_SUM_EXT:
  727.          CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program, cap);
  728.          if (ctx->Fog.ColorSumEnabled == state)
  729.             return;
  730.          FLUSH_VERTICES(ctx, _NEW_FOG);
  731.          ctx->Fog.ColorSumEnabled = state;
  732.          break;
  733.  
  734.       /* GL_ARB_multisample */
  735.       case GL_MULTISAMPLE_ARB:
  736.          if (ctx->Multisample.Enabled == state)
  737.             return;
  738.          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
  739.          ctx->Multisample.Enabled = state;
  740.          break;
  741.       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
  742.          if (ctx->Multisample.SampleAlphaToCoverage == state)
  743.             return;
  744.          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
  745.          ctx->Multisample.SampleAlphaToCoverage = state;
  746.          break;
  747.       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
  748.          if (ctx->Multisample.SampleAlphaToOne == state)
  749.             return;
  750.          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
  751.          ctx->Multisample.SampleAlphaToOne = state;
  752.          break;
  753.       case GL_SAMPLE_COVERAGE_ARB:
  754.          if (ctx->Multisample.SampleCoverage == state)
  755.             return;
  756.          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
  757.          ctx->Multisample.SampleCoverage = state;
  758.          break;
  759.       case GL_SAMPLE_COVERAGE_INVERT_ARB:
  760.          if (ctx->Multisample.SampleCoverageInvert == state)
  761.             return;
  762.          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
  763.          ctx->Multisample.SampleCoverageInvert = state;
  764.          break;
  765.  
  766.       /* GL_IBM_rasterpos_clip */
  767.       case GL_RASTER_POSITION_UNCLIPPED_IBM:
  768.          CHECK_EXTENSION(IBM_rasterpos_clip, cap);
  769.          if (ctx->Transform.RasterPositionUnclipped == state)
  770.             return;
  771.          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
  772.          ctx->Transform.RasterPositionUnclipped = state;
  773.          break;
  774.  
  775.       /* GL_NV_point_sprite */
  776.       case GL_POINT_SPRITE_NV:
  777.          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite, cap);
  778.          if (ctx->Point.PointSprite == state)
  779.             return;
  780.          FLUSH_VERTICES(ctx, _NEW_POINT);
  781.          ctx->Point.PointSprite = state;
  782.          break;
  783.  
  784. #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
  785.       case GL_VERTEX_PROGRAM_ARB:
  786.          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
  787.          if (ctx->VertexProgram.Enabled == state)
  788.             return;
  789.          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
  790.          ctx->VertexProgram.Enabled = state;
  791.          break;
  792.       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
  793.          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
  794.          if (ctx->VertexProgram.PointSizeEnabled == state)
  795.             return;
  796.          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
  797.          ctx->VertexProgram.PointSizeEnabled = state;
  798.          break;
  799.       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
  800.          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
  801.          if (ctx->VertexProgram.TwoSideEnabled == state)
  802.             return;
  803.          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
  804.          ctx->VertexProgram.TwoSideEnabled = state;
  805.          break;
  806. #endif
  807. #if FEATURE_NV_vertex_program
  808.       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
  809.       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
  810.       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
  811.       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
  812.       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
  813.       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
  814.       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
  815.       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
  816.       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
  817.       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
  818.       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
  819.       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
  820.       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
  821.       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
  822.       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
  823.       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
  824.          CHECK_EXTENSION(NV_vertex_program, cap);
  825.          {
  826.             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
  827.             FLUSH_VERTICES(ctx, _NEW_EVAL);
  828.             ctx->Eval.Map1Attrib[map] = state;
  829.          }
  830.          break;
  831.       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
  832.       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
  833.       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
  834.       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
  835.       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
  836.       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
  837.       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
  838.       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
  839.       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
  840.       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
  841.       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
  842.       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
  843.       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
  844.       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
  845.       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
  846.       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
  847.          CHECK_EXTENSION(NV_vertex_program, cap);
  848.          {
  849.             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
  850.             FLUSH_VERTICES(ctx, _NEW_EVAL);
  851.             ctx->Eval.Map2Attrib[map] = state;
  852.          }
  853.          break;
  854. #endif /* FEATURE_NV_vertex_program */
  855.  
  856. #if FEATURE_NV_fragment_program
  857.       case GL_FRAGMENT_PROGRAM_NV:
  858.          CHECK_EXTENSION(NV_fragment_program, cap);
  859.          if (ctx->FragmentProgram.Enabled == state)
  860.             return;
  861.          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
  862.          ctx->FragmentProgram.Enabled = state;
  863.          break;
  864. #endif /* FEATURE_NV_fragment_program */
  865.  
  866.       /* GL_NV_texture_rectangle */
  867.       case GL_TEXTURE_RECTANGLE_NV:
  868.          CHECK_EXTENSION(NV_texture_rectangle, cap);
  869.          if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) {
  870.             return;
  871.          }
  872.          break;
  873.  
  874.       /* GL_EXT_stencil_two_side */
  875.       case GL_STENCIL_TEST_TWO_SIDE_EXT:
  876.          CHECK_EXTENSION(EXT_stencil_two_side, cap);
  877.          if (ctx->Stencil.TestTwoSide == state)
  878.             return;
  879.          FLUSH_VERTICES(ctx, _NEW_STENCIL);
  880.          ctx->Stencil.TestTwoSide = state;
  881.          if (state) {
  882.             ctx->Stencil._BackFace = 2;
  883.             ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL;
  884.          } else {
  885.             ctx->Stencil._BackFace = 1;
  886.             ctx->_TriangleCaps &= ~DD_TRI_TWOSTENCIL;
  887.          }
  888.          break;
  889.  
  890. #if FEATURE_ARB_fragment_program
  891.       case GL_FRAGMENT_PROGRAM_ARB:
  892.          CHECK_EXTENSION(ARB_fragment_program, cap);
  893.          if (ctx->FragmentProgram.Enabled == state)
  894.             return;
  895.          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
  896.          ctx->FragmentProgram.Enabled = state;
  897.          break;
  898. #endif /* FEATURE_ARB_fragment_program */
  899.  
  900.       /* GL_EXT_depth_bounds_test */
  901.       case GL_DEPTH_BOUNDS_TEST_EXT:
  902.          CHECK_EXTENSION(EXT_depth_bounds_test, cap);
  903.          if (ctx->Depth.BoundsTest == state)
  904.             return;
  905.          FLUSH_VERTICES(ctx, _NEW_DEPTH);
  906.          ctx->Depth.BoundsTest = state;
  907.          break;
  908.  
  909.       case GL_DEPTH_CLAMP:
  910.          if (ctx->Transform.DepthClamp == state)
  911.             return;
  912.          CHECK_EXTENSION(ARB_depth_clamp, cap);
  913.          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
  914.          ctx->Transform.DepthClamp = state;
  915.          break;
  916.  
  917. #if FEATURE_ATI_fragment_shader
  918.       case GL_FRAGMENT_SHADER_ATI:
  919.         CHECK_EXTENSION(ATI_fragment_shader, cap);
  920.         if (ctx->ATIFragmentShader.Enabled == state)
  921.           return;
  922.         FLUSH_VERTICES(ctx, _NEW_PROGRAM);
  923.         ctx->ATIFragmentShader.Enabled = state;
  924.         break;
  925. #endif
  926.  
  927.       /* GL_MESA_texture_array */
  928.       case GL_TEXTURE_1D_ARRAY_EXT:
  929.          CHECK_EXTENSION(MESA_texture_array, cap);
  930.          if (!enable_texture(ctx, state, TEXTURE_1D_ARRAY_BIT)) {
  931.             return;
  932.          }
  933.          break;
  934.  
  935.       case GL_TEXTURE_2D_ARRAY_EXT:
  936.          CHECK_EXTENSION(MESA_texture_array, cap);
  937.          if (!enable_texture(ctx, state, TEXTURE_2D_ARRAY_BIT)) {
  938.             return;
  939.          }
  940.          break;
  941.  
  942.       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
  943.          CHECK_EXTENSION(ARB_seamless_cube_map, cap);
  944.          ctx->Texture.CubeMapSeamless = state;
  945.          break;
  946.  
  947. #if FEATURE_EXT_transform_feedback
  948.       case GL_RASTERIZER_DISCARD:
  949.          CHECK_EXTENSION(EXT_transform_feedback, cap);
  950.          if (ctx->TransformFeedback.RasterDiscard != state) {
  951.             ctx->TransformFeedback.RasterDiscard = state;
  952.             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
  953.          }
  954.          break;
  955. #endif
  956.  
  957.       /* GL 3.1 primitive restart.  Note: this enum is different from
  958.        * GL_PRIMITIVE_RESTART_NV (which is client state).
  959.        */
  960.       case GL_PRIMITIVE_RESTART:
  961.          if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
  962.             goto invalid_enum_error;
  963.          }
  964.          if (ctx->Array.PrimitiveRestart != state) {
  965.             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
  966.             ctx->Array.PrimitiveRestart = state;
  967.          }
  968.          break;
  969.  
  970.       default:
  971.          goto invalid_enum_error;
  972.    }
  973.  
  974.    if (ctx->Driver.Enable) {
  975.       ctx->Driver.Enable( ctx, cap, state );
  976.    }
  977.  
  978.    return;
  979.  
  980. invalid_enum_error:
  981.    _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)",
  982.                state ? "Enable" : "Disable", cap);
  983. }
  984.  
  985.  
  986. /**
  987.  * Enable GL capability.  Called by glEnable()
  988.  * \param cap  state to enable.
  989.  */
  990. void GLAPIENTRY
  991. _mesa_Enable( GLenum cap )
  992. {
  993.    GET_CURRENT_CONTEXT(ctx);
  994.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  995.  
  996.    _mesa_set_enable( ctx, cap, GL_TRUE );
  997. }
  998.  
  999.  
  1000. /**
  1001.  * Disable GL capability.  Called by glDisable()
  1002.  * \param cap  state to disable.
  1003.  */
  1004. void GLAPIENTRY
  1005. _mesa_Disable( GLenum cap )
  1006. {
  1007.    GET_CURRENT_CONTEXT(ctx);
  1008.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  1009.  
  1010.    _mesa_set_enable( ctx, cap, GL_FALSE );
  1011. }
  1012.  
  1013.  
  1014.  
  1015. /**
  1016.  * Enable/disable an indexed state var.
  1017.  */
  1018. void
  1019. _mesa_set_enablei(struct gl_context *ctx, GLenum cap, GLuint index, GLboolean state)
  1020. {
  1021.    ASSERT(state == 0 || state == 1);
  1022.    switch (cap) {
  1023.    case GL_BLEND:
  1024.       if (!ctx->Extensions.EXT_draw_buffers2) {
  1025.          goto invalid_enum_error;
  1026.       }
  1027.       if (index >= ctx->Const.MaxDrawBuffers) {
  1028.          _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",
  1029.                      state ? "glEnableIndexed" : "glDisableIndexed", index);
  1030.          return;
  1031.       }
  1032.       if (((ctx->Color.BlendEnabled >> index) & 1) != state) {
  1033.          FLUSH_VERTICES(ctx, _NEW_COLOR);
  1034.          if (state)
  1035.             ctx->Color.BlendEnabled |= (1 << index);
  1036.          else
  1037.             ctx->Color.BlendEnabled &= ~(1 << index);
  1038.       }
  1039.       break;
  1040.    default:
  1041.       goto invalid_enum_error;
  1042.    }
  1043.    return;
  1044.  
  1045. invalid_enum_error:
  1046.     _mesa_error(ctx, GL_INVALID_ENUM, "%s(cap=%s)",
  1047.                 state ? "glEnablei" : "glDisablei",
  1048.                 _mesa_lookup_enum_by_nr(cap));
  1049. }
  1050.  
  1051.  
  1052. void GLAPIENTRY
  1053. _mesa_DisableIndexed( GLenum cap, GLuint index )
  1054. {
  1055.    GET_CURRENT_CONTEXT(ctx);
  1056.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  1057.    _mesa_set_enablei(ctx, cap, index, GL_FALSE);
  1058. }
  1059.  
  1060.  
  1061. void GLAPIENTRY
  1062. _mesa_EnableIndexed( GLenum cap, GLuint index )
  1063. {
  1064.    GET_CURRENT_CONTEXT(ctx);
  1065.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  1066.    _mesa_set_enablei(ctx, cap, index, GL_TRUE);
  1067. }
  1068.  
  1069.  
  1070. GLboolean GLAPIENTRY
  1071. _mesa_IsEnabledIndexed( GLenum cap, GLuint index )
  1072. {
  1073.    GET_CURRENT_CONTEXT(ctx);
  1074.    switch (cap) {
  1075.    case GL_BLEND:
  1076.       if (index >= ctx->Const.MaxDrawBuffers) {
  1077.          _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",
  1078.                      index);
  1079.          return GL_FALSE;
  1080.       }
  1081.       return (ctx->Color.BlendEnabled >> index) & 1;
  1082.    default:
  1083.       _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabledIndexed(cap=%s)",
  1084.                   _mesa_lookup_enum_by_nr(cap));
  1085.       return GL_FALSE;
  1086.    }
  1087. }
  1088.  
  1089.  
  1090.  
  1091.  
  1092. #undef CHECK_EXTENSION
  1093. #define CHECK_EXTENSION(EXTNAME)                        \
  1094.    if (!ctx->Extensions.EXTNAME) {                      \
  1095.       goto invalid_enum_error;                          \
  1096.    }
  1097.  
  1098. #undef CHECK_EXTENSION2
  1099. #define CHECK_EXTENSION2(EXT1, EXT2)                            \
  1100.    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {        \
  1101.       goto invalid_enum_error;                                  \
  1102.    }
  1103.  
  1104.  
  1105. /**
  1106.  * Helper function to determine whether a texture target is enabled.
  1107.  */
  1108. static GLboolean
  1109. is_texture_enabled(struct gl_context *ctx, GLbitfield bit)
  1110. {
  1111.    const struct gl_texture_unit *const texUnit =
  1112.        &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
  1113.    return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE;
  1114. }
  1115.  
  1116.  
  1117. /**
  1118.  * Return simple enable/disable state.
  1119.  *
  1120.  * \param cap  state variable to query.
  1121.  *
  1122.  * Returns the state of the specified capability from the current GL context.
  1123.  * For the capabilities associated with extensions verifies that those
  1124.  * extensions are effectively present before reporting.
  1125.  */
  1126. GLboolean GLAPIENTRY
  1127. _mesa_IsEnabled( GLenum cap )
  1128. {
  1129.    GET_CURRENT_CONTEXT(ctx);
  1130.    switch (cap) {
  1131.       case GL_ALPHA_TEST:
  1132.          return ctx->Color.AlphaEnabled;
  1133.       case GL_AUTO_NORMAL:
  1134.          return ctx->Eval.AutoNormal;
  1135.       case GL_BLEND:
  1136.          return ctx->Color.BlendEnabled & 1;  /* return state for buffer[0] */
  1137.       case GL_CLIP_PLANE0:
  1138.       case GL_CLIP_PLANE1:
  1139.       case GL_CLIP_PLANE2:
  1140.       case GL_CLIP_PLANE3:
  1141.       case GL_CLIP_PLANE4:
  1142.       case GL_CLIP_PLANE5:
  1143.          return (ctx->Transform.ClipPlanesEnabled >> (cap - GL_CLIP_PLANE0)) & 1;
  1144.       case GL_COLOR_MATERIAL:
  1145.          return ctx->Light.ColorMaterialEnabled;
  1146.       case GL_CULL_FACE:
  1147.          return ctx->Polygon.CullFlag;
  1148.       case GL_DEPTH_TEST:
  1149.          return ctx->Depth.Test;
  1150.       case GL_DITHER:
  1151.          return ctx->Color.DitherFlag;
  1152.       case GL_FOG:
  1153.          return ctx->Fog.Enabled;
  1154.       case GL_LIGHTING:
  1155.          return ctx->Light.Enabled;
  1156.       case GL_LIGHT0:
  1157.       case GL_LIGHT1:
  1158.       case GL_LIGHT2:
  1159.       case GL_LIGHT3:
  1160.       case GL_LIGHT4:
  1161.       case GL_LIGHT5:
  1162.       case GL_LIGHT6:
  1163.       case GL_LIGHT7:
  1164.          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
  1165.       case GL_LINE_SMOOTH:
  1166.          return ctx->Line.SmoothFlag;
  1167.       case GL_LINE_STIPPLE:
  1168.          return ctx->Line.StippleFlag;
  1169.       case GL_INDEX_LOGIC_OP:
  1170.          return ctx->Color.IndexLogicOpEnabled;
  1171.       case GL_COLOR_LOGIC_OP:
  1172.          return ctx->Color.ColorLogicOpEnabled;
  1173.       case GL_MAP1_COLOR_4:
  1174.          return ctx->Eval.Map1Color4;
  1175.       case GL_MAP1_INDEX:
  1176.          return ctx->Eval.Map1Index;
  1177.       case GL_MAP1_NORMAL:
  1178.          return ctx->Eval.Map1Normal;
  1179.       case GL_MAP1_TEXTURE_COORD_1:
  1180.          return ctx->Eval.Map1TextureCoord1;
  1181.       case GL_MAP1_TEXTURE_COORD_2:
  1182.          return ctx->Eval.Map1TextureCoord2;
  1183.       case GL_MAP1_TEXTURE_COORD_3:
  1184.          return ctx->Eval.Map1TextureCoord3;
  1185.       case GL_MAP1_TEXTURE_COORD_4:
  1186.          return ctx->Eval.Map1TextureCoord4;
  1187.       case GL_MAP1_VERTEX_3:
  1188.          return ctx->Eval.Map1Vertex3;
  1189.       case GL_MAP1_VERTEX_4:
  1190.          return ctx->Eval.Map1Vertex4;
  1191.       case GL_MAP2_COLOR_4:
  1192.          return ctx->Eval.Map2Color4;
  1193.       case GL_MAP2_INDEX:
  1194.          return ctx->Eval.Map2Index;
  1195.       case GL_MAP2_NORMAL:
  1196.          return ctx->Eval.Map2Normal;
  1197.       case GL_MAP2_TEXTURE_COORD_1:
  1198.          return ctx->Eval.Map2TextureCoord1;
  1199.       case GL_MAP2_TEXTURE_COORD_2:
  1200.          return ctx->Eval.Map2TextureCoord2;
  1201.       case GL_MAP2_TEXTURE_COORD_3:
  1202.          return ctx->Eval.Map2TextureCoord3;
  1203.       case GL_MAP2_TEXTURE_COORD_4:
  1204.          return ctx->Eval.Map2TextureCoord4;
  1205.       case GL_MAP2_VERTEX_3:
  1206.          return ctx->Eval.Map2Vertex3;
  1207.       case GL_MAP2_VERTEX_4:
  1208.          return ctx->Eval.Map2Vertex4;
  1209.       case GL_NORMALIZE:
  1210.          return ctx->Transform.Normalize;
  1211.       case GL_POINT_SMOOTH:
  1212.          return ctx->Point.SmoothFlag;
  1213.       case GL_POLYGON_SMOOTH:
  1214.          return ctx->Polygon.SmoothFlag;
  1215.       case GL_POLYGON_STIPPLE:
  1216.          return ctx->Polygon.StippleFlag;
  1217.       case GL_POLYGON_OFFSET_POINT:
  1218.          return ctx->Polygon.OffsetPoint;
  1219.       case GL_POLYGON_OFFSET_LINE:
  1220.          return ctx->Polygon.OffsetLine;
  1221.       case GL_POLYGON_OFFSET_FILL:
  1222.       /*case GL_POLYGON_OFFSET_EXT:*/
  1223.          return ctx->Polygon.OffsetFill;
  1224.       case GL_RESCALE_NORMAL_EXT:
  1225.          return ctx->Transform.RescaleNormals;
  1226.       case GL_SCISSOR_TEST:
  1227.          return ctx->Scissor.Enabled;
  1228.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  1229.          return ctx->Texture.SharedPalette;
  1230.       case GL_STENCIL_TEST:
  1231.          return ctx->Stencil.Enabled;
  1232.       case GL_TEXTURE_1D:
  1233.          return is_texture_enabled(ctx, TEXTURE_1D_BIT);
  1234.       case GL_TEXTURE_2D:
  1235.          return is_texture_enabled(ctx, TEXTURE_2D_BIT);
  1236.       case GL_TEXTURE_3D:
  1237.          return is_texture_enabled(ctx, TEXTURE_3D_BIT);
  1238.       case GL_TEXTURE_GEN_Q:
  1239.          {
  1240.             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
  1241.             if (texUnit) {
  1242.                return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
  1243.             }
  1244.          }
  1245.          return GL_FALSE;
  1246.       case GL_TEXTURE_GEN_R:
  1247.          {
  1248.             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
  1249.             if (texUnit) {
  1250.                return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
  1251.             }
  1252.          }
  1253.          return GL_FALSE;
  1254.       case GL_TEXTURE_GEN_S:
  1255.          {
  1256.             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
  1257.             if (texUnit) {
  1258.                return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
  1259.             }
  1260.          }
  1261.          return GL_FALSE;
  1262.       case GL_TEXTURE_GEN_T:
  1263.          {
  1264.             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
  1265.             if (texUnit) {
  1266.                return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
  1267.             }
  1268.          }
  1269.          return GL_FALSE;
  1270. #if FEATURE_ES1
  1271.       case GL_TEXTURE_GEN_STR_OES:
  1272.          {
  1273.             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
  1274.             if (texUnit) {
  1275.                     return (texUnit->TexGenEnabled & STR_BITS) == STR_BITS ? GL_TRUE : GL_FALSE;
  1276.             }
  1277.          }
  1278. #endif
  1279.  
  1280.       /*
  1281.        * CLIENT STATE!!!
  1282.        */
  1283.       case GL_VERTEX_ARRAY:
  1284.          return (ctx->Array.ArrayObj->Vertex.Enabled != 0);
  1285.       case GL_NORMAL_ARRAY:
  1286.          return (ctx->Array.ArrayObj->Normal.Enabled != 0);
  1287.       case GL_COLOR_ARRAY:
  1288.          return (ctx->Array.ArrayObj->Color.Enabled != 0);
  1289.       case GL_INDEX_ARRAY:
  1290.          return (ctx->Array.ArrayObj->Index.Enabled != 0);
  1291.       case GL_TEXTURE_COORD_ARRAY:
  1292.          return (ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled != 0);
  1293.       case GL_EDGE_FLAG_ARRAY:
  1294.          return (ctx->Array.ArrayObj->EdgeFlag.Enabled != 0);
  1295.       case GL_FOG_COORDINATE_ARRAY_EXT:
  1296.          CHECK_EXTENSION(EXT_fog_coord);
  1297.          return (ctx->Array.ArrayObj->FogCoord.Enabled != 0);
  1298.       case GL_SECONDARY_COLOR_ARRAY_EXT:
  1299.          CHECK_EXTENSION(EXT_secondary_color);
  1300.          return (ctx->Array.ArrayObj->SecondaryColor.Enabled != 0);
  1301. #if FEATURE_point_size_array
  1302.       case GL_POINT_SIZE_ARRAY_OES:
  1303.          return (ctx->Array.ArrayObj->PointSize.Enabled != 0);
  1304. #endif
  1305.  
  1306.       /* GL_SGI_texture_color_table */
  1307.       case GL_TEXTURE_COLOR_TABLE_SGI:
  1308.          CHECK_EXTENSION(SGI_texture_color_table);
  1309.          return ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled;
  1310.  
  1311.       /* GL_ARB_texture_cube_map */
  1312.       case GL_TEXTURE_CUBE_MAP_ARB:
  1313.          CHECK_EXTENSION(ARB_texture_cube_map);
  1314.          return is_texture_enabled(ctx, TEXTURE_CUBE_BIT);
  1315.  
  1316.       /* GL_EXT_secondary_color */
  1317.       case GL_COLOR_SUM_EXT:
  1318.          CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program);
  1319.          return ctx->Fog.ColorSumEnabled;
  1320.  
  1321.       /* GL_ARB_multisample */
  1322.       case GL_MULTISAMPLE_ARB:
  1323.          return ctx->Multisample.Enabled;
  1324.       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
  1325.          return ctx->Multisample.SampleAlphaToCoverage;
  1326.       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
  1327.          return ctx->Multisample.SampleAlphaToOne;
  1328.       case GL_SAMPLE_COVERAGE_ARB:
  1329.          return ctx->Multisample.SampleCoverage;
  1330.       case GL_SAMPLE_COVERAGE_INVERT_ARB:
  1331.          return ctx->Multisample.SampleCoverageInvert;
  1332.  
  1333.       /* GL_IBM_rasterpos_clip */
  1334.       case GL_RASTER_POSITION_UNCLIPPED_IBM:
  1335.          CHECK_EXTENSION(IBM_rasterpos_clip);
  1336.          return ctx->Transform.RasterPositionUnclipped;
  1337.  
  1338.       /* GL_NV_point_sprite */
  1339.       case GL_POINT_SPRITE_NV:
  1340.          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite)
  1341.          return ctx->Point.PointSprite;
  1342.  
  1343. #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
  1344.       case GL_VERTEX_PROGRAM_ARB:
  1345.          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
  1346.          return ctx->VertexProgram.Enabled;
  1347.       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
  1348.          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
  1349.          return ctx->VertexProgram.PointSizeEnabled;
  1350.       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
  1351.          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
  1352.          return ctx->VertexProgram.TwoSideEnabled;
  1353. #endif
  1354. #if FEATURE_NV_vertex_program
  1355.       case GL_VERTEX_ATTRIB_ARRAY0_NV:
  1356.       case GL_VERTEX_ATTRIB_ARRAY1_NV:
  1357.       case GL_VERTEX_ATTRIB_ARRAY2_NV:
  1358.       case GL_VERTEX_ATTRIB_ARRAY3_NV:
  1359.       case GL_VERTEX_ATTRIB_ARRAY4_NV:
  1360.       case GL_VERTEX_ATTRIB_ARRAY5_NV:
  1361.       case GL_VERTEX_ATTRIB_ARRAY6_NV:
  1362.       case GL_VERTEX_ATTRIB_ARRAY7_NV:
  1363.       case GL_VERTEX_ATTRIB_ARRAY8_NV:
  1364.       case GL_VERTEX_ATTRIB_ARRAY9_NV:
  1365.       case GL_VERTEX_ATTRIB_ARRAY10_NV:
  1366.       case GL_VERTEX_ATTRIB_ARRAY11_NV:
  1367.       case GL_VERTEX_ATTRIB_ARRAY12_NV:
  1368.       case GL_VERTEX_ATTRIB_ARRAY13_NV:
  1369.       case GL_VERTEX_ATTRIB_ARRAY14_NV:
  1370.       case GL_VERTEX_ATTRIB_ARRAY15_NV:
  1371.          CHECK_EXTENSION(NV_vertex_program);
  1372.          {
  1373.             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
  1374.             ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
  1375.             return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0);
  1376.          }
  1377.       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
  1378.       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
  1379.       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
  1380.       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
  1381.       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
  1382.       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
  1383.       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
  1384.       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
  1385.       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
  1386.       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
  1387.       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
  1388.       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
  1389.       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
  1390.       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
  1391.       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
  1392.       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
  1393.          CHECK_EXTENSION(NV_vertex_program);
  1394.          {
  1395.             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
  1396.             return ctx->Eval.Map1Attrib[map];
  1397.          }
  1398.       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
  1399.       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
  1400.       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
  1401.       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
  1402.       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
  1403.       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
  1404.       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
  1405.       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
  1406.       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
  1407.       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
  1408.       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
  1409.       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
  1410.       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
  1411.       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
  1412.       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
  1413.       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
  1414.          CHECK_EXTENSION(NV_vertex_program);
  1415.          {
  1416.             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
  1417.             return ctx->Eval.Map2Attrib[map];
  1418.          }
  1419. #endif /* FEATURE_NV_vertex_program */
  1420.  
  1421. #if FEATURE_NV_fragment_program
  1422.       case GL_FRAGMENT_PROGRAM_NV:
  1423.          CHECK_EXTENSION(NV_fragment_program);
  1424.          return ctx->FragmentProgram.Enabled;
  1425. #endif /* FEATURE_NV_fragment_program */
  1426.  
  1427.       /* GL_NV_texture_rectangle */
  1428.       case GL_TEXTURE_RECTANGLE_NV:
  1429.          CHECK_EXTENSION(NV_texture_rectangle);
  1430.          return is_texture_enabled(ctx, TEXTURE_RECT_BIT);
  1431.  
  1432.       /* GL_EXT_stencil_two_side */
  1433.       case GL_STENCIL_TEST_TWO_SIDE_EXT:
  1434.          CHECK_EXTENSION(EXT_stencil_two_side);
  1435.          return ctx->Stencil.TestTwoSide;
  1436.  
  1437. #if FEATURE_ARB_fragment_program
  1438.       case GL_FRAGMENT_PROGRAM_ARB:
  1439.          return ctx->FragmentProgram.Enabled;
  1440. #endif /* FEATURE_ARB_fragment_program */
  1441.  
  1442.       /* GL_EXT_depth_bounds_test */
  1443.       case GL_DEPTH_BOUNDS_TEST_EXT:
  1444.          CHECK_EXTENSION(EXT_depth_bounds_test);
  1445.          return ctx->Depth.BoundsTest;
  1446.  
  1447.       /* GL_ARB_depth_clamp */
  1448.       case GL_DEPTH_CLAMP:
  1449.          CHECK_EXTENSION(ARB_depth_clamp);
  1450.          return ctx->Transform.DepthClamp;
  1451.  
  1452. #if FEATURE_ATI_fragment_shader
  1453.       case GL_FRAGMENT_SHADER_ATI:
  1454.          CHECK_EXTENSION(ATI_fragment_shader);
  1455.          return ctx->ATIFragmentShader.Enabled;
  1456. #endif /* FEATURE_ATI_fragment_shader */
  1457.  
  1458.       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
  1459.          CHECK_EXTENSION(ARB_seamless_cube_map);
  1460.          return ctx->Texture.CubeMapSeamless;
  1461.  
  1462. #if FEATURE_EXT_transform_feedback
  1463.       case GL_RASTERIZER_DISCARD:
  1464.          CHECK_EXTENSION(EXT_transform_feedback);
  1465.          return ctx->TransformFeedback.RasterDiscard;
  1466. #endif
  1467.  
  1468.       /* GL_NV_primitive_restart */
  1469.       case GL_PRIMITIVE_RESTART_NV:
  1470.          if (!ctx->Extensions.NV_primitive_restart) {
  1471.             goto invalid_enum_error;
  1472.          }
  1473.          return ctx->Array.PrimitiveRestart;
  1474.  
  1475.       /* GL 3.1 primitive restart */
  1476.       case GL_PRIMITIVE_RESTART:
  1477.          if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
  1478.             goto invalid_enum_error;
  1479.          }
  1480.          return ctx->Array.PrimitiveRestart;
  1481.  
  1482.       default:
  1483.          goto invalid_enum_error;
  1484.    }
  1485.  
  1486.    return GL_FALSE;
  1487.  
  1488. invalid_enum_error:
  1489.    _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap);
  1490.    return GL_FALSE;
  1491. }
  1492.