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/Image.cpp

    r13025 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*/ 
     
    112112        // advance to next row 
    113113        ++_rowNum; 
    114          
     114 
    115115        if (_rowNum>=_image->t()) 
    116116        { 
     
    128128        } 
    129129    } 
    130     
     130 
    131131    assign(); 
    132132} 
     
    141141        return; 
    142142    } 
    143      
     143 
    144144    //OSG_NOTICE<<"DataIterator::assign B"<<std::endl; 
    145145 
     
    154154        return; 
    155155    } 
    156      
     156 
    157157    //OSG_NOTICE<<"DataIterator::assign C"<<std::endl; 
    158158 
     
    168168        } 
    169169        const unsigned char* ptr = _image->getMipmapData(_mipmapNum); 
    170          
     170 
    171171        int rowLength = _image->getRowLength()>>_mipmapNum; 
    172172        if (rowLength==0) rowLength = 1; 
    173          
     173 
    174174        int imageHeight = _image->t()>>_mipmapNum; 
    175175        if (imageHeight==0) imageHeight = 1; 
    176          
     176 
    177177        unsigned int rowWidthInBytes = Image::computeRowWidthInBytes(rowLength,_image->getPixelFormat(),_image->getDataType(),_image->getPacking()); 
    178178        unsigned int imageSizeInBytes = rowWidthInBytes*imageHeight; 
    179          
     179 
    180180        _currentPtr = ptr + rowWidthInBytes*_rowNum + imageSizeInBytes*_imageNum; 
    181181        _currentSize = rowWidthInBytes; 
     
    216216    _data(0L) 
    217217{ 
    218     setDataVariance(STATIC);  
     218    setDataVariance(STATIC); 
    219219} 
    220220 
     
    288288 
    289289    // slowest comparison at the bottom! 
    290     COMPARE_StateAttribute_Parameter(getFileName())     
     290    COMPARE_StateAttribute_Parameter(getFileName()) 
    291291 
    292292    return 0; 
     
    323323        case(GL_UNSIGNED_INT_2_10_10_10_REV): return true; 
    324324        default: return false; 
    325     }     
     325    } 
    326326} 
    327327 
     
    370370        case(GL_INTENSITY16UI_EXT): 
    371371        case(GL_INTENSITY32UI_EXT): 
    372             OSG_WARN<<"Image::computePixelFormat("<<std::hex<<format<<std::dec<<") intensity pixel format is not correctly specified, so assume GL_LUMINANCE_INTEGER."<<std::endl;             
     372            OSG_WARN<<"Image::computePixelFormat("<<std::hex<<format<<std::dec<<") intensity pixel format is not correctly specified, so assume GL_LUMINANCE_INTEGER."<<std::endl; 
    373373            return GL_LUMINANCE_INTEGER_EXT; 
    374374        case(GL_LUMINANCE_ALPHA8I_EXT): 
     
    404404    { 
    405405        case GL_LUMINANCE32F_ARB: 
    406         case GL_LUMINANCE16F_ARB:  
     406        case GL_LUMINANCE16F_ARB: 
    407407        case GL_LUMINANCE_ALPHA32F_ARB: 
    408         case GL_LUMINANCE_ALPHA16F_ARB:  
     408        case GL_LUMINANCE_ALPHA16F_ARB: 
    409409        case GL_RGB32F_ARB: 
    410         case GL_RGB16F_ARB:  
     410        case GL_RGB16F_ARB: 
    411411        case GL_RGBA32F_ARB: 
    412412        case GL_RGBA16F_ARB: return GL_FLOAT; 
     
    419419        case GL_RGB16UI_EXT: 
    420420        case GL_RGBA16UI_EXT: 
    421         case GL_LUMINANCE16UI_EXT:  
     421        case GL_LUMINANCE16UI_EXT: 
    422422        case GL_LUMINANCE_ALPHA16UI_EXT: return GL_UNSIGNED_SHORT; 
    423423 
     
    427427        case GL_LUMINANCE_ALPHA8UI_EXT:  return GL_UNSIGNED_BYTE; 
    428428 
    429         case GL_RGBA32I_EXT:   
     429        case GL_RGBA32I_EXT: 
    430430        case GL_RGB32I_EXT: 
    431431        case GL_LUMINANCE32I_EXT: 
     
    437437        case GL_LUMINANCE_ALPHA16I_EXT: return GL_SHORT; 
    438438 
    439         case GL_RGB8I_EXT:  
    440         case GL_RGBA8I_EXT:  
    441         case GL_LUMINANCE8I_EXT:  
     439        case GL_RGB8I_EXT: 
     440        case GL_RGBA8I_EXT: 
     441        case GL_LUMINANCE8I_EXT: 
    442442        case GL_LUMINANCE_ALPHA8I_EXT: return GL_BYTE; 
    443443 
     
    448448        case GL_ALPHA: return GL_UNSIGNED_BYTE; 
    449449 
    450         default:  
     450        default: 
    451451        { 
    452452            OSG_WARN<<"error computeFormatType = "<<std::hex<<pixelFormat<<std::dec<<std::endl; 
     
    467467        case(GL_COMPRESSED_RED_RGTC1_EXT):   return 1; 
    468468        case(GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT): return 2; 
    469         case(GL_COMPRESSED_RED_GREEN_RGTC2_EXT): return 2;     
     469        case(GL_COMPRESSED_RED_GREEN_RGTC2_EXT): return 2; 
    470470        case(GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG): return 3; 
    471471        case(GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG): return 3; 
     
    564564            return 0; 
    565565        } 
    566     }         
     566    } 
    567567} 
    568568 
     
    633633    switch(type) 
    634634    { 
    635     
     635 
    636636        case(GL_BITMAP): return computeNumComponents(format); 
    637          
     637 
    638638        case(GL_BYTE): 
    639639        case(GL_UNSIGNED_BYTE): return 8*computeNumComponents(format); 
    640          
     640 
    641641        case(GL_HALF_FLOAT_NV): 
    642642        case(GL_SHORT): 
    643643        case(GL_UNSIGNED_SHORT): return 16*computeNumComponents(format); 
    644          
     644 
    645645        case(GL_INT): 
    646646        case(GL_UNSIGNED_INT): 
    647647        case(GL_FLOAT): return 32*computeNumComponents(format); 
    648      
    649      
    650         case(GL_UNSIGNED_BYTE_3_3_2):  
     648 
     649 
     650        case(GL_UNSIGNED_BYTE_3_3_2): 
    651651        case(GL_UNSIGNED_BYTE_2_3_3_REV): return 8; 
    652          
     652 
    653653        case(GL_UNSIGNED_SHORT_5_6_5): 
    654654        case(GL_UNSIGNED_SHORT_5_6_5_REV): 
     
    657657        case(GL_UNSIGNED_SHORT_5_5_5_1): 
    658658        case(GL_UNSIGNED_SHORT_1_5_5_5_REV): return 16; 
    659          
     659 
    660660        case(GL_UNSIGNED_INT_8_8_8_8): 
    661661        case(GL_UNSIGNED_INT_8_8_8_8_REV): 
    662662        case(GL_UNSIGNED_INT_10_10_10_2): 
    663663        case(GL_UNSIGNED_INT_2_10_10_10_REV): return 32; 
    664         default:  
     664        default: 
    665665        { 
    666666            OSG_WARN<<"error type = "<<type<<std::endl; 
    667667            return 0; 
    668668        } 
    669     }     
     669    } 
    670670 
    671671} 
     
    711711{ 
    712712    if (width==0 || height==0 || depth==0) return 0; 
    713      
     713 
    714714    return osg::maximum( 
    715715            Image::computeRowWidthInBytes(width,pixelFormat,type,packing)*height*depth, 
     
    758758        case(GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT): 
    759759        case(GL_COMPRESSED_RED_GREEN_RGTC2_EXT): 
    760         case(GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG):  
     760        case(GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG): 
    761761        case(GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG): 
    762762        case(GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG): 
     
    771771unsigned int Image::getTotalSizeInBytesIncludingMipmaps() const 
    772772{ 
    773     if (_mipmapData.empty())  
     773    if (_mipmapData.empty()) 
    774774    { 
    775775        // no mips so just return size of main image 
    776776        return getTotalSizeInBytes(); 
    777777    } 
    778      
     778 
    779779    int s = _s; 
    780780    int t = _t; 
     
    784784    { 
    785785        totalSize += computeImageSizeInBytes(s, t, r, _pixelFormat, _dataType, _packing); 
    786          
     786 
    787787        s >>= 1; 
    788788        t >>= 1; 
     
    797797} 
    798798 
    799 void Image::setRowLength(int length)  
    800 {  
     799void Image::setRowLength(int length) 
     800{ 
    801801    _rowLength = length; 
    802802    #if defined(OSG_GLES1_AVAILABLE) || defined(OSG_GLES2_AVAILABLE) 
    803     if (length > 0)  
     803    if (length > 0) 
    804804    { 
    805805        OSG_WARN << "Image::setRowLength is not supported on this platform, ignoring" << std::endl; 
     
    811811void Image::setInternalTextureFormat(GLint internalFormat) 
    812812{ 
    813     // won't do any sanity checking right now, leave it to  
     813    // won't do any sanity checking right now, leave it to 
    814814    // OpenGL to make the call. 
    815815    _internalTextureFormat = internalFormat; 
     
    844844 
    845845    unsigned int previousTotalSize = 0; 
    846      
     846 
    847847    if (_data) previousTotalSize = computeRowWidthInBytes(_s,_pixelFormat,_dataType,_packing)*_t*_r; 
    848      
     848 
    849849    unsigned int newTotalSize = computeRowWidthInBytes(s,format,type,packing)*t*r; 
    850850 
     
    866866        _packing = packing; 
    867867        _rowLength = 0; 
    868          
     868 
    869869        // preserve internalTextureFormat if already set, otherwise 
    870870        // use the pixelFormat as the source for the format. 
     
    873873    else 
    874874    { 
    875      
     875 
    876876        // failed to allocate memory, for now, will simply set values to 0. 
    877877        _s = 0; 
     
    882882        _packing = 0; 
    883883        _rowLength = 0; 
    884          
     884 
    885885        // commenting out reset of _internalTextureFormat as we are changing 
    886886        // policy so that allocateImage honours previous settings of _internalTextureFormat. 
    887887        //_internalTextureFormat = 0; 
    888888    } 
    889      
     889 
    890890    dirty(); 
    891891} 
     
    913913    _packing = packing; 
    914914    _rowLength = rowLength; 
    915          
     915 
    916916    dirty(); 
    917917 
     
    939939    const osg::Texture2DArray::Extensions* extensions2DArray = osg::Texture2DArray::getExtensions(contextID,true); 
    940940 
    941      
     941 
    942942    GLboolean binding1D = GL_FALSE, binding2D = GL_FALSE, binding3D = GL_FALSE, binding2DArray = GL_FALSE, bindingCubeMap = GL_FALSE; 
    943943 
     
    977977        } 
    978978    } 
    979      
     979 
    980980    if (textureMode==0) return; 
    981981 
     
    10031003        numMipMaps = 1; 
    10041004    } 
    1005      
     1005 
    10061006    // OSG_NOTICE<<"Image::readImageFromCurrentTexture() : numMipMaps = "<<numMipMaps<<std::endl; 
    10071007 
    1008          
     1008 
    10091009    GLint compressed = 0; 
    10101010 
     
    10301030        } 
    10311031    } 
    1032      
    1033      
    1034          
     1032 
     1033 
     1034 
    10351035    /* if the compression has been successful */ 
    10361036    if (compressed == GL_TRUE) 
     
    10381038 
    10391039        MipmapDataType mipMapData; 
    1040          
     1040 
    10411041        unsigned int total_size = 0; 
    10421042        GLint i; 
     
    10441044        { 
    10451045            if (i>0) mipMapData.push_back(total_size); 
    1046              
     1046 
    10471047            GLint compressed_size; 
    10481048            glGetTexLevelParameteriv(textureMode, i, GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, &compressed_size); 
    1049              
     1049 
    10501050            total_size += compressed_size; 
    10511051        } 
    1052          
    1053          
     1052 
     1053 
    10541054        unsigned char* data = new unsigned char[total_size]; 
    10551055        if (!data) 
    10561056        { 
    10571057            OSG_WARN<<"Warning: Image::readImageFromCurrentTexture(..) out of memory, now image read."<<std::endl; 
    1058             return;  
     1058            return; 
    10591059        } 
    10601060 
     
    10741074        _t = height; 
    10751075        _r = depth; 
    1076          
     1076 
    10771077        _pixelFormat = internalformat; 
    10781078        _dataType = type; 
     
    10891089 
    10901090        dirty(); 
    1091      
     1091 
    10921092    } 
    10931093    else 
     
    11081108        { 
    11091109            if (i>0) mipMapData.push_back(total_size); 
    1110              
     1110 
    11111111            glGetTexLevelParameteriv(textureMode, i, GL_TEXTURE_WIDTH, &width); 
    11121112            glGetTexLevelParameteriv(textureMode, i, GL_TEXTURE_HEIGHT, &height); 
    11131113            glGetTexLevelParameteriv(textureMode, i, GL_TEXTURE_DEPTH, &depth); 
    1114              
     1114 
    11151115            unsigned int level_size = computeRowWidthInBytes(width,internalformat,type,packing)*height*depth; 
    11161116 
    11171117            total_size += level_size; 
    11181118        } 
    1119          
    1120          
     1119 
     1120 
    11211121        unsigned char* data = new unsigned char[total_size]; 
    11221122        if (!data) 
    11231123        { 
    11241124            OSG_WARN<<"Warning: Image::readImageFromCurrentTexture(..) out of memory, now image read."<<std::endl; 
    1125             return;  
     1125            return; 
    11261126        } 
    11271127 
     
    11361136        _t = height; 
    11371137        _r = depth; 
    1138          
     1138 
    11391139        _pixelFormat = computePixelFormat(internalformat); 
    11401140        _dataType = type; 
     
    11441144        _packing = packing; 
    11451145        _rowLength = rowLength; 
    1146          
     1146 
    11471147        for(i=0;i<numMipMaps;++i) 
    11481148        { 
     
    11511151 
    11521152        dirty(); 
    1153     }     
     1153    } 
    11541154#else 
    11551155    OSG_NOTICE<<"Warning: Image::readImageFromCurrentTexture() not supported."<<std::endl; 
     
    12871287        unsigned int rowStepInBytes = getRowStepInBytes(); 
    12881288        unsigned int imageStepInBytes = getImageStepInBytes(); 
    1289          
     1289 
    12901290        for(int r=0;r<_r;++r) 
    12911291        { 
     
    13131313        return; 
    13141314    } 
    1315          
     1315 
    13161316    dirty(); 
    13171317} 
     
    13631363                unsigned char* top = data(0,0,r); 
    13641364                unsigned char* bottom = top + (_t-1)*rowStep; 
    1365                      
     1365 
    13661366                flipImageVertical(top, bottom, rowSize, rowStep); 
    13671367            } 
     
    13981398            } 
    13991399       } 
    1400     }    
     1400    } 
    14011401 
    14021402    dirty(); 
     
    14291429    { 
    14301430        for(int row=0; row<_t; ++row) 
    1431         {         
     1431        { 
    14321432            unsigned char* front = data(0, row, r_front); 
    14331433            unsigned char* back = data(0, row, r_back); 
     
    14451445    int new_s = computeNearestPowerOfTwo(_s); 
    14461446    int new_t = computeNearestPowerOfTwo(_t); 
    1447      
     1447 
    14481448    if (new_s>maxTextureSize) new_s = maxTextureSize; 
    14491449    if (new_t>maxTextureSize) new_t = maxTextureSize; 
    1450      
     1450 
    14511451    if (new_s!=_s || new_t!=_t) 
    14521452    { 
     
    14701470 
    14711471 
    1472 template <typename T>     
     1472template <typename T> 
    14731473bool _findLowerAlphaValueInRow(unsigned int num, T* data,T value, unsigned int delta) 
    14741474{ 
     
    14811481} 
    14821482 
    1483 template <typename T>     
     1483template <typename T> 
    14841484bool _maskedFindLowerAlphaValueInRow(unsigned int num, T* data,T value, T mask, unsigned int delta) 
    14851485{ 
     
    15921592                                                        0x00000003u, 1)) 
    15931593                        return true; 
    1594                     break;                     
     1594                    break; 
    15951595                case(GL_UNSIGNED_INT_2_10_10_10_REV): 
    15961596                    if (_maskedFindLowerAlphaValueInRow(s(), (unsigned int*)d, 
     
    16201620 
    16211621 
    1622 #include <osg/TextureRectangle>  
     1622#include <osg/TextureRectangle> 
    16231623 
    16241624 
     
    17051705} 
    17061706 
    1707 template <typename T>     
     1707template <typename T> 
    17081708Vec4 _readColor(GLenum pixelFormat, T* data,float scale) 
    17091709{