root/OpenSceneGraph/trunk/src/osgDB/InputStream.cpp @ 11018

Revision 11018, 23.2 kB (checked in by robert, 4 years ago)

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."

Line 
1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 Robert Osfield
2 *
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
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 * OpenSceneGraph Public License for more details.
12*/
13// Written by Wang Rui, (C) 2010
14
15#include <osg/Notify>
16#include <osg/ImageSequence>
17#include <osgDB/ReadFile>
18#include <osgDB/XmlParser>
19#include <osgDB/FileNameUtils>
20#include <osgDB/ObjectWrapper>
21
22using namespace osgDB;
23
24static std::string s_lastSchema;
25
26InputStream::InputStream( const osgDB::Options* options )
27:   _byteSwap(0), _useFloatMatrix(false), _forceReadingImage(false)
28{
29    if ( !options ) return;
30   
31    std::string schema;
32    StringList optionList;
33    split( options->getOptionString(), optionList );
34    for ( StringList::iterator itr=optionList.begin(); itr!=optionList.end(); ++itr )
35    {
36        const std::string& option = *itr;
37        if ( option=="Ascii" )
38        {
39            // Omit this
40        }
41        else if ( option=="ForceReadingImage" )
42        {
43            _forceReadingImage = true;
44        }
45        else
46        {
47            StringList keyAndValues;
48            split( option, keyAndValues, '=' );
49            if ( keyAndValues.size()<2 ) continue;
50           
51            if ( keyAndValues[0]=="SchemaFile" )
52            {
53                schema = keyAndValues[1];
54                if ( s_lastSchema!=schema )
55                {
56                    osgDB::ifstream schemaStream( schema.c_str(), std::ios::in );
57                    if ( !schemaStream.fail() ) readSchema( schemaStream );
58                    schemaStream.close();
59                    s_lastSchema = schema;
60                }
61            }
62            else
63                osg::notify(osg::WARN) << "InputStream: Unknown option " << option << std::endl;
64        }
65    }
66    if ( schema.empty() )
67    {
68        resetSchema();
69        s_lastSchema.clear();
70    }
71}
72
73InputStream::~InputStream()
74{
75}
76
77InputStream& InputStream::operator>>( osg::Vec2b& v )
78{
79    char x, y; *this >> x >> y;
80    v.set( x, y );
81    return *this;
82}
83
84InputStream& InputStream::operator>>( osg::Vec3b& v )
85{
86    char x, y, z; *this >> x >> y >> z;
87    v.set( x, y, z );
88    return *this;
89}
90
91InputStream& InputStream::operator>>( osg::Vec4b& v )
92{
93    char x, y, z, w; *this >> x >> y >> z >> w;
94    v.set( x, y, z, w );
95    return *this;
96}
97
98InputStream& InputStream::operator>>( osg::Vec4ub& v )
99{
100    char r, g, b, a; *this >> r >> g >> b >> a;
101    v.set( r, g, b, a );
102    return *this;
103}
104
105InputStream& InputStream::operator>>( osg::Vec2s& v )
106{ *this >> v.x() >> v.y(); return *this; }
107
108InputStream& InputStream::operator>>( osg::Vec3s& v )
109{ *this >> v.x() >> v.y() >> v.z(); return *this; }
110
111InputStream& InputStream::operator>>( osg::Vec4s& v )
112{ *this >> v.x() >> v.y() >> v.z() >> v.w(); return *this; }
113
114InputStream& InputStream::operator>>( osg::Vec2f& v )
115{ *this >> v.x() >> v.y(); return *this; }
116
117InputStream& InputStream::operator>>( osg::Vec3f& v )
118{ *this >> v.x() >> v.y() >> v.z(); return *this; }
119
120InputStream& InputStream::operator>>( osg::Vec4f& v )
121{ *this >> v.x() >> v.y() >> v.z() >> v.w(); return *this; }
122
123InputStream& InputStream::operator>>( osg::Vec2d& v )
124{ *this >> v.x() >> v.y(); return *this; }
125
126InputStream& InputStream::operator>>( osg::Vec3d& v )
127{ *this >> v.x() >> v.y() >> v.z(); return *this; }
128
129InputStream& InputStream::operator>>( osg::Vec4d& v )
130{ *this >> v.x() >> v.y() >> v.z() >> v.w(); return *this; }
131
132InputStream& InputStream::operator>>( osg::Quat& q )
133{ *this >> q.x() >> q.y() >> q.z() >> q.w(); return *this; }
134
135InputStream& InputStream::operator>>( osg::Plane& p )
136{
137    double p0, p1, p2, p3; *this >> p0 >> p1 >> p2 >> p3;
138    p.set( p0, p1, p2, p3 ); return *this;
139}
140
141InputStream& InputStream::operator>>( osg::Matrixf& mat )
142{
143    *this >> PROPERTY("Matrixf") >> BEGIN_BRACKET;
144    for ( int r=0; r<4; ++r )
145    {
146        *this >> mat(r, 0) >> mat(r, 1) >> mat(r, 2) >> mat(r, 3);
147    }
148    *this >> END_BRACKET;
149    return *this;
150}
151
152InputStream& InputStream::operator>>( osg::Matrixd& mat )
153{
154    *this >> PROPERTY("Matrixd") >> BEGIN_BRACKET;
155    for ( int r=0; r<4; ++r )
156    {
157        *this >> mat(r, 0) >> mat(r, 1) >> mat(r, 2) >> mat(r, 3);
158    }
159    *this >> END_BRACKET;
160    return *this;
161}
162
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
234osg::Array* InputStream::readArray()
235{
236    osg::ref_ptr<osg::Array> array = NULL;
237   
238    unsigned int id = 0;
239    *this >> PROPERTY("ArrayID") >> id;
240   
241    ArrayMap::iterator itr = _arrayMap.find( id );
242    if ( itr!=_arrayMap.end() ) return itr->second.get();
243   
244    DEF_MAPPEE(ArrayType, type);
245    *this >> type;
246    switch ( type.get() )
247    {
248    case ID_BYTE_ARRAY:
249        {
250            osg::ByteArray* ba = new osg::ByteArray;
251            readArrayImplementation( ba, CHAR_SIZE, true );
252            array = ba;
253        }
254        break;
255    case ID_UBYTE_ARRAY:
256        {
257            osg::UByteArray* uba = new osg::UByteArray;
258            readArrayImplementation( uba, CHAR_SIZE, true );
259            array = uba;
260        }
261        break;
262    case ID_SHORT_ARRAY:
263        {
264            osg::ShortArray* sa = new osg::ShortArray;
265            readArrayImplementation( sa, SHORT_SIZE, true );
266            array = sa;
267        }
268        break;
269    case ID_USHORT_ARRAY:
270        {
271            osg::UShortArray* usa = new osg::UShortArray;
272            readArrayImplementation( usa, SHORT_SIZE, true );
273            array = usa;
274        }
275        break;
276    case ID_INT_ARRAY:
277        {
278            osg::IntArray* ia = new osg::IntArray;
279            readArrayImplementation( ia, INT_SIZE, true );
280            array = ia;
281        }
282        break;
283    case ID_UINT_ARRAY:
284        {
285            osg::UIntArray* uia = new osg::UIntArray;
286            readArrayImplementation( uia, INT_SIZE, true );
287            array = uia;
288        }
289        break;
290    case ID_FLOAT_ARRAY:
291        {
292            osg::FloatArray* fa = new osg::FloatArray;
293            readArrayImplementation( fa, FLOAT_SIZE, true );
294            array = fa;
295        }
296        break;
297    case ID_DOUBLE_ARRAY:
298        {
299            osg::DoubleArray* da = new osg::DoubleArray;
300            readArrayImplementation( da, DOUBLE_SIZE, true );
301            array = da;
302        }
303        break;
304    case ID_VEC2B_ARRAY:
305        {
306            osg::Vec2bArray* va = new osg::Vec2bArray;
307            readArrayImplementation( va, 2*CHAR_SIZE );
308            array = va;
309        }
310        break;
311    case ID_VEC3B_ARRAY:
312        {
313            osg::Vec3bArray* va = new osg::Vec3bArray;
314            readArrayImplementation( va, 3*CHAR_SIZE );
315            array = va;
316        }
317        break;
318    case ID_VEC4B_ARRAY:
319        {
320            osg::Vec4bArray* va = new osg::Vec4bArray;
321            readArrayImplementation( va, 4*CHAR_SIZE );
322            array = va;
323        }
324        break;
325    case ID_VEC4UB_ARRAY:
326        {
327            osg::Vec4ubArray* va = new osg::Vec4ubArray;
328            readArrayImplementation( va, 4*CHAR_SIZE );
329            array = va;
330        }
331        break;
332    case ID_VEC2S_ARRAY:
333        {
334            osg::Vec2sArray* va = new osg::Vec2sArray;
335            readArrayImplementation( va, 2*SHORT_SIZE );
336            array = va;
337        }
338        break;
339    case ID_VEC3S_ARRAY:
340        {
341            osg::Vec3sArray* va = new osg::Vec3sArray;
342            readArrayImplementation( va, 3*SHORT_SIZE );
343            array = va;
344        }
345        break;
346    case ID_VEC4S_ARRAY:
347        {
348            osg::Vec4sArray* va = new osg::Vec4sArray;
349            readArrayImplementation( va, 4*SHORT_SIZE );
350            array = va;
351        }
352        break;
353    case ID_VEC2_ARRAY:
354        {
355            osg::Vec2Array* va = new osg::Vec2Array;
356            readArrayImplementation( va, 2*FLOAT_SIZE );
357            array = va;
358        }
359        break;
360    case ID_VEC3_ARRAY:
361        {
362            osg::Vec3Array* va = new osg::Vec3Array;
363            readArrayImplementation( va, 3*FLOAT_SIZE );
364            array = va;
365        }
366        break;
367    case ID_VEC4_ARRAY:
368        {
369            osg::Vec4Array* va = new osg::Vec4Array;
370            readArrayImplementation( va, 4*FLOAT_SIZE );
371            array = va;
372        }
373        break;
374    case ID_VEC2D_ARRAY:
375        {
376            osg::Vec2dArray* va = new osg::Vec2dArray;
377            readArrayImplementation( va, 2*DOUBLE_SIZE );
378            array = va;
379        }
380        break;
381    case ID_VEC3D_ARRAY:
382        {
383            osg::Vec3dArray* va = new osg::Vec3dArray;
384            readArrayImplementation( va, 3*DOUBLE_SIZE );
385            array = va;
386        }
387        break;
388    case ID_VEC4D_ARRAY:
389        {
390            osg::Vec4dArray* va = new osg::Vec4dArray;
391            readArrayImplementation( va, 4*DOUBLE_SIZE );
392            array = va;
393        }
394        break;
395    default:
396        throwException( "InputStream::readArray(): Unsupported array type." );
397    }
398   
399    if ( getException() ) return NULL;
400    _arrayMap[id] = array;
401    return array.release();
402}
403
404osg::PrimitiveSet* InputStream::readPrimitiveSet()
405{
406    osg::ref_ptr<osg::PrimitiveSet> primitive = NULL;
407   
408    DEF_MAPPEE(PrimitiveType, type);
409    DEF_MAPPEE(PrimitiveType, mode);
410    *this >> type >> mode;
411   
412    switch ( type.get() )
413    {
414    case ID_DRAWARRAYS:
415        {
416            int first = 0, count = 0;
417            *this >> first >> count;
418            osg::DrawArrays* da = new osg::DrawArrays( mode.get(), first, count );
419            primitive = da;
420        }
421        break;
422    case ID_DRAWARRAY_LENGTH:
423        {
424            int first = 0, value = 0; unsigned int size = 0;
425            *this >> first >> size >> BEGIN_BRACKET;
426            osg::DrawArrayLengths* dl = new osg::DrawArrayLengths( mode.get(), first );
427            for ( unsigned int i=0; i<size; ++i )
428            {
429                *this >> value;
430                dl->push_back( value );
431            }
432            *this >> END_BRACKET;
433            primitive = dl;
434        }
435        break;
436    case ID_DRAWELEMENTS_UBYTE:
437        {
438            osg::DrawElementsUByte* de = new osg::DrawElementsUByte( mode.get() );
439            unsigned int size = 0; unsigned char value = 0;
440            *this >> size >> BEGIN_BRACKET;
441            for ( unsigned int i=0; i<size; ++i )
442            {
443                *this >> value;
444                de->push_back( value );
445            }
446            *this >> END_BRACKET;
447            primitive = de;
448        }
449        break;
450    case ID_DRAWELEMENTS_USHORT:
451        {
452            osg::DrawElementsUShort* de = new osg::DrawElementsUShort( mode.get() );
453            unsigned int size = 0; unsigned short value = 0;
454            *this >> size >> BEGIN_BRACKET;
455            for ( unsigned int i=0; i<size; ++i )
456            {
457                *this >> value;
458                de->push_back( value );
459            }
460            *this >> END_BRACKET;
461            primitive = de;
462        }
463        break;
464    case ID_DRAWELEMENTS_UINT:
465        {
466            osg::DrawElementsUInt* de = new osg::DrawElementsUInt( mode.get() );
467            unsigned int size = 0, value = 0;
468            *this >> size >> BEGIN_BRACKET;
469            for ( unsigned int i=0; i<size; ++i )
470            {
471                *this >> value;
472                de->push_back( value );
473            }
474            *this >> END_BRACKET;
475            primitive = de;
476        }
477        break;
478    default:
479        throwException( "InputStream::readPrimitiveSet(): Unsupported array type." );
480    }
481   
482    if ( getException() ) return NULL;
483    return primitive.release();
484}
485
486osg::Image* InputStream::readImage()
487{
488    std::string name;
489    int writeHint, decision = IMAGE_EXTERNAL;
490    *this >> PROPERTY("FileName"); readWrappedString(name);
491    *this >> PROPERTY("WriteHint") >> writeHint >> decision;
492    if ( getException() ) return NULL;
493   
494    osg::ref_ptr<osg::Image> image = NULL;
495    bool readFromExternal = true;
496    switch ( decision )
497    {
498    case IMAGE_INLINE_DATA:
499        if ( isBinary() )
500        {
501            image = new osg::Image;
502           
503            // _origin, _s & _t & _r, _internalTextureFormat
504            int origin, s, t, r, internalFormat;
505            *this >> origin >> s >> t >> r >> internalFormat;
506           
507            // _pixelFormat, _dataType, _packing, _allocationMode
508            int pixelFormat, dataType, packing, mode;
509            *this >> pixelFormat >> dataType >> packing >> mode;
510           
511            // _data
512            unsigned int size = 0; *this >> size;
513            if ( size )
514            {
515                char* data = new char[size];
516                if ( !data )
517                    throwException( "InputStream::readImage() Out of memory." );
518                if ( getException() ) return NULL;
519               
520                readCharArray( data, size );
521                image->setOrigin( (osg::Image::Origin)origin );
522                image->setImage( s, t, r, internalFormat, pixelFormat, dataType,
523                    (unsigned char*)data, (osg::Image::AllocationMode)mode, packing );
524            }
525
526            // _mipmapData
527            unsigned int levelSize = 0; *this >> levelSize;
528            osg::Image::MipmapDataType levels(levelSize);
529            for ( unsigned int i=0; i<levelSize; ++i )
530            {
531                *this >> levels[i];
532            }
533            if ( levelSize>0 )
534                image->setMipmapLevels( levels );
535            readFromExternal = false;
536        }
537        break;
538    case IMAGE_INLINE_FILE:
539        if ( isBinary() )
540        {
541            unsigned int size = 0; *this >> size;
542            if ( size>0 )
543            {
544                char* data = new char[size];
545                if ( !data )
546                    throwException( "InputStream::readImage(): Out of memory." );
547                if ( getException() ) return NULL;
548                readCharArray( data, size );
549               
550                std::string ext = osgDB::getFileExtension( name );
551                osgDB::ReaderWriter* reader =
552                    osgDB::Registry::instance()->getReaderWriterForExtension( ext );
553                if ( reader )
554                {
555                    std::stringstream inputStream;
556                    inputStream.write( data, size );
557                   
558                    osgDB::ReaderWriter::ReadResult rr = reader->readImage( inputStream );
559                    if ( rr.validImage() )
560                        image = rr.takeImage();
561                    else
562                    {
563                        osg::notify(osg::WARN) << "InputStream::readImage(): "
564                                               << rr.message() << std::endl;
565                    }
566                }
567                else
568                {
569                    osg::notify(osg::WARN) << "InputStream::readImage(): Unable to find a plugin for "
570                                           << ext << std::endl;
571                }
572                delete[] data;
573            }
574            readFromExternal = false;
575        }
576        break;
577    case IMAGE_EXTERNAL: case IMAGE_WRITE_OUT:
578        break;
579    default:
580        break;
581    }
582   
583    if ( readFromExternal )
584    {
585        image = osgDB::readImageFile( name );
586        if ( !image && _forceReadingImage ) image = new osg::Image;
587    }
588    if ( image.valid() )
589    {
590        image->setFileName( name );
591        image->setWriteHint( (osg::Image::WriteHint)writeHint );
592    }
593   
594    image = static_cast<osg::Image*>( readObject(image.get()) );
595    return image.release();
596}
597
598osg::Object* InputStream::readObject( osg::Object* existingObj )
599{
600    std::string className;
601    unsigned int id = 0;
602    *this >> className >> BEGIN_BRACKET >> PROPERTY("UniqueID") >> id;
603    if ( getException() ) return NULL;
604   
605    IdentifierMap::iterator itr = _identifierMap.find( id );
606    if ( itr!=_identifierMap.end() )
607    {
608        advanceToCurrentEndBracket();
609        return itr->second.get();
610    }
611   
612    ObjectWrapper* wrapper = Registry::instance()->getObjectWrapperManager()->findWrapper( className );
613    if ( !wrapper )
614    {
615        osg::notify(osg::WARN) << "InputStream::readObject(): Unsupported wrapper class "
616                               << className << std::endl;
617        advanceToCurrentEndBracket();
618        return NULL;
619    }
620    _fields.push_back( className );
621   
622    osg::ref_ptr<osg::Object> obj = existingObj ? existingObj : wrapper->getProto()->cloneType();
623    if ( obj.valid() )
624    {
625        _identifierMap[id] = obj;
626       
627        const StringList& associates = wrapper->getAssociates();
628        for ( StringList::const_iterator itr=associates.begin(); itr!=associates.end(); ++itr )
629        {
630            ObjectWrapper* assocWrapper = Registry::instance()->getObjectWrapperManager()->findWrapper(*itr);
631            if ( !assocWrapper )
632            {
633                osg::notify(osg::WARN) << "InputStream::readObject(): Unsupported associated class "
634                                       << *itr << std::endl;
635                continue;
636            }
637            _fields.push_back( assocWrapper->getName() );
638           
639            assocWrapper->read( *this, *obj );
640            if ( getException() ) return NULL;
641           
642            _fields.pop_back();
643        }
644    }
645    advanceToCurrentEndBracket();
646    _fields.pop_back();
647    return obj.release();
648}
649
650void InputStream::readSchema( std::istream& fin )
651{
652    // Read from external ascii stream
653    std::string line;
654    while ( std::getline(fin, line) )
655    {
656        if ( line[0]=='#' ) continue// Comment
657       
658        StringList keyAndValue;
659        split( line, keyAndValue, '=' );
660        if ( keyAndValue.size()<2 ) continue;
661       
662        setWrapperSchema( osgDB::trimEnclosingSpaces(keyAndValue[0]),
663                          osgDB::trimEnclosingSpaces(keyAndValue[1]) );
664    }
665}
666
667InputStream::ReadType InputStream::start( InputIterator* inIterator )
668{
669    _fields.clear();
670    _fields.push_back( "Start" );
671   
672    ReadType type = READ_UNKNOWN;
673    _in = inIterator;
674    if ( !_in )
675        throwException( "InputStream: Null stream specified." );
676    if ( getException() ) return type;
677   
678    // Check OSG header information
679    unsigned int version = 0;
680    if ( isBinary() )
681    {
682        unsigned int typeValue;
683        *this >> typeValue >> version;
684        type = static_cast<ReadType>(typeValue);
685       
686        unsigned int matrixValueType; *this >> matrixValueType;
687        if ( matrixValueType==0 ) _useFloatMatrix = true;
688        else _useFloatMatrix = false;
689    }
690    if ( !isBinary() )
691    {
692        std::string typeString; *this >> typeString;
693        if ( typeString=="Scene" ) type = READ_SCENE;
694        else if ( typeString=="Image" ) type = READ_IMAGE;
695       
696        std::string osgName, osgVersion;
697        *this >> PROPERTY("#Version") >> version;
698        *this >> PROPERTY("#Generator") >> osgName >> osgVersion;
699    }
700   
701    // Check file version
702    if ( version!=PLUGIN_VERSION )
703    {
704        osg::notify(osg::WARN) << "InputStream: Input data version " << version
705                               << " may be incompatible with current reader version "
706                               << PLUGIN_VERSION << std::endl;
707    }
708    _fields.pop_back();
709    return type;
710}
711
712void InputStream::decompress()
713{
714    _fields.clear();
715    _fields.push_back( "Decompression" );
716    if ( !isBinary() ) return;
717   
718    std::string compressorName; *this >> compressorName;
719    if ( compressorName=="0" ) return;
720   
721    BaseCompressor* compressor = Registry::instance()->getObjectWrapperManager()->findCompressor(compressorName);
722    if ( !compressor )
723    {
724        osg::notify(osg::WARN) << "InputStream::decompress(): No such compressor "
725                               << compressorName << std::endl;
726    }
727   
728    std::string data;
729    if ( !compressor->decompress(*(_in->getStream()), data) )
730        throwException( "InputStream: Failed to decompress stream." );
731    if ( getException() ) return;
732   
733    _in->setStream( new std::stringstream(data) );
734    _fields.pop_back();
735}
736
737// PROTECTED METHODS
738
739void InputStream::setWrapperSchema( const std::string& name, const std::string& properties )
740{
741    ObjectWrapper* wrapper = Registry::instance()->getObjectWrapperManager()->findWrapper(name);
742    if ( !wrapper )
743    {
744        osg::notify(osg::WARN) << "InputStream::setSchema(): Unsupported wrapper class "
745                               << name << std::endl;
746        return;
747    }
748   
749    StringList schema;
750    split( properties, schema );
751    wrapper->readSchema( schema );
752}
753
754void InputStream::resetSchema()
755{
756    const ObjectWrapperManager::WrapperMap& wrappers = Registry::instance()->getObjectWrapperManager()->getWrapperMap();
757    for ( ObjectWrapperManager::WrapperMap::const_iterator itr=wrappers.begin();
758          itr!=wrappers.end(); ++itr )
759    {
760        ObjectWrapper* wrapper = itr->second.get();
761        wrapper->resetSchema();
762    }
763}
764
765template<typename T>
766void InputStream::readArrayImplementation( T* a, int readSize, bool useByteSwap )
767{
768    int size = 0;
769    *this >> size >> BEGIN_BRACKET;
770    if ( size )
771    {
772        a->resize( size );
773        if ( isBinary() )
774        {
775            _in->getStream()->read( (char*)&((*a)[0]), readSize*size ); checkStream();
776            if ( useByteSwap && _byteSwap )
777            {
778                for ( int i=0; i<size; ++i )
779                    osg::swapBytes( (char*)&((*a)[i]), readSize );
780            }
781        }
782        else
783        {
784            for ( int i=0; i<size; ++i )
785                *this >> (*a)[i];
786        }
787    }
788    *this >> END_BRACKET;
789}
Note: See TracBrowser for help on using the browser.