Show
Ignore:
Timestamp:
03/21/12 18:36:20 (2 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osg/Texture.cpp

    r12993 r13041  
    11/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
    22 * 
    3  * This library is open source and may be redistributed and/or modified under   
    4  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or  
     3 * This library is open source and may be redistributed and/or modified under 
     4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
    55 * (at your option) any later version.  The full license is in LICENSE file 
    66 * included with this distribution, and on the openscenegraph.org website. 
    7  *  
     7 * 
    88 * This library is distributed in the hope that it will be useful, 
    99 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1111 * OpenSceneGraph Public License for more details. 
    1212*/ 
     
    436436        static_cast<unsigned int>(ceil(double(sizeRequired) / double(_profile._size))): 
    437437        _orphanedTextureObjects.size(); 
    438          
     438 
    439439    OSG_INFO<<"_parent->getCurrTexturePoolSize()="<<_parent->getCurrTexturePoolSize() <<" _parent->getMaxTexturePoolSize()="<< _parent->getMaxTexturePoolSize()<<std::endl; 
    440440    OSG_INFO<<"Looking to reclaim "<<sizeRequired<<", going to look to remove "<<maxNumObjectsToDelete<<" from "<<_orphanedTextureObjects.size()<<" orhpans"<<std::endl; 
     
    810810} 
    811811 
    812 Texture::TextureObject* Texture::TextureObjectManager::generateTextureObject(const Texture* texture,  
     812Texture::TextureObject* Texture::TextureObjectManager::generateTextureObject(const Texture* texture, 
    813813                                             GLenum    target, 
    814814                                             GLint     numMipmapLevels, 
     
    11561156 
    11571157    COMPARE_StateAttribute_Parameter(_internalFormatType); 
    1158      
     1158 
    11591159    return 0; 
    11601160} 
     
    11621162int Texture::compareTextureObjects(const Texture& rhs) const 
    11631163{ 
    1164     if (_textureObjectBuffer.size()<rhs._textureObjectBuffer.size()) return -1;  
     1164    if (_textureObjectBuffer.size()<rhs._textureObjectBuffer.size()) return -1; 
    11651165    if (rhs._textureObjectBuffer.size()<_textureObjectBuffer.size()) return 1; 
    11661166    for(unsigned int i=0; i<_textureObjectBuffer.size(); ++i) 
     
    11811181        default : OSG_WARN<<"Error: invalid 'which' passed Texture::setWrap("<<(unsigned int)which<<","<<(unsigned int)wrap<<")"<<std::endl; break; 
    11821182    } 
    1183      
     1183 
    11841184} 
    11851185 
     
    12221222    if (_maxAnisotropy!=anis) 
    12231223    { 
    1224         _maxAnisotropy = anis;  
     1224        _maxAnisotropy = anis; 
    12251225        dirtyTextureParameters(); 
    12261226    } 
     
    13091309                switch(image.getPixelFormat()) 
    13101310                { 
    1311                     case(3):         
    1312                     case(4):         
    1313                     case(GL_RGB):    
     1311                    case(3): 
     1312                    case(4): 
     1313                    case(GL_RGB): 
    13141314                    case(GL_RGBA):  internalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; break; 
    13151315                    default:        internalFormat = image.getInternalTextureFormat(); break; 
     
    13231323                switch(image.getPixelFormat()) 
    13241324                { 
    1325                     case(3):         
    1326                     case(4):         
    1327                     case(GL_RGB):    
     1325                    case(3): 
     1326                    case(4): 
     1327                    case(GL_RGB): 
    13281328                    case(GL_RGBA):  internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break; 
    13291329                    default:        internalFormat = image.getInternalTextureFormat(); break; 
     
    14131413            } 
    14141414            break; 
    1415              
     1415 
    14161416        case(USE_RGTC2_COMPRESSION): 
    14171417            if (extensions->isTextureCompressionRGTCSupported()) 
     
    14321432        } 
    14331433    } 
    1434      
     1434 
    14351435    _internalFormat = internalFormat; 
    14361436 
     
    14421442 
    14431443    computeInternalFormatType(); 
    1444      
     1444 
    14451445    //OSG_NOTICE<<"Internal format="<<std::hex<<internalFormat<<std::dec<<std::endl; 
    14461446} 
     
    14521452    // (i.e. rgba integer texture --> _sourceFormat = GL_RGBA_INTEGER_EXT) 
    14531453    // Should we do this?  ( Art, 09. Sept. 2007) 
    1454      
     1454 
    14551455    // compute internal format type based on the internal format 
    14561456    switch(_internalFormat) 
     
    14641464        case GL_RGB8UI_EXT: 
    14651465 
    1466         case GL_LUMINANCE32UI_EXT:   
    1467         case GL_LUMINANCE16UI_EXT:    
    1468         case GL_LUMINANCE8UI_EXT:     
    1469  
    1470         case GL_INTENSITY32UI_EXT:     
    1471         case GL_INTENSITY16UI_EXT:     
    1472         case GL_INTENSITY8UI_EXT:    
    1473  
    1474         case GL_LUMINANCE_ALPHA32UI_EXT:     
    1475         case GL_LUMINANCE_ALPHA16UI_EXT:     
    1476         case GL_LUMINANCE_ALPHA8UI_EXT :    
     1466        case GL_LUMINANCE32UI_EXT: 
     1467        case GL_LUMINANCE16UI_EXT: 
     1468        case GL_LUMINANCE8UI_EXT: 
     1469 
     1470        case GL_INTENSITY32UI_EXT: 
     1471        case GL_INTENSITY16UI_EXT: 
     1472        case GL_INTENSITY8UI_EXT: 
     1473 
     1474        case GL_LUMINANCE_ALPHA32UI_EXT: 
     1475        case GL_LUMINANCE_ALPHA16UI_EXT: 
     1476        case GL_LUMINANCE_ALPHA8UI_EXT : 
    14771477            _internalFormatType = UNSIGNED_INTEGER; 
    14781478            break; 
     
    14861486        case GL_RGB8I_EXT: 
    14871487 
    1488         case GL_LUMINANCE32I_EXT:     
    1489         case GL_LUMINANCE16I_EXT:     
    1490         case GL_LUMINANCE8I_EXT:     
    1491  
    1492         case GL_INTENSITY32I_EXT:     
    1493         case GL_INTENSITY16I_EXT:     
    1494         case GL_INTENSITY8I_EXT:     
    1495  
    1496         case GL_LUMINANCE_ALPHA32I_EXT:     
    1497         case GL_LUMINANCE_ALPHA16I_EXT:     
    1498         case GL_LUMINANCE_ALPHA8I_EXT:     
     1488        case GL_LUMINANCE32I_EXT: 
     1489        case GL_LUMINANCE16I_EXT: 
     1490        case GL_LUMINANCE8I_EXT: 
     1491 
     1492        case GL_INTENSITY32I_EXT: 
     1493        case GL_INTENSITY16I_EXT: 
     1494        case GL_INTENSITY8I_EXT: 
     1495 
     1496        case GL_LUMINANCE_ALPHA32I_EXT: 
     1497        case GL_LUMINANCE_ALPHA16I_EXT: 
     1498        case GL_LUMINANCE_ALPHA8I_EXT: 
    14991499            _internalFormatType = SIGNED_INTEGER; 
    15001500            break; 
    1501          
     1501 
    15021502        case GL_RGBA32F_ARB: 
    15031503        case GL_RGBA16F_ARB: 
     
    15071507 
    15081508        case GL_LUMINANCE32F_ARB: 
    1509         case GL_LUMINANCE16F_ARB:     
     1509        case GL_LUMINANCE16F_ARB: 
    15101510 
    15111511        case GL_INTENSITY32F_ARB: 
    1512         case GL_INTENSITY16F_ARB:     
     1512        case GL_INTENSITY16F_ARB: 
    15131513 
    15141514        case GL_LUMINANCE_ALPHA32F_ARB: 
    1515         case GL_LUMINANCE_ALPHA16F_ARB:     
     1515        case GL_LUMINANCE_ALPHA16F_ARB: 
    15161516            _internalFormatType = FLOAT; 
    15171517            break; 
    1518              
     1518 
    15191519        default: 
    15201520            _internalFormatType = NORMALIZED; 
     
    15461546        case(GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT): 
    15471547        case(GL_COMPRESSED_RED_GREEN_RGTC2_EXT): 
    1548         case(GL_ETC1_RGB8_OES):   
     1548        case(GL_ETC1_RGB8_OES): 
    15491549        case(GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG): 
    15501550        case(GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG): 
     
    15681568        blockSize = 8; 
    15691569    else if (internalFormat == GL_COMPRESSED_RED_GREEN_RGTC2_EXT || internalFormat == GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT) 
    1570         blockSize = 16;     
     1570        blockSize = 16; 
    15711571    else if (internalFormat == GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG || internalFormat == GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG) 
    15721572    { 
     
    15751575         GLint heightBlocks = height / 4; 
    15761576         GLint bpp = 2; 
    1577           
     1577 
    15781578         // Clamp to minimum number of blocks 
    15791579         if(widthBlocks < 2) 
     
    15811581         if(heightBlocks < 2) 
    15821582             heightBlocks = 2; 
    1583           
    1584          size = widthBlocks * heightBlocks * ((blockSize  * bpp) / 8);     
     1583 
     1584         size = widthBlocks * heightBlocks * ((blockSize  * bpp) / 8); 
    15851585         return; 
    15861586     } 
     
    15911591         GLint heightBlocks = height / 4; 
    15921592         GLint bpp = 4; 
    1593           
     1593 
    15941594         // Clamp to minimum number of blocks 
    15951595         if(widthBlocks < 2) 
     
    15971597         if(heightBlocks < 2) 
    15981598             heightBlocks = 2; 
    1599           
    1600          size = widthBlocks * heightBlocks * ((blockSize  * bpp) / 8);     
     1599 
     1600         size = widthBlocks * heightBlocks * ((blockSize  * bpp) / 8); 
    16011601         return; 
    16021602    } 
     
    16061606        blockSize = 0; 
    16071607    } 
    1608           
    1609     size = ((width+3)/4)*((height+3)/4)*depth*blockSize;         
     1608 
     1609    size = ((width+3)/4)*((height+3)/4)*depth*blockSize; 
    16101610} 
    16111611 
    16121612void Texture::applyTexParameters(GLenum target, State& state) const 
    16131613{ 
    1614     // get the contextID (user defined ID of 0 upwards) for the  
     1614    // get the contextID (user defined ID of 0 upwards) for the 
    16151615    // current OpenGL context. 
    16161616    const unsigned int contextID = state.getContextID(); 
     
    16511651    } 
    16521652 
    1653     #if defined(OSG_GLES1_AVAILABLE) || defined(OSG_GLES2_AVAILABLE)  
     1653    #if defined(OSG_GLES1_AVAILABLE) || defined(OSG_GLES2_AVAILABLE) 
    16541654        if (ws == CLAMP) ws = CLAMP_TO_EDGE; 
    16551655        if (wt == CLAMP) wt = CLAMP_TO_EDGE; 
    16561656        if (wr == CLAMP) wr = CLAMP_TO_EDGE; 
    16571657    #endif 
    1658      
     1658 
    16591659    const Image * image = getImage(0); 
    16601660    if( image && 
     
    16631663        int( image->getNumMipmapLevels() ) < 
    16641664            Image::computeNumberOfMipmapLevels( image->s(), image->t(), image->r() ) ) 
    1665             glTexParameteri( target, GL_TEXTURE_MAX_LEVEL, image->getNumMipmapLevels() - 1 );     
     1665            glTexParameteri( target, GL_TEXTURE_MAX_LEVEL, image->getNumMipmapLevels() - 1 ); 
    16661666 
    16671667 
    16681668    glTexParameteri( target, GL_TEXTURE_WRAP_S, ws ); 
    1669      
     1669 
    16701670    if (target!=GL_TEXTURE_1D) glTexParameteri( target, GL_TEXTURE_WRAP_T, wt ); 
    1671      
     1671 
    16721672    if (target==GL_TEXTURE_3D) glTexParameteri( target, GL_TEXTURE_WRAP_R, wr ); 
    16731673 
    1674      
     1674 
    16751675    glTexParameteri( target, GL_TEXTURE_MIN_FILTER, _min_filter); 
    16761676    glTexParameteri( target, GL_TEXTURE_MAG_FILTER, _mag_filter); 
     
    17091709    // integer textures are not supported by the shadow 
    17101710    // GL_TEXTURE_1D_ARRAY_EXT could be included in the check below but its not yet implemented in OSG 
    1711     if (extensions->isShadowSupported() &&  
     1711    if (extensions->isShadowSupported() && 
    17121712        (target == GL_TEXTURE_2D || target == GL_TEXTURE_1D || target == GL_TEXTURE_RECTANGLE || target == GL_TEXTURE_CUBE_MAP || target == GL_TEXTURE_2D_ARRAY_EXT ) && 
    17131713        _internalFormatType != SIGNED_INTEGER && _internalFormatType != UNSIGNED_INTEGER) 
     
    17261726            } 
    17271727        } 
    1728         else  
     1728        else 
    17291729        { 
    17301730            glTexParameteri(target, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE); 
     
    17601760    inwidth = width; 
    17611761    inheight = height; 
    1762      
     1762 
    17631763    if( _min_filter == LINEAR || _min_filter == NEAREST) 
    17641764    { 
     
    17751775    } 
    17761776 
    1777     // OSG_NOTICE<<"Texture::computeRequiredTextureDimensions() image.s() "<<image.s()<<" image.t()="<<image.t()<<" width="<<width<<" height="<<height<<" numMipmapLevels="<<numMipmapLevels<<std::endl;  
    1778     // OSG_NOTICE<<"  _resizeNonPowerOfTwoHint="<<_resizeNonPowerOfTwoHint<<" extensions->isNonPowerOfTwoTextureSupported(_min_filter)="<<extensions->isNonPowerOfTwoTextureSupported(_min_filter) <<std::endl;  
     1777    // OSG_NOTICE<<"Texture::computeRequiredTextureDimensions() image.s() "<<image.s()<<" image.t()="<<image.t()<<" width="<<width<<" height="<<height<<" numMipmapLevels="<<numMipmapLevels<<std::endl; 
     1778    // OSG_NOTICE<<"  _resizeNonPowerOfTwoHint="<<_resizeNonPowerOfTwoHint<<" extensions->isNonPowerOfTwoTextureSupported(_min_filter)="<<extensions->isNonPowerOfTwoTextureSupported(_min_filter) <<std::endl; 
    17791779} 
    17801780 
     
    18001800#endif 
    18011801 
    1802     // get the contextID (user defined ID of 0 upwards) for the  
     1802    // get the contextID (user defined ID of 0 upwards) for the 
    18031803    // current OpenGL context. 
    18041804    const unsigned int contextID = state.getContextID(); 
     
    18101810    // If the texture's internal format is a compressed type, then the 
    18111811    // user is requesting that the graphics card compress the image if it's 
    1812     // not already compressed. However, if the image is not a multiple of  
     1812    // not already compressed. However, if the image is not a multiple of 
    18131813    // four in each dimension the subsequent calls to glTexSubImage* will 
    18141814    // fail. Revert to uncompressed format in this case. 
     
    18541854        #endif 
    18551855 
    1856         #ifdef GL_TEXTURE_STORAGE_HINT_APPLE     
     1856        #ifdef GL_TEXTURE_STORAGE_HINT_APPLE 
    18571857            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_STORAGE_HINT_APPLE , GL_STORAGE_CACHED_APPLE); 
    18581858        #endif 
     
    18671867    { 
    18681868        // resize the image to power of two. 
    1869          
     1869 
    18701870        if (image->isMipmap()) 
    18711871        { 
     
    18781878            return; 
    18791879        } 
    1880          
     1880 
    18811881        unsigned int newTotalSize = osg::Image::computeRowWidthInBytes(inwidth,image->getPixelFormat(),image->getDataType(),image->getPacking())*inheight; 
    18821882        dataPtr = new unsigned char [newTotalSize]; 
    1883          
     1883 
    18841884        if (!dataPtr) 
    18851885        { 
     
    19491949            getCompressedSize(_internalFormat, inwidth, inheight, 1, blockSize,size); 
    19501950 
    1951             extensions->glCompressedTexImage2D(target, 0, _internalFormat,  
    1952                 inwidth, inheight,0,  
    1953                 size,  
     1951            extensions->glCompressedTexImage2D(target, 0, _internalFormat, 
     1952                inwidth, inheight,0, 
     1953                size, 
    19541954                dataPtr); 
    19551955        } 
     
    19641964 
    19651965            // image is mip mapped so we take the mip map levels from the image. 
    1966          
     1966 
    19671967            numMipmapLevels = image->getNumMipmapLevels(); 
    19681968 
     
    20022002 
    20032003                    getCompressedSize(_internalFormat, width, height, 1, blockSize,size); 
    2004                      
    2005                     extensions->glCompressedTexImage2D(target, k, _internalFormat,  
    2006                                                        width, height, _borderWidth,  
     2004 
     2005                    extensions->glCompressedTexImage2D(target, k, _internalFormat, 
     2006                                                       width, height, _borderWidth, 
    20072007                                                       size, dataPtr + image->getMipmapOffset(k)); 
    20082008 
     
    20312031                } 
    20322032            } 
    2033             else  
     2033            else 
    20342034            { 
    20352035                OSG_WARN<<"Warning:: Compressed image cannot be mip mapped"<<std::endl; 
     
    20512051        } 
    20522052    } 
    2053      
     2053 
    20542054#ifdef DO_TIMING 
    20552055    static double s_total_time = 0.0; 
     
    20642064        delete [] dataPtr; 
    20652065    } 
    2066      
     2066 
    20672067    if (useClientStorage) 
    20682068    { 
     
    20802080 
    20812081    // image size has changed so we have to re-load the image from scratch. 
    2082     if (image->s()!=inwidth || image->t()!=inheight || image->getInternalTextureFormat()!=inInternalFormat )  
    2083     { 
    2084         applyTexImage2D_load(state, target, image, inwidth, inheight,numMipmapLevels);  
     2082    if (image->s()!=inwidth || image->t()!=inheight || image->getInternalTextureFormat()!=inInternalFormat ) 
     2083    { 
     2084        applyTexImage2D_load(state, target, image, inwidth, inheight,numMipmapLevels); 
    20852085        return; 
    20862086    } 
    20872087    // else image size the same as when loaded so we can go ahead and subload 
    2088      
     2088 
    20892089    // If the texture's internal format is a compressed type, then the 
    20902090    // user is requesting that the graphics card compress the image if it's 
    2091     // not already compressed. However, if the image is not a multiple of  
     2091    // not already compressed. However, if the image is not a multiple of 
    20922092    // four in each dimension the subsequent calls to glTexSubImage* will 
    20932093    // fail. Revert to uncompressed format in this case. 
     
    21042104    OSG_NOTICE<<"glTexSubImage2D pixelFormat = "<<std::hex<<image->getPixelFormat()<<std::dec<<std::endl; 
    21052105#endif 
    2106     
    2107  
    2108     // get the contextID (user defined ID of 0 upwards) for the  
     2106 
     2107 
     2108    // get the contextID (user defined ID of 0 upwards) for the 
    21092109    // current OpenGL context. 
    21102110    const unsigned int contextID = state.getContextID(); 
     
    21132113    // select the internalFormat required for the texture. 
    21142114    bool compressed_image = isCompressedInternalFormat((GLenum)image->getPixelFormat()); 
    2115      
     2115 
    21162116    glPixelStorei(GL_UNPACK_ALIGNMENT,image->getPacking()); 
    21172117    unsigned int rowLength = image->getRowLength(); 
    2118      
     2118 
    21192119    unsigned char* dataPtr = (unsigned char*)image->data(); 
    21202120 
     
    21962196        } 
    21972197        else if (extensions->isCompressedTexImage2DSupported()) 
    2198         {         
     2198        { 
    21992199            GLint blockSize,size; 
    22002200            getCompressedSize(image->getInternalTextureFormat(), inwidth, inheight, 1, blockSize,size); 
    22012201 
    2202             extensions->glCompressedTexSubImage2D(target, 0,  
     2202            extensions->glCompressedTexSubImage2D(target, 0, 
    22032203                0,0, 
    22042204                inwidth, inheight, 
     
    22292229                        height = 1; 
    22302230 
    2231                     glTexSubImage2D( target, k,  
     2231                    glTexSubImage2D( target, k, 
    22322232                        0, 0, 
    22332233                        width, height, 
     
    22542254                    //state.checkGLErrors("before extensions->glCompressedTexSubImage2D("); 
    22552255 
    2256                     extensions->glCompressedTexSubImage2D(target, k,   
     2256                    extensions->glCompressedTexSubImage2D(target, k, 
    22572257                                                       0, 0, 
    2258                                                        width, height,  
     2258                                                       width, height, 
    22592259                                                       (GLenum)image->getPixelFormat(), 
    22602260                                                       size, 
     
    22722272        { 
    22732273            //OSG_WARN<<"Warning:: cannot subload mip mapped texture from non mipmapped image."<<std::endl; 
    2274             applyTexImage2D_load(state, target, image, inwidth, inheight,numMipmapLevels);  
    2275         } 
    2276     } 
    2277      
     2274            applyTexImage2D_load(state, target, image, inwidth, inheight,numMipmapLevels); 
     2275        } 
     2276    } 
     2277 
    22782278    if (pbo) 
    22792279    { 
     
    23182318    if (hardwareMipmapOn) 
    23192319    { 
    2320 #if defined( OSG_GLES2_AVAILABLE ) || defined( OSG_GL3_AVAILABLE )  
     2320#if defined( OSG_GLES2_AVAILABLE ) || defined( OSG_GL3_AVAILABLE ) 
    23212321        return GENERATE_MIPMAP; 
    23222322#else 
     
    23802380 
    23812381    _texMipmapGenerationDirtyList[contextID] = 0; 
    2382      
     2382 
    23832383    // if internal format does not provide automatic mipmap generation, then do manual allocation 
    23842384    if (_internalFormatType == SIGNED_INTEGER || _internalFormatType == UNSIGNED_INTEGER) 
     
    23872387        return; 
    23882388    } 
    2389      
     2389 
    23902390    // get fbo extension which provides us with the glGenerateMipmapEXT function 
    23912391    osg::FBOExtensions* fbo_ext = osg::FBOExtensions::instance(state.getContextID(), true); 
     
    23962396        textureObject->bind(); 
    23972397        fbo_ext->glGenerateMipmap(textureObject->target()); 
    2398          
     2398 
    23992399        // inform state that this texture is the current one bound. 
    24002400        state.haveAppliedTextureAttribute(state.getActiveTextureUnit(), this); 
    2401      
     2401 
    24022402    // if the function is not supported, then do manual allocation 
    24032403    }else 
     
    24052405        allocateMipmap(state); 
    24062406    } 
    2407      
     2407 
    24082408} 
    24092409 
     
    24572457        return; 
    24582458    } 
    2459      
     2459 
    24602460    const char* renderer = (const char*) glGetString(GL_RENDERER); 
    24612461    std::string rendererString(renderer ? renderer : ""); 
    24622462 
    24632463    bool builtInSupport = OSG_GLES2_FEATURES || OSG_GL3_FEATURES; 
    2464      
    2465     _isMultiTexturingSupported = builtInSupport || OSG_GLES1_FEATURES ||  
     2464 
     2465    _isMultiTexturingSupported = builtInSupport || OSG_GLES1_FEATURES || 
    24662466                                 isGLExtensionOrVersionSupported( contextID,"GL_ARB_multitexture", 1.3f) || 
    24672467                                 isGLExtensionOrVersionSupported(contextID,"GL_EXT_multitexture", 1.3f); 
    2468                                   
     2468 
    24692469    _isTextureFilterAnisotropicSupported = isGLExtensionSupported(contextID,"GL_EXT_texture_filter_anisotropic"); 
    2470      
     2470 
    24712471    _isTextureCompressionARBSupported = builtInSupport || isGLExtensionOrVersionSupported(contextID,"GL_ARB_texture_compression", 1.3f); 
    2472      
     2472 
    24732473    _isTextureCompressionS3TCSupported = isGLExtensionSupported(contextID,"GL_EXT_texture_compression_s3tc"); 
    24742474 
     
    24782478 
    24792479    _isTextureCompressionETCSupported = isGLExtensionSupported(contextID,"GL_OES_compressed_ETC1_RGB8_texture"); 
    2480      
     2480 
    24812481 
    24822482    _isTextureCompressionRGTCSupported = isGLExtensionSupported(contextID,"GL_EXT_texture_compression_rgtc"); 
     
    24842484    _isTextureCompressionPVRTCSupported = isGLExtensionSupported(contextID,"GL_IMG_texture_compression_pvrtc"); 
    24852485 
    2486     _isTextureMirroredRepeatSupported = builtInSupport ||  
     2486    _isTextureMirroredRepeatSupported = builtInSupport || 
    24872487                                        isGLExtensionOrVersionSupported(contextID,"GL_IBM_texture_mirrored_repeat", 1.4f) || 
    24882488                                        isGLExtensionOrVersionSupported(contextID,"GL_ARB_texture_mirrored_repeat", 1.4f); 
    2489                                          
     2489 
    24902490    _isTextureEdgeClampSupported = builtInSupport || 
    2491                                    isGLExtensionOrVersionSupported(contextID,"GL_EXT_texture_edge_clamp", 1.2f) ||  
     2491                                   isGLExtensionOrVersionSupported(contextID,"GL_EXT_texture_edge_clamp", 1.2f) || 
    24922492                                   isGLExtensionOrVersionSupported(contextID,"GL_SGIS_texture_edge_clamp", 1.2f); 
    2493                                     
     2493 
    24942494 
    24952495    _isTextureBorderClampSupported = OSG_GL3_FEATURES || 
    24962496                                     ((OSG_GL1_FEATURES || OSG_GL2_FEATURES) && isGLExtensionOrVersionSupported(contextID,"GL_ARB_texture_border_clamp", 1.3f)); 
    2497      
     2497 
    24982498    _isGenerateMipMapSupported = builtInSupport || isGLExtensionOrVersionSupported(contextID,"GL_SGIS_generate_mipmap", 1.4f); 
    24992499 
    25002500    _isTextureMultisampledSupported = isGLExtensionSupported(contextID,"GL_ARB_texture_multisample"); 
    2501                                    
     2501 
    25022502    _isShadowSupported = OSG_GL3_FEATURES || isGLExtensionSupported(contextID,"GL_ARB_shadow"); 
    2503      
     2503 
    25042504    _isShadowAmbientSupported = isGLExtensionSupported(contextID,"GL_ARB_shadow_ambient"); 
    25052505 
     
    25092509 
    25102510    _isNonPowerOfTwoTextureMipMappedSupported = builtInSupport || _isNonPowerOfTwoTextureNonMipMappedSupported; 
    2511      
     2511 
    25122512    _isTextureIntegerEXTSupported = OSG_GL3_FEATURES || isGLExtensionSupported(contextID, "GL_EXT_texture_integer"); 
    25132513 
     
    25192519    } 
    25202520    #endif 
    2521      
     2521 
    25222522    if (rendererString.find("GeForce FX")!=std::string::npos) 
    25232523    {