Show
Ignore:
Timestamp:
01/27/10 18:09:05 (4 years ago)
Author:
robert
Message:

From Wang Rui, "Changes:

1. Rewrite the reading/writing exception handlers to work like the ive
plugin exceptions.
2. Write a header writing/checking function in ReaderWriterOSG2.cpp,
which may help decide if the stream is ascii or binary. The
readInputIterator() function will return null pointer if the input
file is nither osgb nor osgt format, which indicates that the old .osg
format could be used here, in case we've merged the two plugins
together.
3. Add a new ForceReadingImage? option in the InputStream?, which will
allocate an empty image object with the filename if specifed external
image file is missed. It may be useful for format converting in some
cases.
4. Add new osgParticle wrappers, as well as some modification to the
osgParticle headers, for instance, change isEnabled() to getEnabled().
5. Some fixes to the osg serialization wrappers."

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgDB/InputStream.cpp

    r10986 r11018  
    2525 
    2626InputStream::InputStream( const osgDB::Options* options ) 
    27 :   _byteSwap(0), _useFloatMatrix(false), 
    28     _in(0) 
     27:   _byteSwap(0), _useFloatMatrix(false), _forceReadingImage(false) 
    2928{ 
    3029    if ( !options ) return; 
     
    3938        { 
    4039            // Omit this 
     40        } 
     41        else if ( option=="ForceReadingImage" ) 
     42        { 
     43            _forceReadingImage = true; 
    4144        } 
    4245        else 
     
    158161} 
    159162 
     163bool InputStream::matchString( const std::string& str ) 
     164{ 
     165    if ( !isBinary() ) 
     166    { 
     167        std::string s; *this >> s; 
     168        if ( s==str ) return true; 
     169        else _in->getStream()->seekg( -(int)(s.length()), std::ios::cur ); 
     170    } 
     171    return false; 
     172} 
     173 
     174void InputStream::advanceToCurrentEndBracket() 
     175{ 
     176    if ( isBinary() ) 
     177        return; 
     178     
     179    std::string passString; 
     180    unsigned int blocks = 0; 
     181    while ( !_in->getStream()->eof() ) 
     182    { 
     183        passString.clear(); 
     184        *this >> passString; 
     185         
     186        if ( passString=="}" ) 
     187        { 
     188            if ( blocks<=0 ) return; 
     189            else blocks--; 
     190        } 
     191        else if ( passString=="{" ) 
     192            blocks++; 
     193    } 
     194} 
     195 
     196void InputStream::readWrappedString( std::string& str ) 
     197{ 
     198    *this >> str; 
     199    if ( !isBinary() ) 
     200    { 
     201        if ( str[0]=='\"' ) 
     202        { 
     203            if ( str.size()==1 || (*str.rbegin())!='\"' ) 
     204            { 
     205                char ch; 
     206                do 
     207                { 
     208                    _in->getStream()->get( ch ); checkStream(); 
     209                    if ( ch=='\\' ) 
     210                    { 
     211                        _in->getStream()->get( ch ); checkStream(); 
     212                        if ( ch=='\"' ) 
     213                        { 
     214                            str += ch; ch = 0; 
     215                        } 
     216                        else if ( ch=='\\' ) 
     217                        { 
     218                            str += ch; 
     219                        } 
     220                        else 
     221                        { 
     222                            str += '\\'; str += ch; 
     223                        } 
     224                    } 
     225                    else 
     226                        str += ch; 
     227                } while ( ch!='\"' ); 
     228            } 
     229            str = str.substr(1, str.size()-2); 
     230        } 
     231    } 
     232} 
     233 
    160234osg::Array* InputStream::readArray() 
    161235{ 
     
    320394        break; 
    321395    default: 
    322         throw InputException(_currentField, "InputStream::readArray(): Unsupported array type."); 
    323     } 
    324      
     396        throwException( "InputStream::readArray(): Unsupported array type." ); 
     397    } 
     398     
     399    if ( getException() ) return NULL; 
    325400    _arrayMap[id] = array; 
    326401    return array.release(); 
     
    402477        break; 
    403478    default: 
    404         throw InputException(_currentField, "InputStream::readPrimitiveSet(): Unsupported array type."); 
    405     } 
     479        throwException( "InputStream::readPrimitiveSet(): Unsupported array type." ); 
     480    } 
     481     
     482    if ( getException() ) return NULL; 
    406483    return primitive.release(); 
    407484} 
     
    413490    *this >> PROPERTY("FileName"); readWrappedString(name); 
    414491    *this >> PROPERTY("WriteHint") >> writeHint >> decision; 
     492    if ( getException() ) return NULL; 
    415493     
    416494    osg::ref_ptr<osg::Image> image = NULL; 
     
    437515                char* data = new char[size]; 
    438516                if ( !data ) 
    439                     throw InputException(_currentField, "InputStream::readImage() Out of memory."); 
     517                    throwException( "InputStream::readImage() Out of memory." ); 
     518                if ( getException() ) return NULL; 
     519                 
    440520                readCharArray( data, size ); 
    441521                image->setOrigin( (osg::Image::Origin)origin ); 
     
    464544                char* data = new char[size]; 
    465545                if ( !data ) 
    466                     throw InputException(_currentField, "InputStream::readImage(): Out of memory."); 
     546                    throwException( "InputStream::readImage(): Out of memory." ); 
     547                if ( getException() ) return NULL; 
    467548                readCharArray( data, size ); 
    468549                 
     
    501582     
    502583    if ( readFromExternal ) 
     584    { 
    503585        image = osgDB::readImageFile( name ); 
     586        if ( !image && _forceReadingImage ) image = new osg::Image; 
     587    } 
    504588    if ( image.valid() ) 
    505589    { 
     
    517601    unsigned int id = 0; 
    518602    *this >> className >> BEGIN_BRACKET >> PROPERTY("UniqueID") >> id; 
     603    if ( getException() ) return NULL; 
    519604     
    520605    IdentifierMap::iterator itr = _identifierMap.find( id ); 
     
    533618        return NULL; 
    534619    } 
     620    _fields.push_back( className ); 
     621     
    535622    osg::ref_ptr<osg::Object> obj = existingObj ? existingObj : wrapper->getProto()->cloneType(); 
    536623    if ( obj.valid() ) 
     
    548635                continue; 
    549636            } 
     637            _fields.push_back( assocWrapper->getName() ); 
    550638             
    551             _currentField = assocWrapper->getName(); 
    552639            assocWrapper->read( *this, *obj ); 
     640            if ( getException() ) return NULL; 
     641             
     642            _fields.pop_back(); 
    553643        } 
    554644    } 
    555645    advanceToCurrentEndBracket(); 
     646    _fields.pop_back(); 
    556647    return obj.release(); 
    557648} 
     
    576667InputStream::ReadType InputStream::start( InputIterator* inIterator ) 
    577668{ 
     669    _fields.clear(); 
     670    _fields.push_back( "Start" ); 
     671     
    578672    ReadType type = READ_UNKNOWN; 
    579     _currentField = "Header"; 
    580673    _in = inIterator; 
    581674    if ( !_in ) 
    582         throw InputException(_currentField, "InputStream: Null stream specified."); 
     675        throwException( "InputStream: Null stream specified." ); 
     676    if ( getException() ) return type; 
    583677     
    584678    // Check OSG header information 
     
    596690    if ( !isBinary() ) 
    597691    { 
    598         DEF_PROPERTY("#Ascii", header); *this >> header; 
    599         if ( header._name!="#Ascii" ) return READ_UNKNOWN; 
    600          
    601692        std::string typeString; *this >> typeString; 
    602693        if ( typeString=="Scene" ) type = READ_SCENE; 
     
    615706                               << PLUGIN_VERSION << std::endl; 
    616707    } 
     708    _fields.pop_back(); 
    617709    return type; 
    618710} 
     
    620712void InputStream::decompress() 
    621713{ 
    622     _currentField = "Decompression"; 
     714    _fields.clear(); 
     715    _fields.push_back( "Decompression" ); 
    623716    if ( !isBinary() ) return; 
    624717     
     
    635728    std::string data; 
    636729    if ( !compressor->decompress(*(_in->getStream()), data) ) 
    637         throw InputException(_currentField, "InputStream: Failed to decompress stream."); 
     730        throwException( "InputStream: Failed to decompress stream." ); 
     731    if ( getException() ) return; 
     732     
    638733    _in->setStream( new std::stringstream(data) ); 
     734    _fields.pop_back(); 
    639735} 
    640736