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/osgPlugins/dds/ReaderWriterDDS.cpp

    r12912 r13041  
    1515*             Modified  13.05.2004 
    1616*                by George Tarantilis, gtaranti@nps.navy.mil 
    17 *             Modified  22.05.2009  
    18 *                Wojtek Lewandowski, lewandowski@ai.com.pl  
     17*             Modified  22.05.2009 
     18*                Wojtek Lewandowski, lewandowski@ai.com.pl 
    1919* 
    20 *    WARNING:  
    21 *          Bit Masks in the WrtiteDDS are set for 8 bit components  
    22 *          write with 4 or 16 bit components will  
    23 *          probably produce corrupted file  
    24 *          Wojtek Lewandowski 2009-05-22  
     20*    WARNING: 
     21*          Bit Masks in the WrtiteDDS are set for 8 bit components 
     22*          write with 4 or 16 bit components will 
     23*          probably produce corrupted file 
     24*          Wojtek Lewandowski 2009-05-22 
    2525* 
    2626**********************************************************************/ 
     
    5757        dwColorSpaceLowValue(0), 
    5858        dwColorSpaceHighValue(0) {} 
    59          
     59 
    6060    UI32    dwColorSpaceLowValue; 
    6161    UI32    dwColorSpaceHighValue; 
     
    7474        dwBBitMask(0), 
    7575        dwRGBAlphaBitMask(0) {} 
    76          
     76 
    7777 
    7878    UI32    dwSize; 
     
    135135        dwFlags(0), 
    136136        dwHeight(0), 
    137         dwWidth(0),  
     137        dwWidth(0), 
    138138        lPitch(0), 
    139139        dwBackBufferCount(0), 
    140140        dwMipMapCount(0), 
    141141        dwAlphaBitDepth(0), 
    142         dwReserved(0),      
    143         lpSurface(0),       
    144         dwTextureStage(0) {}       
    145          
     142        dwReserved(0), 
     143        lpSurface(0), 
     144        dwTextureStage(0) {} 
     145 
    146146 
    147147    UI32         dwSize; 
    148148    UI32         dwFlags; 
    149149    UI32         dwHeight; 
    150     UI32         dwWidth;  
    151     union                           
     150    UI32         dwWidth; 
     151    union 
    152152    { 
    153153        I32              lPitch; 
     
    157157    { 
    158158        UI32      dwBackBufferCount; 
    159         UI32      dwDepth;       
     159        UI32      dwDepth; 
    160160    }; 
    161161    union 
     
    165165    }; 
    166166    UI32         dwAlphaBitDepth; 
    167     UI32         dwReserved;      
    168     UI32        lpSurface;         //Fred Marmond: removed from pointer type to UI32 for 64bits compatibility. it is unused data  
    169     DDCOLORKEY    ddckCKDestOverlay;       
    170     DDCOLORKEY    ddckCKDestBlt;            
    171     DDCOLORKEY    ddckCKSrcOverlay;         
    172     DDCOLORKEY    ddckCKSrcBlt;             
    173     DDPIXELFORMAT ddpfPixelFormat;          
    174     DDSCAPS2      ddsCaps;                  
    175     UI32 dwTextureStage;           
     167    UI32         dwReserved; 
     168    UI32        lpSurface;         //Fred Marmond: removed from pointer type to UI32 for 64bits compatibility. it is unused data 
     169    DDCOLORKEY    ddckCKDestOverlay; 
     170    DDCOLORKEY    ddckCKDestBlt; 
     171    DDCOLORKEY    ddckCKSrcOverlay; 
     172    DDCOLORKEY    ddckCKSrcBlt; 
     173    DDPIXELFORMAT ddpfPixelFormat; 
     174    DDSCAPS2      ddsCaps; 
     175    UI32 dwTextureStage; 
    176176}; 
    177177 
     
    204204// 
    205205#define DDPF_ALPHAPIXELS        0x00000001l 
    206 #define DDPF_FOURCC             0x00000004l        // Compressed formats  
     206#define DDPF_FOURCC             0x00000004l        // Compressed formats 
    207207#define DDPF_RGB                0x00000040l        // Uncompressed formats 
    208208#define DDPF_ALPHA              0x00000002l 
     
    251251    if( depth < 1 )  depth = 1; 
    252252 
    253     // Taking advantage of the fact that  
     253    // Taking advantage of the fact that 
    254254    // DXT formats are defined as 4 successive numbers: 
    255255    // GL_COMPRESSED_RGB_S3TC_DXT1_EXT         0x83F0 
     
    296296 
    297297    char filecode[4]; 
    298      
     298 
    299299    _istream.read(filecode, 4); 
    300300    if (strncmp(filecode, "DDS ", 4) != 0) { 
     
    304304    _istream.read((char*)(&ddsd), sizeof(ddsd)); 
    305305 
    306     osg::ref_ptr<osg::Image> osgImage = new osg::Image();     
    307      
     306    osg::ref_ptr<osg::Image> osgImage = new osg::Image(); 
     307 
    308308    //Check valid structure sizes 
    309309    if(ddsd.dwSize != 124 && ddsd.ddpfPixelFormat.dwSize != 32) 
     
    323323    int s = ddsd.dwWidth; 
    324324    int t = ddsd.dwHeight; 
    325     int r = depth;  
     325    int r = depth; 
    326326    unsigned int dataType = GL_UNSIGNED_BYTE; 
    327327    unsigned int pixelFormat = 0; 
     
    329329 
    330330    // Handle some esoteric formats 
    331     if(ddsd.ddpfPixelFormat.dwFlags & DDPF_BUMPDUDV)  
     331    if(ddsd.ddpfPixelFormat.dwFlags & DDPF_BUMPDUDV) 
    332332    { 
    333333        OSG_WARN << "ReadDDSFile warning: DDPF_BUMPDUDV format is not supported" << std::endl; 
     
    340340//         // A2W10U10V10 as RGBA (dwFlags == DDPF_BUMPDUDV + DDPF_ALPHAPIXELS) 
    341341    } 
    342     if(ddsd.ddpfPixelFormat.dwFlags & DDPF_BUMPLUMINANCE)  
     342    if(ddsd.ddpfPixelFormat.dwFlags & DDPF_BUMPLUMINANCE) 
    343343    { 
    344344        OSG_WARN << "ReadDDSFile warning: DDPF_BUMPLUMINANCE format is not supported" << std::endl; 
     
    349349//         // X8L8V8U8 -- just as RGB 
    350350    } 
    351      
     351 
    352352    // Uncompressed formats will usually use DDPF_RGB to indicate an RGB format, 
    353353    // while compressed formats will use DDPF_FOURCC with a four-character code. 
    354      
     354 
    355355    bool usingAlpha = ddsd.ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS; 
    356356 
     
    373373        const unsigned int UNSUPPORTED = 0; 
    374374 
    375         static const RGBFormat rgbFormats[] =             
     375        static const RGBFormat rgbFormats[] = 
    376376        { 
    377377            { "R3G3B2"     ,  8,       0xe0,       0x1c,       0x03,       0x00, 
     
    392392 
    393393            { "R8G8B8",      24,   0xff0000,   0x00ff00,   0x0000ff,   0x000000, 
    394               GL_RGB , GL_BGR , GL_UNSIGNED_BYTE },  
     394              GL_RGB , GL_BGR , GL_UNSIGNED_BYTE }, 
    395395 
    396396            { "B8G8R8",      24,   0x0000ff,   0x00ff00,   0xff0000,   0x000000, 
    397               GL_RGB , GL_RGB , GL_UNSIGNED_BYTE },  
     397              GL_RGB , GL_RGB , GL_UNSIGNED_BYTE }, 
    398398 
    399399            { "A8R8G8B8",    32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000, 
    400               GL_RGBA, GL_BGRA, GL_UNSIGNED_BYTE },  
     400              GL_RGBA, GL_BGRA, GL_UNSIGNED_BYTE }, 
    401401            { "X8R8G8B8",    32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000, 
    402               GL_RGB , GL_BGRA, GL_UNSIGNED_BYTE },  
     402              GL_RGB , GL_BGRA, GL_UNSIGNED_BYTE }, 
    403403            { "A8B8G8R8",    32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000, 
    404               GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE },  
     404              GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE }, 
    405405            { "X8B8G8R8",    32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000, 
    406               GL_RGB , GL_RGBA, GL_UNSIGNED_BYTE },  
     406              GL_RGB , GL_RGBA, GL_UNSIGNED_BYTE }, 
    407407            { "A2R10G10B10", 32, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000, 
    408               GL_RGBA, GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV },  
     408              GL_RGBA, GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV }, 
    409409            { "A2B10G10R10", 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000, 
    410               GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV },  
     410              GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV }, 
    411411            { "G16R16",      32, 0x0000ffff, 0xffff0000, 0x00000000, 0x00000000, 
    412               GL_RGB, UNSUPPORTED, GL_UNSIGNED_SHORT },  
     412              GL_RGB, UNSUPPORTED, GL_UNSIGNED_SHORT }, 
    413413        }; 
    414414 
     
    439439                    OSG_INFO << "ReadDDSFile info : " << f.name 
    440440                                           << " format is not supported" << std::endl; 
    441                     return NULL;                    
     441                    return NULL; 
    442442                } 
    443             }             
     443            } 
    444444        } 
    445445 
     
    450450                                   << ddsd.ddpfPixelFormat.dwRGBBitCount << std::endl; 
    451451            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwRBitMask        = 0x" 
    452                                    << std::hex << std::setw(8) << std::setfill('0')  
     452                                   << std::hex << std::setw(8) << std::setfill('0') 
    453453                                   << ddsd.ddpfPixelFormat.dwRBitMask << std::endl; 
    454454            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwGBitMask        = 0x" 
    455                                    << std::hex << std::setw(8) << std::setfill('0')  
     455                                   << std::hex << std::setw(8) << std::setfill('0') 
    456456                                   << ddsd.ddpfPixelFormat.dwGBitMask << std::endl; 
    457457            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwBBitMask        = 0x" 
    458                                    << std::hex << std::setw(8) << std::setfill('0')  
     458                                   << std::hex << std::setw(8) << std::setfill('0') 
    459459                                   << ddsd.ddpfPixelFormat.dwBBitMask << std::endl; 
    460460            OSG_INFO << "ReadDDSFile info : ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0x" 
    461                                    << std::hex << std::setw(8) << std::setfill('0')  
     461                                   << std::hex << std::setw(8) << std::setfill('0') 
    462462                                   << ddsd.ddpfPixelFormat.dwRGBAlphaBitMask << std::dec << std::endl; 
    463463            return NULL; 
     
    500500            OSG_INFO << "ReadDDSFile info : format = ALPHA" << std::endl; 
    501501            internalFormat = GL_ALPHA; 
    502             pixelFormat    = GL_ALPHA;               
     502            pixelFormat    = GL_ALPHA; 
    503503    } 
    504504    // Compressed formats 
     
    539539            internalFormat = GL_COMPRESSED_RED_GREEN_RGTC2_EXT; 
    540540            pixelFormat    = GL_COMPRESSED_RED_GREEN_RGTC2_EXT; 
    541             break;         
     541            break; 
    542542        case 0x00000024: // A16B16G16R16 
    543543            OSG_INFO << "ReadDDSFile info : format = A16B16G16R16" << std::endl; 
     
    550550            internalFormat = GL_RGBA; // why no transparency? 
    551551            pixelFormat    = GL_RGBA; 
    552             dataType       = GL_HALF_FLOAT_NV;  
     552            dataType       = GL_HALF_FLOAT_NV; 
    553553            break; 
    554554        case 0x0000006E: // Q16W16V16U16 
     
    611611                                   << ddsd.ddpfPixelFormat.dwFourCC << std::dec 
    612612                                   << ") in dds file, image not loaded." << std::endl; 
    613             return NULL;  
    614         } 
    615     } 
    616     else  
     613            return NULL; 
     614        } 
     615    } 
     616    else 
    617617    { 
    618618        OSG_WARN << "ReadDDSFile warning: unhandled pixel format (ddsd.ddpfPixelFormat.dwFlags" 
     
    629629    osg::Image::MipmapDataType mipmap_offsets; 
    630630    if ( ddsd.dwMipMapCount>1 ) 
    631     {         
     631    { 
    632632        unsigned numMipmaps = osg::Image::computeNumberOfMipmapLevels( s, t, r ); 
    633633        if( numMipmaps > ddsd.dwMipMapCount ) numMipmaps = ddsd.dwMipMapCount; 
     
    636636 
    637637        int width = s; 
    638         int height = t;  
     638        int height = t; 
    639639        int depth = r; 
    640640 
     
    647647           depth = osg::maximum( depth >> 1, 1 ); 
    648648 
    649            sizeWithMipmaps +=  
     649           sizeWithMipmaps += 
    650650                ComputeImageSizeInBytes( width, height, depth, pixelFormat, dataType ); 
    651651        } 
    652652    } 
    653       
     653 
    654654    unsigned char* imageData = new unsigned char [sizeWithMipmaps]; 
    655655    if(!imageData) 
     
    658658        return NULL; 
    659659    } 
    660      
    661     // Read pixels in two chunks. First main image, next mipmaps.  
     660 
     661    // Read pixels in two chunks. First main image, next mipmaps. 
    662662    if ( !_istream.read( (char*)imageData, size ) ) 
    663663    { 
     
    689689{ 
    690690 
    691     // Initialize ddsd structure and its members  
     691    // Initialize ddsd structure and its members 
    692692    DDSURFACEDESC2 ddsd; 
    693693    memset( &ddsd, 0, sizeof( ddsd ) ); 
     
    701701    memset( &ddsCaps, 0, sizeof( ddsCaps ) ); 
    702702 
    703     ddsd.dwSize = sizeof(ddsd);   
     703    ddsd.dwSize = sizeof(ddsd); 
    704704    ddpf.dwSize = sizeof(ddpf); 
    705705 
    706706    // Default values and initialization of structures' flags 
    707707    unsigned int SD_flags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT; 
    708     unsigned int CAPS_flags  = DDSCAPS_TEXTURE;  
     708    unsigned int CAPS_flags  = DDSCAPS_TEXTURE; 
    709709    unsigned int PF_flags = 0; 
    710710    unsigned int CAPS2_flags = 0; 
     
    738738            ddpf.dwRBitMask        = 0x000000ff; 
    739739            ddpf.dwGBitMask        = 0x0000ff00; 
    740             ddpf.dwBBitMask        = 0x00ff0000;   
     740            ddpf.dwBBitMask        = 0x00ff0000; 
    741741            ddpf.dwRGBAlphaBitMask = 0xff000000; 
    742742            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_RGB); 
    743             ddpf.dwRGBBitCount = pixelSize;  
     743            ddpf.dwRGBBitCount = pixelSize; 
    744744            ddsd.lPitch = img->getRowSizeInBytes(); 
    745745            SD_flags |= DDSD_PITCH; 
     
    750750            ddpf.dwBBitMask        = 0x000000ff; 
    751751            ddpf.dwGBitMask        = 0x0000ff00; 
    752             ddpf.dwRBitMask        = 0x00ff0000;   
     752            ddpf.dwRBitMask        = 0x00ff0000; 
    753753            ddpf.dwRGBAlphaBitMask = 0xff000000; 
    754754            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_RGB); 
    755             ddpf.dwRGBBitCount = pixelSize;  
     755            ddpf.dwRGBBitCount = pixelSize; 
    756756            ddsd.lPitch = img->getRowSizeInBytes(); 
    757757            SD_flags |= DDSD_PITCH; 
     
    762762            ddpf.dwRBitMask         = 0x000000ff; 
    763763            ddpf.dwRGBAlphaBitMask  = 0x0000ff00; 
    764             PF_flags |= (DDPF_ALPHAPIXELS | DDPF_LUMINANCE);   
    765             ddpf.dwRGBBitCount = pixelSize;  
     764            PF_flags |= (DDPF_ALPHAPIXELS | DDPF_LUMINANCE); 
     765            ddpf.dwRGBBitCount = pixelSize; 
    766766            ddsd.lPitch = img->getRowSizeInBytes(); 
    767767            SD_flags |= DDSD_PITCH; 
     
    772772            ddpf.dwRBitMask        = 0x000000ff; 
    773773            ddpf.dwGBitMask        = 0x0000ff00; 
    774             ddpf.dwBBitMask        = 0x00ff0000;   
     774            ddpf.dwBBitMask        = 0x00ff0000; 
    775775            PF_flags |= DDPF_RGB; 
    776776            ddpf.dwRGBBitCount = pixelSize; 
     
    783783            ddpf.dwBBitMask        = 0x000000ff; 
    784784            ddpf.dwGBitMask        = 0x0000ff00; 
    785             ddpf.dwRBitMask        = 0x00ff0000;   
     785            ddpf.dwRBitMask        = 0x00ff0000; 
    786786            PF_flags |= DDPF_RGB; 
    787787            ddpf.dwRGBBitCount = pixelSize; 
     
    857857            SD_flags |= DDSD_LINEARSIZE; 
    858858        } 
    859         break;     
     859        break; 
    860860    case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 
    861861        { 
     
    865865            SD_flags |= DDSD_LINEARSIZE; 
    866866        } 
    867         break;     
     867        break; 
    868868    case GL_COMPRESSED_RED_GREEN_RGTC2_EXT: 
    869869        { 
     
    873873            SD_flags |= DDSD_LINEARSIZE; 
    874874        } 
    875         break;     
     875        break; 
    876876    default: 
    877877        OSG_WARN<<"Warning:: unhandled pixel format in image, file cannot be written."<<std::endl; 
     
    892892        SD_flags   |= DDSD_MIPMAPCOUNT; 
    893893        CAPS_flags |= DDSCAPS_COMPLEX | DDSCAPS_MIPMAP; 
    894          
     894 
    895895        ddsd.dwMipMapCount = img->getNumMipmapLevels(); 
    896896 
     
    921921 
    922922    // If we get that far the file was saved properly // 
    923     return true;  
     923    return true; 
    924924} 
    925925 
     
    939939 
    940940    virtual const char* className() const 
    941     {  
    942         return "DDS Image Reader/Writer";  
     941    { 
     942        return "DDS Image Reader/Writer"; 
    943943    } 
    944944 
     
    959959 
    960960        std::string fileName = osgDB::findDataFile( file, options ); 
    961      
     961 
    962962        if (fileName.empty()) return ReadResult::FILE_NOT_FOUND; 
    963          
     963 
    964964        osgDB::ifstream stream(fileName.c_str(), std::ios::in | std::ios::binary); 
    965965        if(!stream) return ReadResult::FILE_NOT_HANDLED; 
     
    10161016            osgImage->flipVertical(); 
    10171017        } 
    1018          
     1018 
    10191019        return osgImage; 
    10201020    }