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

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

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

    r12993 r13041  
    1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield  
     1/* -*-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*/ 
     
    6060        if (noImages && _images[n].valid()) noImages = false; 
    6161        if (noImages && rhs._images[n].valid()) noImages = false; 
    62      
     62 
    6363        if (_images[n]!=rhs._images[n]) // smart pointer comparison. 
    6464        { 
     
    7272                else 
    7373                { 
    74                     return 1; // valid lhs._image is greater than null.  
     74                    return 1; // valid lhs._image is greater than null. 
    7575                } 
    7676            } 
    77             else if (rhs._images[n].valid())  
    78             { 
    79                 return -1; // valid rhs._image is greater than null.  
    80             } 
    81         } 
    82     } 
    83  
    84      
     77            else if (rhs._images[n].valid()) 
     78            { 
     79                return -1; // valid rhs._image is greater than null. 
     80            } 
     81        } 
     82    } 
     83 
     84 
    8585    if (noImages) 
    8686    { 
     
    110110        return; 
    111111    } 
    112      
     112 
    113113    if (_images[layer] == image) return; 
    114114 
     
    144144    } 
    145145} 
    146   
     146 
    147147void Texture2DArray::setTextureSize(int width, int height, int depth) 
    148148{ 
     
    154154 
    155155void Texture2DArray::setTextureDepth(int depth) 
    156 {     
     156{ 
    157157    // if we decrease the number of layers, then delete non-used 
    158158    if (depth < _textureDepth) 
     
    161161        _modifiedCount.resize(depth); 
    162162    } 
    163      
     163 
    164164    // if we increase the array, then add new empty elements 
    165165    if (depth > _textureDepth) 
     
    168168        _modifiedCount.resize(depth, ImageModifiedCount()); 
    169169    } 
    170          
     170 
    171171    // resize the texture array 
    172172    _textureDepth = depth; 
     
    196196void Texture2DArray::computeInternalFormat() const 
    197197{ 
    198     if (imagesValid()) computeInternalFormatWithImage(*_images[0]);  
     198    if (imagesValid()) computeInternalFormatWithImage(*_images[0]); 
    199199    else computeInternalFormatType(); 
    200200} 
     
    203203void Texture2DArray::apply(State& state) const 
    204204{ 
    205     // get the contextID (user defined ID of 0 upwards) for the  
     205    // get the contextID (user defined ID of 0 upwards) for the 
    206206    // current OpenGL context. 
    207207    const unsigned int contextID = state.getContextID(); 
     
    219219        return; 
    220220    } 
    221      
     221 
    222222    // get the texture object for the current contextID. 
    223223    TextureObject* textureObject = getTextureObject(contextID); 
     
    245245    } 
    246246 
    247     // if we already have an texture object, then  
     247    // if we already have an texture object, then 
    248248    if (textureObject) 
    249249    { 
     
    265265            { 
    266266                osg::Image* image = _images[n].get(); 
    267                  
     267 
    268268                // if image content is modified, then upload it to the GPU memory 
    269269                if (image && getModifiedCount(n,contextID) != image->getModifiedCount()) 
     
    276276 
    277277    } 
    278      
     278 
    279279    // there is no texture object, but exists a subload callback, so use it to upload images 
    280280    else if (_subloadCallback.valid()) 
     
    286286        _subloadCallback->load(*this,state); 
    287287    } 
    288      
     288 
    289289    // nothing before, but we have valid images, so do manual upload and create texture object manually 
    290290    // TODO: we assume _images[0] is valid, however this may not be always the case 
     
    301301        textureObject = generateTextureObject( 
    302302                this, contextID,GL_TEXTURE_2D_ARRAY_EXT,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,_textureDepth,0); 
    303          
     303 
    304304        // bind texture 
    305305        textureObject->bind(); 
     
    311311        int sourceFormat = _sourceFormat ? _sourceFormat : _internalFormat; 
    312312 
    313         if( isCompressedInternalFormat( sourceFormat ) &&  
     313        if( isCompressedInternalFormat( sourceFormat ) && 
    314314            sourceFormat == _internalFormat && 
    315315            extensions->isCompressedTexImage3DSupported() ) 
     
    321321        } 
    322322        else 
    323         {    
     323        { 
    324324            // Override compressed source format with safe GL_RGBA value which not generate error 
    325325            // We can safely do this as source format is not important when source data is NULL 
     
    330330                     _textureWidth, _textureHeight, _textureDepth, _borderWidth, 
    331331                     sourceFormat, _sourceType ? _sourceType : GL_UNSIGNED_BYTE, 
    332                      0);  
     332                     0); 
    333333        } 
    334334 
    335335       // For certain we have to manually allocate memory for mipmaps if images are compressed 
    336336       // if not allocated OpenGL will produce errors on mipmap upload. 
    337        // I have not tested if this is neccessary for plain texture formats but  
     337       // I have not tested if this is neccessary for plain texture formats but 
    338338       // common sense suggests its required as well. 
    339339       if( _min_filter != LINEAR && _min_filter != NEAREST && _images[0]->isMipmap() ) 
     
    354354 
    355355        const Texture::Extensions* texExtensions = Texture::getExtensions(contextID,true); 
    356         // source images have no mipmamps but we could generate them...   
    357         if( _min_filter != LINEAR && _min_filter != NEAREST && !_images[0]->isMipmap() &&   
     356        // source images have no mipmamps but we could generate them... 
     357        if( _min_filter != LINEAR && _min_filter != NEAREST && !_images[0]->isMipmap() && 
    358358            _useHardwareMipMapGeneration && texExtensions->isGenerateMipMapSupported() ) 
    359359            { 
     
    363363 
    364364        textureObject->setAllocated(_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,_textureDepth,0); 
    365          
     365 
    366366        // unref image data? 
    367367        if (isSafeToUnrefImageData(state)) 
     
    369369            Texture2DArray* non_const_this = const_cast<Texture2DArray*>(this); 
    370370            for (int n=0; n<_textureDepth; n++) 
    371             {                 
     371            { 
    372372                if (_images[n].valid() && _images[n]->getDataVariance()==STATIC) 
    373373                { 
     
    376376            } 
    377377        } 
    378          
    379     } 
    380      
     378 
     379    } 
     380 
    381381    // No images present, but dimensions are set. So create empty texture 
    382382    else if ( (_textureWidth > 0) && (_textureHeight > 0) && (_textureDepth > 0) && (_internalFormat!=0) ) 
    383383    { 
    384         // generate texture  
     384        // generate texture 
    385385        _textureObjectBuffer[contextID] = textureObject = generateTextureObject( 
    386386                this, contextID, GL_TEXTURE_2D_ARRAY_EXT,_numMipmapLevels,_internalFormat,_textureWidth,_textureHeight,_textureDepth,0); 
    387          
     387 
    388388        textureObject->bind(); 
    389389        applyTexParameters(GL_TEXTURE_2D_ARRAY_EXT,state); 
    390          
     390 
    391391        extensions->glTexImage3D( GL_TEXTURE_2D_ARRAY_EXT, 0, _internalFormat, 
    392392                     _textureWidth, _textureHeight, _textureDepth, 
     
    394394                     _sourceFormat ? _sourceFormat : _internalFormat, 
    395395                     _sourceType ? _sourceType : GL_UNSIGNED_BYTE, 
    396                      0);  
    397          
    398     } 
    399      
     396                     0); 
     397 
     398    } 
     399 
    400400    // nothing before, so just unbind the texture target 
    401401    else 
     
    418418        return; 
    419419 
    420     // get the contextID (user defined ID of 0 upwards) for the  
     420    // get the contextID (user defined ID of 0 upwards) for the 
    421421    // current OpenGL context. 
    422422    const unsigned int contextID = state.getContextID(); 
    423     const Extensions* extensions = getExtensions(contextID,true);     
     423    const Extensions* extensions = getExtensions(contextID,true); 
    424424    const Texture::Extensions* texExtensions = Texture::getExtensions(contextID,true); 
    425425    GLenum target = GL_TEXTURE_2D_ARRAY_EXT; 
    426      
     426 
    427427    // compute the internal texture format, this set the _internalFormat to an appropriate value. 
    428428    computeInternalFormat(); 
     
    437437        // we give a warning and do nothing 
    438438        OSG_WARN<<"Warning: Texture2DArray::applyTexImage2DArray_subload(..) the given layer number exceeds the maximum number of supported layers."<<std::endl; 
    439         return;         
     439        return; 
    440440    } 
    441441 
     
    447447 
    448448    // image size or format has changed, this is not allowed, hence return 
    449     if (image->s()!=inwidth ||  
    450         image->t()!=inheight ||  
    451         image->getInternalTextureFormat()!=inInternalFormat )  
     449    if (image->s()!=inwidth || 
     450        image->t()!=inheight || 
     451        image->getInternalTextureFormat()!=inInternalFormat ) 
    452452    { 
    453453        OSG_WARN<<"Warning: Texture2DArray::applyTexImage2DArray_subload(..) given image do have wrong dimension or internal format."<<std::endl; 
    454         return;         
    455     }     
    456      
     454        return; 
     455    } 
     456 
    457457    glPixelStorei(GL_UNPACK_ALIGNMENT,image->getPacking()); 
    458458#if !defined(OSG_GLES1_AVAILABLE) && !defined(OSG_GLES2_AVAILABLE) 
     
    460460#endif 
    461461 
    462     bool useHardwareMipmapGeneration =  
     462    bool useHardwareMipmapGeneration = 
    463463        !image->isMipmap() && _useHardwareMipMapGeneration && texExtensions->isGenerateMipMapSupported(); 
    464464 
     
    481481                                      image->data() ); 
    482482        } 
    483          
     483 
    484484        // if we support compression and image is compressed, then 
    485485        else if (extensions->isCompressedTexImage3DSupported()) 
     
    491491 
    492492            extensions->glCompressedTexSubImage3D(target, 0, 
    493                 0, 0, indepth,   
    494                 inwidth, inheight, 1,  
     493                0, 0, indepth, 
     494                inwidth, inheight, 1, 
    495495                (GLenum)image->getPixelFormat(), 
    496                 size,  
     496                size, 
    497497                image->data()); 
    498498        } 
     
    526526 
    527527                    extensions->glTexSubImage3D( target, k, 0, 0, indepth, 
    528                                               width, height, 1,  
     528                                              width, height, 1, 
    529529                                              (GLenum)image->getPixelFormat(), 
    530530                                              (GLenum)image->getDataType(), 
     
    599599    // get the texture object for the current contextID. 
    600600    TextureObject* textureObject = getTextureObject(contextID); 
    601      
     601 
    602602    if (textureObject && _textureWidth != 0 && _textureHeight != 0 && _textureDepth != 0) 
    603     {         
     603    { 
    604604        const Extensions* extensions = getExtensions(contextID,true); 
    605605 
     
    608608        // Make sure source format does not contain compressed formats value (like DXT3) 
    609609        // they are invalid when passed to glTexImage3D source format parameter 
    610         if( isCompressedInternalFormat( safeSourceFormat ) )  
     610        if( isCompressedInternalFormat( safeSourceFormat ) ) 
    611611        { 
    612612            if( safeSourceFormat != _internalFormat || !extensions->isCompressedTexImage3DSupported() ) 
     
    625625        width >>= 1; 
    626626        height >>= 1; 
    627          
     627 
    628628        for( GLsizei k = 1; k < numMipmapLevels  && (width || height); k++) 
    629629        { 
     
    633633                height = 1; 
    634634 
    635             if( isCompressedInternalFormat(safeSourceFormat) )  
     635            if( isCompressedInternalFormat(safeSourceFormat) ) 
    636636            { 
    637637                int size = 0, blockSize = 0; 
     
    639639                getCompressedSize( _internalFormat, width, height, _textureDepth, blockSize, size); 
    640640 
    641                 extensions->glCompressedTexImage3D( GL_TEXTURE_2D_ARRAY_EXT, k, _internalFormat,  
     641                extensions->glCompressedTexImage3D( GL_TEXTURE_2D_ARRAY_EXT, k, _internalFormat, 
    642642                                                    width, height, _textureDepth, _borderWidth, 
    643643                                                    size, 
     
    648648                extensions->glTexImage3D( GL_TEXTURE_2D_ARRAY_EXT, k, _internalFormat, 
    649649                     width, height, _textureDepth, _borderWidth, 
    650                      safeSourceFormat, _sourceType ? _sourceType : GL_UNSIGNED_BYTE,  
     650                     safeSourceFormat, _sourceType ? _sourceType : GL_UNSIGNED_BYTE, 
    651651                     NULL); 
    652652            } 
     
    655655            height >>= 1; 
    656656        } 
    657                  
     657 
    658658        // inform state that this texture is the current one bound. 
    659         state.haveAppliedTextureAttribute(state.getActiveTextureUnit(), this);         
     659        state.haveAppliedTextureAttribute(state.getActiveTextureUnit(), this); 
    660660    } 
    661661} 
     
    685685    _isTexture3DSupported = rhs._isTexture3DSupported; 
    686686    _isTexture2DArraySupported = rhs._isTexture2DArraySupported; 
    687      
     687 
    688688    _max2DSize = rhs._max2DSize; 
    689689    _maxLayerCount = rhs._maxLayerCount; 
    690      
     690 
    691691    _glTexImage3D = rhs._glTexImage3D; 
    692692    _glTexSubImage3D = rhs._glTexSubImage3D;