nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "stdopengl.h"
+00027 
+00028 
+00029 // ***************************************************************************
+00030 // define it For Debug purpose only. Normal use is to hide this line
+00031 //#define               NL3D_GLSTATE_DISABLE_CACHE
+00032 
+00033 namespace NL3D 
+00034 {
+00035 
+00036 // ***************************************************************************
+00037         CDriverGLStates::CDriverGLStates()
+00038 {
+00039         _TextureCubeMapSupported= false;
+00040 }
+00041 
+00042 
+00043 // ***************************************************************************
+00044 void                    CDriverGLStates::init(bool supportTextureCubeMap)
+00045 {
+00046         _TextureCubeMapSupported= supportTextureCubeMap;
+00047 
+00048         // By default all arrays are disabled.
+00049         _VertexArrayEnabled= false;
+00050         _NormalArrayEnabled= false;
+00051         _WeightArrayEnabled= false;
+00052         _ColorArrayEnabled= false;      
+00053         _SecondaryColorArrayEnabled= false;
+00054         uint    i;
+00055         for(i=0; i<IDRV_MAT_MAXTEXTURES; i++)
+00056         {
+00057                 _TexCoordArrayEnabled[i]= false;
+00058         }
+00059         for(i=0; i<CVertexBuffer::NumValue; i++)
+00060         {
+00061                 _VertexAttribArrayEnabled[i]= false;
+00062         }
+00063 }
+00064 
+00065 
+00066 // ***************************************************************************
+00067 void                    CDriverGLStates::forceDefaults(uint nbStages)
+00068 {
+00069         // Enable / disable.
+00070         _CurBlend= false;
+00071         _CurCullFace= true;
+00072         _CurAlphaTest= false;
+00073         _CurLighting= false;
+00074         _CurZWrite= true;
+00075         // setup GLStates.
+00076         glDisable(GL_BLEND);
+00077         glEnable(GL_CULL_FACE);
+00078         glDisable(GL_ALPHA_TEST);
+00079         glDisable(GL_LIGHTING);
+00080         glDepthMask(GL_TRUE);
+00081 
+00082         // Func.
+00083         _CurBlendSrc= GL_SRC_ALPHA;
+00084         _CurBlendDst= GL_ONE_MINUS_SRC_ALPHA;
+00085         _CurDepthFunc= GL_LEQUAL;
+00086         _CurAlphaTestThreshold= 0.5f;
+00087         // setup GLStates.
+00088         glBlendFunc(_CurBlendSrc, _CurBlendDst);
+00089         glDepthFunc(_CurDepthFunc);
+00090         glAlphaFunc(GL_GREATER, _CurAlphaTestThreshold);
+00091 
+00092         // Materials.
+00093         uint32                  packedOne= (CRGBA(255,255,255,255)).getPacked();
+00094         uint32                  packedZero= (CRGBA(0,0,0,255)).getPacked();
+00095         _CurEmissive= packedZero;
+00096         _CurAmbient= packedOne;
+00097         _CurDiffuse= packedOne;
+00098         _CurSpecular= packedZero;
+00099         _CurShininess= 1;
+00100 
+00101         // Lighted vertex color
+00102         _VertexColorLighted=false;
+00103         glDisable(GL_COLOR_MATERIAL);
+00104 
+00105         // setup GLStates.
+00106         static const GLfloat            one[4]= {1,1,1,1};
+00107         static const GLfloat            zero[4]= {0,0,0,1};
+00108         glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, zero);
+00109         glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, one);
+00110         glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, one);
+00111         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, zero);
+00112         glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, _CurShininess);
+00113         
+00114 
+00115         // TexModes
+00116         uint stage;
+00117         for(stage=0;stage<nbStages; stage++)
+00118         {
+00119                 // disable texturing.
+00120                 nglActiveTextureARB(GL_TEXTURE0_ARB+stage);
+00121                 glDisable(GL_TEXTURE_2D);
+00122                 if(_TextureCubeMapSupported)
+00123                         glDisable(GL_TEXTURE_CUBE_MAP_ARB);
+00124                 _TextureMode[stage]= TextureDisabled;
+00125 
+00126                 // Tex gen init
+00127                 _TexGen[stage] = false;
+00128                 _TexGenMode[stage] = GL_SPHERE_MAP;
+00129                 glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
+00130                 glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
+00131                 glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
+00132                 glDisable( GL_TEXTURE_GEN_S );
+00133                 glDisable( GL_TEXTURE_GEN_T );
+00134                 glDisable( GL_TEXTURE_GEN_R );
+00135         }
+00136 
+00137         // ActiveTexture current texture to 0.
+00138         nglActiveTextureARB(GL_TEXTURE0_ARB);
+00139         _CurrentActiveTextureARB= 0;
+00140         nglClientActiveTextureARB(GL_TEXTURE0_ARB);
+00141         _CurrentClientActiveTextureARB= 0;
+00142 
+00143         // Depth range
+00144         _CurZRangeDelta = 0;
+00145         glDepthRange (0, 1);
+00146 }
+00147 
+00148 
+00149 
+00150 // ***************************************************************************
+00151 void                    CDriverGLStates::enableBlend(uint enable)
+00152 {
+00153         // If different from current setup, update.
+00154         bool    enabled= (enable!=0);
+00155 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00156         if( enabled != _CurBlend )
+00157 #endif
+00158         {
+00159                 // new state.
+00160                 _CurBlend= enabled;
+00161                 // Setup GLState.
+00162                 if(_CurBlend)
+00163                         glEnable(GL_BLEND);
+00164                 else
+00165                         glDisable(GL_BLEND);
+00166         }
+00167 }
+00168 
+00169 // ***************************************************************************
+00170 void                    CDriverGLStates::enableCullFace(uint enable)
+00171 {
+00172         // If different from current setup, update.
+00173         bool    enabled= (enable!=0);
+00174 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00175         if( enabled != _CurCullFace )
+00176 #endif
+00177         {
+00178                 // new state.
+00179                 _CurCullFace= enabled;
+00180                 // Setup GLState.
+00181                 if(_CurCullFace)
+00182                         glEnable(GL_CULL_FACE);
+00183                 else
+00184                         glDisable(GL_CULL_FACE);
+00185         }
+00186 }
+00187 
+00188 // ***************************************************************************
+00189 void                    CDriverGLStates::enableAlphaTest(uint enable)
+00190 {
+00191         // If different from current setup, update.
+00192         bool    enabled= (enable!=0);
+00193 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00194         if( enabled != _CurAlphaTest )
+00195 #endif
+00196         {
+00197                 // new state.
+00198                 _CurAlphaTest= enabled;
+00199 
+00200                 // Setup GLState.
+00201                 if(_CurAlphaTest)
+00202                 {
+00203                         glEnable(GL_ALPHA_TEST);
+00204                 }
+00205                 else
+00206                 {
+00207                         glDisable(GL_ALPHA_TEST);
+00208                 }
+00209         }
+00210 }
+00211 
+00212 // ***************************************************************************
+00213 void                    CDriverGLStates::enableLighting(uint enable)
+00214 {
+00215         // If different from current setup, update.
+00216         bool    enabled= (enable!=0);
+00217 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00218         if( enabled != _CurLighting )
+00219 #endif
+00220         {
+00221                 // new state.
+00222                 _CurLighting= enabled;
+00223                 // Setup GLState.
+00224                 if(_CurLighting)
+00225                         glEnable(GL_LIGHTING);
+00226                 else
+00227                         glDisable(GL_LIGHTING);
+00228         }
+00229 }
+00230 
+00231 // ***************************************************************************
+00232 void                    CDriverGLStates::enableZWrite(uint enable)
+00233 {
+00234         // If different from current setup, update.
+00235         bool    enabled= (enable!=0);
+00236 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00237         if( enabled != _CurZWrite )
+00238 #endif
+00239         {
+00240                 // new state.
+00241                 _CurZWrite= enabled;
+00242                 // Setup GLState.
+00243                 if(_CurZWrite)
+00244                         glDepthMask(GL_TRUE);
+00245                 else
+00246                         glDepthMask(GL_FALSE);
+00247         }
+00248 }
+00249 
+00250 
+00251 
+00252 // ***************************************************************************
+00253 void                    CDriverGLStates::blendFunc(GLenum src, GLenum dst)
+00254 {
+00255         // If different from current setup, update.
+00256 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00257         if( src!= _CurBlendSrc || dst!=_CurBlendDst )
+00258 #endif
+00259         {
+00260                 // new state.
+00261                 _CurBlendSrc= src;
+00262                 _CurBlendDst= dst;
+00263                 // Setup GLState.
+00264                 glBlendFunc(_CurBlendSrc, _CurBlendDst);
+00265         }
+00266 }
+00267 
+00268 // ***************************************************************************
+00269 void                    CDriverGLStates::depthFunc(GLenum zcomp)
+00270 {
+00271         // If different from current setup, update.
+00272 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00273         if( zcomp != _CurDepthFunc )
+00274 #endif
+00275         {
+00276                 // new state.
+00277                 _CurDepthFunc= zcomp;
+00278                 // Setup GLState.
+00279                 glDepthFunc(_CurDepthFunc);
+00280         }
+00281 }
+00282 
+00283 
+00284 // ***************************************************************************
+00285 void                    CDriverGLStates::alphaFunc(float threshold)
+00286 {
+00287 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00288         if(threshold != _CurAlphaTestThreshold)
+00289 #endif
+00290         {
+00291                 // new state
+00292                 _CurAlphaTestThreshold= threshold;
+00293                 // setup function.
+00294                 glAlphaFunc(GL_GREATER, _CurAlphaTestThreshold);
+00295         }
+00296 }
+00297 
+00298 
+00299 // ***************************************************************************
+00300 void                    CDriverGLStates::setEmissive(uint32 packedColor, const GLfloat color[4])
+00301 {
+00302 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00303         if( packedColor!=_CurEmissive )
+00304 #endif
+00305         {
+00306                 _CurEmissive= packedColor;
+00307                 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
+00308         }
+00309 }
+00310 
+00311 // ***************************************************************************
+00312 void                    CDriverGLStates::setAmbient(uint32 packedColor, const GLfloat color[4])
+00313 {
+00314 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00315         if( packedColor!=_CurAmbient )
+00316 #endif
+00317         {
+00318                 _CurAmbient= packedColor;
+00319                 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
+00320         }
+00321 }
+00322 
+00323 // ***************************************************************************
+00324 void                    CDriverGLStates::setDiffuse(uint32 packedColor, const GLfloat color[4])
+00325 {
+00326 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00327         if( packedColor!=_CurDiffuse )
+00328 #endif
+00329         {
+00330                 _CurDiffuse= packedColor;
+00331                 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
+00332         }
+00333 }
+00334 
+00335 // ***************************************************************************
+00336 void                    CDriverGLStates::setSpecular(uint32 packedColor, const GLfloat color[4])
+00337 {
+00338 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00339         if( packedColor!=_CurSpecular )
+00340 #endif
+00341         {
+00342                 _CurSpecular= packedColor;
+00343                 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
+00344         }
+00345 }
+00346 
+00347 // ***************************************************************************
+00348 void                    CDriverGLStates::setShininess(float shin)
+00349 {
+00350 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00351         if( shin != _CurShininess )
+00352 #endif
+00353         {
+00354                 _CurShininess= shin;
+00355                 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shin);
+00356         }
+00357 }
+00358 
+00359 
+00360 // ***************************************************************************
+00361 static void     convColor(CRGBA col, GLfloat glcol[4])
+00362 {
+00363         static  const float     OO255= 1.0f/255;
+00364         glcol[0]= col.R*OO255;
+00365         glcol[1]= col.G*OO255;
+00366         glcol[2]= col.B*OO255;
+00367         glcol[3]= col.A*OO255;
+00368 }
+00369 
+00370 // ***************************************************************************
+00371 void                    CDriverGLStates::setVertexColorLighted(bool enable)
+00372 {
+00373 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00374         if( enable != _VertexColorLighted)
+00375 #endif
+00376         {
+00377                 _VertexColorLighted= enable;
+00378 
+00379                 if (_VertexColorLighted)
+00380                 {
+00381                         glEnable (GL_COLOR_MATERIAL);
+00382                         glColorMaterial (GL_FRONT_AND_BACK, GL_DIFFUSE);
+00383                 }
+00384                 else
+00385                 {
+00386                         glDisable (GL_COLOR_MATERIAL);
+00387                         // Since we leave glColorMaterial mode, GL diffuse is now scracth. reset him to current value.
+00388                         CRGBA   diffCol;
+00389                         diffCol.R= (uint8)((_CurDiffuse >> 24) & 255);
+00390                         diffCol.G= (uint8)((_CurDiffuse >> 16) & 255);
+00391                         diffCol.B= (uint8)((_CurDiffuse >>  8) & 255);
+00392                         diffCol.A= (uint8)((_CurDiffuse      ) & 255);
+00393                         GLfloat glColor[4];
+00394                         convColor(diffCol, glColor);
+00395                         glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, glColor);
+00396                 }
+00397         }
+00398 }
+00399 
+00400 // ***************************************************************************
+00401 void            CDriverGLStates::setDepthRange (float zDelta)
+00402 {
+00403 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00404         if (zDelta != _CurZRangeDelta)
+00405 #endif
+00406         {               
+00407                 _CurZRangeDelta = zDelta;
+00408 
+00409                 // Setup the range
+00410                 glDepthRange (zDelta, 1+zDelta);
+00411         }
+00412 }
+00413 
+00414 // ***************************************************************************
+00415 void            CDriverGLStates::enableTexGen (uint stage, bool enable)
+00416 {
+00417 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00418         if (enable != _TexGen[stage])
+00419 #endif
+00420         {               
+00421                 _TexGen[stage] = enable;
+00422 
+00423                 // Enable the tex gen
+00424                 if (_TexGen[stage])
+00425                 {
+00426                         glEnable( GL_TEXTURE_GEN_S );
+00427                         glEnable( GL_TEXTURE_GEN_T );
+00428                         glEnable( GL_TEXTURE_GEN_R );
+00429                 }
+00430                 else
+00431                 {
+00432                         glDisable( GL_TEXTURE_GEN_S );
+00433                         glDisable( GL_TEXTURE_GEN_T );
+00434                         glDisable( GL_TEXTURE_GEN_R );
+00435                 }
+00436         }
+00437 }
+00438 
+00439 // ***************************************************************************
+00440 void            CDriverGLStates::setTexGenMode (uint stage, GLint mode)
+00441 {
+00442 #ifndef NL3D_GLSTATE_DISABLE_CACHE
+00443         if (mode != _TexGenMode[stage])
+00444 #endif
+00445         {               
+00446                 _TexGenMode[stage] = mode;
+00447 
+00448                 glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, mode);
+00449                 glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, mode);
+00450                 glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, mode);
+00451         }
+00452 }
+00453 
+00454 
+00455 
+00456 
+00457 // ***************************************************************************
+00458 void                    CDriverGLStates::resetTextureMode()
+00459 {
+00460         glDisable(GL_TEXTURE_2D);
+00461         if (_TextureCubeMapSupported)
+00462         {
+00463                 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
+00464         }
+00465         _TextureMode[_CurrentActiveTextureARB]= TextureDisabled;
+00466 }
+00467 
+00468 
+00469 // ***************************************************************************
+00470 void                    CDriverGLStates::setTextureMode(TTextureMode texMode)
+00471 {       
+00472         TTextureMode    oldTexMode = _TextureMode[_CurrentActiveTextureARB];
+00473         if(oldTexMode != texMode)
+00474         {
+00475                 // Disable first old mode.
+00476                 if(oldTexMode == Texture2D)
+00477                         glDisable(GL_TEXTURE_2D);
+00478                 else if(oldTexMode == TextureCubeMap)
+00479                 {
+00480                         if(_TextureCubeMapSupported)
+00481                                 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
+00482                         else
+00483                                 glDisable(GL_TEXTURE_2D);
+00484                 }
+00485 
+00486                 // Enable new mode.
+00487                 if(texMode == Texture2D)
+00488                         glEnable(GL_TEXTURE_2D);
+00489                 else if(texMode == TextureCubeMap)
+00490                 {
+00491                         if(_TextureCubeMapSupported)
+00492                                 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
+00493                         else
+00494                                 glDisable(GL_TEXTURE_2D);
+00495                 }
+00496 
+00497                 // new mode.
+00498                 _TextureMode[_CurrentActiveTextureARB]= texMode;
+00499         }
+00500 }
+00501 
+00502 
+00503 // ***************************************************************************
+00504 void                    CDriverGLStates::activeTextureARB(uint stage)
+00505 {
+00506         if( _CurrentActiveTextureARB != stage )
+00507         {
+00508                 nglActiveTextureARB(GL_TEXTURE0_ARB+stage);
+00509                 _CurrentActiveTextureARB= stage;
+00510         }
+00511 }
+00512 
+00513 // ***************************************************************************
+00514 void                    CDriverGLStates::forceActiveTextureARB(uint stage)
+00515 {       
+00516         nglActiveTextureARB(GL_TEXTURE0_ARB+stage);
+00517         _CurrentActiveTextureARB= stage;        
+00518 }
+00519 
+00520 
+00521 // ***************************************************************************
+00522 void                    CDriverGLStates::enableVertexArray(bool enable)
+00523 {
+00524         if(_VertexArrayEnabled != enable)
+00525         {
+00526                 if(enable)
+00527                         glEnableClientState(GL_VERTEX_ARRAY);
+00528                 else
+00529                         glDisableClientState(GL_VERTEX_ARRAY);
+00530                 _VertexArrayEnabled= enable;
+00531         }
+00532 }
+00533 // ***************************************************************************
+00534 void                    CDriverGLStates::enableNormalArray(bool enable)
+00535 {
+00536         if(_NormalArrayEnabled != enable)
+00537         {
+00538                 if(enable)
+00539                         glEnableClientState(GL_NORMAL_ARRAY);
+00540                 else
+00541                         glDisableClientState(GL_NORMAL_ARRAY);
+00542                 _NormalArrayEnabled= enable;
+00543         }
+00544 }
+00545 // ***************************************************************************
+00546 void                    CDriverGLStates::enableWeightArray(bool enable)
+00547 {
+00548         if(_WeightArrayEnabled != enable)
+00549         {
+00550                 if(enable)
+00551                         glEnableClientState(GL_VERTEX_WEIGHTING_EXT);
+00552                 else
+00553                         glDisableClientState(GL_VERTEX_WEIGHTING_EXT);
+00554                 _WeightArrayEnabled= enable;
+00555         }
+00556 }
+00557 // ***************************************************************************
+00558 void                    CDriverGLStates::enableColorArray(bool enable)
+00559 {
+00560         if(_ColorArrayEnabled != enable)
+00561         {
+00562                 if(enable)
+00563                         glEnableClientState(GL_COLOR_ARRAY);
+00564                 else
+00565                         glDisableClientState(GL_COLOR_ARRAY);
+00566                 _ColorArrayEnabled= enable;
+00567         }
+00568 }
+00569 
+00570 
+00571 // ***************************************************************************
+00572 void                    CDriverGLStates::enableSecondaryColorArray(bool enable)
+00573 {
+00574         if(_SecondaryColorArrayEnabled != enable)
+00575         {
+00576                 if(enable)
+00577                         glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
+00578                 else
+00579                         glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
+00580                 _SecondaryColorArrayEnabled= enable;
+00581         }
+00582 }
+00583 
+00584 // ***************************************************************************
+00585 void                    CDriverGLStates::clientActiveTextureARB(uint stage)
+00586 {
+00587         if( _CurrentClientActiveTextureARB != stage )
+00588         {
+00589                 nglClientActiveTextureARB(GL_TEXTURE0_ARB+stage);
+00590                 _CurrentClientActiveTextureARB= stage;
+00591         }
+00592 }
+00593 
+00594 // ***************************************************************************
+00595 void                    CDriverGLStates::enableTexCoordArray(bool enable)
+00596 {
+00597         if(_TexCoordArrayEnabled[_CurrentClientActiveTextureARB] != enable)
+00598         {
+00599                 if(enable)
+00600                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+00601                 else
+00602                         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+00603                 _TexCoordArrayEnabled[_CurrentClientActiveTextureARB]= enable;
+00604         }
+00605 }
+00606 
+00607 // ***************************************************************************
+00608 void                    CDriverGLStates::enableVertexAttribArray(uint glIndex, bool enable)
+00609 {
+00610         if(_VertexAttribArrayEnabled[glIndex] != enable)
+00611         {
+00612                 if(enable)
+00613                         glEnableClientState(glIndex+GL_VERTEX_ATTRIB_ARRAY0_NV);
+00614                 else
+00615                         glDisableClientState(glIndex+GL_VERTEX_ATTRIB_ARRAY0_NV);
+00616                 _VertexAttribArrayEnabled[glIndex]= enable;
+00617         }
+00618 }
+00619 
+00620 
+00621 // ***************************************************************************
+00622 void CDriverGLStates::enableVertexAttribArrayForEXTVertexShader(uint glIndex, bool enable, uint *variants)
+00623 {
+00624         if(_VertexAttribArrayEnabled[glIndex] != enable)
+00625         {               
+00626                 switch(glIndex)
+00627                 {
+00628                         case 0: // position 
+00629                                 enableVertexArray(enable);
+00630                         break;
+00631                         case 1: // skin weight
+00632                                 if(enable)
+00633                                         nglEnableVariantClientStateEXT(variants[CDriverGL::EVSSkinWeightVariant]);
+00634                                 else
+00635                                         nglDisableVariantClientStateEXT(variants[CDriverGL::EVSSkinWeightVariant]);     
+00636                         break;
+00637                         case 2: // normal
+00638                                 enableNormalArray(enable);
+00639                         break;
+00640                         case 3: // color
+00641                                 enableColorArray(enable);
+00642                         break;
+00643                         case 4: // secondary color
+00644                                 if(enable)
+00645                                         nglEnableVariantClientStateEXT(variants[CDriverGL::EVSSecondaryColorVariant]);
+00646                                 else
+00647                                         nglDisableVariantClientStateEXT(variants[CDriverGL::EVSSecondaryColorVariant]); 
+00648                         break;
+00649                         case 5: // fog coordinate
+00650                                 if(enable)
+00651                                         nglEnableVariantClientStateEXT(variants[CDriverGL::EVSFogCoordsVariant]);
+00652                                 else
+00653                                         nglDisableVariantClientStateEXT(variants[CDriverGL::EVSFogCoordsVariant]);
+00654                         break;
+00655                         case 6: // palette skin
+00656                                 if(enable)
+00657                                         nglEnableVariantClientStateEXT(variants[CDriverGL::EVSPaletteSkinVariant]);
+00658                                 else
+00659                                         nglDisableVariantClientStateEXT(variants[CDriverGL::EVSPaletteSkinVariant]);
+00660                         break;
+00661                         case 7: // empty
+00662                                 nlstop
+00663                         break;
+00664                         case 8:
+00665                         case 9:
+00666                         case 10:
+00667                         case 11:
+00668                         case 12:
+00669                         case 13:
+00670                         case 14:
+00671                         case 15:
+00672                                 clientActiveTextureARB(glIndex - 8);
+00673                                 enableTexCoordArray(enable);
+00674                         break;
+00675                         default:
+00676                                 nlstop; // invalid value
+00677                         break;
+00678                 }               
+00679                 _VertexAttribArrayEnabled[glIndex]= enable;
+00680         }       
+00681 }
+00682 
+00683 
+00684 
+00685 } // NL3D
+
driver_opengl_states.cpp
