projects / mesa.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Header file clean-up:
[mesa.git] / src / mesa / main / enable.c
diff --git a/src/mesa/main/enable.c b/src/mesa/main/enable.c
index 5d29149ca06652e6903f395ad30f0f819e9d4e20..744668fd2938ecc8650a1ffdc859cc13679b74a4 100644 (file)
--- a/src/mesa/main/enable.c
+++ b/src/mesa/main/enable.c
@@ -1,4 +1,4 @@
-/* $Id: enable.c,v 1.64 2002/06/13 04:28:29 brianp Exp $ */
+/* $Id: enable.c,v 1.71 2002/10/24 23:57:20 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -25,9 +25,6 @@
  */
 
 
-#ifdef PC_HEADER
-#include "all.h"
-#else
 #include "glheader.h"
 #include "context.h"
 #include "enable.h"
@@ -39,13 +36,13 @@
 #include "enums.h"
 #include "math/m_matrix.h"
 #include "math/m_xform.h"
-#endif
 
 
-#define CHECK_EXTENSION(EXTNAME)                                       \
+
+#define CHECK_EXTENSION(EXTNAME, CAP)                                  \
    if (!ctx->Extensions.EXTNAME) {                                     \
-      _mesa_error(ctx, GL_INVALID_ENUM,                                        \
-         state ? "glEnableClientState": "glDisableClientState");       \
+      _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(0x%x)",       \
+                  state ? "Enable" : "Disable", CAP);                  \
       return;                                                          \
    }
 
@@ -91,7 +88,7 @@ client_state( GLcontext *ctx, GLenum cap, GLboolean state )
          flag = _NEW_ARRAY_COLOR1;
          break;
 
-      /* GL_NV_vertex_program */
+#if FEATURE_NV_vertex_program
       case GL_VERTEX_ATTRIB_ARRAY0_NV:
       case GL_VERTEX_ATTRIB_ARRAY1_NV:
       case GL_VERTEX_ATTRIB_ARRAY2_NV:
@@ -108,15 +105,18 @@ client_state( GLcontext *ctx, GLenum cap, GLboolean state )
       case GL_VERTEX_ATTRIB_ARRAY13_NV:
       case GL_VERTEX_ATTRIB_ARRAY14_NV:
       case GL_VERTEX_ATTRIB_ARRAY15_NV:
-         CHECK_EXTENSION(NV_vertex_program);
+         CHECK_EXTENSION(NV_vertex_program, cap);
          {
             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
             var = &ctx->Array.VertexAttrib[n].Enabled;
             flag = _NEW_ARRAY_ATTRIB(n);
          }
          break;
+#endif /* FEATURE_NV_vertex_program */
+
       default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
+         _mesa_error( ctx, GL_INVALID_ENUM,
+                      "glEnable/DisableClientState(0x%x)", cap);
          return;
    }
 
@@ -159,11 +159,11 @@ _mesa_DisableClientState( GLenum cap )
 
 
 #undef CHECK_EXTENSION
-#define CHECK_EXTENSION(EXTNAME)                       \
-   if (!ctx->Extensions.EXTNAME) {                     \
-      _mesa_error(ctx, GL_INVALID_ENUM,                        \
-                  state ? "glEnable": "glDisable");    \
-      return;                                          \
+#define CHECK_EXTENSION(EXTNAME, CAP)                                  \
+   if (!ctx->Extensions.EXTNAME) {                                     \
+      _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)",                  \
+                  state ? "Enable" : "Disable", CAP);                  \
+      return;                                                          \
    }
 
 
@@ -173,7 +173,7 @@ _mesa_DisableClientState( GLenum cap )
 void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 {
    if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug("%s %s (newstate is %x)\n",
+      _mesa_debug(ctx, "%s %s (newstate is %x)\n",
                   state ? "glEnable" : "glDisable",
                   _mesa_lookup_enum_by_nr(cap),
                   ctx->NewState);
@@ -276,7 +276,7 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
          ctx->Fog.Enabled = state;
          break;
       case GL_HISTOGRAM:
-         CHECK_EXTENSION(EXT_histogram);
+         CHECK_EXTENSION(EXT_histogram, cap);
          if (ctx->Pixel.HistogramEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_PIXEL);
@@ -539,9 +539,9 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
       case GL_TEXTURE_1D: {
          const GLuint curr = ctx->Texture.CurrentUnit;
          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-         GLuint newenabled = texUnit->Enabled & ~TEXTURE0_1D;
+         GLuint newenabled = texUnit->Enabled & ~TEXTURE_1D_BIT;
          if (state)
-            newenabled |= TEXTURE0_1D;
+            newenabled |= TEXTURE_1D_BIT;
          if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
             return;
          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
@@ -551,9 +551,9 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
       case GL_TEXTURE_2D: {
          const GLuint curr = ctx->Texture.CurrentUnit;
          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-         GLuint newenabled = texUnit->Enabled & ~TEXTURE0_2D;
+         GLuint newenabled = texUnit->Enabled & ~TEXTURE_2D_BIT;
          if (state)
-            newenabled |= TEXTURE0_2D;
+            newenabled |= TEXTURE_2D_BIT;
          if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
             return;
          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
@@ -563,9 +563,9 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
       case GL_TEXTURE_3D: {
          const GLuint curr = ctx->Texture.CurrentUnit;
          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-         GLuint newenabled = texUnit->Enabled & ~TEXTURE0_3D;
+         GLuint newenabled = texUnit->Enabled & ~TEXTURE_3D_BIT;
          if (state)
-            newenabled |= TEXTURE0_3D;
+            newenabled |= TEXTURE_3D_BIT;
          if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
             return;
          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
@@ -640,7 +640,7 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         CHECK_EXTENSION(HP_occlusion_test);
+         CHECK_EXTENSION(HP_occlusion_test, cap);
          if (ctx->Depth.OcclusionTest == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_DEPTH);
@@ -653,7 +653,7 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 
       /* GL_SGIS_pixel_texture */
       case GL_PIXEL_TEXTURE_SGIS:
-         CHECK_EXTENSION(SGIS_pixel_texture);
+         CHECK_EXTENSION(SGIS_pixel_texture, cap);
          if (ctx->Pixel.PixelTextureEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_PIXEL);
@@ -662,7 +662,7 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 
       /* GL_SGIX_pixel_texture */
       case GL_PIXEL_TEX_GEN_SGIX:
-         CHECK_EXTENSION(SGIX_pixel_texture);
+         CHECK_EXTENSION(SGIX_pixel_texture, cap);
          if (ctx->Pixel.PixelTextureEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_PIXEL);
@@ -671,21 +671,21 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 
       /* GL_SGI_color_table */
       case GL_COLOR_TABLE_SGI:
-         CHECK_EXTENSION(SGI_color_table);
+         CHECK_EXTENSION(SGI_color_table, cap);
          if (ctx->Pixel.ColorTableEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.ColorTableEnabled = state;
          break;
       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
-         CHECK_EXTENSION(SGI_color_table);
+         CHECK_EXTENSION(SGI_color_table, cap);
          if (ctx->Pixel.PostConvolutionColorTableEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostConvolutionColorTableEnabled = state;
          break;
       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
-         CHECK_EXTENSION(SGI_color_table);
+         CHECK_EXTENSION(SGI_color_table, cap);
          if (ctx->Pixel.PostColorMatrixColorTableEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_PIXEL);
@@ -694,21 +694,21 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 
       /* GL_EXT_convolution */
       case GL_CONVOLUTION_1D:
-         CHECK_EXTENSION(EXT_convolution);
+         CHECK_EXTENSION(EXT_convolution, cap);
          if (ctx->Pixel.Convolution1DEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.Convolution1DEnabled = state;
          break;
       case GL_CONVOLUTION_2D:
-         CHECK_EXTENSION(EXT_convolution);
+         CHECK_EXTENSION(EXT_convolution, cap);
          if (ctx->Pixel.Convolution2DEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.Convolution2DEnabled = state;
          break;
       case GL_SEPARABLE_2D:
-         CHECK_EXTENSION(EXT_convolution);
+         CHECK_EXTENSION(EXT_convolution, cap);
          if (ctx->Pixel.Separable2DEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_PIXEL);
@@ -720,10 +720,10 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
          {
             const GLuint curr = ctx->Texture.CurrentUnit;
             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-            GLuint newenabled = texUnit->Enabled & ~TEXTURE0_CUBE;
-            CHECK_EXTENSION(ARB_texture_cube_map);
+            GLuint newenabled = texUnit->Enabled & ~TEXTURE_CUBE_BIT;
+            CHECK_EXTENSION(ARB_texture_cube_map, cap);
             if (state)
-               newenabled |= TEXTURE0_CUBE;
+               newenabled |= TEXTURE_CUBE_BIT;
             if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
                return;
             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
@@ -733,7 +733,7 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 
       /* GL_EXT_secondary_color */
       case GL_COLOR_SUM_EXT:
-         CHECK_EXTENSION(EXT_secondary_color);
+         CHECK_EXTENSION(EXT_secondary_color, cap);
          if (ctx->Fog.ColorSumEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_FOG);
@@ -750,35 +750,35 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         CHECK_EXTENSION(ARB_multisample);
+         CHECK_EXTENSION(ARB_multisample, cap);
          if (ctx->Multisample.Enabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
          ctx->Multisample.Enabled = state;
          break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         CHECK_EXTENSION(ARB_multisample);
+         CHECK_EXTENSION(ARB_multisample, cap);
          if (ctx->Multisample.SampleAlphaToCoverage == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
          ctx->Multisample.SampleAlphaToCoverage = state;
          break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         CHECK_EXTENSION(ARB_multisample);
+         CHECK_EXTENSION(ARB_multisample, cap);
          if (ctx->Multisample.SampleAlphaToOne == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
          ctx->Multisample.SampleAlphaToOne = state;
          break;
       case GL_SAMPLE_COVERAGE_ARB:
-         CHECK_EXTENSION(ARB_multisample);
+         CHECK_EXTENSION(ARB_multisample, cap);
          if (ctx->Multisample.SampleCoverage == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
          ctx->Multisample.SampleCoverage = state;
          break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         CHECK_EXTENSION(ARB_multisample);
+         CHECK_EXTENSION(ARB_multisample, cap);
          if (ctx->Multisample.SampleCoverageInvert == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
@@ -787,7 +787,7 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 
       /* GL_IBM_rasterpos_clip */
       case GL_RASTER_POSITION_UNCLIPPED_IBM:
-         CHECK_EXTENSION(IBM_rasterpos_clip);
+         CHECK_EXTENSION(IBM_rasterpos_clip, cap);
          if (ctx->Transform.RasterPositionUnclipped == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
@@ -796,30 +796,30 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 
       /* GL_NV_point_sprite */
       case GL_POINT_SPRITE_NV:
-         CHECK_EXTENSION(NV_point_sprite);
+         CHECK_EXTENSION(NV_point_sprite, cap);
          if (ctx->Point.PointSprite == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_POINT);
          ctx->Point.PointSprite = state;
          break;
 
-      /* GL_NV_vertex_program */
+#if FEATURE_NV_vertex_program
       case GL_VERTEX_PROGRAM_NV:
-         CHECK_EXTENSION(NV_vertex_program);
+         CHECK_EXTENSION(NV_vertex_program, cap);
          if (ctx->VertexProgram.Enabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_TRANSFORM | _NEW_PROGRAM);  /* XXX OK? */
          ctx->VertexProgram.Enabled = state;
          break;
       case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
-         CHECK_EXTENSION(NV_vertex_program);
+         CHECK_EXTENSION(NV_vertex_program, cap);
          if (ctx->VertexProgram.PointSizeEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_POINT | _NEW_PROGRAM);
          ctx->VertexProgram.PointSizeEnabled = state;
          break;
       case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
-         CHECK_EXTENSION(NV_vertex_program);
+         CHECK_EXTENSION(NV_vertex_program, cap);
          if (ctx->VertexProgram.TwoSideEnabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_PROGRAM);  /* XXX OK? */
@@ -841,7 +841,7 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
-         CHECK_EXTENSION(NV_vertex_program);
+         CHECK_EXTENSION(NV_vertex_program, cap);
          {
             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
             FLUSH_VERTICES(ctx, _NEW_EVAL);
@@ -864,16 +864,44 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
-         CHECK_EXTENSION(NV_vertex_program);
+         CHECK_EXTENSION(NV_vertex_program, cap);
          {
             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
             FLUSH_VERTICES(ctx, _NEW_EVAL);
             ctx->Eval.Map2Attrib[map] = state;
          }
          break;
+#endif /* FEATURE_NV_vertex_program */
+
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+         CHECK_EXTENSION(NV_texture_rectangle, cap);
+         {
+            const GLuint curr = ctx->Texture.CurrentUnit;
+            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+            GLuint newenabled = texUnit->Enabled & ~TEXTURE_RECT_BIT;
+            CHECK_EXTENSION(NV_texture_rectangle, cap);
+            if (state)
+               newenabled |= TEXTURE_RECT_BIT;
+            if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+               return;
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            texUnit->Enabled = newenabled;
+         }
+         break;
+
+      /* GL_EXT_stencil_two_side */
+      case GL_STENCIL_TEST_TWO_SIDE_EXT:
+         CHECK_EXTENSION(EXT_stencil_two_side, cap);
+         if (ctx->Stencil.TestTwoSide == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_STENCIL);
+         ctx->Stencil.TestTwoSide = state;
+         break;
 
       default:
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "%s(0x%x)", state ? "glEnable" : "glDisable", cap);
          return;
    }
 
@@ -1021,19 +1049,19 @@ _mesa_IsEnabled( GLenum cap )
          {
             const struct gl_texture_unit *texUnit;
             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-            return (texUnit->Enabled & TEXTURE0_1D) ? GL_TRUE : GL_FALSE;
+            return (texUnit->Enabled & TEXTURE_1D_BIT) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_2D:
          {
             const struct gl_texture_unit *texUnit;
             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-            return (texUnit->Enabled & TEXTURE0_2D) ? GL_TRUE : GL_FALSE;
+            return (texUnit->Enabled & TEXTURE_2D_BIT) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_3D:
          {
             const struct gl_texture_unit *texUnit;
             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-            return (texUnit->Enabled & TEXTURE0_3D) ? GL_TRUE : GL_FALSE;
+            return (texUnit->Enabled & TEXTURE_3D_BIT) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_GEN_Q:
          {
@@ -1133,7 +1161,7 @@ _mesa_IsEnabled( GLenum cap )
          {
             const struct gl_texture_unit *texUnit;
             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-            return (texUnit->Enabled & TEXTURE0_CUBE) ? GL_TRUE : GL_FALSE;
+            return (texUnit->Enabled & TEXTURE_CUBE_BIT) ? GL_TRUE : GL_FALSE;
          }
 
       /* GL_ARB_multisample */
@@ -1162,7 +1190,7 @@ _mesa_IsEnabled( GLenum cap )
       case GL_POINT_SPRITE_NV:
          return ctx->Point.PointSprite;
 
-      /* GL_NV_vertex_program */
+#if FEATURE_NV_vertex_program
       case GL_VERTEX_PROGRAM_NV:
          CHECK_EXTENSION(NV_vertex_program);
          return ctx->VertexProgram.Enabled;
@@ -1235,9 +1263,24 @@ _mesa_IsEnabled( GLenum cap )
             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
             return ctx->Eval.Map2Attrib[map];
          }
+#endif /* FEATURE_NV_vertex_program */
+
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+         CHECK_EXTENSION(NV_texture_rectangle);
+         {
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            return (texUnit->Enabled & TEXTURE_RECT_BIT) ? GL_TRUE : GL_FALSE;
+         }
+
+      /* GL_EXT_stencil_two_side */
+      case GL_STENCIL_TEST_TWO_SIDE_EXT:
+         CHECK_EXTENSION(EXT_stencil_two_side);
+         return ctx->Stencil.TestTwoSide;
 
       default:
-        _mesa_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
+         _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap);
         return GL_FALSE;
    }
 }