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/osgPlugins/pvr/ReaderWriterPVR.cpp

    r12597 r13041  
    7373      int testWord; 
    7474      char testByte[sizeof(int)]; 
    75     }endianTest;  
     75    }endianTest; 
    7676    endianTest.testWord = 1; 
    7777    if( endianTest.testByte[0] == 1 ) 
     
    8080      return true; 
    8181  } 
    82    
     82 
    8383  template <class T> 
    8484  inline void swapBytes(  T &s ) 
    8585  { 
    86     if( sizeof( T ) == 1 )  
     86    if( sizeof( T ) == 1 ) 
    8787      return; 
    88      
     88 
    8989    T d = s; 
    9090    BytePtr sptr = (BytePtr)&s; 
    9191    BytePtr dptr = &(((BytePtr)&d)[sizeof(T)-1]); 
    92      
     92 
    9393    for( unsigned int i = 0; i < sizeof(T); i++ ) 
    9494      *(sptr++) = *(dptr--); 
     
    118118{ 
    119119public: 
    120      
     120 
    121121    ReaderWriterPVR() 
    122122    { 
    123123        supportsExtension("pvr","PVR image format"); 
    124124    } 
    125      
     125 
    126126    virtual const char* className() const { return "PVR Image Reader/Writer"; } 
    127127 
    128    
     128 
    129129    ReadResult readPVRStream(std::istream& fin) const 
    130130    { 
    131131        PVRTexHeader header; 
    132          
     132 
    133133        fin.read((char*)&header, sizeof(PVRTexHeader)); 
    134134        if(!fin.good()){ 
     
    136136            return ReadResult::ERROR_IN_READING_FILE; 
    137137        } 
    138          
     138 
    139139        if(header.needsBytesSwapped()) 
    140140            header.swapBytes(); 
    141          
     141 
    142142        if(gPVRTexIdentifier[0] != static_cast<char>((header.pvrTag >>  0) & 0xff) || 
    143143           gPVRTexIdentifier[1] != static_cast<char>((header.pvrTag >>  8) & 0xff) || 
     
    148148                return ReadResult::FILE_NOT_HANDLED; 
    149149            } 
    150          
    151          
     150 
     151 
    152152        uint32_t formatFlags = header.flags & PVR_TEXTURE_FLAG_TYPE_MASK; 
    153153        GLenum internalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; 
    154154        uint32_t width, height; 
    155          
     155 
    156156        if(formatFlags == kPVRTextureFlagTypePVRTC_4 || formatFlags == kPVRTextureFlagTypePVRTC_2 || 
    157157           formatFlags == kPVRTextureFlagTypeOGLPVRTC_4 || formatFlags == kPVRTextureFlagTypeOGLPVRTC_2 || 
     
    163163            else if(formatFlags == kPVRTextureFlagTypeETC) 
    164164                internalFormat = GL_ETC1_RGB8_OES; 
    165              
     165 
    166166            width = header.width; 
    167167            height = header.height; 
     
    169169            osg::ref_ptr<osg::Image> image = new osg::Image; 
    170170            if (!image) return ReadResult::INSUFFICIENT_MEMORY_TO_LOAD; 
    171              
     171 
    172172            unsigned char *imageData = new unsigned char[header.dataLength]; 
    173173            if (!imageData) return ReadResult::INSUFFICIENT_MEMORY_TO_LOAD; 
    174              
     174 
    175175            fin.read((char*)imageData, header.dataLength); 
    176176            if(!fin.good()) 
     
    179179                return ReadResult::ERROR_IN_READING_FILE; 
    180180            } 
    181              
     181 
    182182            image->setImage(header.width, header.height, 1, 
    183183                            internalFormat,    internalFormat, 
     
    185185                            imageData, 
    186186                            osg::Image::USE_NEW_DELETE); 
    187              
     187 
    188188            uint32_t dataOffset = 0; 
    189189            uint32_t blockSize = 0, widthBlocks = 0, heightBlocks = 0; 
    190190            uint32_t bpp = 4; 
    191              
     191 
    192192            osg::Image::MipmapDataType mipmapdata; 
    193              
     193 
    194194            // Calculate the data size for each texture level and respect the minimum number of blocks 
    195195            while(dataOffset < header.dataLength){ 
     
    210210                    bpp = 2; 
    211211                } 
    212                  
     212 
    213213                // Clamp to minimum number of blocks 
    214214                if(widthBlocks < 2) 
     
    216216                if(heightBlocks < 2) 
    217217                    heightBlocks = 2; 
    218                  
     218 
    219219                if(dataOffset > 0) 
    220220                    mipmapdata.push_back(dataOffset); 
    221                  
     221 
    222222                dataOffset += widthBlocks * heightBlocks * ((blockSize  * bpp) / 8); 
    223                  
     223 
    224224                width = osg::maximum(width >> 1, (uint32_t)1); 
    225225                height = osg::maximum(height >> 1, (uint32_t)1); 
    226226            } 
    227              
     227 
    228228            if(!mipmapdata.empty()) 
    229229                image->setMipmapLevels(mipmapdata); 
    230              
     230 
    231231            return image.get(); 
    232232        } 
    233          
     233 
    234234        osg::notify(osg::WARN) << "Failed to read pvr data." << std::endl; 
    235         return ReadResult::FILE_NOT_HANDLED;     
    236     } 
    237    
     235        return ReadResult::FILE_NOT_HANDLED; 
     236    } 
     237 
    238238    virtual ReadResult readObject(std::istream& fin,const osgDB::ReaderWriter::Options* options =NULL) const 
    239239    { 
     
    250250        return readPVRStream(fin); 
    251251    } 
    252      
     252 
    253253    virtual ReadResult readImage(const std::string& file, const osgDB::ReaderWriter::Options* options) const 
    254254    { 
     
    256256        if(!acceptsExtension(ext)) 
    257257            return ReadResult::FILE_NOT_HANDLED; 
    258          
     258 
    259259        std::string fileName = osgDB::findDataFile(file, options); 
    260260        if(fileName.empty()) 
    261261            return ReadResult::FILE_NOT_FOUND; 
    262          
     262 
    263263        std::ifstream istream(fileName.c_str(), std::ios::in | std::ios::binary); 
    264264        if(!istream) return ReadResult::FILE_NOT_HANDLED;