Ignore:
Timestamp:
May 23, 2000, 10:41:28 PM (25 years ago)
Author:
jeroen
Message:

* empty log message *

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/opengl/mesa/enable.c

    r2962 r3598  
    1 /* $Id: enable.c,v 1.2 2000-03-01 18:49:27 jeroen Exp $ */
     1/* $Id: enable.c,v 1.3 2000-05-23 20:40:32 jeroen Exp $ */
    22
    33/*
    44 * Mesa 3-D graphics library
    5  * Version:  3.1
     5 * Version:  3.3
    66 *
    77 * Copyright (C) 1999  Brian Paul   All Rights Reserved.
    … …  
    3131#include "all.h"
    3232#else
    33 #ifndef XFree86Server
    34 #include <stdio.h>
    35 #include <string.h>
    36 #else
    37 #include "GL/xf86glx.h"
    38 #endif
     33#include "glheader.h"
    3934#include "types.h"
    4035#include "context.h"
    … …  
    5550 * Perform glEnable and glDisable calls.
    5651 */
    57 void gl_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
     52void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
    5853{
    5954   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "gl_enable/disable" );
    … …  
    6156   if (MESA_VERBOSE & VERBOSE_API)
    6257      fprintf(stderr, "%s %s (newstate is %x)\n",
    63               state ? "glEnable" : "glDisable",
    64               gl_lookup_enum_by_nr(cap),
    65               ctx->NewState);
     58              state ? "glEnable" : "glDisable",
     59              gl_lookup_enum_by_nr(cap),
     60              ctx->NewState);
    6661
    6762   switch (cap) {
    … …  
    7166            ctx->NewState |= NEW_RASTER_OPS;
    7267         }
    73         break;
     68        break;
    7469      case GL_AUTO_NORMAL:
    75         ctx->Eval.AutoNormal = state;
    76         break;
     70        ctx->Eval.AutoNormal = state;
     71        break;
    7772      case GL_BLEND:
    7873         if (ctx->Color.BlendEnabled!=state) {
    … …  
    8782            ctx->NewState |= NEW_RASTER_OPS;
    8883         }
    89         break;
     84        break;
    9085      case GL_CLIP_PLANE0:
    9186      case GL_CLIP_PLANE1:
    … …  
    9489      case GL_CLIP_PLANE4:
    9590      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;
     91        if (cap >= GL_CLIP_PLANE0 &&
     92             cap <= GL_CLIP_PLANE5 &&
     93             ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0] != state)
     94        {
     95            GLuint p = cap-GL_CLIP_PLANE0;
     96
     97            ctx->Transform.ClipEnabled[p] = state;
     98            ctx->NewState |= NEW_USER_CLIP;
     99
     100            if (state) {
     101               ctx->Enabled |= ENABLE_USERCLIP;
     102               ctx->Transform.AnyClip++;
     103
     104               if (ctx->ProjectionMatrix.flags & MAT_DIRTY_ALL_OVER) {
     105                  gl_matrix_analyze( &ctx->ProjectionMatrix );
     106               }
     107
     108               gl_transform_vector( ctx->Transform.ClipUserPlane[p],
     109                                    ctx->Transform.EyeUserPlane[p],
     110                                    ctx->ProjectionMatrix.inv );
     111            } else {
     112               if (--ctx->Transform.AnyClip == 0)
     113                  ctx->Enabled &= ~ENABLE_USERCLIP;
     114            }
     115        }
     116        break;
    122117      case GL_COLOR_MATERIAL:
    123118         if (ctx->Light.ColorMaterialEnabled!=state) {
    124119            ctx->Light.ColorMaterialEnabled = state;
    125             ctx->NewState |= NEW_LIGHTING;
    126             if (state)
    127                gl_update_color_material( ctx, ctx->Current.ByteColor );
    128          }
    129         break;
     120            ctx->NewState |= NEW_LIGHTING;
     121            if (state)
     122               gl_update_color_material( ctx, ctx->Current.ByteColor );
     123         }
     124        break;
    130125      case GL_CULL_FACE:
    131126         if (ctx->Polygon.CullFlag!=state) {
    132127            ctx->Polygon.CullFlag = state;
    133             ctx->TriangleCaps ^= DD_TRI_CULL;
     128            ctx->TriangleCaps ^= DD_TRI_CULL;
    134129            ctx->NewState |= NEW_POLYGON;
    135130         }
    136         break;
     131        break;
    137132      case GL_DEPTH_TEST:
    138133         if (state && ctx->Visual->DepthBits==0) {
    … …  
    140135            return;
    141136         }
    142         if (ctx->Depth.Test!=state) {
     137        if (ctx->Depth.Test!=state) {
    143138            ctx->Depth.Test = state;
    144139            ctx->NewState |= NEW_RASTER_OPS;
    … …  
    154149            ctx->NewState |= NEW_RASTER_OPS;
    155150         }
    156         break;
     151        break;
    157152      case GL_FOG:
    158         if (ctx->Fog.Enabled!=state) {
     153        if (ctx->Fog.Enabled!=state) {
    159154            ctx->Fog.Enabled = state;
    160             ctx->Enabled ^= ENABLE_FOG;
     155            ctx->Enabled ^= ENABLE_FOG;
    161156            ctx->NewState |= NEW_FOG|NEW_RASTER_OPS;
    162157         }
    163         break;
     158        break;
    164159      case GL_LIGHT0:
    165160      case GL_LIGHT1:
    … …  
    170165      case GL_LIGHT6:
    171166      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         }
     167        if (ctx->Light.Light[cap-GL_LIGHT0].Enabled != state)
     168        {
     169            ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
     170
     171            if (state) {
     172               insert_at_tail(&ctx->Light.EnabledList,
     173                              &ctx->Light.Light[cap-GL_LIGHT0]);
     174               if (ctx->Light.Enabled)
     175                  ctx->Enabled |= ENABLE_LIGHT;
     176            } else {
     177               remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
     178               if (is_empty_list(&ctx->Light.EnabledList))
     179                  ctx->Enabled &= ~ENABLE_LIGHT;
     180            }
     181
     182            ctx->NewState |= NEW_LIGHTING;
     183        }
    189184         break;
    190185      case GL_LIGHTING:
    191186         if (ctx->Light.Enabled!=state) {
    192187            ctx->Light.Enabled = state;
    193             ctx->Enabled &= ~ENABLE_LIGHT;
     188            ctx->Enabled &= ~ENABLE_LIGHT;
    194189            if (state)
    195                ctx->Enabled |= ENABLE_LIGHT;
     190               ctx->Enabled |= ENABLE_LIGHT;
    196191            ctx->NewState |= NEW_LIGHTING;
    197192         }
    198193         break;
    199194      case GL_LINE_SMOOTH:
    200         if (ctx->Line.SmoothFlag!=state) {
     195        if (ctx->Line.SmoothFlag!=state) {
    201196            ctx->Line.SmoothFlag = state;
    202197            ctx->NewState |= NEW_RASTER_OPS;
    203198         }
    204         break;
     199        break;
    205200      case GL_LINE_STIPPLE:
    206         if (ctx->Line.StippleFlag!=state) {
     201        if (ctx->Line.StippleFlag!=state) {
    207202            ctx->Line.StippleFlag = state;
    208             ctx->TriangleCaps ^= DD_LINE_STIPPLE;
    209             ctx->NewState |= NEW_RASTER_OPS;
    210          }
    211         break;
     203            ctx->TriangleCaps ^= DD_LINE_STIPPLE;
     204            ctx->NewState |= NEW_RASTER_OPS;
     205         }
     206        break;
    212207      case GL_INDEX_LOGIC_OP:
    213208         if (ctx->Color.IndexLogicOpEnabled!=state) {
    214             ctx->Color.IndexLogicOpEnabled = state;
    215             ctx->NewState |= NEW_RASTER_OPS;
    216          }
    217         break;
     209            ctx->Color.IndexLogicOpEnabled = state;
     210            ctx->NewState |= NEW_RASTER_OPS;
     211         }
     212        break;
    218213      case GL_COLOR_LOGIC_OP:
    219214         if (ctx->Color.ColorLogicOpEnabled!=state) {
    220             ctx->Color.ColorLogicOpEnabled = state;
    221             ctx->NewState |= NEW_RASTER_OPS;
    222          }
    223         break;
     215            ctx->Color.ColorLogicOpEnabled = state;
     216            ctx->NewState |= NEW_RASTER_OPS;
     217         }
     218        break;
    224219      case GL_MAP1_COLOR_4:
    225         ctx->Eval.Map1Color4 = state;
    226         break;
     220        ctx->Eval.Map1Color4 = state;
     221        break;
    227222      case GL_MAP1_INDEX:
    228         ctx->Eval.Map1Index = state;
    229         break;
     223        ctx->Eval.Map1Index = state;
     224        break;
    230225      case GL_MAP1_NORMAL:
    231         ctx->Eval.Map1Normal = state;
    232         break;
     226        ctx->Eval.Map1Normal = state;
     227        break;
    233228      case GL_MAP1_TEXTURE_COORD_1:
    234         ctx->Eval.Map1TextureCoord1 = state;
    235         break;
     229        ctx->Eval.Map1TextureCoord1 = state;
     230        break;
    236231      case GL_MAP1_TEXTURE_COORD_2:
    237         ctx->Eval.Map1TextureCoord2 = state;
    238         break;
     232        ctx->Eval.Map1TextureCoord2 = state;
     233        break;
    239234      case GL_MAP1_TEXTURE_COORD_3:
    240         ctx->Eval.Map1TextureCoord3 = state;
    241         break;
     235        ctx->Eval.Map1TextureCoord3 = state;
     236        break;
    242237      case GL_MAP1_TEXTURE_COORD_4:
    243         ctx->Eval.Map1TextureCoord4 = state;
    244         break;
     238        ctx->Eval.Map1TextureCoord4 = state;
     239        break;
    245240      case GL_MAP1_VERTEX_3:
    246         ctx->Eval.Map1Vertex3 = state;
    247         break;
     241        ctx->Eval.Map1Vertex3 = state;
     242        break;
    248243      case GL_MAP1_VERTEX_4:
    249         ctx->Eval.Map1Vertex4 = state;
    250         break;
     244        ctx->Eval.Map1Vertex4 = state;
     245        break;
    251246      case GL_MAP2_COLOR_4:
    252         ctx->Eval.Map2Color4 = state;
    253         break;
     247        ctx->Eval.Map2Color4 = state;
     248        break;
    254249      case GL_MAP2_INDEX:
    255         ctx->Eval.Map2Index = state;
    256         break;
     250        ctx->Eval.Map2Index = state;
     251        break;
    257252      case GL_MAP2_NORMAL:
    258         ctx->Eval.Map2Normal = state;
    259         break;
     253        ctx->Eval.Map2Normal = state;
     254        break;
    260255      case GL_MAP2_TEXTURE_COORD_1:
    261         ctx->Eval.Map2TextureCoord1 = state;
    262         break;
     256        ctx->Eval.Map2TextureCoord1 = state;
     257        break;
    263258      case GL_MAP2_TEXTURE_COORD_2:
    264         ctx->Eval.Map2TextureCoord2 = state;
    265         break;
     259        ctx->Eval.Map2TextureCoord2 = state;
     260        break;
    266261      case GL_MAP2_TEXTURE_COORD_3:
    267         ctx->Eval.Map2TextureCoord3 = state;
    268         break;
     262        ctx->Eval.Map2TextureCoord3 = state;
     263        break;
    269264      case GL_MAP2_TEXTURE_COORD_4:
    270         ctx->Eval.Map2TextureCoord4 = state;
    271         break;
     265        ctx->Eval.Map2TextureCoord4 = state;
     266        break;
    272267      case GL_MAP2_VERTEX_3:
    273         ctx->Eval.Map2Vertex3 = state;
    274         break;
     268        ctx->Eval.Map2Vertex3 = state;
     269        break;
    275270      case GL_MAP2_VERTEX_4:
    276         ctx->Eval.Map2Vertex4 = state;
    277         break;
     271        ctx->Eval.Map2Vertex4 = state;
     272        break;
    278273      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;
     274        if (ctx->Transform.Normalize != state) {
     275            ctx->Transform.Normalize = state;
     276            ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
     277            ctx->Enabled ^= ENABLE_NORMALIZE;
     278        }
     279        break;
    285280      case GL_POINT_SMOOTH:
    286         if (ctx->Point.SmoothFlag!=state) {
     281        if (ctx->Point.SmoothFlag!=state) {
    287282            ctx->Point.SmoothFlag = state;
    288283            ctx->NewState |= NEW_RASTER_OPS;
    289284         }
    290         break;
     285        break;
    291286      case GL_POLYGON_SMOOTH:
    292         if (ctx->Polygon.SmoothFlag!=state) {
     287        if (ctx->Polygon.SmoothFlag!=state) {
    293288            ctx->Polygon.SmoothFlag = state;
    294289            ctx->NewState |= NEW_RASTER_OPS;
    295290         }
    296         break;
     291        break;
    297292      case GL_POLYGON_STIPPLE:
    298         if (ctx->Polygon.StippleFlag!=state) {
     293        if (ctx->Polygon.StippleFlag!=state) {
    299294            ctx->Polygon.StippleFlag = state;
    300             ctx->TriangleCaps ^= DD_TRI_STIPPLE;
    301             ctx->NewState |= NEW_RASTER_OPS;
    302          }
    303         break;
     295            ctx->TriangleCaps ^= DD_TRI_STIPPLE;
     296            ctx->NewState |= NEW_RASTER_OPS;
     297         }
     298        break;
    304299      case GL_POLYGON_OFFSET_POINT:
    305300         if (ctx->Polygon.OffsetPoint!=state) {
    … …  
    322317         break;
    323318      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         }
     319        if (ctx->Transform.RescaleNormals != state) {
     320            ctx->Transform.RescaleNormals = state;
     321            ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
     322            ctx->Enabled ^= ENABLE_RESCALE;
     323        }
    329324         break;
    330325      case GL_SCISSOR_TEST:
    … …  
    333328            ctx->NewState |= NEW_RASTER_OPS;
    334329         }
    335         break;
     330        break;
    336331      case GL_SHARED_TEXTURE_PALETTE_EXT:
    337332         ctx->Texture.SharedPalette = state;
    338          if (ctx->Driver.UseGlobalTexturePalette)
    339             (*ctx->Driver.UseGlobalTexturePalette)( ctx, state );
    340333         break;
    341334      case GL_STENCIL_TEST:
    342         if (state && ctx->Visual->StencilBits==0) {
     335        if (state && ctx->Visual->StencilBits==0) {
    343336            gl_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
    344337            return;
    345         }
    346         if (ctx->Stencil.Enabled!=state) {
     338        }
     339        if (ctx->Stencil.Enabled!=state) {
    347340            ctx->Stencil.Enabled = state;
    348341            ctx->NewState |= NEW_RASTER_OPS;
    349             ctx->TriangleCaps ^= DD_STENCIL;
    350          }
    351         break;
     342            ctx->TriangleCaps ^= DD_STENCIL;
     343         }
     344        break;
    352345      case GL_TEXTURE_1D:
    353346         if (ctx->Visual->RGBAflag) {
    354             const GLuint curr = ctx->Texture.CurrentUnit;
    355             const GLuint flag = TEXTURE0_1D << (curr * 4);
     347            const GLuint curr = ctx->Texture.CurrentUnit;
     348            const GLuint flag = TEXTURE0_1D << (curr * 4);
    356349            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
    357             ctx->NewState |= NEW_TEXTURE_ENABLE;
     350            ctx->NewState |= NEW_TEXTURE_ENABLE;
    358351            if (state) {
    359                texUnit->Enabled |= TEXTURE0_1D;
    360                ctx->Enabled |= flag;
    361             }
     352               texUnit->Enabled |= TEXTURE0_1D;
     353               ctx->Enabled |= flag;
     354            }
    362355            else {
    363356               texUnit->Enabled &= ~TEXTURE0_1D;
    … …  
    368361      case GL_TEXTURE_2D:
    369362         if (ctx->Visual->RGBAflag) {
    370             const GLuint curr = ctx->Texture.CurrentUnit;
    371             const GLuint flag = TEXTURE0_2D << (curr * 4);
     363            const GLuint curr = ctx->Texture.CurrentUnit;
     364            const GLuint flag = TEXTURE0_2D << (curr * 4);
    372365            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
    373             ctx->NewState |= NEW_TEXTURE_ENABLE;
     366            ctx->NewState |= NEW_TEXTURE_ENABLE;
    374367            if (state) {
    375                texUnit->Enabled |= TEXTURE0_2D;
    376                ctx->Enabled |= flag;
    377             }
     368               texUnit->Enabled |= TEXTURE0_2D;
     369               ctx->Enabled |= flag;
     370            }
    378371            else {
    379372               texUnit->Enabled &= ~TEXTURE0_2D;
    … …  
    381374            }
    382375         }
    383         break;
     376        break;
    384377      case GL_TEXTURE_3D:
    385378         if (ctx->Visual->RGBAflag) {
    386             const GLuint curr = ctx->Texture.CurrentUnit;
    387             const GLuint flag = TEXTURE0_3D << (curr * 4);
     379            const GLuint curr = ctx->Texture.CurrentUnit;
     380            const GLuint flag = TEXTURE0_3D << (curr * 4);
    388381            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
    389             ctx->NewState |= NEW_TEXTURE_ENABLE;
     382            ctx->NewState |= NEW_TEXTURE_ENABLE;
    390383            if (state) {
    391                texUnit->Enabled |= TEXTURE0_3D;
    392                ctx->Enabled |= flag;
    393             }
     384               texUnit->Enabled |= TEXTURE0_3D;
     385               ctx->Enabled |= flag;
     386            }
    394387            else {
    395388               texUnit->Enabled &= ~TEXTURE0_3D;
    … …  
    407400            ctx->NewState |= NEW_TEXTURING;
    408401         }
    409         break;
     402        break;
    410403      case GL_TEXTURE_GEN_R:
    411404         {
    … …  
    417410            ctx->NewState |= NEW_TEXTURING;
    418411         }
    419         break;
     412        break;
    420413      case GL_TEXTURE_GEN_S:
    421414         {
    … …  
    427420            ctx->NewState |= NEW_TEXTURING;
    428421         }
    429         break;
     422        break;
    430423      case GL_TEXTURE_GEN_T:
    431424         {
    … …  
    437430            ctx->NewState |= NEW_TEXTURING;
    438431         }
    439         break;
     432        break;
    440433
    441434      /*
    … …  
    461454         break;
    462455
     456      /* GL_HP_occlusion_test */
     457      case GL_OCCLUSION_TEST_HP:
     458         if (ctx->Extensions.HaveHpOcclusionTest) {
     459            ctx->Depth.OcclusionTest = state;
     460            ctx->NewState |= NEW_RASTER_OPS;
     461         }
     462         else {
     463            gl_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
     464            return;
     465         }
     466         break;
     467
    463468      default:
    464         if (state) {
    465             gl_error( ctx, GL_INVALID_ENUM, "glEnable" );
    466         }
    467         else {
    468             gl_error( ctx, GL_INVALID_ENUM, "glDisable" );
    469         }
     469        if (state) {
     470            gl_error( ctx, GL_INVALID_ENUM, "glEnable" );
     471        }
     472        else {
     473            gl_error( ctx, GL_INVALID_ENUM, "glDisable" );
     474        }
    470475         return;
    471476   }
    … …  
    479484
    480485
    481 void gl_Enable( GLcontext* ctx, GLenum cap )
     486void
     487_mesa_Enable( GLenum cap )
    482488{
    483    gl_set_enable( ctx, cap, GL_TRUE );
     489   GET_CURRENT_CONTEXT(ctx);
     490   _mesa_set_enable( ctx, cap, GL_TRUE );
    484491}
    485492
    486493
    487494
    488 void gl_Disable( GLcontext* ctx, GLenum cap )
     495void
     496_mesa_Disable( GLenum cap )
    489497{
    490    gl_set_enable( ctx, cap, GL_FALSE );
     498   GET_CURRENT_CONTEXT(ctx);
     499   _mesa_set_enable( ctx, cap, GL_FALSE );
    491500}
    492501
    493502
    494503
    495 GLboolean gl_IsEnabled( GLcontext* ctx, GLenum cap )
     504GLboolean
     505_mesa_IsEnabled( GLenum cap )
    496506{
     507   GET_CURRENT_CONTEXT(ctx);
    497508   switch (cap) {
    498509      case GL_ALPHA_TEST:
    499510         return ctx->Color.AlphaEnabled;
    500511      case GL_AUTO_NORMAL:
    501         return ctx->Eval.AutoNormal;
     512        return ctx->Eval.AutoNormal;
    502513      case GL_BLEND:
    503514         return ctx->Color.BlendEnabled;
    … …  
    508519      case GL_CLIP_PLANE4:
    509520      case GL_CLIP_PLANE5:
    510         return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
     521        return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
    511522      case GL_COLOR_MATERIAL:
    512         return ctx->Light.ColorMaterialEnabled;
     523        return ctx->Light.ColorMaterialEnabled;
    513524      case GL_CULL_FACE:
    514525         return ctx->Polygon.CullFlag;
    … …  
    516527         return ctx->Depth.Test;
    517528      case GL_DITHER:
    518         return ctx->Color.DitherFlag;
     529        return ctx->Color.DitherFlag;
    519530      case GL_FOG:
    520         return ctx->Fog.Enabled;
     531        return ctx->Fog.Enabled;
    521532      case GL_LIGHTING:
    522533         return ctx->Light.Enabled;
    … …  
    531542         return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
    532543      case GL_LINE_SMOOTH:
    533         return ctx->Line.SmoothFlag;
     544        return ctx->Line.SmoothFlag;
    534545      case GL_LINE_STIPPLE:
    535         return ctx->Line.StippleFlag;
     546        return ctx->Line.StippleFlag;
    536547      case GL_INDEX_LOGIC_OP:
    537         return ctx->Color.IndexLogicOpEnabled;
     548        return ctx->Color.IndexLogicOpEnabled;
    538549      case GL_COLOR_LOGIC_OP:
    539         return ctx->Color.ColorLogicOpEnabled;
     550        return ctx->Color.ColorLogicOpEnabled;
    540551      case GL_MAP1_COLOR_4:
    541         return ctx->Eval.Map1Color4;
     552        return ctx->Eval.Map1Color4;
    542553      case GL_MAP1_INDEX:
    543         return ctx->Eval.Map1Index;
     554        return ctx->Eval.Map1Index;
    544555      case GL_MAP1_NORMAL:
    545         return ctx->Eval.Map1Normal;
     556        return ctx->Eval.Map1Normal;
    546557      case GL_MAP1_TEXTURE_COORD_1:
    547         return ctx->Eval.Map1TextureCoord1;
     558        return ctx->Eval.Map1TextureCoord1;
    548559      case GL_MAP1_TEXTURE_COORD_2:
    549         return ctx->Eval.Map1TextureCoord2;
     560        return ctx->Eval.Map1TextureCoord2;
    550561      case GL_MAP1_TEXTURE_COORD_3:
    551         return ctx->Eval.Map1TextureCoord3;
     562        return ctx->Eval.Map1TextureCoord3;
    552563      case GL_MAP1_TEXTURE_COORD_4:
    553         return ctx->Eval.Map1TextureCoord4;
     564        return ctx->Eval.Map1TextureCoord4;
    554565      case GL_MAP1_VERTEX_3:
    555         return ctx->Eval.Map1Vertex3;
     566        return ctx->Eval.Map1Vertex3;
    556567      case GL_MAP1_VERTEX_4:
    557         return ctx->Eval.Map1Vertex4;
     568        return ctx->Eval.Map1Vertex4;
    558569      case GL_MAP2_COLOR_4:
    559         return ctx->Eval.Map2Color4;
     570        return ctx->Eval.Map2Color4;
    560571      case GL_MAP2_INDEX:
    561         return ctx->Eval.Map2Index;
     572        return ctx->Eval.Map2Index;
    562573      case GL_MAP2_NORMAL:
    563         return ctx->Eval.Map2Normal;
     574        return ctx->Eval.Map2Normal;
    564575      case GL_MAP2_TEXTURE_COORD_1:
    565         return ctx->Eval.Map2TextureCoord1;
     576        return ctx->Eval.Map2TextureCoord1;
    566577      case GL_MAP2_TEXTURE_COORD_2:
    567         return ctx->Eval.Map2TextureCoord2;
     578        return ctx->Eval.Map2TextureCoord2;
    568579      case GL_MAP2_TEXTURE_COORD_3:
    569         return ctx->Eval.Map2TextureCoord3;
     580        return ctx->Eval.Map2TextureCoord3;
    570581      case GL_MAP2_TEXTURE_COORD_4:
    571         return ctx->Eval.Map2TextureCoord4;
     582        return ctx->Eval.Map2TextureCoord4;
    572583      case GL_MAP2_VERTEX_3:
    573         return ctx->Eval.Map2Vertex3;
     584        return ctx->Eval.Map2Vertex3;
    574585      case GL_MAP2_VERTEX_4:
    575         return ctx->Eval.Map2Vertex4;
     586        return ctx->Eval.Map2Vertex4;
    576587      case GL_NORMALIZE:
    577         return ctx->Transform.Normalize;
     588        return ctx->Transform.Normalize;
    578589      case GL_POINT_SMOOTH:
    579         return ctx->Point.SmoothFlag;
     590        return ctx->Point.SmoothFlag;
    580591      case GL_POLYGON_SMOOTH:
    581         return ctx->Polygon.SmoothFlag;
     592        return ctx->Polygon.SmoothFlag;
    582593      case GL_POLYGON_STIPPLE:
    583         return ctx->Polygon.StippleFlag;
     594        return ctx->Polygon.StippleFlag;
    584595      case GL_POLYGON_OFFSET_POINT:
    585         return ctx->Polygon.OffsetPoint;
     596        return ctx->Polygon.OffsetPoint;
    586597      case GL_POLYGON_OFFSET_LINE:
    587         return ctx->Polygon.OffsetLine;
     598        return ctx->Polygon.OffsetLine;
    588599      case GL_POLYGON_OFFSET_FILL:
    589600      /*case GL_POLYGON_OFFSET_EXT:*/
    590         return ctx->Polygon.OffsetFill;
     601        return ctx->Polygon.OffsetFill;
    591602      case GL_RESCALE_NORMAL_EXT:
    592603         return ctx->Transform.RescaleNormals;
    593604      case GL_SCISSOR_TEST:
    594         return ctx->Scissor.Enabled;
     605        return ctx->Scissor.Enabled;
    595606      case GL_SHARED_TEXTURE_PALETTE_EXT:
    596607         return ctx->Texture.SharedPalette;
    597608      case GL_STENCIL_TEST:
    598         return ctx->Stencil.Enabled;
     609        return ctx->Stencil.Enabled;
    599610      case GL_TEXTURE_1D:
    600611         {
    … …  
    648659      case GL_EDGE_FLAG_ARRAY:
    649660         return ctx->Array.EdgeFlag.Enabled;
     661
     662      /* GL_HP_occlusion_test */
     663      case GL_OCCLUSION_TEST_HP:
     664         if (ctx->Extensions.HaveHpOcclusionTest) {
     665            return ctx->Depth.OcclusionTest;
     666         }
     667         else {
     668            gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
     669            return GL_FALSE;
     670         }
     671
    650672      default:
    651         gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
    652         return GL_FALSE;
     673        gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
     674        return GL_FALSE;
    653675   }
    654676}
    … …  
    657679
    658680
    659 static void gl_client_state( GLcontext *ctx, GLenum cap, GLboolean state )
     681static void
     682client_state( GLcontext *ctx, GLenum cap, GLboolean state )
    660683{
    661684   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx,
    662                                        (state
    663                                         ? "glEnableClientState"
    664                                         : "glDisableClientState") );
     685                                       (state
     686                                        ? "glEnableClientState"
     687                                        : "glDisableClientState") );
    665688
    666689   switch (cap) {
    … …  
    692715
    693716
    694 void gl_EnableClientState( GLcontext *ctx, GLenum cap )
     717void
     718_mesa_EnableClientState( GLenum cap )
    695719{
    696    gl_client_state( ctx, cap, GL_TRUE );
     720   GET_CURRENT_CONTEXT(ctx);
     721   client_state( ctx, cap, GL_TRUE );
    697722}
    698723
    699724
    700725
    701 void gl_DisableClientState( GLcontext *ctx, GLenum cap )
     726void
     727_mesa_DisableClientState( GLenum cap )
    702728{
    703    gl_client_state( ctx, cap, GL_FALSE );
     729   GET_CURRENT_CONTEXT(ctx);
     730   client_state( ctx, cap, GL_FALSE );
    704731}
    705732
Note: See TracChangeset for help on using the changeset viewer.