From Wang Rui, new native binary/ascii format infrastructure and wrappers.

From Robert Osfield, refactor of Wang Rui's original osg2 into 3 parts - parts placed into osgDB, the ReaderWriter placed into src/osg/Plugin/osg and wrappers into src/osgWrappers/serializers/osg

src/CMakeLists.txt

@@ -17,6 +17,7 @@ FOREACH( mylibfolder
         osgTerrain
         osgWidget
         osgVolume
+        osgWrappers/serializers
         osgWrappers/deprecated-dotosg
         osgPlugins
     )

src/osgDB/CMakeLists.txt

@@ -19,6 +19,11 @@ ENDIF()
 SET(LIB_NAME osgDB)
 SET(HEADER_PATH ${OpenSceneGraph_SOURCE_DIR}/include/${LIB_NAME})
 SET(LIB_PUBLIC_HEADERS
+    ${HEADER_PATH}/DataTypes
+    ${HEADER_PATH}/Serializer
+    ${HEADER_PATH}/ObjectWrapper
+    ${HEADER_PATH}/InputStream
+    ${HEADER_PATH}/OutputStream
     ${HEADER_PATH}/Archive
     ${HEADER_PATH}/AuthenticationMap
     ${HEADER_PATH}/Callbacks
@@ -55,6 +60,10 @@ SET(LIB_PUBLIC_HEADERS
 ADD_LIBRARY(${LIB_NAME}
     ${OPENSCENEGRAPH_USER_DEFINED_DYNAMIC_OR_STATIC}
     ${LIB_PUBLIC_HEADERS}
+    ObjectWrapper.cpp
+    InputStream.cpp
+    OutputStream.cpp
+    Compressors.cpp
     Archive.cpp
     AuthenticationMap.cpp
     Callbacks.cpp
@@ -116,6 +125,11 @@ IF(OPENVRML_FOUND)
     ADD_DEFINITIONS(-DUSE_VRML)
 ENDIF()
 
+IF( ZLIB_FOUND )
+    ADD_DEFINITIONS( -DUSE_ZLIB )
+    INCLUDE_DIRECTORIES( ${ZLIB_INCLUDE_DIR} )
+    SET(COMPRESSION_LIBRARIES ${ZLIB_LIBRARY})
+ENDIF()
 
 ADD_DEFINITIONS(-DOSG_PLUGIN_EXTENSION=${CMAKE_SHARED_MODULE_SUFFIX})
 
@@ -123,7 +137,11 @@ LINK_INTERNAL(${LIB_NAME}
     osg
     OpenThreads
 )
-LINK_EXTERNAL(${LIB_NAME}     ${OSGDB_PLATFORM_SPECIFIC_LIBRARIES} )
+LINK_EXTERNAL(${LIB_NAME} ${OSGDB_PLATFORM_SPECIFIC_LIBRARIES} ${COMPRESSION_LIBRARIES})
 LINK_CORELIB_DEFAULT(${LIB_NAME})
 
+IF( ZLIB_FOUND )
+    SET( TARGET_LIBRARIES_VARS ZLIB_LIBRARY )
+ENDIF( ZLIB_FOUND )
+
 INCLUDE(ModuleInstall OPTIONAL)

src/osgDB/Compressors.cpp

@@ -0,0 +1,176 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+// Written by Wang Rui, (C) 2010
+
+#include <osg/Notify>
+#include <osgDB/Registry>
+#include <osgDB/Registry>
+#include <osgDB/ObjectWrapper>
+#include <sstream>
+
+using namespace osgDB;
+
+// Example compressor copying data to/from stream directly
+class NullCompressor : public BaseCompressor
+{
+public:
+    NullCompressor() {}
+    
+    virtual bool compress( std::ostream& fout, const std::string& src )
+    {
+        int size = src.size();
+        fout.write( (char*)&size, INT_SIZE );
+        fout.write( src.c_str(), src.size() );
+        return true;
+    }
+    
+    virtual bool decompress( std::istream& fin, std::string& target )
+    {
+        int size = 0; fin.read( (char*)&size, INT_SIZE );
+        if ( size )
+        {
+            target.resize( size );
+            fin.read( (char*)target.c_str(), size );
+        }
+        return true;
+    }
+};
+
+REGISTER_COMPRESSOR( "null", NullCompressor )
+
+#ifdef USE_ZLIB
+
+#include <zlib.h>
+
+#define CHUNK 32768
+
+// ZLib compressor
+class ZLibCompressor : public BaseCompressor
+{
+public:
+    ZLibCompressor() {}
+    
+    virtual bool compress( std::ostream& fout, const std::string& src )
+    {
+        int ret, flush = Z_FINISH;
+        unsigned have;
+        z_stream strm;
+        unsigned char out[CHUNK];
+        
+        int level = 6;
+        int stategy = Z_DEFAULT_STRATEGY;
+        
+        /* allocate deflate state */
+        strm.zalloc = Z_NULL;
+        strm.zfree = Z_NULL;
+        strm.opaque = Z_NULL;
+        ret = deflateInit2( &strm, level, Z_DEFLATED,
+                           15+16, // +16 to use gzip encoding
+                           8, // default
+                           stategy );
+        if ( ret != Z_OK ) return false;
+        
+        strm.avail_in = src.size();
+        strm.next_in = (Bytef*)( &(*src.begin()) );
+        
+        /* run deflate() on input until output buffer not full, finish
+           compression if all of source has been read in */
+        do
+        {
+            strm.avail_out = CHUNK;
+            strm.next_out = out;
+            ret = deflate(&strm, flush);    /* no bad return value */
+            
+            if ( ret == Z_STREAM_ERROR )
+            {
+                osg::notify(osg::NOTICE) << "Z_STREAM_ERROR" << std::endl;
+                return false;
+            }
+            
+            have = CHUNK - strm.avail_out;
+            if ( have>0 ) fout.write( (const char*)out, have );
+            
+            if ( fout.fail() )
+            {
+                (void)deflateEnd( &strm );
+                return false;
+            }
+        } while ( strm.avail_out==0 );
+        
+        /* clean up and return */
+        (void)deflateEnd( &strm );
+        return true;
+    }
+    
+    virtual bool decompress( std::istream& fin, std::string& target )
+    {
+        int ret;
+        unsigned have;
+        z_stream strm;
+        unsigned char in[CHUNK];
+        unsigned char out[CHUNK];
+        
+        /* allocate inflate state */
+        strm.zalloc = Z_NULL;
+        strm.zfree = Z_NULL;
+        strm.opaque = Z_NULL;
+        strm.avail_in = 0;
+        strm.next_in = Z_NULL;
+        ret = inflateInit2( &strm,
+                            15 + 32 ); // autodected zlib or gzip header
+        
+        if ( ret!=Z_OK )
+        {
+            osg::notify(osg::INFO) << "failed to init" << std::endl;
+            return ret!=0;
+        }
+        
+        /* decompress until deflate stream ends or end of file */
+        do
+        {
+            fin.read( (char *)in, CHUNK );
+            strm.avail_in = fin.gcount();
+            if (strm.avail_in==0 ) break;
+            
+            /* run inflate() on input until output buffer not full */
+            strm.next_in = in;
+            do
+            {
+                strm.avail_out = CHUNK;
+                strm.next_out = out;
+                ret = inflate( &strm, Z_NO_FLUSH );
+                
+                switch (ret)
+                {
+                case Z_NEED_DICT:
+                case Z_DATA_ERROR:
+                case Z_MEM_ERROR:
+                    (void)inflateEnd( &strm );
+                    return false;
+                }
+                have = CHUNK - strm.avail_out;
+                target.append( (char*)out, have );
+            } while ( strm.avail_out==0 );
+            
+            /* done when inflate() says it's done */
+        } while ( ret!=Z_STREAM_END );
+        
+        /* clean up and return */
+        (void)inflateEnd( &strm );
+        return ret==Z_STREAM_END ? true : false;
+    }
+};
+
+REGISTER_COMPRESSOR( "zlib", ZLibCompressor )
+
+#endif

src/osgDB/DotOsgWrapper.cpp

@@ -11,6 +11,7 @@
  * OpenSceneGraph Public License for more details.
 */
 #include <osgDB/DotOsgWrapper>
+#include <osgDB/Registry>
 
 using namespace osgDB;
 
@@ -50,3 +51,26 @@ DotOsgWrapper::DotOsgWrapper(osg::Object* proto,
     
     _readWriteMode = readWriteMode;
 }
+
+
+RegisterDotOsgWrapperProxy::RegisterDotOsgWrapperProxy(osg::Object* proto,
+                            const std::string& name,
+                            const std::string& associates,
+                            DotOsgWrapper::ReadFunc readFunc,
+                            DotOsgWrapper::WriteFunc writeFunc,
+                            DotOsgWrapper::ReadWriteMode readWriteMode)
+{
+    if (Registry::instance())
+    {
+        _wrapper = new DotOsgWrapper(proto,name,associates,readFunc,writeFunc,readWriteMode);
+        Registry::instance()->addDotOsgWrapper(_wrapper.get());
+    }
+}
+
+RegisterDotOsgWrapperProxy::~RegisterDotOsgWrapperProxy()
+{
+    if (Registry::instance())
+    {
+        Registry::instance()->removeDotOsgWrapper(_wrapper.get());
+    }
+}

src/osgDB/InputStream.cpp

@@ -0,0 +1,764 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+// Written by Wang Rui, (C) 2010
+
+#include <osg/Notify>
+#include <osg/ImageSequence>
+#include <osgDB/ReadFile>
+#include <osgDB/XmlParser>
+#include <osgDB/FileNameUtils>
+#include <osgDB/ObjectWrapper>
+
+using namespace osgDB;
+
+static std::string s_lastSchema;
+
+InputStream::InputStream( std::istream* istream, const osgDB::Options* options )
+:   _readMode(READ_BINARY), _byteSwap(0), _useFloatMatrix(false),
+    _in(istream)
+{
+    if ( !_in )
+        throw InputException(_currentField, "InputStream: Null stream specified.");
+    if ( !options ) return;
+    
+    std::string schema;
+    StringList optionList;
+    split( options->getOptionString(), optionList );
+    for ( StringList::iterator itr=optionList.begin(); itr!=optionList.end(); ++itr )
+    {
+        const std::string& option = *itr;
+        if ( option=="Ascii" )
+            _readMode = READ_ASCII;
+        else
+        {
+            StringList keyAndValues;
+            split( option, keyAndValues, '=' );
+            if ( keyAndValues.size()<2 ) continue;
+            
+            if ( keyAndValues[0]=="SchemaFile" )
+            {
+                schema = keyAndValues[1];
+                if ( s_lastSchema!=schema )
+                {
+                    osgDB::ifstream schemaStream( schema.c_str(), std::ios::in );
+                    if ( !schemaStream.fail() ) readSchema( schemaStream );
+                    schemaStream.close();
+                    s_lastSchema = schema;
+                }
+            }
+            else
+                osg::notify(osg::WARN) << "InputStream: Unknown option " << option << std::endl;
+        }
+    }
+    if ( schema.empty() )
+    {
+        resetSchema();
+        s_lastSchema.clear();
+    }
+}
+
+InputStream::~InputStream()
+{
+}
+
+InputStream& InputStream::operator>>( osg::Vec2b& v )
+{
+    char x, y; *this >> x >> y;
+    v.set( x, y );
+    return *this;
+}
+
+InputStream& InputStream::operator>>( osg::Vec3b& v )
+{
+    char x, y, z; *this >> x >> y >> z;
+    v.set( x, y, z );
+    return *this;
+}
+
+InputStream& InputStream::operator>>( osg::Vec4b& v )
+{
+    char x, y, z, w; *this >> x >> y >> z >> w;
+    v.set( x, y, z, w );
+    return *this;
+}
+
+InputStream& InputStream::operator>>( osg::Vec4ub& v )
+{
+    char r, g, b, a; *this >> r >> g >> b >> a;
+    v.set( r, g, b, a );
+    return *this;
+}
+
+InputStream& InputStream::operator>>( osg::Vec2s& v )
+{ *this >> v.x() >> v.y(); return *this; }
+
+InputStream& InputStream::operator>>( osg::Vec3s& v )
+{ *this >> v.x() >> v.y() >> v.z(); return *this; }
+
+InputStream& InputStream::operator>>( osg::Vec4s& v )
+{ *this >> v.x() >> v.y() >> v.z() >> v.w(); return *this; }
+
+InputStream& InputStream::operator>>( osg::Vec2f& v )
+{ *this >> v.x() >> v.y(); return *this; }
+
+InputStream& InputStream::operator>>( osg::Vec3f& v )
+{ *this >> v.x() >> v.y() >> v.z(); return *this; }
+
+InputStream& InputStream::operator>>( osg::Vec4f& v )
+{ *this >> v.x() >> v.y() >> v.z() >> v.w(); return *this; }
+
+InputStream& InputStream::operator>>( osg::Vec2d& v )
+{ *this >> v.x() >> v.y(); return *this; }
+
+InputStream& InputStream::operator>>( osg::Vec3d& v )
+{ *this >> v.x() >> v.y() >> v.z(); return *this; }
+
+InputStream& InputStream::operator>>( osg::Vec4d& v )
+{ *this >> v.x() >> v.y() >> v.z() >> v.w(); return *this; }
+
+InputStream& InputStream::operator>>( osg::Quat& q )
+{ *this >> q.x() >> q.y() >> q.z() >> q.w(); return *this; }
+
+InputStream& InputStream::operator>>( osg::Plane& p )
+{
+    double p0, p1, p2, p3; *this >> p0 >> p1 >> p2 >> p3;
+    p.set( p0, p1, p2, p3 ); return *this;
+}
+
+InputStream& InputStream::operator>>( osg::Matrixf& mat )
+{
+    *this >> PROPERTY("Matrixf") >> BEGIN_BRACKET;
+    for ( int r=0; r<4; ++r )
+    {
+        *this >> mat(r, 0) >> mat(r, 1) >> mat(r, 2) >> mat(r, 3);
+    }
+    *this >> END_BRACKET;
+    return *this;
+}
+
+InputStream& InputStream::operator>>( osg::Matrixd& mat )
+{
+    *this >> PROPERTY("Matrixd") >> BEGIN_BRACKET;
+    for ( int r=0; r<4; ++r )
+    {
+        *this >> mat(r, 0) >> mat(r, 1) >> mat(r, 2) >> mat(r, 3);
+    }
+    *this >> END_BRACKET;
+    return *this;
+}
+
+InputStream& InputStream::operator>>( ObjectGLenum& value )
+{
+    GLenum e = 0;
+    if ( isBinary() )
+    {
+        _in->read( (char*)&e, GLENUM_SIZE ); checkStream();
+        if ( _byteSwap ) osg::swapBytes( (char*)&e, GLENUM_SIZE );
+    }
+    else
+    {
+        std::string enumString;
+        *this >> enumString;
+        e = GlobalLookupTable::instance()->getValue("GL", enumString);
+    }
+    value.set( e );
+    return *this;
+}
+
+InputStream& InputStream::operator>>( ObjectProperty& prop )
+{
+    int value = 0;
+    if ( isBinary() )
+    {
+        if ( prop._mapProperty )
+        {
+            _in->read( (char*)&value, INT_SIZE ); checkStream();
+            if ( _byteSwap ) osg::swapBytes( (char*)&value, INT_SIZE );
+        }
+    }
+    else
+    {
+        std::string enumString;
+        *this >> enumString;
+        if ( prop._mapProperty )
+        {
+            value =
+                GlobalLookupTable::instance()->getValue(prop._name, enumString);
+        }
+        else
+        {
+            if ( prop._name!=enumString )
+            {
+                osg::notify(osg::WARN) << "InputStream::operator>>(ObjectProperty&): Unmatched property "
+                                       << enumString << ", expecting " << prop._name
+                                       << ". At " << _currentField << std::endl;
+            }
+            prop._name = enumString;
+        }
+    }
+    prop.set( value );
+    return *this;
+}
+
+InputStream& InputStream::operator>>( ObjectMark& mark )
+{
+    if ( !isBinary() )
+    {
+        std::string markString;
+        *this >> markString;
+    }
+    return *this;
+}
+
+osg::Array* InputStream::readArray()
+{
+    osg::ref_ptr<osg::Array> array = NULL;
+    
+    unsigned int id = 0;
+    *this >> PROPERTY("ArrayID") >> id;
+    
+    ArrayMap::iterator itr = _arrayMap.find( id );
+    if ( itr!=_arrayMap.end() ) return itr->second.get();
+    
+    DEF_MAPPEE(ArrayType, type);
+    *this >> type;
+    switch ( type.get() )
+    {
+    case ID_BYTE_ARRAY:
+        {
+            osg::ByteArray* ba = new osg::ByteArray;
+            readArrayImplementation( ba, CHAR_SIZE, true );
+            array = ba;
+        }
+        break;
+    case ID_UBYTE_ARRAY:
+        {
+            osg::UByteArray* uba = new osg::UByteArray;
+            readArrayImplementation( uba, CHAR_SIZE, true );
+            array = uba;
+        }
+        break;
+    case ID_SHORT_ARRAY:
+        {
+            osg::ShortArray* sa = new osg::ShortArray;
+            readArrayImplementation( sa, SHORT_SIZE, true );
+            array = sa;
+        }
+        break;
+    case ID_USHORT_ARRAY:
+        {
+            osg::UShortArray* usa = new osg::UShortArray;
+            readArrayImplementation( usa, SHORT_SIZE, true );
+            array = usa;
+        }
+        break;
+    case ID_INT_ARRAY:
+        {
+            osg::IntArray* ia = new osg::IntArray;
+            readArrayImplementation( ia, INT_SIZE, true );
+            array = ia;
+        }
+        break;
+    case ID_UINT_ARRAY:
+        {
+            osg::UIntArray* uia = new osg::UIntArray;
+            readArrayImplementation( uia, INT_SIZE, true );
+            array = uia;
+        }
+        break;
+    case ID_FLOAT_ARRAY:
+        {
+            osg::FloatArray* fa = new osg::FloatArray;
+            readArrayImplementation( fa, FLOAT_SIZE, true );
+            array = fa;
+        }
+        break;
+    case ID_DOUBLE_ARRAY:
+        {
+            osg::DoubleArray* da = new osg::DoubleArray;
+            readArrayImplementation( da, DOUBLE_SIZE, true );
+            array = da;
+        }
+        break;
+    case ID_VEC2B_ARRAY:
+        {
+            osg::Vec2bArray* va = new osg::Vec2bArray;
+            readArrayImplementation( va, 2*CHAR_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC3B_ARRAY:
+        {
+            osg::Vec3bArray* va = new osg::Vec3bArray;
+            readArrayImplementation( va, 3*CHAR_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC4B_ARRAY:
+        {
+            osg::Vec4bArray* va = new osg::Vec4bArray;
+            readArrayImplementation( va, 4*CHAR_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC4UB_ARRAY:
+        {
+            osg::Vec4ubArray* va = new osg::Vec4ubArray;
+            readArrayImplementation( va, 4*CHAR_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC2S_ARRAY:
+        {
+            osg::Vec2sArray* va = new osg::Vec2sArray;
+            readArrayImplementation( va, 2*SHORT_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC3S_ARRAY:
+        {
+            osg::Vec3sArray* va = new osg::Vec3sArray;
+            readArrayImplementation( va, 3*SHORT_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC4S_ARRAY:
+        {
+            osg::Vec4sArray* va = new osg::Vec4sArray;
+            readArrayImplementation( va, 4*SHORT_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC2_ARRAY:
+        {
+            osg::Vec2Array* va = new osg::Vec2Array;
+            readArrayImplementation( va, 2*FLOAT_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC3_ARRAY:
+        {
+            osg::Vec3Array* va = new osg::Vec3Array;
+            readArrayImplementation( va, 3*FLOAT_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC4_ARRAY:
+        {
+            osg::Vec4Array* va = new osg::Vec4Array;
+            readArrayImplementation( va, 4*FLOAT_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC2D_ARRAY:
+        {
+            osg::Vec2dArray* va = new osg::Vec2dArray;
+            readArrayImplementation( va, 2*DOUBLE_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC3D_ARRAY:
+        {
+            osg::Vec3dArray* va = new osg::Vec3dArray;
+            readArrayImplementation( va, 3*DOUBLE_SIZE );
+            array = va;
+        }
+        break;
+    case ID_VEC4D_ARRAY:
+        {
+            osg::Vec4dArray* va = new osg::Vec4dArray;
+            readArrayImplementation( va, 4*DOUBLE_SIZE );
+            array = va;
+        }
+        break;
+    default:
+        throw InputException(_currentField, "InputStream::readArray(): Unsupported array type.");
+    }
+    
+    _arrayMap[id] = array;
+    return array.release();
+}
+
+osg::PrimitiveSet* InputStream::readPrimitiveSet()
+{
+    osg::ref_ptr<osg::PrimitiveSet> primitive = NULL;
+    
+    DEF_MAPPEE(PrimitiveType, type);
+    DEF_MAPPEE(PrimitiveType, mode);
+    *this >> type >> mode;
+    
+    switch ( type.get() )
+    {
+    case ID_DRAWARRAYS:
+        {
+            int first = 0, count = 0;
+            *this >> first >> count;
+            osg::DrawArrays* da = new osg::DrawArrays( mode.get(), first, count );
+            primitive = da;
+        }
+        break;
+    case ID_DRAWARRAY_LENGTH:
+        {
+            int first = 0, value = 0; unsigned int size = 0;
+            *this >> first >> size >> BEGIN_BRACKET;
+            osg::DrawArrayLengths* dl = new osg::DrawArrayLengths( mode.get(), first );
+            for ( unsigned int i=0; i<size; ++i )
+            {
+                *this >> value;
+                dl->push_back( value );
+            }
+            *this >> END_BRACKET;
+            primitive = dl;
+        }
+        break;
+    case ID_DRAWELEMENTS_UBYTE:
+        {
+            osg::DrawElementsUByte* de = new osg::DrawElementsUByte( mode.get() );
+            unsigned int size = 0; unsigned char value = 0;
+            *this >> size >> BEGIN_BRACKET;
+            for ( unsigned int i=0; i<size; ++i )
+            {
+                *this >> value;
+                de->push_back( value );
+            }
+            *this >> END_BRACKET;
+            primitive = de;
+        }
+        break;
+    case ID_DRAWELEMENTS_USHORT:
+        {
+            osg::DrawElementsUShort* de = new osg::DrawElementsUShort( mode.get() );
+            unsigned int size = 0; unsigned short value = 0;
+            *this >> size >> BEGIN_BRACKET;
+            for ( unsigned int i=0; i<size; ++i )
+            {
+                *this >> value;
+                de->push_back( value );
+            }
+            *this >> END_BRACKET;
+            primitive = de;
+        }
+        break;
+    case ID_DRAWELEMENTS_UINT:
+        {
+            osg::DrawElementsUInt* de = new osg::DrawElementsUInt( mode.get() );
+            unsigned int size = 0, value = 0;
+            *this >> size >> BEGIN_BRACKET;
+            for ( unsigned int i=0; i<size; ++i )
+            {
+                *this >> value;
+                de->push_back( value );
+            }
+            *this >> END_BRACKET;
+            primitive = de;
+        }
+        break;
+    default:
+        throw InputException(_currentField, "InputStream::readPrimitiveSet(): Unsupported array type.");
+    }
+    return primitive.release();
+}
+
+osg::Image* InputStream::readImage()
+{
+    std::string name;
+    int writeHint, decision = IMAGE_EXTERNAL;
+    *this >> PROPERTY("FileName"); readWrappedString(name);
+    *this >> PROPERTY("WriteHint") >> writeHint >> decision;
+    
+    osg::ref_ptr<osg::Image> image = NULL;
+    bool readFromExternal = true;
+    switch ( decision )
+    {
+    case IMAGE_INLINE_DATA:
+        if ( isBinary() )
+        {
+            image = new osg::Image;
+            
+            // _origin, _s & _t & _r, _internalTextureFormat
+            int origin, s, t, r, internalFormat;
+            *this >> origin >> s >> t >> r >> internalFormat;
+            
+            // _pixelFormat, _dataType, _packing, _allocationMode
+            int pixelFormat, dataType, packing, mode;
+            *this >> pixelFormat >> dataType >> packing >> mode;
+            
+            // _data
+            unsigned int size = 0; *this >> size;
+            if ( size )
+            {
+                char* data = new char[size];
+                if ( !data )
+                    throw InputException(_currentField, "InputStream::readImage() Out of memory.");
+                readCharArray( data, size );
+                image->setOrigin( (osg::Image::Origin)origin );
+                image->setImage( s, t, r, internalFormat, pixelFormat, dataType,
+                    (unsigned char*)data, (osg::Image::AllocationMode)mode, packing );
+            }
+            
+            // _mipmapData
+            unsigned int levelSize = 0; *this >> levelSize;
+            osg::Image::MipmapDataType levels(levelSize);
+            for ( unsigned int i=0; i<levelSize; ++i )
+            {
+                *this >> levels[i];
+            }
+            if ( levelSize>0 )
+                image->setMipmapLevels( levels );
+            readFromExternal = false;
+        }
+        break;
+    case IMAGE_INLINE_FILE:
+        if ( isBinary() )
+        {
+            unsigned int size = 0; *this >> size;
+            if ( size>0 )
+            {
+                char* data = new char[size];
+                if ( !data )
+                    throw InputException(_currentField, "InputStream::readImage(): Out of memory.");
+                readCharArray( data, size );
+                
+                std::string ext = osgDB::getFileExtension( name );
+                osgDB::ReaderWriter* reader =
+                    osgDB::Registry::instance()->getReaderWriterForExtension( ext );
+                if ( reader )
+                {
+                    std::stringstream inputStream;
+                    inputStream.write( data, size );
+                    
+                    osgDB::ReaderWriter::ReadResult rr = reader->readImage( inputStream );
+                    if ( rr.validImage() )
+                        image = rr.takeImage();
+                    else
+                    {
+                        osg::notify(osg::WARN) << "InputStream::readImage(): "
+                                               << rr.message() << std::endl;
+                    }
+                }
+                else
+                {
+                    osg::notify(osg::WARN) << "InputStream::readImage(): Unable to find a plugin for "
+                                           << ext << std::endl;
+                }
+                delete[] data;
+            }
+            readFromExternal = false;
+        }
+        break;
+    case IMAGE_EXTERNAL: case IMAGE_WRITE_OUT:
+        break;
+    default:
+        break;
+    }
+    
+    if ( readFromExternal )
+        image = osgDB::readImageFile( name );
+    if ( image.valid() )
+    {
+        image->setFileName( name );
+        image->setWriteHint( (osg::Image::WriteHint)writeHint );
+    }
+    
+    image = static_cast<osg::Image*>( readObject(image.get()) );
+    return image.release();
+}
+
+osg::Object* InputStream::readObject( osg::Object* existingObj )
+{
+    std::string className;
+    unsigned int id = 0;
+    *this >> className >> BEGIN_BRACKET >> PROPERTY("UniqueID") >> id;
+    
+    IdentifierMap::iterator itr = _identifierMap.find( id );
+    if ( itr!=_identifierMap.end() )
+    {
+        advanceToCurrentEndBracket();
+        return itr->second.get();
+    }
+    
+    ObjectWrapper* wrapper = ObjectRegistry::instance()->findWrapper( className );
+    if ( !wrapper )
+    {
+        osg::notify(osg::WARN) << "InputStream::readObject(): Unsupported wrapper class "
+                               << className << std::endl;
+        advanceToCurrentEndBracket();
+        return NULL;
+    }
+    osg::ref_ptr<osg::Object> obj = existingObj ? existingObj : wrapper->getProto()->cloneType();
+    if ( obj.valid() )
+    {
+        _identifierMap[id] = obj;
+        
+        const StringList& associates = wrapper->getAssociates();
+        for ( StringList::const_iterator itr=associates.begin(); itr!=associates.end(); ++itr )
+        {
+            ObjectWrapper* assocWrapper = ObjectRegistry::instance()->findWrapper(*itr);
+            if ( !assocWrapper )
+            {
+                osg::notify(osg::WARN) << "InputStream::readObject(): Unsupported associated class "
+                                       << *itr << std::endl;
+                continue;
+            }
+            
+            _currentField = assocWrapper->getName();
+            assocWrapper->read( *this, *obj );
+        }
+    }
+    advanceToCurrentEndBracket();
+    return obj.release();
+}
+
+void InputStream::readSchema( std::istream& fin )
+{
+    // Read from external ascii stream
+    std::string line;
+    while ( std::getline(fin, line) )
+    {
+        if ( line[0]=='#' ) continue;  // Comment
+        
+        StringList keyAndValue;
+        split( line, keyAndValue, '=' );
+        if ( keyAndValue.size()<2 ) continue;
+        
+        setWrapperSchema( osgDB::trimEnclosingSpaces(keyAndValue[0]),
+                          osgDB::trimEnclosingSpaces(keyAndValue[1]) );
+    }
+}
+
+InputStream::ReadType InputStream::start()
+{
+    ReadType type = READ_UNKNOWN;
+    _currentField = "Header";
+    
+    // Check OSG header information
+    unsigned int version = 0;
+    if ( isBinary() )
+    {
+        unsigned int headerLow = 0, headerHigh = 0;
+        *this >> headerLow >> headerHigh;
+        if ( headerLow!=OSG_HEADER_LOW || headerHigh!=OSG_HEADER_HIGH )
+        {
+            _in->seekg( 0, std::ios::beg );
+            _readMode = READ_ASCII;
+        }
+        else
+        {
+            unsigned int typeValue;
+            *this >> typeValue >> version;
+            type = static_cast<ReadType>(typeValue);
+            
+            unsigned int matrixValueType; *this >> matrixValueType;
+            if ( matrixValueType==0 ) _useFloatMatrix = true;
+            else _useFloatMatrix = false;
+        }
+    }
+    if ( !isBinary() )
+    {
+        DEF_PROPERTY("#Ascii", header); *this >> header;
+        if ( header._name!="#Ascii" ) return READ_UNKNOWN;
+        
+        std::string typeString; *this >> typeString;
+        if ( typeString=="Scene" ) type = READ_SCENE;
+        else if ( typeString=="Image" ) type = READ_IMAGE;
+        
+        std::string osgName, osgVersion;
+        *this >> PROPERTY("#Version") >> version;
+        *this >> PROPERTY("#Generator") >> osgName >> osgVersion;
+    }
+    
+    // Check file version
+    if ( version!=PLUGIN_VERSION )
+    {
+        osg::notify(osg::WARN) << "InputStream: Input data version " << version
+                               << " may be incompatible with current reader version "
+                               << PLUGIN_VERSION << std::endl;
+    }
+    return type;
+}
+
+void InputStream::decompress()
+{
+    _currentField = "Decompression";
+    if ( !isBinary() ) return;
+    
+    std::string compressorName; *this >> compressorName;
+    if ( compressorName=="0" ) return;
+    
+    BaseCompressor* compressor =
+        ObjectRegistry::instance()->findCompressor(compressorName);
+    if ( !compressor )
+    {
+        osg::notify(osg::WARN) << "InputStream::decompress(): No such compressor "
+                               << compressorName << std::endl;
+    }
+    
+    std::string data;
+    if ( !compressor->decompress(*_in, data) )
+        throw InputException(_currentField, "InputStream: Failed to decompress stream.");
+    _in = new std::stringstream(data);
+}
+
+// PROTECTED METHODS
+
+void InputStream::setWrapperSchema( const std::string& name, const std::string& properties )
+{
+    ObjectWrapper* wrapper = ObjectRegistry::instance()->findWrapper(name);
+    if ( !wrapper )
+    {
+        osg::notify(osg::WARN) << "InputStream::setSchema(): Unsupported wrapper class "
+                               << name << std::endl;
+        return;
+    }
+    
+    StringList schema;
+    split( properties, schema );
+    wrapper->readSchema( schema );
+}
+
+void InputStream::resetSchema()
+{
+    const ObjectRegistry::WrapperMap& wrappers = ObjectRegistry::instance()->getWrapperMap();
+    for ( ObjectRegistry::WrapperMap::const_iterator itr=wrappers.begin();
+          itr!=wrappers.end(); ++itr )
+    {
+        ObjectWrapper* wrapper = itr->second.get();
+        wrapper->resetSchema();
+    }
+}
+
+template<typename T>
+void InputStream::readArrayImplementation( T* a, int readSize, bool useByteSwap )
+{
+    int size = 0;
+    *this >> size >> BEGIN_BRACKET;
+    if ( size )
+    {
+        a->resize( size );
+        if ( isBinary() )
+        {
+            _in->read( (char*)&((*a)[0]), readSize*size ); checkStream();
+            if ( useByteSwap && _byteSwap )
+            {
+                for ( int i=0; i<size; ++i )
+                    osg::swapBytes( (char*)&((*a)[i]), readSize );
+            }
+        }
+        else
+        {
+            for ( int i=0; i<size; ++i )
+                *this >> (*a)[i];
+        }
+    }
+    *this >> END_BRACKET;
+}

src/osgDB/ObjectWrapper.cpp

@@ -0,0 +1,478 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+// Written by Wang Rui, (C) 2010
+
+#include <osg/Notify>
+#include <osg/BlendFunc>
+#include <osg/ClampColor>
+#include <osg/Fog>
+#include <osg/FragmentProgram>
+#include <osg/GL2Extensions>
+#include <osg/PointSprite>
+#include <osg/StateSet>
+#include <osg/StencilTwoSided>
+#include <osg/TexEnvCombine>
+#include <osg/Texture>
+#include <osg/TextureCubeMap>
+#include <osg/TextureRectangle>
+#include <osg/VertexProgram>
+#include <osgDB/Options>
+#include <osgDB/DataTypes>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/Registry>
+#include <sstream>
+
+using namespace osgDB;
+
+void osgDB::split( const std::string& src, StringList& list, char separator )
+{
+    std::string::size_type start = src.find_first_not_of(separator);
+    while ( start!=std::string::npos )
+    {
+        std::string::size_type end = src.find_first_of(separator, start);
+        if ( end!=std::string::npos )
+        {
+            list.push_back( std::string(src, start, end-start) );
+            start = src.find_first_not_of(separator, end);
+        }
+        else
+        {
+            list.push_back( std::string(src, start, src.size()-start) );
+            start = end;
+        }
+    }
+}
+
+ObjectWrapper::ObjectWrapper( osg::Object* proto, const std::string& name,
+                              const std::string& associates )
+:   osg::Referenced(),
+    _proto(proto), _name(name)
+{
+    split( associates, _associates );
+}
+
+bool ObjectWrapper::read( InputStream& is, osg::Object& obj )
+{
+    bool readOK = true;
+    for ( SerializerList::iterator itr=_serializers.begin();
+          itr!=_serializers.end(); ++itr )
+    {
+        if ( (*itr)->read(is, obj) ) continue;
+        osg::notify(osg::WARN) << "ObjectWrapper::read(): Error reading property "
+                               << _name << "::" << (*itr)->getName() << std::endl;
+        readOK = false;
+    }
+    return readOK;
+}
+
+bool ObjectWrapper::write( OutputStream& os, const osg::Object& obj )
+{
+    bool writeOK = true;
+    for ( SerializerList::iterator itr=_serializers.begin();
+          itr!=_serializers.end(); ++itr )
+    {
+        if ( (*itr)->write(os, obj) ) continue;
+        osg::notify(osg::WARN) << "ObjectWrapper::write(): Error writing property "
+                               << _name << "::" << (*itr)->getName() << std::endl;
+        writeOK = false;
+    }
+    return writeOK;
+}
+
+bool ObjectWrapper::readSchema( const StringList& properties )
+{
+    if ( !_backupSerializers.size() )
+        _backupSerializers = _serializers;
+    _serializers.clear();
+    
+    unsigned int size = properties.size();
+    unsigned int serializersSize = _backupSerializers.size();
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        if ( serializersSize<i )
+        {
+            osg::notify(osg::WARN) << "ObjectWrapper::readSchema(): Wrapper " << _name
+                                   << ": Incompatible serializers size" << std::endl;
+            break;
+        }
+        
+        const std::string& prop = properties[i];
+        if ( prop==_backupSerializers[i]->getName() )
+        {
+            _serializers.push_back( _backupSerializers[i] );
+        }
+        else
+        {
+            bool hasSerializer = false;
+            for ( SerializerList::iterator itr=_backupSerializers.begin();
+                  itr!=_backupSerializers.end(); ++itr )
+            {
+                if ( prop!=(*itr)->getName() ) continue;
+                _serializers.push_back( *itr );
+                hasSerializer = true;
+            }
+            if ( !hasSerializer )
+            {
+                osg::notify(osg::WARN) << "ObjectWrapper::readSchema(): Wrapper " << _name
+                                       << ": Unknown property " << prop << std::endl;
+            }
+        }
+    }
+    return size==_serializers.size();
+}
+
+void ObjectWrapper::writeSchema( StringList& properties )
+{
+    for ( SerializerList::iterator itr=_serializers.begin();
+          itr!=_serializers.end(); ++itr )
+    {
+        properties.push_back( (*itr)->getName() );
+    }
+}
+
+GlobalLookupTable* GlobalLookupTable::instance()
+{
+    static osg::ref_ptr<GlobalLookupTable> s_lookup = new GlobalLookupTable;
+    return s_lookup.get();
+}
+
+GlobalLookupTable::GlobalLookupTable()
+{
+    IntLookup& glTable = _globalMap["GL"];
+    
+    // Modes
+    glTable.add( "GL_ALPHA_TEST", GL_ALPHA_TEST );
+    glTable.add( "GL_BLEND", GL_BLEND );
+    glTable.add( "GL_COLOR_LOGIC_OP", GL_COLOR_LOGIC_OP );
+    glTable.add( "GL_COLOR_MATERIAL", GL_COLOR_MATERIAL );
+    glTable.add( "GL_CULL_FACE", GL_CULL_FACE );
+    glTable.add( "GL_DEPTH_TEST", GL_DEPTH_TEST );
+    glTable.add( "GL_FOG", GL_FOG );
+    glTable.add( "GL_FRAGMENT_PROGRAM_ARB", GL_FRAGMENT_PROGRAM_ARB );
+    glTable.add( "GL_LINE_STIPPLE", GL_LINE_STIPPLE );
+    glTable.add( "GL_POINT_SMOOTH", GL_POINT_SMOOTH );
+    glTable.add( "GL_POINT_SPRITE_ARB", GL_POINT_SPRITE_ARB );
+    glTable.add( "GL_POLYGON_OFFSET_FILL", GL_POLYGON_OFFSET_FILL );
+    glTable.add( "GL_POLYGON_OFFSET_LINE", GL_POLYGON_OFFSET_LINE );
+    glTable.add( "GL_POLYGON_OFFSET_POINT", GL_POLYGON_OFFSET_POINT );
+    glTable.add( "GL_POLYGON_STIPPLE", GL_POLYGON_STIPPLE );
+    glTable.add( "GL_SCISSOR_TEST", GL_SCISSOR_TEST);
+    glTable.add( "GL_STENCIL_TEST", GL_STENCIL_TEST );
+    glTable.add( "GL_STENCIL_TEST_TWO_SIDE", GL_STENCIL_TEST_TWO_SIDE );
+    glTable.add( "GL_VERTEX_PROGRAM_ARB", GL_VERTEX_PROGRAM_ARB );
+    
+    glTable.add( "GL_COLOR_SUM", GL_COLOR_SUM );
+    glTable.add( "GL_LIGHTING", GL_LIGHTING );
+    glTable.add( "GL_NORMALIZE", GL_NORMALIZE );
+    glTable.add( "GL_RESCALE_NORMAL", GL_RESCALE_NORMAL );
+    
+    glTable.add( "GL_TEXTURE_1D", GL_TEXTURE_1D );
+    glTable.add( "GL_TEXTURE_2D", GL_TEXTURE_2D );
+    glTable.add( "GL_TEXTURE_3D", GL_TEXTURE_3D );
+    glTable.add( "GL_TEXTURE_CUBE_MAP", GL_TEXTURE_CUBE_MAP );
+    glTable.add( "GL_TEXTURE_RECTANGLE", GL_TEXTURE_RECTANGLE );
+    glTable.add( "GL_TEXTURE_GEN_Q", GL_TEXTURE_GEN_Q );
+    glTable.add( "GL_TEXTURE_GEN_R", GL_TEXTURE_GEN_R );
+    glTable.add( "GL_TEXTURE_GEN_S", GL_TEXTURE_GEN_S );
+    glTable.add( "GL_TEXTURE_GEN_T", GL_TEXTURE_GEN_T );
+    
+    glTable.add( "GL_CLIP_PLANE0", GL_CLIP_PLANE0 );
+    glTable.add( "GL_CLIP_PLANE1", GL_CLIP_PLANE1 );
+    glTable.add( "GL_CLIP_PLANE2", GL_CLIP_PLANE2 );
+    glTable.add( "GL_CLIP_PLANE3", GL_CLIP_PLANE3 );
+    glTable.add( "GL_CLIP_PLANE4", GL_CLIP_PLANE4 );
+    glTable.add( "GL_CLIP_PLANE5", GL_CLIP_PLANE5 );
+    
+    glTable.add( "GL_LIGHT0", GL_LIGHT0 );
+    glTable.add( "GL_LIGHT1", GL_LIGHT1 );
+    glTable.add( "GL_LIGHT2", GL_LIGHT2 );
+    glTable.add( "GL_LIGHT3", GL_LIGHT3 );
+    glTable.add( "GL_LIGHT4", GL_LIGHT4 );
+    glTable.add( "GL_LIGHT5", GL_LIGHT5 );
+    glTable.add( "GL_LIGHT6", GL_LIGHT6 );
+    glTable.add( "GL_LIGHT7", GL_LIGHT7 );
+    
+    // Functions
+    glTable.add( "NEVER", GL_NEVER );
+    glTable.add( "LESS", GL_LESS );
+    glTable.add( "EQUAL", GL_EQUAL );
+    glTable.add( "LEQUAL", GL_LEQUAL );
+    glTable.add( "GREATER", GL_GREATER );
+    glTable.add( "NOTEQUAL", GL_NOTEQUAL );
+    glTable.add( "GEQUAL", GL_GEQUAL );
+    glTable.add( "ALWAYS", GL_ALWAYS );
+    
+    // Texture environment states
+    glTable.add( "REPLACE", GL_REPLACE );
+    glTable.add( "MODULATE", GL_MODULATE );
+    glTable.add( "ADD", GL_ADD );
+    glTable.add( "ADD_SIGNED", GL_ADD_SIGNED_ARB );
+    glTable.add( "INTERPOLATE", GL_INTERPOLATE_ARB );
+    glTable.add( "SUBTRACT", GL_SUBTRACT_ARB );
+    glTable.add( "DOT3_RGB", GL_DOT3_RGB_ARB );
+    glTable.add( "DOT3_RGBA", GL_DOT3_RGBA_ARB );
+    
+    glTable.add( "CONSTANT", GL_CONSTANT_ARB );
+    glTable.add( "PRIMARY_COLOR", GL_PRIMARY_COLOR_ARB );
+    glTable.add( "PREVIOUS", GL_PREVIOUS_ARB );
+    glTable.add( "TEXTURE", GL_TEXTURE );
+    glTable.add( "TEXTURE0", GL_TEXTURE0 );
+    glTable.add( "TEXTURE1", GL_TEXTURE0+1 );
+    glTable.add( "TEXTURE2", GL_TEXTURE0+2 );
+    glTable.add( "TEXTURE3", GL_TEXTURE0+3 );
+    glTable.add( "TEXTURE4", GL_TEXTURE0+4 );
+    glTable.add( "TEXTURE5", GL_TEXTURE0+5 );
+    glTable.add( "TEXTURE6", GL_TEXTURE0+6 );
+    glTable.add( "TEXTURE7", GL_TEXTURE0+7 );
+    
+    // Texture clamp modes
+    glTable.add( "CLAMP", GL_CLAMP );
+    glTable.add( "CLAMP_TO_EDGE", GL_CLAMP_TO_EDGE );
+    glTable.add( "CLAMP_TO_BORDER", GL_CLAMP_TO_BORDER_ARB );
+    glTable.add( "REPEAT", GL_REPEAT );
+    glTable.add( "MIRROR", GL_MIRRORED_REPEAT_IBM );
+    
+    // Texture filter modes
+    glTable.add( "LINEAR", GL_LINEAR );
+    glTable.add( "LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR );
+    glTable.add( "LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST );
+    glTable.add( "NEAREST", GL_NEAREST );
+    glTable.add( "NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR );
+    glTable.add( "NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST );
+    
+    // Texture formats
+    glTable.add( "GL_INTENSITY", GL_INTENSITY );
+    glTable.add( "GL_LUMINANCE", GL_LUMINANCE );
+    glTable.add( "GL_ALPHA", GL_ALPHA );
+    glTable.add( "GL_LUMINANCE_ALPHA", GL_LUMINANCE_ALPHA );
+    glTable.add( "GL_RGB", GL_RGB );
+    glTable.add( "GL_RGBA", GL_RGBA );
+    glTable.add( "GL_COMPRESSED_ALPHA_ARB", GL_COMPRESSED_ALPHA_ARB );
+    glTable.add( "GL_COMPRESSED_LUMINANCE_ARB", GL_COMPRESSED_LUMINANCE_ARB );
+    glTable.add( "GL_COMPRESSED_INTENSITY_ARB", GL_COMPRESSED_INTENSITY_ARB );
+    glTable.add( "GL_COMPRESSED_LUMINANCE_ALPHA_ARB", GL_COMPRESSED_LUMINANCE_ALPHA_ARB );
+    glTable.add( "GL_COMPRESSED_RGB_ARB", GL_COMPRESSED_RGB_ARB );
+    glTable.add( "GL_COMPRESSED_RGBA_ARB", GL_COMPRESSED_RGBA_ARB );
+    glTable.add( "GL_COMPRESSED_RGB_S3TC_DXT1_EXT", GL_COMPRESSED_RGB_S3TC_DXT1_EXT );
+    glTable.add( "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT", GL_COMPRESSED_RGBA_S3TC_DXT1_EXT );
+    glTable.add( "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT", GL_COMPRESSED_RGBA_S3TC_DXT3_EXT );
+    glTable.add( "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT", GL_COMPRESSED_RGBA_S3TC_DXT5_EXT );
+    
+    // Texture source types
+    glTable.add( "GL_BYTE", GL_BYTE );
+    glTable.add( "GL_SHORT", GL_SHORT );
+    glTable.add( "GL_INT", GL_INT );
+    glTable.add( "GL_FLOAT", GL_FLOAT );
+    glTable.add( "GL_DOUBLE", GL_DOUBLE );
+    glTable.add( "GL_UNSIGNED_BYTE", GL_UNSIGNED_BYTE );
+    glTable.add( "GL_UNSIGNED_SHORT", GL_UNSIGNED_SHORT );
+    glTable.add( "GL_UNSIGNED_INT", GL_UNSIGNED_INT );
+    
+    // Blend values
+    glTable.add( "DST_ALPHA", GL_DST_ALPHA );
+    glTable.add( "DST_COLOR", GL_DST_COLOR );
+    glTable.add( "ONE", GL_ONE );
+    glTable.add( "ONE_MINUS_DST_ALPHA", GL_ONE_MINUS_DST_ALPHA );
+    glTable.add( "ONE_MINUS_DST_COLOR", GL_ONE_MINUS_DST_COLOR );
+    glTable.add( "ONE_MINUS_SRC_ALPHA", GL_ONE_MINUS_SRC_ALPHA );
+    glTable.add( "ONE_MINUS_SRC_COLOR", GL_ONE_MINUS_SRC_COLOR );
+    glTable.add( "SRC_ALPHA", GL_SRC_ALPHA );
+    glTable.add( "SRC_ALPHA_SATURATE", GL_SRC_ALPHA_SATURATE );
+    glTable.add( "SRC_COLOR", GL_SRC_COLOR );
+    glTable.add( "CONSTANT_COLOR", GL_CONSTANT_COLOR );
+    glTable.add( "ONE_MINUS_CONSTANT_COLOR", GL_ONE_MINUS_CONSTANT_COLOR );
+    glTable.add( "CONSTANT_ALPHA", GL_CONSTANT_ALPHA );
+    glTable.add( "ONE_MINUS_CONSTANT_ALPHA", GL_ONE_MINUS_CONSTANT_ALPHA );
+    glTable.add( "ZERO", GL_ZERO );
+    
+    // Fog coordinate sources
+    glTable.add( "COORDINATE", GL_FOG_COORDINATE );
+    glTable.add( "DEPTH", GL_FRAGMENT_DEPTH );
+    
+    // Hint targets
+    glTable.add( "FOG_HINT", GL_FOG_HINT );
+    glTable.add( "GENERATE_MIPMAP_HINT", GL_GENERATE_MIPMAP_HINT_SGIS );
+    glTable.add( "LINE_SMOOTH_HINT", GL_LINE_SMOOTH_HINT );
+    glTable.add( "PERSPECTIVE_CORRECTION_HINT", GL_PERSPECTIVE_CORRECTION_HINT );
+    glTable.add( "POINT_SMOOTH_HINT", GL_POINT_SMOOTH_HINT );
+    glTable.add( "POLYGON_SMOOTH_HINT", GL_POLYGON_SMOOTH_HINT );
+    glTable.add( "TEXTURE_COMPRESSION_HINT", GL_TEXTURE_COMPRESSION_HINT_ARB );
+    glTable.add( "FRAGMENT_SHADER_DERIVATIVE_HINT", GL_FRAGMENT_SHADER_DERIVATIVE_HINT );
+    
+    // Polygon modes
+    glTable.add( "POINT", GL_POINT );
+    glTable.add( "LINE", GL_LINE );
+    glTable.add( "FILL", GL_FILL );
+    
+    // Misc
+    glTable.add( "BACK", GL_BACK );
+    glTable.add( "FRONT", GL_FRONT );
+    glTable.add( "FRONT_AND_BACK", GL_FRONT_AND_BACK );
+    glTable.add( "FIXED_ONLY", GL_FIXED_ONLY );
+    glTable.add( "FASTEST", GL_FASTEST );
+    glTable.add( "NICEST", GL_NICEST );
+    glTable.add( "DONT_CARE", GL_DONT_CARE );
+    
+    IntLookup& arrayTable = _globalMap["ArrayType"];
+    
+    arrayTable.add( "ByteArray", ID_BYTE_ARRAY );
+    arrayTable.add( "UByteArray", ID_UBYTE_ARRAY );
+    arrayTable.add( "ShortArray", ID_SHORT_ARRAY );
+    arrayTable.add( "UShortArray", ID_USHORT_ARRAY );
+    arrayTable.add( "IntArray", ID_INT_ARRAY );
+    arrayTable.add( "UIntArray", ID_UINT_ARRAY );
+    arrayTable.add( "FloatArray", ID_FLOAT_ARRAY );
+    arrayTable.add( "DoubleArray", ID_DOUBLE_ARRAY );
+    
+    arrayTable.add( "Vec2bArray", ID_VEC2B_ARRAY );
+    arrayTable.add( "Vec3bArray", ID_VEC3B_ARRAY );
+    arrayTable.add( "Vec4bArray", ID_VEC4B_ARRAY );
+    arrayTable.add( "Vec4ubArray", ID_VEC4UB_ARRAY );
+    arrayTable.add( "Vec2sArray", ID_VEC2S_ARRAY );
+    arrayTable.add( "Vec3sArray", ID_VEC3S_ARRAY );
+    arrayTable.add( "Vec4sArray", ID_VEC4S_ARRAY );
+    arrayTable.add( "Vec2fArray", ID_VEC2_ARRAY );
+    arrayTable.add( "Vec3fArray", ID_VEC3_ARRAY );
+    arrayTable.add( "Vec4fArray", ID_VEC4_ARRAY );
+    arrayTable.add( "Vec2dArray", ID_VEC2D_ARRAY );
+    arrayTable.add( "Vec3dArray", ID_VEC3D_ARRAY );
+    arrayTable.add( "Vec4dArray", ID_VEC4D_ARRAY );
+    
+    IntLookup& primitiveTable = _globalMap["PrimitiveType"];
+    
+    primitiveTable.add( "DrawArrays", ID_DRAWARRAYS );
+    primitiveTable.add( "DrawArraysLength", ID_DRAWARRAY_LENGTH );
+    primitiveTable.add( "DrawElementsUByte", ID_DRAWELEMENTS_UBYTE );
+    primitiveTable.add( "DrawElementsUShort", ID_DRAWELEMENTS_USHORT );
+    primitiveTable.add( "DrawElementsUInt", ID_DRAWELEMENTS_UINT );
+    
+    primitiveTable.add( "GL_POINTS", GL_POINTS );
+    primitiveTable.add( "GL_LINES", GL_LINES );
+    primitiveTable.add( "GL_LINE_STRIP", GL_LINE_STRIP );
+    primitiveTable.add( "GL_LINE_LOOP", GL_LINE_LOOP );
+    primitiveTable.add( "GL_TRIANGLES", GL_TRIANGLES );
+    primitiveTable.add( "GL_TRIANGLE_STRIP", GL_TRIANGLE_STRIP );
+    primitiveTable.add( "GL_TRIANGLE_FAN", GL_TRIANGLE_FAN );
+    primitiveTable.add( "GL_QUADS", GL_QUADS );
+    primitiveTable.add( "GL_QUAD_STRIP", GL_QUAD_STRIP );
+    primitiveTable.add( "GL_POLYGON", GL_POLYGON );
+    primitiveTable.add( "GL_LINES_ADJACENCY_EXT", GL_LINES_ADJACENCY_EXT );
+    primitiveTable.add( "GL_LINE_STRIP_ADJACENCY_EXT", GL_LINE_STRIP_ADJACENCY_EXT );
+    primitiveTable.add( "GL_TRIANGLES_ADJACENCY_EXT", GL_TRIANGLES_ADJACENCY_EXT );
+    primitiveTable.add( "GL_TRIANGLE_STRIP_ADJACENCY_EXT", GL_TRIANGLE_STRIP_ADJACENCY_EXT );
+}
+
+RegisterWrapperProxy::RegisterWrapperProxy( osg::Object* proto, const std::string& name,
+                        const std::string& associates, AddPropFunc func )
+{
+    _wrapper = new ObjectWrapper( proto, name, associates );
+    if ( func ) (*func)( _wrapper.get() );
+    ObjectRegistry::instance()->addWrapper( _wrapper.get() );
+}
+
+RegisterWrapperProxy::~RegisterWrapperProxy()
+{
+    ObjectRegistry::instance()->removeWrapper( _wrapper.get() );
+}
+
+ObjectRegistry* ObjectRegistry::instance()
+{
+    static osg::ref_ptr<ObjectRegistry> s_registry = new ObjectRegistry;
+    return s_registry.get();
+}
+
+void ObjectRegistry::addWrapper( ObjectWrapper* wrapper )
+{
+    if ( !wrapper ) return;
+
+    WrapperMap::iterator itr = _wrappers.find( wrapper->getName() );
+    if ( itr!=_wrappers.end() )
+    {
+        osg::notify(osg::WARN) << "ObjectRegistry::addWrapper(): '" << wrapper->getName()
+                               << "' already exists." << std::endl;
+    }
+    _wrappers[wrapper->getName()] = wrapper;
+}
+
+void ObjectRegistry::removeWrapper( ObjectWrapper* wrapper )
+{
+    if ( !wrapper ) return;
+
+    WrapperMap::iterator itr = _wrappers.find( wrapper->getName() );
+    if ( itr!=_wrappers.end() ) _wrappers.erase( itr );
+}
+
+ObjectWrapper* ObjectRegistry::findWrapper( const std::string& name )
+{
+    WrapperMap::iterator itr = _wrappers.find( name );
+    if ( itr!=_wrappers.end() ) return itr->second.get();
+
+    // Load external libraries
+    std::string::size_type posDoubleColon = name.rfind("::");
+    if ( posDoubleColon!=std::string::npos )
+    {
+        std::string libName = std::string( name, 0, posDoubleColon );
+
+        std::string nodeKitLib = osgDB::Registry::instance()->createLibraryNameForNodeKit(libName);
+        if ( osgDB::Registry::instance()->loadLibrary(nodeKitLib)==osgDB::Registry::LOADED )
+            return findWrapper(name);
+
+        std::string pluginLib = osgDB::Registry::instance()->createLibraryNameForExtension(libName);
+        if ( osgDB::Registry::instance()->loadLibrary(pluginLib)==osgDB::Registry::LOADED )
+            return findWrapper(name);
+    }
+    return NULL;
+}
+
+void ObjectRegistry::addCompressor( BaseCompressor* compressor )
+{
+    if ( !compressor ) return;
+
+    CompressorMap::iterator itr = _compressors.find( compressor->getName() );
+    if ( itr!=_compressors.end() )
+    {
+        osg::notify(osg::WARN) << "ObjectRegistry::addCompressor(): '" << compressor->getName()
+                               << "' already exists." << std::endl;
+    }
+    _compressors[compressor->getName()] = compressor;
+}
+
+void ObjectRegistry::removeCompressor( BaseCompressor* compressor )
+{
+    if ( !compressor ) return;
+
+    CompressorMap::iterator itr = _compressors.find( compressor->getName() );
+    if ( itr!=_compressors.end() ) _compressors.erase( itr );
+}
+
+BaseCompressor* ObjectRegistry::findCompressor( const std::string& name )
+{
+    CompressorMap::iterator itr = _compressors.find( name );
+    if ( itr!=_compressors.end() ) return itr->second.get();
+
+    // Load external libraries
+    std::string::size_type posDoubleColon = name.rfind("::");
+    if ( posDoubleColon!=std::string::npos )
+    {
+        std::string libName = std::string( name, 0, posDoubleColon );
+
+        std::string nodeKitLib = osgDB::Registry::instance()->createLibraryNameForNodeKit(libName);
+        if ( osgDB::Registry::instance()->loadLibrary(nodeKitLib)==osgDB::Registry::LOADED )
+            return findCompressor(name);
+
+        std::string pluginLib = osgDB::Registry::instance()->createLibraryNameForExtension(libName);
+        if ( osgDB::Registry::instance()->loadLibrary(pluginLib)==osgDB::Registry::LOADED )
+            return findCompressor(name);
+    }
+    return NULL;
+}

src/osgDB/OutputStream.cpp

@@ -0,0 +1,625 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+// Written by Wang Rui, (C) 2010
+
+#include <osg/Version>
+#include <osg/Notify>
+#include <osgDB/FileUtils>
+#include <osgDB/WriteFile>
+#include <osgDB/ObjectWrapper>
+#include <fstream>
+
+using namespace osgDB;
+
+OutputStream::OutputStream( std::ostream* ostream, const osgDB::Options* options )
+:   _writeMode(WRITE_BINARY), _writeImageHint(WRITE_USE_IMAGE_HINT),
+    _readyForEndBracket(false), _indent(0),
+    _out(ostream)
+{
+    if ( !_out )
+        throw OutputException(_currentField, "OutputStream: Null stream specified.");
+    if ( !options ) return;
+    
+    StringList optionList;
+    split( options->getOptionString(), optionList );
+    for ( StringList::iterator itr=optionList.begin(); itr!=optionList.end(); ++itr )
+    {
+        const std::string& option = *itr;
+        if ( option=="Ascii" )
+            _writeMode = WRITE_ASCII;
+        else
+        {
+            StringList keyAndValues;
+            split( option, keyAndValues, '=' );
+            if ( keyAndValues.size()<2 ) continue;
+            
+            if ( keyAndValues[0]=="SchemaFile" )
+            {
+                osgDB::ofstream schemaStream( keyAndValues[1].c_str(), std::ios::out );
+                if ( !schemaStream.fail() ) writeSchema( schemaStream );
+                schemaStream.close();
+            }
+            else if ( keyAndValues[0]=="Compressor" )
+                _compressorName = keyAndValues[1];
+            else if ( keyAndValues[0]=="WriteImageHint" )
+            {
+                if ( keyAndValues[1]=="IncludeData" ) _writeImageHint = WRITE_INLINE_DATA;
+                else if ( keyAndValues[1]=="IncludeFile" ) _writeImageHint = WRITE_INLINE_FILE;
+                else if ( keyAndValues[1]=="UseExternal" ) _writeImageHint = WRITE_USE_EXTERNAL;
+                else if ( keyAndValues[1]=="WriteOut" ) _writeImageHint = WRITE_EXTERNAL_FILE;
+            }
+            else
+                osg::notify(osg::WARN) << "OutputStream: Unknown option " << option << std::endl;
+        }
+    }
+}
+
+OutputStream::~OutputStream()
+{
+}
+
+OutputStream& OutputStream::operator<<( const osg::Vec2b& v )
+{ *this << v.x() << v.y(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec3b& v )
+{ *this << v.x() << v.y() << v.z(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec4b& v )
+{ *this << v.x() << v.y() << v.z() << v.w(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec4ub& v )
+{ *this << v.r() << v.g() << v.b() << v.a(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec2s& v )
+{ *this << v.x() << v.y(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec3s& v )
+{ *this << v.x() << v.y() << v.z(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec4s& v )
+{ *this << v.x() << v.y() << v.z() << v.w(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec2f& v )
+{ *this << v.x() << v.y(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec3f& v )
+{ *this << v.x() << v.y() << v.z(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec4f& v )
+{ *this << v.x() << v.y() << v.z() << v.w(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec2d& v )
+{ *this << v.x() << v.y(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec3d& v )
+{ *this << v.x() << v.y() << v.z(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Vec4d& v )
+{ *this << v.x() << v.y() << v.z() << v.w(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Quat& q )
+{ *this << q.x() << q.y() << q.z() << q.w(); return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Plane& p )
+{ *this << (double)p[0] << (double)p[1] << (double)p[2] << (double)p[3]; return *this; }
+
+OutputStream& OutputStream::operator<<( const osg::Matrixf& mat )
+{
+    *this << PROPERTY("Matrixf") << BEGIN_BRACKET << std::endl;
+    for ( int r=0; r<4; ++r )
+    {
+        *this << mat(r, 0) << mat(r, 1)
+              << mat(r, 2) << mat(r, 3) << std::endl;
+    }
+    *this << END_BRACKET << std::endl;
+    return *this;
+}
+
+OutputStream& OutputStream::operator<<( const osg::Matrixd& mat )
+{
+    *this << PROPERTY("Matrixd") << BEGIN_BRACKET << std::endl;
+    for ( int r=0; r<4; ++r )
+    {
+        *this << mat(r, 0) << mat(r, 1)
+              << mat(r, 2) << mat(r, 3) << std::endl;
+    }
+    *this << END_BRACKET << std::endl;
+    return *this;
+}
+
+OutputStream& OutputStream::operator<<( const ObjectGLenum& value )
+{
+    GLenum e = value.get();
+    if ( isBinary() )
+    {
+        _out->write((char*)&e, GLENUM_SIZE);
+    }
+    else
+    {
+        const std::string& enumString =
+            GlobalLookupTable::instance()->getString("GL", e);
+        *_out << enumString << ' ';
+    }
+    return *this;
+}
+
+OutputStream& OutputStream::operator<<( const ObjectProperty& prop )
+{
+    if ( isBinary() )
+    {
+        if ( prop._mapProperty )
+            _out->write( (char*)&(prop._value), INT_SIZE );
+    }
+    else
+    {
+        std::string enumString = prop._name;
+        if ( prop._mapProperty )
+        {
+            enumString =
+                GlobalLookupTable::instance()->getString(prop._name, prop._value);
+        }
+        *_out << enumString << ' ';
+    }
+    return *this;
+}
+
+OutputStream& OutputStream::operator<<( const ObjectMark& mark )
+{
+    if ( !isBinary() )
+    {
+        int delta = mark._indentDelta;
+        if ( delta<0 && _readyForEndBracket )
+        {
+            if ( _indent<-delta ) delta = -_indent;
+            _readyForEndBracket = false;
+            _out->seekp( delta, std::ios::cur );
+        }
+        _indent += delta;
+        *this << mark._name;
+    }
+    return *this;
+}
+
+void OutputStream::writeArray( const osg::Array* a )
+{
+    if ( !a ) return;
+    
+    unsigned int id = findOrCreateArrayID( a );
+    *this << PROPERTY("ArrayID") << id;
+    if ( id<_arrayMap.size() )  // Shared array
+    {
+        *this << std::endl;
+        return;
+    }
+    
+    switch ( a->getType() )
+    {
+    case osg::Array::ByteArrayType:
+        *this << MAPPEE(ArrayType, ID_BYTE_ARRAY);
+        writeArrayImplementation( static_cast<const osg::ByteArray*>(a), a->getNumElements(), 4 );
+        break;
+    case osg::Array::UByteArrayType:
+        *this << MAPPEE(ArrayType, ID_UBYTE_ARRAY);
+        writeArrayImplementation( static_cast<const osg::UByteArray*>(a), a->getNumElements(), 4 );
+        break;
+    case osg::Array::ShortArrayType:
+        *this << MAPPEE(ArrayType, ID_SHORT_ARRAY);
+        writeArrayImplementation( static_cast<const osg::ShortArray*>(a), a->getNumElements(), 4 );
+        break;
+    case osg::Array::UShortArrayType:
+        *this << MAPPEE(ArrayType, ID_USHORT_ARRAY);
+        writeArrayImplementation( static_cast<const osg::UShortArray*>(a), a->getNumElements(), 4 );
+        break;
+    case osg::Array::IntArrayType:
+        *this << MAPPEE(ArrayType, ID_INT_ARRAY);
+        writeArrayImplementation( static_cast<const osg::IntArray*>(a), a->getNumElements(), 4 );
+        break;
+    case osg::Array::UIntArrayType:
+        *this << MAPPEE(ArrayType, ID_UINT_ARRAY);
+        writeArrayImplementation( static_cast<const osg::UIntArray*>(a), a->getNumElements(), 4 );
+        break;
+    case osg::Array::FloatArrayType:
+        *this << MAPPEE(ArrayType, ID_FLOAT_ARRAY);
+        writeArrayImplementation( static_cast<const osg::FloatArray*>(a), a->getNumElements(), 4 );
+        break;
+    case osg::Array::DoubleArrayType:
+        *this << MAPPEE(ArrayType, ID_DOUBLE_ARRAY);
+        writeArrayImplementation( static_cast<const osg::DoubleArray*>(a), a->getNumElements(), 4 );
+        break;
+    case osg::Array::Vec2bArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC2B_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec2bArray*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec3bArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC3B_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec3bArray*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec4bArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC4B_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec4bArray*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec4ubArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC4UB_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec4ubArray*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec2sArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC2S_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec2sArray*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec3sArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC3S_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec3sArray*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec4sArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC4S_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec4sArray*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec2ArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC2_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec2Array*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec3ArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC3_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec3Array*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec4ArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC4_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec4Array*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec2dArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC4D_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec2dArray*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec3dArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC4D_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec3dArray*>(a), a->getNumElements() );
+        break;
+    case osg::Array::Vec4dArrayType:
+        *this << MAPPEE(ArrayType, ID_VEC4D_ARRAY);
+        writeArrayImplementation( static_cast<const osg::Vec4dArray*>(a), a->getNumElements() );
+        break;
+    default:
+        throw OutputException(_currentField, "OutputStream::writeArray(): Unsupported array type.");
+    }
+}
+
+void OutputStream::writePrimitiveSet( const osg::PrimitiveSet* p )
+{
+    if ( !p ) return;
+    
+    switch ( p->getType() )
+    {
+    case osg::PrimitiveSet::DrawArraysPrimitiveType:
+        *this << MAPPEE(PrimitiveType, ID_DRAWARRAYS);
+        {
+            const osg::DrawArrays* da = static_cast<const osg::DrawArrays*>(p);
+            *this << MAPPEE(PrimitiveType, da->getMode())
+                  << da->getFirst() << da->getCount() << std::endl;
+        }
+        break;
+    case osg::PrimitiveSet::DrawArrayLengthsPrimitiveType:
+        *this << MAPPEE(PrimitiveType, ID_DRAWARRAY_LENGTH);
+        {
+            const osg::DrawArrayLengths* dl = static_cast<const osg::DrawArrayLengths*>(p);
+            *this << MAPPEE(PrimitiveType, dl->getMode()) << dl->getFirst();
+            writeArrayImplementation( dl, dl->size(), 4 );
+        }
+        break;
+    case osg::PrimitiveSet::DrawElementsUBytePrimitiveType:
+        *this << MAPPEE(PrimitiveType, ID_DRAWELEMENTS_UBYTE);
+        {
+            const osg::DrawElementsUByte* de = static_cast<const osg::DrawElementsUByte*>(p);
+            *this << MAPPEE(PrimitiveType, de->getMode());
+            writeArrayImplementation( de, de->size(), 4 );
+        }
+        break;
+    case osg::PrimitiveSet::DrawElementsUShortPrimitiveType:
+        *this << MAPPEE(PrimitiveType, ID_DRAWELEMENTS_USHORT);
+        {
+            const osg::DrawElementsUShort* de = static_cast<const osg::DrawElementsUShort*>(p);
+            *this << MAPPEE(PrimitiveType, de->getMode());
+            writeArrayImplementation( de, de->size(), 4 );
+        }
+        break;
+    case osg::PrimitiveSet::DrawElementsUIntPrimitiveType:
+        *this << MAPPEE(PrimitiveType, ID_DRAWELEMENTS_UINT);
+        {
+            const osg::DrawElementsUInt* de = static_cast<const osg::DrawElementsUInt*>(p);
+            *this << MAPPEE(PrimitiveType, de->getMode());
+            writeArrayImplementation( de, de->size(), 4 );
+        }
+        break;
+    default:
+        throw OutputException(_currentField, "OutputStream::writePrimitiveSet(): Unsupported primitive type.");
+    }
+}
+
+void OutputStream::writeImage( const osg::Image* img )
+{
+    if ( !img ) return;
+    
+    *this << PROPERTY("FileName"); writeWrappedString(img->getFileName()); *this << std::endl;
+    *this << PROPERTY("WriteHint") << (int)img->getWriteHint();
+    
+    int decision = IMAGE_EXTERNAL;
+    switch ( _writeImageHint )
+    {
+    case OutputStream::WRITE_INLINE_DATA: decision = IMAGE_INLINE_DATA; break;
+    case OutputStream::WRITE_INLINE_FILE: decision = IMAGE_INLINE_FILE; break;
+    case OutputStream::WRITE_EXTERNAL_FILE: decision = IMAGE_EXTERNAL; break;
+    case OutputStream::WRITE_USE_EXTERNAL: decision = IMAGE_WRITE_OUT; break;
+    default:
+        if ( img->getWriteHint()==osg::Image::STORE_INLINE && isBinary() )
+            decision = IMAGE_INLINE_DATA;
+        else if ( img->getWriteHint()==osg::Image::EXTERNAL_FILE )
+            decision = IMAGE_WRITE_OUT;
+        break;
+    }
+    
+    *this << decision << std::endl;
+    if ( decision==IMAGE_WRITE_OUT || _writeImageHint==WRITE_EXTERNAL_FILE )
+    {
+        bool result = osgDB::writeImageFile( *img, img->getFileName() );
+        osg::notify(osg::NOTICE) << "OutputStream::writeImage(): Write image data to external file "
+                                 << img->getFileName() << std::endl;
+        if ( !result )
+        {
+            osg::notify(osg::WARN) << "OutputStream::writeImage(): Failed to write "
+                                   << img->getFileName() << std::endl;
+        }
+    }
+    
+    switch ( decision )
+    {
+    case IMAGE_INLINE_DATA:
+        if ( isBinary() )
+        {
+            *this << img->getOrigin();  // _origin
+            *this << img->s() << img->t() << img->r(); // _s & _t & _r
+            *this << img->getInternalTextureFormat();  // _internalTextureFormat
+            *this << img->getPixelFormat();  // _pixelFormat
+            *this << img->getDataType();  // _dataType
+            *this << img->getPacking();  // _packing
+            *this << img->getAllocationMode();  // _allocationMode
+            
+            // _data
+            unsigned int size = img->getTotalSizeInBytesIncludingMipmaps();
+            *this << size; writeCharArray( (char*)img->data(), size );
+            
+            // _mipmapData
+            const osg::Image::MipmapDataType& levels = img->getMipmapLevels();
+            *this << levels.size();
+            for ( osg::Image::MipmapDataType::const_iterator itr=levels.begin();
+                  itr!=levels.end(); ++itr )
+            {
+                *this << *itr;
+            }
+        }
+        break;
+    case IMAGE_INLINE_FILE:
+        if ( isBinary() )
+        {
+            std::string fullPath = osgDB::findDataFile( img->getFileName() );
+            std::ifstream infile( fullPath.c_str(), std::ios::in|std::ios::binary );
+            if ( infile )
+            {
+                infile.seekg( 0, std::ios::end );
+                unsigned int size = infile.tellg();
+                *this << size;
+                
+                if ( size>0 )
+                {
+                    char* data = new char[size];
+                    if ( !data )
+                        throw OutputException(_currentField, "OutputStream::writeImage(): Out of memory.");
+                    infile.seekg( 0, std::ios::beg );
+                    infile.read( data, size );
+                    writeCharArray( data, size );
+                    delete[] data;
+                }
+                infile.close();
+            }
+            else
+            {
+                osg::notify(osg::WARN) << "OutputStream::writeImage(): Failed to open image file "
+                                       << img->getFileName() << std::endl;
+                *this << (unsigned int)0;
+            }
+        }
+        break;
+    case IMAGE_EXTERNAL:
+        break;
+    default:
+        break;
+    }
+    
+    writeObject( img );
+}
+
+void OutputStream::writeObject( const osg::Object* obj )
+{
+    if ( !obj ) return;
+    
+    std::string name = obj->libraryName();
+    name += std::string("::") + obj->className();
+    unsigned int id = findOrCreateObjectID( obj );
+    
+    *this << name << BEGIN_BRACKET << std::endl;       // Write object name
+    *this << PROPERTY("UniqueID") << id << std::endl;  // Write object ID
+    
+    // Check whether this is a shared object or not
+    if ( id>=_objectMap.size() )
+    {
+        ObjectWrapper* wrapper = ObjectRegistry::instance()->findWrapper( name );
+        if ( !wrapper )
+        {
+            osg::notify(osg::WARN) << "OutputStream::writeObject(): Unsupported wrapper class "
+                                   << name << std::endl;
+            *this << END_BRACKET << std::endl;
+            return;
+        }
+        
+        const StringList& associates = wrapper->getAssociates();
+        for ( StringList::const_iterator itr=associates.begin(); itr!=associates.end(); ++itr )
+        {
+            ObjectWrapper* assocWrapper = ObjectRegistry::instance()->findWrapper(*itr);
+            if ( !assocWrapper )
+            {
+                osg::notify(osg::WARN) << "OutputStream::writeObject(): Unsupported associated class "
+                                       << *itr << std::endl;
+                continue;
+            }
+            
+            _currentField = assocWrapper->getName();
+            assocWrapper->write( *this, *obj );
+        }
+    }
+    *this << END_BRACKET << std::endl;
+}
+
+void OutputStream::start( OutputStream::WriteType type )
+{
+    _currentField = "Header";
+    
+    if ( isBinary() )
+    {
+        *this << (unsigned int)OSG_HEADER_LOW << (unsigned int)OSG_HEADER_HIGH
+              << (unsigned int)type << (unsigned int)PLUGIN_VERSION;
+        
+        if ( sizeof(osg::Matrix::value_type)==FLOAT_SIZE ) *this << (unsigned int)0;
+        else *this << (unsigned int)1;  // Record matrix value type of current built OSG
+        
+        if ( !_compressorName.empty() )
+        {
+            BaseCompressor* compressor =
+                ObjectRegistry::instance()->findCompressor(_compressorName);
+            if ( !compressor )
+            {
+                osg::notify(osg::WARN) << "OutputStream::start(): No such compressor "
+                                       << _compressorName << std::endl;
+            }
+            else
+            {
+                *this << _compressorName;
+                _out->flush();
+                _out = &_compressSource;
+                return;
+            }
+        }
+        *this << std::string("0");
+    }
+    else
+    {
+        std::string typeString("Unknown");
+        switch ( type )
+        {
+        case WRITE_SCENE: typeString = "Scene"; break;
+        case WRITE_IMAGE: typeString = "Image"; break;
+        default: break;
+        }
+        
+        *this << PROPERTY("#Ascii") << typeString << std::endl;
+        *this << PROPERTY("#Version") << (unsigned int)PLUGIN_VERSION << std::endl;
+        *this << PROPERTY("#Generator") << std::string("OpenSceneGraph")
+              << std::string(osgGetVersion()) << std::endl;
+        *this << std::endl;
+    }
+}
+
+void OutputStream::compress( std::ostream* ostream )
+{
+    _currentField = "Compression";
+    if ( _compressorName.empty() || !isBinary() ) return;
+    
+    BaseCompressor* compressor =
+        ObjectRegistry::instance()->findCompressor(_compressorName);
+    if ( !compressor || !ostream ) return;
+    
+    if ( !compressor->compress(*ostream, _compressSource.str()) )
+        throw OutputException(_currentField, "OutputStream: Failed to compress stream.");
+}
+
+// PROTECTED METHODS
+
+void OutputStream::writeSchema( std::ostream& fout )
+{
+    // Write to external ascii stream
+    const ObjectRegistry::WrapperMap& wrappers = ObjectRegistry::instance()->getWrapperMap();
+    for ( ObjectRegistry::WrapperMap::const_iterator itr=wrappers.begin();
+          itr!=wrappers.end(); ++itr )
+    {
+        ObjectWrapper* wrapper = itr->second.get();
+        fout << itr->first << " =";
+        
+        StringList properties;
+        wrapper->writeSchema( properties );
+        if ( properties.size()>0 )
+        {
+            for ( StringList::iterator sitr=properties.begin(); sitr!=properties.end(); ++sitr )
+            {
+                fout << ' ' << *sitr;
+            }
+        }
+        fout << std::endl;
+    }
+}
+
+template<typename T>
+void OutputStream::writeArrayImplementation( const T* a, int writeSize, unsigned int numInRow )
+{
+    *this << writeSize << BEGIN_BRACKET;
+    if ( numInRow>1 )
+    {
+        for ( int i=0; i<writeSize; ++i )
+        {
+            if ( !(i%numInRow) )
+            {
+                *this << std::endl << (*a)[i];
+            }
+            else
+                *this << (*a)[i];
+        }
+        *this << std::endl;
+    }
+    else
+    {
+        *this << std::endl;
+        for ( int i=0; i<writeSize; ++i )
+            *this << (*a)[i] << std::endl;
+    }
+    *this << END_BRACKET << std::endl;
+}
+
+unsigned int OutputStream::findOrCreateArrayID( const osg::Array* array )
+{
+    ArrayMap::iterator itr = _arrayMap.find( array );
+    if ( itr==_arrayMap.end() )
+    {
+        unsigned int id = _arrayMap.size()+1;
+        _arrayMap[array] = id;
+        return id;
+    }
+    return itr->second;
+}
+
+unsigned int OutputStream::findOrCreateObjectID( const osg::Object* obj )
+{
+    ObjectMap::iterator itr = _objectMap.find( obj );
+    if ( itr==_objectMap.end() )
+    {
+        unsigned int id = _objectMap.size()+1;
+        _objectMap[obj] = id;
+        return id;
+    }
+    return itr->second;
+}

src/osgDB/Registry.cpp

@@ -229,9 +229,13 @@ Registry::Registry()
     }
 
     addFileExtensionAlias("osgs", "osg");
-    addFileExtensionAlias("shadow",  "osgShadow");
-    addFileExtensionAlias("terrain", "osgTerrain");
-    addFileExtensionAlias("view",  "osgViewer");
+    addFileExtensionAlias("osgt", "osg");
+    addFileExtensionAlias("osgb", "osg");
+    addFileExtensionAlias("osgx", "osg");
+
+    addFileExtensionAlias("osgShadow", "shadow");
+    addFileExtensionAlias("osgTerrain", "terrain");
+    addFileExtensionAlias("osgViewer", "view");
 
     addFileExtensionAlias("sgi",  "rgb");
     addFileExtensionAlias("rgba", "rgb");

src/osgPlugins/osg/CMakeLists.txt

@@ -1,5 +1,6 @@
 SET(TARGET_SRC
     ReaderWriterOSG.cpp
+    ReaderWriterOSG2.cpp
 )
 
 #### end var setup  ###

src/osgPlugins/osg/ReaderWriterOSG2.cpp

@@ -0,0 +1,221 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+// Written by Wang Rui, (C) 2010
+
+#include <osgDB/FileNameUtils>
+#include <osgDB/FileUtils>
+#include <osgDB/Registry>
+#include <osgDB/ObjectWrapper>
+
+using namespace osgDB;
+
+class ReaderWriterOSG2 : public osgDB::ReaderWriter
+{
+public:
+    ReaderWriterOSG2()
+    {
+        supportsExtension( "osg2", "OpenSceneGraph extendable format" );
+        supportsExtension( "osgt", "OpenSceneGraph extendable ascii format" );
+        supportsExtension( "osgb", "OpenSceneGraph extendable binary format" );
+        
+        supportsOption( "Ascii", "Import/Export option: Force the writer export ascii file" );
+        supportsOption( "SchemaFile=<file>", "Import/Export option: Use/Record a ascii schema file" );
+        supportsOption( "Compressor=<name>", "Export option: Use an inbuilt or user-defined compressor" );
+        supportsOption( "WriteImageHint=<hint>", "Export option: Hint of writing image to stream: "
+                        "<IncludeData> writes Image::data() directly; "
+                        "<IncludeFile> writes the image file itself to stream; "
+                        "<UseExternal> writes only the filename; "
+                        "<WriteOut> writes Image::data() to disk as external file." );
+
+        std::string filename = osgDB::Registry::instance()->createLibraryNameForExtension("serializers_osg");
+        if (osgDB::Registry::instance()->loadLibrary(filename)==osgDB::Registry::LOADED)
+        {
+            osg::notify(osg::NOTICE)<<"Constructor ReaderWriterOSG2 - loaded OK"<<std::endl;
+        }
+        else
+        {
+            osg::notify(osg::NOTICE)<<"Constructor ReaderWriterOSG2 - failed to load"<<std::endl;
+        }
+    }
+    
+    virtual const char* className() const
+    { return "OpenSceneGraph Native Format Reader/Writer"; }
+    
+    virtual ReadResult readObject( const std::string& file, const Options* options ) const
+    { return readNode(file, options); }
+    
+    virtual ReadResult readObject( std::istream& fin, const Options* options ) const
+    { return readNode(fin, options); }
+    
+    virtual ReadResult readImage( const std::string& file, const Options* options ) const
+    {
+        std::string ext = osgDB::getLowerCaseFileExtension( file );
+        if ( !acceptsExtension(ext) ) return ReadResult::FILE_NOT_HANDLED;
+        std::string fileName = osgDB::findDataFile( file, options );
+        if ( fileName.empty() ) return ReadResult::FILE_NOT_FOUND;
+        
+        osg::ref_ptr<Options> local_opt = options ?
+            static_cast<Options*>(options->clone(osg::CopyOp::SHALLOW_COPY)) : new Options;
+        local_opt->getDatabasePathList().push_front(osgDB::getFilePath(fileName));
+        
+        osgDB::ifstream istream( fileName.c_str(), std::ios::out|std::ios::binary );
+        return readImage( istream, local_opt.get() );
+    }
+    
+    virtual ReadResult readImage( std::istream& fin, const Options* options ) const
+    {
+        try
+        {
+            InputStream is( &fin, options );
+            if ( is.start()!=InputStream::READ_IMAGE )
+                return ReadResult::FILE_NOT_HANDLED;
+            is.decompress();
+            return is.readImage();
+        }
+        catch ( InputException e )
+        {
+            return e.getError() + " At " + e.getField();
+        }
+    }
+    
+    virtual ReadResult readNode( const std::string& file, const Options* options ) const
+    {
+        std::string ext = osgDB::getLowerCaseFileExtension( file );
+        if ( !acceptsExtension(ext) ) return ReadResult::FILE_NOT_HANDLED;
+        std::string fileName = osgDB::findDataFile( file, options );
+        if ( fileName.empty() ) return ReadResult::FILE_NOT_FOUND;
+        
+        osg::ref_ptr<Options> local_opt = options ?
+            static_cast<Options*>(options->clone(osg::CopyOp::SHALLOW_COPY)) : new Options;
+        local_opt->getDatabasePathList().push_front(osgDB::getFilePath(fileName));
+        
+        osgDB::ifstream istream( fileName.c_str(), std::ios::out|std::ios::binary );
+        return readNode( istream, local_opt.get() );
+    }
+    
+    virtual ReadResult readNode( std::istream& fin, const Options* options ) const
+    {
+        try
+        {
+            InputStream is( &fin, options );
+            if ( is.start()!=InputStream::READ_SCENE )
+                return ReadResult::FILE_NOT_HANDLED;
+            is.decompress();
+            return dynamic_cast<osg::Node*>( is.readObject() );
+        }
+        catch ( InputException e )
+        {
+            return e.getError() + " At " + e.getField();
+        }
+    }
+    
+    virtual WriteResult writeObject( const osg::Object& object, const std::string& fileName, const Options* options ) const
+    {
+        const osg::Node* node = dynamic_cast<const osg::Node*>( &object );
+        if ( node ) return writeNode( *node, fileName, options );
+        
+        const osg::Image* image = dynamic_cast<const osg::Image*>( &object );
+        if ( image ) return writeImage( *image, fileName, options );
+        return WriteResult::FILE_NOT_HANDLED;
+    }
+    
+    virtual WriteResult writeObject( const osg::Object& object, std::ostream& fout, const Options* options ) const
+    {
+        const osg::Node* node = dynamic_cast<const osg::Node*>( &object );
+        if ( node ) return writeNode( *node, fout, options );
+        
+        const osg::Image* image = dynamic_cast<const osg::Image*>( &object );
+        if ( image ) return writeImage( *image, fout, options );
+        return WriteResult::FILE_NOT_HANDLED;
+    }
+    
+    virtual WriteResult writeImage( const osg::Image& image, const std::string& fileName, const Options* options ) const
+    {
+        std::string ext = osgDB::getFileExtension( fileName );
+        if ( !acceptsExtension(ext) ) return WriteResult::FILE_NOT_HANDLED;
+        
+        osg::ref_ptr<Options> local_opt = options ?
+            static_cast<Options*>(options->clone(osg::CopyOp::SHALLOW_COPY)) : new Options;
+        if( local_opt->getDatabasePathList().empty() )
+            local_opt->setDatabasePath( osgDB::getFilePath(fileName) );
+        if ( ext=="osgt" ) local_opt->setOptionString( local_opt->getOptionString() + " Ascii" );
+        
+        osgDB::ofstream fout( fileName.c_str(), std::ios::out|std::ios::binary );
+        if ( !fout ) return WriteResult::ERROR_IN_WRITING_FILE;
+        
+        WriteResult result = writeImage( image, fout, local_opt.get() );
+        fout.close();
+        return result;
+    }
+    
+    virtual WriteResult writeImage( const osg::Image& image, std::ostream& fout, const Options* options ) const
+    {
+        try
+        {
+            OutputStream os( &fout, options );
+            os.start( OutputStream::WRITE_IMAGE );
+            os.writeImage( &image );
+            os.compress( &fout );
+            
+            if ( fout.fail() ) return WriteResult::ERROR_IN_WRITING_FILE;
+            return WriteResult::FILE_SAVED;
+        }
+        catch ( OutputException e )
+        {
+            osg::notify(osg::WARN) << "ReaderWriterOSG2::writeImage(): " << e.getError()
+                                   << " At " << e.getField() << std::endl;
+        }
+        return WriteResult::FILE_NOT_HANDLED;
+    }
+    
+    virtual WriteResult writeNode( const osg::Node& node, const std::string& fileName, const Options* options ) const
+    {
+        std::string ext = osgDB::getFileExtension( fileName );
+        if ( !acceptsExtension(ext) ) return WriteResult::FILE_NOT_HANDLED;
+        
+        osg::ref_ptr<Options> local_opt = options ?
+            static_cast<Options*>(options->clone(osg::CopyOp::SHALLOW_COPY)) : new Options;
+        if ( local_opt->getDatabasePathList().empty() )
+            local_opt->setDatabasePath( osgDB::getFilePath(fileName) );
+        if ( ext=="osgt" ) local_opt->setOptionString( local_opt->getOptionString() + " Ascii" );
+        
+        osgDB::ofstream fout( fileName.c_str(), std::ios::out|std::ios::binary );
+        if ( !fout ) return WriteResult::ERROR_IN_WRITING_FILE;
+        
+        WriteResult result = writeNode( node, fout, local_opt.get() );
+        fout.close();
+        return result;
+    }
+    
+    virtual WriteResult writeNode( const osg::Node& node, std::ostream& fout, const Options* options ) const
+    {
+        try
+        {
+            OutputStream os( &fout, options );
+            os.start( OutputStream::WRITE_SCENE );
+            os.writeObject( &node );
+            os.compress( &fout );
+            
+            if ( fout.fail() ) return WriteResult::ERROR_IN_WRITING_FILE;
+            return WriteResult::FILE_SAVED;
+        }
+        catch ( OutputException e )
+        {
+            osg::notify(osg::WARN) << "ReaderWriterOSG2::writeNode(): " << e.getError()
+                                   << " At " << e.getField() << std::endl;
+        }
+        return WriteResult::FILE_NOT_HANDLED;
+    }
+};
+
+REGISTER_OSGPLUGIN( osg2, ReaderWriterOSG2 )

src/osgWrappers/serializers/CMakeLists.txt

@@ -0,0 +1,36 @@
+#---------------------------------------------------
+# OSG CMAKE SUPPORT
+# (C) by Michael Wagner, mtw@shared-reality.com 2005
+# (C) Eric Wing, Luigi Calori and Robert Osfield 2006-2007
+#---------------------------------------------------
+
+PROJECT(OSG_PLUGINS_MASTER)
+
+IF(NOT DYNAMIC_OPENSCENEGRAPH)
+    ADD_DEFINITIONS(-DOSG_LIBRARY_STATIC)
+ENDIF()
+
+IF(NOT MSVC)
+    SET(LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH}/${OSG_PLUGINS}")
+    SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${OSG_PLUGINS}")
+ENDIF()
+
+SET(CMAKE_SHARED_MODULE_PREFIX ${OSG_PLUGIN_PREFIX})
+
+IF(MSVC80 OR MSVC90)
+    IF(NOT OSG_MSVC_GENERATE_PLUGINS_AND_WRAPPERS_MANIFESTS)
+        SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /MANIFEST:NO")
+    ENDIF()
+ENDIF()
+
+SET(TARGET_DEFAULT_PREFIX "osgdb_serializers_")
+SET(TARGET_DEFAULT_LABEL_PREFIX "Plugins")
+SET(TARGET_COMMON_LIBRARIES
+    OpenThreads
+    osg
+    osgDB
+    osgUtil
+)
+
+ADD_SUBDIRECTORY(osg)
+

src/osgWrappers/serializers/osg/AlphaFunc.cpp

@@ -0,0 +1,23 @@
+#include <osg/AlphaFunc>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( AlphaFunc,
+                         new osg::AlphaFunc,
+                         osg::AlphaFunc,
+                         "osg::Object osg::StateAttribute osg::AlphaFunc" )
+{
+    BEGIN_ENUM_SERIALIZER2( Function, osg::AlphaFunc::ComparisonFunction, ALWAYS );
+        ADD_ENUM_VALUE( NEVER );
+        ADD_ENUM_VALUE( LESS );
+        ADD_ENUM_VALUE( EQUAL );
+        ADD_ENUM_VALUE( LEQUAL );
+        ADD_ENUM_VALUE( GREATER );
+        ADD_ENUM_VALUE( NOTEQUAL );
+        ADD_ENUM_VALUE( GEQUAL );
+        ADD_ENUM_VALUE( ALWAYS );
+    END_ENUM_SERIALIZER();  // _comparisonFunc
+    
+    ADD_FLOAT_SERIALIZER( ReferenceValue, 1.0f );  // _referenceValue
+}

src/osgWrappers/serializers/osg/AnimationPath.cpp

@@ -0,0 +1,75 @@
+#undef OBJECT_CAST
+#define OBJECT_CAST dynamic_cast
+
+#include <osg/AnimationPath>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static bool checkTimeControlPointMap( const osg::AnimationPath& path )
+{
+    return path.getTimeControlPointMap().size()>0;
+}
+
+static bool readTimeControlPointMap( osgDB::InputStream& is, osg::AnimationPath& path )
+{
+    unsigned int size = 0; is >> size;
+    if ( size>0 )
+    {
+        is >> osgDB::BEGIN_BRACKET;
+        for ( unsigned int i=0; i<size; ++i )
+        {
+            double time = 0.0;
+            osg::Vec3d pos, scale;
+            osg::Quat rot;
+            is >> osgDB::PROPERTY("Time") >> time >> osgDB::BEGIN_BRACKET;
+            is >> osgDB::PROPERTY("Position") >> pos;
+            is >> osgDB::PROPERTY("Rotation") >> rot;
+            is >> osgDB::PROPERTY("Scale") >> scale;
+            is >> osgDB::END_BRACKET;
+            path.insert( time, osg::AnimationPath::ControlPoint(pos, rot, scale) );
+        }
+        is >> osgDB::END_BRACKET;
+    }
+    return true;
+}
+
+static bool writeTimeControlPointMap( osgDB::OutputStream& os, const osg::AnimationPath& path )
+{
+    const osg::AnimationPath::TimeControlPointMap& map = path.getTimeControlPointMap();
+    os << map.size();
+    if ( map.size()>0 )
+    {
+        os << osgDB::BEGIN_BRACKET << std::endl;
+        for ( osg::AnimationPath::TimeControlPointMap::const_iterator itr=map.begin();
+              itr!=map.end(); ++itr )
+        {
+            const osg::AnimationPath::ControlPoint& pt = itr->second;
+            os << osgDB::PROPERTY("Time") << itr->first << osgDB::BEGIN_BRACKET << std::endl;
+            os << osgDB::PROPERTY("Position") << pt.getPosition() << std::endl;
+            os << osgDB::PROPERTY("Rotation") << pt.getRotation() << std::endl;
+            os << osgDB::PROPERTY("Scale") << pt.getScale() << std::endl;
+            os << osgDB::END_BRACKET << std::endl;
+        }
+        os << osgDB::END_BRACKET;
+    }
+    os << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( AnimationPath,
+                         new osg::AnimationPath,
+                         osg::AnimationPath,
+                         "osg::Object osg::AnimationPath" )
+{
+    ADD_USER_SERIALIZER( TimeControlPointMap );  // _timeControlPointMap
+    
+    BEGIN_ENUM_SERIALIZER( LoopMode, NO_LOOPING );
+        ADD_ENUM_VALUE( SWING );
+        ADD_ENUM_VALUE( LOOP );
+        ADD_ENUM_VALUE( NO_LOOPING );
+    END_ENUM_SERIALIZER();  //_loopMode
+}
+
+#undef OBJECT_CAST
+#define OBJECT_CAST static_cast

src/osgWrappers/serializers/osg/AnimationPathCallback.cpp

@@ -0,0 +1,23 @@
+#undef OBJECT_CAST
+#define OBJECT_CAST dynamic_cast
+
+#include <osg/AnimationPath>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( AnimationPathCallback,
+                         new osg::AnimationPathCallback,
+                         osg::AnimationPathCallback,
+                         "osg::Object osg::NodeCallback osg::AnimationPathCallback" )
+{
+    ADD_OBJECT_SERIALIZER( AnimationPath, osg::AnimationPath, NULL );  // _animationPath
+    ADD_VEC3D_SERIALIZER( PivotPoint, osg::Vec3d() );  // _pivotPoint
+    ADD_BOOL_SERIALIZER( UseInverseMatrix, false );  // _useInverseMatrix
+    ADD_DOUBLE_SERIALIZER( TimeOffset, 0.0 );  // _timeOffset
+    ADD_DOUBLE_SERIALIZER( TimeMultiplier, 1.0 );  // _timeMultiplier
+    ADD_BOOL_SERIALIZER( Pause, false );  // _pause
+}
+
+#undef OBJECT_CAST
+#define OBJECT_CAST static_cast

src/osgWrappers/serializers/osg/AudioSink.cpp

@@ -0,0 +1,11 @@
+#include <osg/AudioStream>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( AudioSink,
+                         /*new osg::AudioSink*/NULL,
+                         osg::AudioSink,
+                         "osg::Object osg::AudioSink" )
+{
+}

src/osgWrappers/serializers/osg/AudioStream.cpp

@@ -0,0 +1,11 @@
+#include <osg/AudioStream>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( AudioStream,
+                         /*new osg::AudioStream*/NULL,
+                         osg::AudioStream,
+                         "osg::Object osg::AudioStream" )
+{
+}

src/osgWrappers/serializers/osg/AutoTransform.cpp

@@ -0,0 +1,27 @@
+#include <osg/AutoTransform>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( AutoTransform,
+                         new osg::AutoTransform,
+                         osg::AutoTransform,
+                         "osg::Object osg::Node osg::Group osg::Transform osg::AutoTransform" )
+{
+    ADD_DOUBLE_SERIALIZER( MinimumScale, 0.0 );  // _minimumScale
+    ADD_DOUBLE_SERIALIZER( MaximumScale, 0.0 );  // _maximumScale
+    ADD_VEC3D_SERIALIZER( Position, osg::Vec3d() );  // _position
+    ADD_VEC3D_SERIALIZER( Scale, osg::Vec3d() );  // _scale
+    ADD_VEC3D_SERIALIZER( PivotPoint, osg::Vec3d() );  // _pivotPoint
+    ADD_FLOAT_SERIALIZER( AutoUpdateEyeMovementTolerance, 0.0f );  // _autoUpdateEyeMovementTolerance
+    
+    BEGIN_ENUM_SERIALIZER( AutoRotateMode, NO_ROTATION );
+        ADD_ENUM_VALUE( NO_ROTATION );
+        ADD_ENUM_VALUE( ROTATE_TO_SCREEN );
+        ADD_ENUM_VALUE( ROTATE_TO_CAMERA );
+    END_ENUM_SERIALIZER();  // _autoRotateMode
+    
+    ADD_BOOL_SERIALIZER( AutoScaleToScreen, false );  // _autoScaleToScreen
+    ADD_QUAT_SERIALIZER( Rotation, osg::Quat() );  // _rotation
+    ADD_FLOAT_SERIALIZER( AutoScaleTransitionWidthRatio, 0.25f );  // _autoScaleTransitionWidthRatio
+}

src/osgWrappers/serializers/osg/Billboard.cpp

@@ -0,0 +1,50 @@
+#include <osg/Billboard>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static bool checkPositionList( const osg::Billboard& node )
+{
+    return node.getPositionList().size()>0;
+}
+
+static bool readPositionList( osgDB::InputStream& is, osg::Billboard& node )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        osg::Vec3d pos; is >> pos;
+        node.setPosition( i, pos );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writePositionList( osgDB::OutputStream& os, const osg::Billboard& node )
+{
+    const osg::Billboard::PositionList& posList = node.getPositionList();
+    os << posList.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::Billboard::PositionList::const_iterator itr=posList.begin();
+          itr!=posList.end(); ++itr )
+    {
+        os << osg::Vec3d(*itr) << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( Billboard,
+                         new osg::Billboard,
+                         osg::Billboard,
+                         "osg::Object osg::Node osg::Geode osg::Billboard" )
+{
+    BEGIN_ENUM_SERIALIZER( Mode, AXIAL_ROT );
+        ADD_ENUM_VALUE( POINT_ROT_EYE );
+        ADD_ENUM_VALUE( POINT_ROT_WORLD );
+        ADD_ENUM_VALUE( AXIAL_ROT );
+    END_ENUM_SERIALIZER();  // _mode
+    
+    ADD_VEC3_SERIALIZER( Axis, osg::Vec3f() );  // _axis
+    ADD_VEC3_SERIALIZER( Normal, osg::Vec3f() );  // _normal
+    ADD_USER_SERIALIZER( PositionList );  // _positionList
+}

src/osgWrappers/serializers/osg/BlendColor.cpp

@@ -0,0 +1,12 @@
+#include <osg/BlendColor>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( BlendColor,
+                         new osg::BlendColor,
+                         osg::BlendColor,
+                         "osg::Object osg::StateAttribute osg::BlendColor" )
+{
+    ADD_VEC4_SERIALIZER( ConstantColor, osg::Vec4() );  // _constantColor
+}

src/osgWrappers/serializers/osg/BlendEquation.cpp

@@ -0,0 +1,32 @@
+#include <osg/BlendEquation>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( BlendEquation,
+                         new osg::BlendEquation,
+                         osg::BlendEquation,
+                         "osg::Object osg::StateAttribute osg::BlendEquation" )
+{
+    BEGIN_ENUM_SERIALIZER2( EquationRGB, osg::BlendEquation::Equation, FUNC_ADD );
+        ADD_ENUM_VALUE( RGBA_MIN );
+        ADD_ENUM_VALUE( RGBA_MAX );
+        ADD_ENUM_VALUE( ALPHA_MIN );
+        ADD_ENUM_VALUE( ALPHA_MAX );
+        ADD_ENUM_VALUE( LOGIC_OP );
+        ADD_ENUM_VALUE( FUNC_ADD );
+        ADD_ENUM_VALUE( FUNC_SUBTRACT );
+        ADD_ENUM_VALUE( FUNC_REVERSE_SUBTRACT );
+    END_ENUM_SERIALIZER();  // _equationRGB
+    
+    BEGIN_ENUM_SERIALIZER2( EquationAlpha, osg::BlendEquation::Equation, FUNC_ADD );
+        ADD_ENUM_VALUE( RGBA_MIN );
+        ADD_ENUM_VALUE( RGBA_MAX );
+        ADD_ENUM_VALUE( ALPHA_MIN );
+        ADD_ENUM_VALUE( ALPHA_MAX );
+        ADD_ENUM_VALUE( LOGIC_OP );
+        ADD_ENUM_VALUE( FUNC_ADD );
+        ADD_ENUM_VALUE( FUNC_SUBTRACT );
+        ADD_ENUM_VALUE( FUNC_REVERSE_SUBTRACT );
+    END_ENUM_SERIALIZER();  // _equationAlpha
+}

src/osgWrappers/serializers/osg/BlendFunc.cpp

@@ -0,0 +1,15 @@
+#include <osg/BlendFunc>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( BlendFunc,
+                         new osg::BlendFunc,
+                         osg::BlendFunc,
+                         "osg::Object osg::StateAttribute osg::BlendFunc" )
+{
+    ADD_GLENUM_SERIALIZER( SourceRGB, GLenum, GL_ONE );  // _source_factor
+    ADD_GLENUM_SERIALIZER( SourceAlpha, GLenum, GL_ONE );  // _source_factor_alpha
+    ADD_GLENUM_SERIALIZER( DestinationRGB, GLenum, GL_ONE );  // _destination_factor
+    ADD_GLENUM_SERIALIZER( DestinationAlpha, GLenum, GL_ONE );  // _destination_factor_alpha
+}

src/osgWrappers/serializers/osg/Box.cpp

@@ -0,0 +1,14 @@
+#include <osg/Shape>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Box,
+                         new osg::Box,
+                         osg::Box,
+                         "osg::Object osg::Shape osg::Box" )
+{
+    ADD_VEC3_SERIALIZER( Center, osg::Vec3() );  // _center
+    ADD_VEC3_SERIALIZER( HalfLengths, osg::Vec3() );  // _halfLengths
+    ADD_QUAT_SERIALIZER( Rotation, osg::Quat() );  // _rotation
+}

src/osgWrappers/serializers/osg/CMakeLists.txt

@@ -0,0 +1,5 @@
+FILE(GLOB TARGET_SRC *.cpp)
+FILE(GLOB TARGET_H *.h)
+
+#### end var setup  ###
+SETUP_PLUGIN(osg)

src/osgWrappers/serializers/osg/Camera.cpp

@@ -0,0 +1,271 @@
+#include <osg/Camera>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+BEGIN_USER_TABLE( RenderOrder, osg::Camera );
+    ADD_USER_VALUE( PRE_RENDER );
+    ADD_USER_VALUE( NESTED_RENDER );
+    ADD_USER_VALUE( POST_RENDER );
+END_USER_TABLE()
+
+USER_READ_FUNC( RenderOrder, readOrderValue )
+USER_WRITE_FUNC( RenderOrder, writeOrderValue )
+
+BEGIN_USER_TABLE( BufferComponent, osg::Camera );
+    ADD_USER_VALUE( DEPTH_BUFFER );
+    ADD_USER_VALUE( STENCIL_BUFFER );
+    ADD_USER_VALUE( PACKED_DEPTH_STENCIL_BUFFER );
+    ADD_USER_VALUE( COLOR_BUFFER );
+    ADD_USER_VALUE( COLOR_BUFFER0 );
+    ADD_USER_VALUE( COLOR_BUFFER1 );
+    ADD_USER_VALUE( COLOR_BUFFER2 );
+    ADD_USER_VALUE( COLOR_BUFFER3 );
+    ADD_USER_VALUE( COLOR_BUFFER4 );
+    ADD_USER_VALUE( COLOR_BUFFER5 );
+    ADD_USER_VALUE( COLOR_BUFFER6 );
+    ADD_USER_VALUE( COLOR_BUFFER7 );
+    ADD_USER_VALUE( COLOR_BUFFER8 );
+    ADD_USER_VALUE( COLOR_BUFFER9 );
+    ADD_USER_VALUE( COLOR_BUFFER10 );
+    ADD_USER_VALUE( COLOR_BUFFER11 );
+    ADD_USER_VALUE( COLOR_BUFFER12 );
+    ADD_USER_VALUE( COLOR_BUFFER13 );
+    ADD_USER_VALUE( COLOR_BUFFER14 );
+    ADD_USER_VALUE( COLOR_BUFFER15 );
+END_USER_TABLE()
+
+USER_READ_FUNC( BufferComponent, readBufferComponent )
+USER_WRITE_FUNC( BufferComponent, writeBufferComponent )
+
+static osg::Camera::Attachment readBufferAttachment( osgDB::InputStream& is )
+{
+    osg::Camera::Attachment attachment;
+    char type = -1; is >> osgDB::PROPERTY("Type") >> type;
+    if ( type==0 )
+    {
+        is >> osgDB::PROPERTY("InternalFormat") >> attachment._internalFormat;
+        return attachment;
+    }
+    else if ( type==1 )
+    {
+        is >> osgDB::PROPERTY("Image");
+        attachment._image = dynamic_cast<osg::Image*>( is.readObject() );
+    }
+    else if ( type==2 )
+    {
+        is >> osgDB::PROPERTY("Texture");
+        attachment._texture = dynamic_cast<osg::Texture*>( is.readObject() );
+        is >> osgDB::PROPERTY("Level") >> attachment._level;
+        is >> osgDB::PROPERTY("Face") >> attachment._face;
+        is >> osgDB::PROPERTY("MipMapGeneration") >> attachment._mipMapGeneration;
+    }
+    else
+        return attachment;
+    
+    is >> osgDB::PROPERTY("MultisampleSamples") >> attachment._multisampleSamples;
+    is >> osgDB::PROPERTY("MultisampleColorSamples") >> attachment._multisampleColorSamples;
+    return attachment;
+}
+
+static void writeBufferAttachment( osgDB::OutputStream& os, const osg::Camera::Attachment& attachment )
+{
+    os << osgDB::PROPERTY("Type");
+    if ( attachment._internalFormat!=GL_NONE )
+    {
+        os << (char)0 << std::endl;
+        os << osgDB::PROPERTY("InternalFormat") << GLENUM(attachment._internalFormat) << std::endl;
+        return;
+    }
+    else if ( attachment._image.valid() )
+    {
+        os << (char)1 << std::endl;
+        os << osgDB::PROPERTY("Image") << attachment._image.get();
+    }
+    else if ( attachment._texture.valid() )
+    {
+        os << (char)2 << std::endl;
+        os << osgDB::PROPERTY("Texture") << attachment._texture.get();
+        os << osgDB::PROPERTY("Level") << attachment._level << std::endl;
+        os << osgDB::PROPERTY("Face") << attachment._face << std::endl;
+        os << osgDB::PROPERTY("MipMapGeneration") << attachment._mipMapGeneration << std::endl;
+    }
+    else
+    {
+        os << (char)-1 << std::endl;
+        return;
+    }
+    
+    os << osgDB::PROPERTY("MultisampleSamples") << attachment._multisampleSamples << std::endl;
+    os << osgDB::PROPERTY("MultisampleColorSamples") << attachment._multisampleColorSamples << std::endl;
+}
+
+// _clearMask
+static bool checkClearMask( const osg::Camera& node )
+{
+    return node.getClearMask()!=(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+}
+
+static bool readClearMask( osgDB::InputStream& is, osg::Camera& node )
+{
+    GLbitfield mask = 0;
+    if ( is.isBinary() )
+    {
+        int maskValue; is >> maskValue;
+        mask = (GLbitfield)maskValue;
+    }
+    else
+    {
+        std::string maskSetString; is >> maskSetString;
+        osgDB::StringList maskList; osgDB::split( maskSetString, maskList, '|' );
+        for ( unsigned int i=0; i<maskList.size(); ++i )
+        {
+            const std::string& maskValue = maskList[i];
+            if ( maskValue=="COLOR" ) mask |= GL_COLOR_BUFFER_BIT;
+            else if ( maskValue=="DEPTH" ) mask |= GL_DEPTH_BUFFER_BIT;
+            else if ( maskValue=="ACCUM" ) mask |= GL_ACCUM_BUFFER_BIT;
+            else if ( maskValue=="STENCIL" ) mask |= GL_STENCIL_BUFFER_BIT;
+        }
+    }
+    node.setClearMask( mask );
+    return true;
+}
+
+static bool writeClearMask( osgDB::OutputStream& os, const osg::Camera& node )
+{
+    GLbitfield mask = node.getClearMask();
+    if ( os.isBinary() )
+        os << (int)mask;
+    else
+    {
+        std::string maskString;
+        if ( mask==GL_COLOR_BUFFER_BIT ) maskString += std::string("COLOR|");
+        if ( mask==GL_DEPTH_BUFFER_BIT ) maskString += std::string("DEPTH|");
+        if ( mask==GL_ACCUM_BUFFER_BIT ) maskString += std::string("ACCUM|");
+        if ( mask==GL_STENCIL_BUFFER_BIT ) maskString += std::string("STENCIL|");
+        if ( !maskString.size() ) maskString = std::string("NONE|");
+        os << maskString.substr(0, maskString.size()-1) << std::endl;
+    }
+    return true;
+}
+
+// _renderOrder & _renderOrderNum
+static bool checkRenderOrder( const osg::Camera& node )
+{
+    return true;
+}
+
+static bool readRenderOrder( osgDB::InputStream& is, osg::Camera& node )
+{
+    int order = readOrderValue(is);
+    int orderNumber = 0; is >> orderNumber;
+    node.setRenderOrder( static_cast<osg::Camera::RenderOrder>(order), orderNumber );
+    return true;
+}
+
+static bool writeRenderOrder( osgDB::OutputStream& os, const osg::Camera& node )
+{
+    writeOrderValue( os, (int)node.getRenderOrder() );
+    os << node.getRenderOrderNum() << std::endl;
+    return true;
+}
+
+// _bufferAttachmentMap
+static bool checkBufferAttachmentMap( const osg::Camera& node )
+{
+    return node.getBufferAttachmentMap().size()>0;
+}
+
+static bool readBufferAttachmentMap( osgDB::InputStream& is, osg::Camera& node )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        is >> osgDB::PROPERTY("Attachment");
+        osg::Camera::BufferComponent bufferComponent =
+            static_cast<osg::Camera::BufferComponent>( readBufferComponent(is) );
+        is >> osgDB::BEGIN_BRACKET;
+        osg::Camera::Attachment attachment = readBufferAttachment(is);
+        is >> osgDB::END_BRACKET;
+        
+        if ( attachment._internalFormat!=GL_NONE )
+        {
+            node.attach( bufferComponent, attachment._internalFormat );
+        }
+        else if ( attachment._image.valid() )
+        {
+            node.attach( bufferComponent, attachment._image.get(),
+                         attachment._multisampleSamples, attachment._multisampleColorSamples );
+        }
+        else if ( attachment._texture.valid() )
+        {
+            node.attach( bufferComponent, attachment._texture.get(),
+                         attachment._level, attachment._face, attachment._mipMapGeneration,
+                         attachment._multisampleSamples, attachment._multisampleColorSamples );
+        }
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeBufferAttachmentMap( osgDB::OutputStream& os, const osg::Camera& node )
+{
+    const osg::Camera::BufferAttachmentMap& map = node.getBufferAttachmentMap();
+    os << map.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::Camera::BufferAttachmentMap::const_iterator itr=map.begin();
+          itr!=map.end(); ++itr )
+    {
+        os << osgDB::PROPERTY("Attachment"); writeBufferComponent( os, itr->first );
+        os << osgDB::BEGIN_BRACKET << std::endl;
+        writeBufferAttachment( os, itr->second );
+        os << osgDB::END_BRACKET << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( Camera,
+                         new osg::Camera,
+                         osg::Camera,
+                         "osg::Object osg::Node osg::Group osg::Transform osg::Camera" )
+{
+    ADD_BOOL_SERIALIZER( AllowEventFocus, true );  // _allowEventFocus
+    ADD_USER_SERIALIZER( ClearMask );  // _clearMask
+    ADD_VEC4_SERIALIZER( ClearColor, osg::Vec4() );  // _clearColor
+    ADD_VEC4_SERIALIZER( ClearAccum, osg::Vec4() );  // _clearAccum
+    ADD_DOUBLE_SERIALIZER( ClearDepth, 1.0 );  // _clearDepth
+    ADD_INT_SERIALIZER( ClearStencil, 0 );  // _clearStencil
+    ADD_OBJECT_SERIALIZER( ColorMask, osg::ColorMask, NULL );  // _colorMask
+    ADD_OBJECT_SERIALIZER( Viewport, osg::Viewport, NULL );  // _viewport
+    
+    BEGIN_ENUM_SERIALIZER( TransformOrder, PRE_MULTIPLY );
+        ADD_ENUM_VALUE( PRE_MULTIPLY );
+        ADD_ENUM_VALUE( POST_MULTIPLY );
+    END_ENUM_SERIALIZER();  // _transformOrder
+    
+    BEGIN_ENUM_SERIALIZER( ProjectionResizePolicy, HORIZONTAL );
+        ADD_ENUM_VALUE( FIXED );
+        ADD_ENUM_VALUE( HORIZONTAL );
+        ADD_ENUM_VALUE( VERTICAL );
+    END_ENUM_SERIALIZER();  // _projectionResizePolicy
+    
+    ADD_MATRIXD_SERIALIZER( ProjectionMatrix, osg::Matrixd() );  // _projectionMatrix
+    ADD_MATRIXD_SERIALIZER( ViewMatrix, osg::Matrixd() );  // _viewMatrix
+    ADD_USER_SERIALIZER( RenderOrder );  // _renderOrder & _renderOrderNum
+    ADD_GLENUM_SERIALIZER( DrawBuffer, GLenum, GL_NONE );  // _drawBuffer
+    ADD_GLENUM_SERIALIZER( ReadBuffer, GLenum, GL_NONE );  // _readBuffer
+    
+    BEGIN_ENUM_SERIALIZER( RenderTargetImplementation, FRAME_BUFFER );
+        ADD_ENUM_VALUE( FRAME_BUFFER_OBJECT );
+        ADD_ENUM_VALUE( PIXEL_BUFFER_RTT );
+        ADD_ENUM_VALUE( PIXEL_BUFFER );
+        ADD_ENUM_VALUE( FRAME_BUFFER );
+        ADD_ENUM_VALUE( SEPERATE_WINDOW );
+    END_ENUM_SERIALIZER();  // _renderTargetImplementation
+    
+    ADD_USER_SERIALIZER( BufferAttachmentMap );  // _bufferAttachmentMap
+    ADD_OBJECT_SERIALIZER( InitialDrawCallback, osg::Camera::DrawCallback, NULL );  // _initialDrawCallback
+    ADD_OBJECT_SERIALIZER( PreDrawCallback, osg::Camera::DrawCallback, NULL );  // _preDrawCallback
+    ADD_OBJECT_SERIALIZER( PostDrawCallback, osg::Camera::DrawCallback, NULL );  // _postDrawCallback
+    ADD_OBJECT_SERIALIZER( FinalDrawCallback, osg::Camera::DrawCallback, NULL );  // _finalDrawCallback
+}

src/osgWrappers/serializers/osg/CameraView.cpp

@@ -0,0 +1,22 @@
+#include <osg/CameraView>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( CameraView,
+                         new osg::CameraView,
+                         osg::CameraView,
+                         "osg::Object osg::Node osg::Group osg::Transform osg::CameraView" )
+{
+    ADD_VEC3D_SERIALIZER( Position, osg::Vec3d() );  // _position
+    ADD_QUAT_SERIALIZER( Attitude, osg::Quat() );  // _attitude
+    ADD_DOUBLE_SERIALIZER( FieldOfView, 60.0 );  // _fieldOfView
+    
+    BEGIN_ENUM_SERIALIZER( FieldOfViewMode, VERTICAL );
+        ADD_ENUM_VALUE( UNCONSTRAINED );
+        ADD_ENUM_VALUE( HORIZONTAL );
+        ADD_ENUM_VALUE( VERTICAL );
+    END_ENUM_SERIALIZER();  // _fieldOfViewMode
+    
+    ADD_DOUBLE_SERIALIZER( FocalLength, 0.0 );  // _focalLength
+}

src/osgWrappers/serializers/osg/Capsule.cpp

@@ -0,0 +1,15 @@
+#include <osg/Shape>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Capsule,
+                         new osg::Capsule,
+                         osg::Capsule,
+                         "osg::Object osg::Shape osg::Capsule" )
+{
+    ADD_VEC3_SERIALIZER( Center, osg::Vec3() );  // _center
+    ADD_FLOAT_SERIALIZER( Radius, 0.0f );  // _radius
+    ADD_FLOAT_SERIALIZER( Height, 0.0f );  // _height
+    ADD_QUAT_SERIALIZER( Rotation, osg::Quat() );  // _rotation
+}

src/osgWrappers/serializers/osg/ClampColor.cpp

@@ -0,0 +1,14 @@
+#include <osg/ClampColor>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( ClampColor,
+                         new osg::ClampColor,
+                         osg::ClampColor,
+                         "osg::Object osg::StateAttribute osg::ClampColor" )
+{
+    ADD_GLENUM_SERIALIZER( ClampVertexColor, GLenum, GL_FIXED_ONLY );  // _clampVertexColor
+    ADD_GLENUM_SERIALIZER( ClampFragmentColor, GLenum, GL_FIXED_ONLY );  // _clampFragmentColor
+    ADD_GLENUM_SERIALIZER( ClampReadColor, GLenum, GL_FIXED_ONLY );  // _clampReadColor
+}

src/osgWrappers/serializers/osg/ClearNode.cpp

@@ -0,0 +1,63 @@
+#include <osg/ClearNode>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+// _clearMask
+static bool checkClearMask( const osg::ClearNode& node )
+{
+    return node.getClearMask()!=(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+}
+
+static bool readClearMask( osgDB::InputStream& is, osg::ClearNode& node )
+{
+    GLbitfield mask = GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT;
+    if ( is.isBinary() )
+    {
+        int maskValue; is >> maskValue;
+        mask = (GLbitfield)maskValue;
+    }
+    else
+    {
+        std::string maskSetString; is >> maskSetString;
+        osgDB::StringList maskList; osgDB::split( maskSetString, maskList, '|' );
+        for ( unsigned int i=0; i<maskList.size(); ++i )
+        {
+            const std::string& maskValue = maskList[i];
+            if ( maskValue=="COLOR" ) mask |= GL_COLOR_BUFFER_BIT;
+            else if ( maskValue=="DEPTH" ) mask |= GL_DEPTH_BUFFER_BIT;
+            else if ( maskValue=="ACCUM" ) mask |= GL_ACCUM_BUFFER_BIT;
+            else if ( maskValue=="STENCIL" ) mask |= GL_STENCIL_BUFFER_BIT;
+        }
+    }
+    node.setClearMask( mask );
+    return true;
+}
+
+static bool writeClearMask( osgDB::OutputStream& os, const osg::ClearNode& node )
+{
+    GLbitfield mask = node.getClearMask();
+    if ( os.isBinary() )
+        os << (int)mask;
+    else
+    {
+        std::string maskString;
+        if ( mask==GL_COLOR_BUFFER_BIT ) maskString += std::string("COLOR|");
+        if ( mask==GL_DEPTH_BUFFER_BIT ) maskString += std::string("DEPTH|");
+        if ( mask==GL_ACCUM_BUFFER_BIT ) maskString += std::string("ACCUM|");
+        if ( mask==GL_STENCIL_BUFFER_BIT ) maskString += std::string("STENCIL|");
+        if ( !maskString.size() ) maskString = std::string("NONE|");
+        os << maskString.substr(0, maskString.size()-1) << std::endl;
+    }
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( ClearNode,
+                         new osg::ClearNode,
+                         osg::ClearNode,
+                         "osg::Object osg::Node osg::Group osg::ClearNode" )
+{
+    ADD_BOOL_SERIALIZER( RequiresClear, true );  // _requiresClear
+    ADD_VEC4_SERIALIZER( ClearColor, osg::Vec4(0.0f, 0.0f, 0.0f, 1.0f) );  // _clearColor
+    ADD_USER_SERIALIZER( ClearMask );  // _clearMask
+}

src/osgWrappers/serializers/osg/ClipNode.cpp

@@ -0,0 +1,17 @@
+#include <osg/ClipNode>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( ClipNode,
+                         new osg::ClipNode,
+                         osg::ClipNode,
+                         "osg::Object osg::Node osg::Group osg::ClipNode" )
+{
+    ADD_LIST_SERIALIZER( ClipPlaneList, osg::ClipNode::ClipPlaneList );  // _planes
+    
+    BEGIN_ENUM_SERIALIZER( ReferenceFrame, RELATIVE_RF );
+        ADD_ENUM_VALUE( RELATIVE_RF );
+        ADD_ENUM_VALUE( ABSOLUTE_RF );
+    END_ENUM_SERIALIZER();  // _referenceFrame
+}

src/osgWrappers/serializers/osg/ClipPlane.cpp

@@ -0,0 +1,13 @@
+#include <osg/ClipPlane>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( ClipPlane,
+                         new osg::ClipPlane,
+                         osg::ClipPlane,
+                         "osg::Object osg::StateAttribute osg::ClipPlane" )
+{
+    ADD_VEC4D_SERIALIZER( ClipPlane, osg::Vec4d() );  // _clipPlane
+    ADD_UINT_SERIALIZER( ClipPlaneNum, 0 );  // _clipPlaneNum
+}

src/osgWrappers/serializers/osg/ClusterCullingCallback.cpp

@@ -0,0 +1,21 @@
+#undef OBJECT_CAST
+#define OBJECT_CAST dynamic_cast
+
+#include <osg/ClusterCullingCallback>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( ClusterCullingCallback,
+                         new osg::ClusterCullingCallback,
+                         osg::ClusterCullingCallback,
+                         "osg::Object osg::NodeCallback osg::ClusterCullingCallback" )
+{
+    ADD_VEC3_SERIALIZER( ControlPoint, osg::Vec3() );  // _controlPoint
+    ADD_VEC3_SERIALIZER( Normal, osg::Vec3() );  // _normal
+    ADD_FLOAT_SERIALIZER( Radius, -1.0f );  // _radius
+    ADD_FLOAT_SERIALIZER( Deviation, -1.0f );  // _deviation
+}
+
+#undef OBJECT_CAST
+#define OBJECT_CAST static_cast

src/osgWrappers/serializers/osg/ColorMask.cpp

@@ -0,0 +1,15 @@
+#include <osg/ColorMask>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( ColorMask,
+                         new osg::ColorMask,
+                         osg::ColorMask,
+                         "osg::Object osg::StateAttribute osg::ColorMask" )
+{
+    ADD_BOOL_SERIALIZER( RedMask, true );  // _red
+    ADD_BOOL_SERIALIZER( GreenMask, true );  // _green
+    ADD_BOOL_SERIALIZER( BlueMask, true );  // _blue
+    ADD_BOOL_SERIALIZER( AlphaMask, true );  // _alpha
+}

src/osgWrappers/serializers/osg/ColorMatrix.cpp

@@ -0,0 +1,12 @@
+#include <osg/ColorMatrix>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( ColorMatrix,
+                         new osg::ColorMatrix,
+                         osg::ColorMatrix,
+                         "osg::Object osg::StateAttribute osg::ColorMatrix" )
+{
+    ADD_MATRIX_SERIALIZER( Matrix, osg::Matrix() );  // _matrix
+}

src/osgWrappers/serializers/osg/CompositeShape.cpp

@@ -0,0 +1,42 @@
+#include <osg/Shape>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static bool checkChildren( const osg::CompositeShape& shape )
+{
+    return shape.getNumChildren()>0;
+}
+
+static bool readChildren( osgDB::InputStream& is, osg::CompositeShape& shape )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        osg::Shape* child = dynamic_cast<osg::Shape*>( is.readObject() );
+        if ( child ) shape.addChild( child );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeChildren( osgDB::OutputStream& os, const osg::CompositeShape& shape )
+{
+    unsigned int size = shape.getNumChildren();
+    os << size << osgDB::BEGIN_BRACKET << std::endl;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        os << shape.getChild(i);
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( CompositeShape,
+                         new osg::CompositeShape,
+                         osg::CompositeShape,
+                         "osg::Object osg::Shape osg::CompositeShape" )
+{
+    ADD_OBJECT_SERIALIZER( Shape, osg::Shape, NULL );  // _shape
+    ADD_USER_SERIALIZER( Children );  //_children
+}

src/osgWrappers/serializers/osg/Cone.cpp

@@ -0,0 +1,15 @@
+#include <osg/Shape>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Cone,
+                         new osg::Cone,
+                         osg::Cone,
+                         "osg::Object osg::Shape osg::Cone" )
+{
+    ADD_VEC3_SERIALIZER( Center, osg::Vec3() );  // _center
+    ADD_FLOAT_SERIALIZER( Radius, 0.0f );  // _radius
+    ADD_FLOAT_SERIALIZER( Height, 0.0f );  // _height
+    ADD_QUAT_SERIALIZER( Rotation, osg::Quat() );  // _rotation
+}

src/osgWrappers/serializers/osg/ConvexHull.cpp

@@ -0,0 +1,11 @@
+#include <osg/Shape>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( ConvexHull,
+                         new osg::ConvexHull,
+                         osg::ConvexHull,
+                         "osg::Object osg::Shape osg::TriangleMesh osg::ConvexHull" )
+{
+}

src/osgWrappers/serializers/osg/ConvexPlanarOccluder.cpp

@@ -0,0 +1,90 @@
+#include <osg/ConvexPlanarOccluder>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static void readConvexPlanarPolygon( osgDB::InputStream& is, osg::ConvexPlanarPolygon& polygon )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        osg::Vec3d vertex; is >> vertex;
+        polygon.add( vertex );
+    }
+    is >> osgDB::END_BRACKET;
+}
+
+static void writeConvexPlanarPolygon( osgDB::OutputStream& os, const osg::ConvexPlanarPolygon& polygon )
+{
+    const osg::ConvexPlanarPolygon::VertexList& vertices = polygon.getVertexList();
+    os << vertices.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::ConvexPlanarPolygon::VertexList::const_iterator itr=vertices.begin();
+          itr!=vertices.end(); ++itr )
+    {
+        os << osg::Vec3d(*itr) << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+}
+
+// _occluder
+static bool checkOccluder( const osg::ConvexPlanarOccluder& obj )
+{
+    return obj.getOccluder().getVertexList().size()>0;
+}
+
+static bool readOccluder( osgDB::InputStream& is, osg::ConvexPlanarOccluder& obj )
+{
+    osg::ConvexPlanarPolygon polygon;
+    readConvexPlanarPolygon( is, polygon );
+    obj.setOccluder( polygon );
+    return true;
+}
+
+static bool writeOccluder( osgDB::OutputStream& os, const osg::ConvexPlanarOccluder& obj )
+{
+    writeConvexPlanarPolygon( os, obj.getOccluder() );
+    return true;
+}
+
+// _holeList
+static bool checkHoles( const osg::ConvexPlanarOccluder& obj )
+{
+    return obj.getHoleList().size()>0;
+}
+
+static bool readHoles( osgDB::InputStream& is, osg::ConvexPlanarOccluder& obj )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        osg::ConvexPlanarPolygon polygon;
+        is >> osgDB::PROPERTY("Polygon");
+        readConvexPlanarPolygon( is, polygon );
+        obj.addHole( polygon );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeHoles( osgDB::OutputStream& os, const osg::ConvexPlanarOccluder& obj )
+{
+    const osg::ConvexPlanarOccluder::HoleList& holes = obj.getHoleList();
+    os << holes.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::ConvexPlanarOccluder::HoleList::const_iterator itr=holes.begin();
+          itr!=holes.end(); ++itr )
+    {
+        os << osgDB::PROPERTY("Polygon");
+        writeConvexPlanarPolygon( os, *itr );
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( ConvexPlanarOccluder,
+                         new osg::ConvexPlanarOccluder,
+                         osg::ConvexPlanarOccluder,
+                         "osg::Object osg::ConvexPlanarOccluder" )
+{
+    ADD_USER_SERIALIZER( Occluder );  // _occluder
+    ADD_USER_SERIALIZER( Holes );  // _holeList
+}

src/osgWrappers/serializers/osg/CoordinateSystemNode.cpp

@@ -0,0 +1,14 @@
+#include <osg/CoordinateSystemNode>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( CoordinateSystemNode,
+                         new osg::CoordinateSystemNode,
+                         osg::CoordinateSystemNode,
+                         "osg::Object osg::Node osg::Group osg::CoordinateSystemNode" )
+{
+    ADD_STRING_SERIALIZER( Format, "" );  // _format
+    ADD_STRING_SERIALIZER( CoordinateSystem, "" );  // _cs
+    ADD_OBJECT_SERIALIZER( EllipsoidModel, osg::EllipsoidModel, NULL );  // _ellipsoidModel
+}

src/osgWrappers/serializers/osg/CullFace.cpp

@@ -0,0 +1,16 @@
+#include <osg/CullFace>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( CullFace,
+                         new osg::CullFace,
+                         osg::CullFace,
+                         "osg::Object osg::StateAttribute osg::CullFace" )
+{
+    BEGIN_ENUM_SERIALIZER( Mode, BACK );
+        ADD_ENUM_VALUE( FRONT );
+        ADD_ENUM_VALUE( BACK );
+        ADD_ENUM_VALUE( FRONT_AND_BACK );
+    END_ENUM_SERIALIZER();  // _mode
+}

src/osgWrappers/serializers/osg/Cylinder.cpp

@@ -0,0 +1,15 @@
+#include <osg/Shape>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Cylinder,
+                         new osg::Cylinder,
+                         osg::Cylinder,
+                         "osg::Object osg::Shape osg::Cylinder" )
+{
+    ADD_VEC3_SERIALIZER( Center, osg::Vec3() );  // _center
+    ADD_FLOAT_SERIALIZER( Radius, 0.0f );  // _radius
+    ADD_FLOAT_SERIALIZER( Height, 0.0f );  // _height
+    ADD_QUAT_SERIALIZER( Rotation, osg::Quat() );  // _rotation
+}

src/osgWrappers/serializers/osg/Depth.cpp

@@ -0,0 +1,25 @@
+#include <osg/Depth>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Depth,
+                         new osg::Depth,
+                         osg::Depth,
+                         "osg::Object osg::StateAttribute osg::Depth" )
+{
+    BEGIN_ENUM_SERIALIZER( Function, LESS );
+        ADD_ENUM_VALUE( NEVER );
+        ADD_ENUM_VALUE( LESS );
+        ADD_ENUM_VALUE( EQUAL );
+        ADD_ENUM_VALUE( LEQUAL );
+        ADD_ENUM_VALUE( GREATER );
+        ADD_ENUM_VALUE( NOTEQUAL );
+        ADD_ENUM_VALUE( GEQUAL );
+        ADD_ENUM_VALUE( ALWAYS );
+    END_ENUM_SERIALIZER();  // _func
+    
+    ADD_DOUBLE_SERIALIZER( ZNear, 0.0 );  // _zNear
+    ADD_DOUBLE_SERIALIZER( ZFar, 1.0 );  // _zFar
+    ADD_BOOL_SERIALIZER( WriteMask, true );  // _depthWriteMask
+}

src/osgWrappers/serializers/osg/DrawPixels.cpp

@@ -0,0 +1,36 @@
+#include <osg/DrawPixels>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static bool checkArea( const osg::DrawPixels& drawable )
+{
+    return drawable.getUseSubImage();
+}
+
+static bool readArea( osgDB::InputStream& is, osg::DrawPixels& drawable )
+{
+    unsigned int x, y, w, h;
+    is >> x >> y >> w >> h;
+    drawable.setSubImageDimensions( x, y, w, h );
+    return true;
+}
+
+static bool writeArea( osgDB::OutputStream& os, const osg::DrawPixels& drawable )
+{
+    unsigned int x, y, w, h;
+    drawable.getSubImageDimensions( x, y, w, h );
+    os << x << y << w << h << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( DrawPixels,
+                         new osg::DrawPixels,
+                         osg::DrawPixels,
+                         "osg::Object osg::Drawable osg::DrawPixels" )
+{
+    ADD_VEC3_SERIALIZER( Position, osg::Vec3() );  // _position
+    ADD_IMAGE_SERIALIZER( Image, osg::Image, NULL );  // _image
+    ADD_BOOL_SERIALIZER( UseSubImage, false );  // _useSubImage
+    ADD_USER_SERIALIZER( Area );  // _offsetX, _offsetY, _width, _height
+}

src/osgWrappers/serializers/osg/Drawable.cpp

@@ -0,0 +1,56 @@
+#include <osg/Drawable>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static bool checkInitialBound( const osg::Drawable& drawable )
+{
+    return drawable.getInitialBound().valid();
+}
+
+static bool readInitialBound( osgDB::InputStream& is, osg::Drawable& drawable )
+{
+    bool valid = false; is >> valid;
+    if ( valid )
+    {
+        osg::Vec3d min, max;
+        is >> osgDB::BEGIN_BRACKET >> osgDB::PROPERTY("Minimum") >> min;
+        is >> osgDB::PROPERTY("Maximum") >> max >> osgDB::END_BRACKET;
+        drawable.setInitialBound( osg::BoundingBox(min, max) );
+    }
+    return true;
+}
+
+static bool writeInitialBound( osgDB::OutputStream& os, const osg::Drawable& drawable )
+{
+    const osg::BoundingBox& bb = drawable.getInitialBound();
+    os << bb.valid();
+    if ( bb.valid() )
+    {
+        os << osgDB::BEGIN_BRACKET << std::endl;
+        os << osgDB::PROPERTY("Minimum") << osg::Vec3d(bb._min) << std::endl;
+        os << osgDB::PROPERTY("Maximum") << osg::Vec3d(bb._max) << std::endl;
+        os << osgDB::END_BRACKET;
+    }
+    os << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( Drawable,
+                         /*new osg::Drawable*/NULL,
+                         osg::Drawable,
+                         "osg::Object osg::Drawable" )
+{
+    ADD_OBJECT_SERIALIZER( StateSet, osg::StateSet, NULL );  // _stateset
+    ADD_USER_SERIALIZER( InitialBound );  // _initialBound
+    ADD_OBJECT_SERIALIZER( ComputeBoundingBoxCallback,
+                           osg::Drawable::ComputeBoundingBoxCallback, NULL );  // _computeBoundCallback
+    ADD_OBJECT_SERIALIZER( Shape, osg::Shape, NULL );  // _shape
+    ADD_BOOL_SERIALIZER( SupportsDisplayList, true );  // _supportsDisplayList
+    ADD_BOOL_SERIALIZER( UseDisplayList, true );  // _useDisplayList
+    ADD_BOOL_SERIALIZER( UseVertexBufferObjects, false );  // _useVertexBufferObjects
+    ADD_OBJECT_SERIALIZER( UpdateCallback, osg::Drawable::UpdateCallback, NULL );  // _updateCallback
+    ADD_OBJECT_SERIALIZER( EventCallback, osg::Drawable::EventCallback, NULL );  // _eventCallback
+    ADD_OBJECT_SERIALIZER( CullCallback, osg::Drawable::CullCallback, NULL );  // _cullCallback
+    ADD_OBJECT_SERIALIZER( DrawCallback, osg::Drawable::DrawCallback, NULL );  // _drawCallback
+}

src/osgWrappers/serializers/osg/EllipsoidModel.cpp

@@ -0,0 +1,13 @@
+#include <osg/CoordinateSystemNode>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( EllipsoidModel,
+                         new osg::EllipsoidModel,
+                         osg::EllipsoidModel,
+                         "osg::Object osg::EllipsoidModel" )
+{
+    ADD_DOUBLE_SERIALIZER( RadiusEquator, 0.0 );  // _radiusEquator
+    ADD_DOUBLE_SERIALIZER( RadiusPolar, 0.0 );  // _radiusPolar
+}

src/osgWrappers/serializers/osg/Fog.cpp

@@ -0,0 +1,22 @@
+#include <osg/Fog>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Fog,
+                         new osg::Fog,
+                         osg::Fog,
+                         "osg::Object osg::StateAttribute osg::Fog" )
+{
+    BEGIN_ENUM_SERIALIZER( Mode, LINEAR );
+        ADD_ENUM_VALUE( LINEAR );
+        ADD_ENUM_VALUE( EXP );
+        ADD_ENUM_VALUE( EXP2 );
+    END_ENUM_SERIALIZER();  // _mode
+    
+    ADD_FLOAT_SERIALIZER( Start, 0.0f );  // _start
+    ADD_FLOAT_SERIALIZER( End, 1.0f );  // _end
+    ADD_FLOAT_SERIALIZER( Density, 1.0f );  // _density
+    ADD_VEC4_SERIALIZER( Color, osg::Vec4() );  // _color
+    ADD_GLENUM_SERIALIZER( FogCoordinateSource, GLint, GL_NONE );  // _fogCoordinateSource
+}

src/osgWrappers/serializers/osg/FragmentProgram.cpp

@@ -0,0 +1,78 @@
+#include <osg/FragmentProgram>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+// _programLocalParameters
+static bool checkLocalParameters( const osg::FragmentProgram& fp )
+{
+    return fp.getLocalParameters().size()>0;
+}
+
+static bool readLocalParameters( osgDB::InputStream& is, osg::FragmentProgram& fp )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        GLuint key; osg::Vec4d value;
+        is >> key >> value;
+        fp.setProgramLocalParameter( key, value );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeLocalParameters( osgDB::OutputStream& os, const osg::FragmentProgram& fp )
+{
+    const osg::FragmentProgram::LocalParamList& params = fp.getLocalParameters();
+    os << params.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::FragmentProgram::LocalParamList::const_iterator itr=params.begin();
+          itr!=params.end(); ++itr )
+    {
+        os << itr->first << osg::Vec4d(itr->second) << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+// _matrixList
+static bool checkMatrices( const osg::FragmentProgram& fp )
+{
+    return fp.getMatrices().size()>0;
+}
+
+static bool readMatrices( osgDB::InputStream& is, osg::FragmentProgram& fp )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        unsigned int key; osg::Matrixd value;
+        is >> key >> value;
+        fp.setMatrix( key, value );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeMatrices( osgDB::OutputStream& os, const osg::FragmentProgram& fp )
+{
+    const osg::FragmentProgram::MatrixList& matrices = fp.getMatrices();
+    os << matrices.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::FragmentProgram::MatrixList::const_iterator itr=matrices.begin();
+          itr!=matrices.end(); ++itr )
+    {
+        os << (unsigned int)itr->first << osg::Matrixd(itr->second) << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( FragmentProgram,
+                         new osg::FragmentProgram,
+                         osg::FragmentProgram,
+                         "osg::Object osg::StateAttribute osg::FragmentProgram" )
+{
+    ADD_STRING_SERIALIZER( FragmentProgram, "" );  // _fragmentProgram
+    ADD_USER_SERIALIZER( LocalParameters );  // _programLocalParameters
+    ADD_USER_SERIALIZER( Matrices );  // _matrixList
+}

src/osgWrappers/serializers/osg/FrontFace.cpp

@@ -0,0 +1,15 @@
+#include <osg/FrontFace>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( FrontFace,
+                         new osg::FrontFace,
+                         osg::FrontFace,
+                         "osg::Object osg::StateAttribute osg::FrontFace" )
+{
+    BEGIN_ENUM_SERIALIZER( Mode, COUNTER_CLOCKWISE );
+        ADD_ENUM_VALUE( CLOCKWISE );
+        ADD_ENUM_VALUE( COUNTER_CLOCKWISE );
+    END_ENUM_SERIALIZER();  // _mode
+}

src/osgWrappers/serializers/osg/Geode.cpp

@@ -0,0 +1,41 @@
+#include <osg/Geode>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static bool checkDrawables( const osg::Geode& node )
+{
+    return node.getNumDrawables()>0;
+}
+
+static bool readDrawables( osgDB::InputStream& is, osg::Geode& node )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        osg::Drawable* drawable = dynamic_cast<osg::Drawable*>( is.readObject() );
+        if ( drawable ) node.addDrawable( drawable );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeDrawables( osgDB::OutputStream& os, const osg::Geode& node )
+{
+    unsigned int size = node.getNumDrawables();
+    os << size << osgDB::BEGIN_BRACKET << std::endl;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        os << node.getDrawable(i);
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( Geode,
+                         new osg::Geode,
+                         osg::Geode,
+                         "osg::Object osg::Node osg::Geode" )
+{
+    ADD_USER_SERIALIZER( Drawables );  // _drawables
+}

src/osgWrappers/serializers/osg/Geometry.cpp

@@ -0,0 +1,115 @@
+#include <osg/Geometry>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+BEGIN_USER_TABLE( AttributeBinding, osg::Geometry );
+    ADD_USER_VALUE( BIND_OFF );
+    ADD_USER_VALUE( BIND_OVERALL );
+    ADD_USER_VALUE( BIND_PER_PRIMITIVE_SET );
+    ADD_USER_VALUE( BIND_PER_PRIMITIVE );
+    ADD_USER_VALUE( BIND_PER_VERTEX );
+END_USER_TABLE()
+
+USER_READ_FUNC( AttributeBinding, readAttributeBinding )
+USER_WRITE_FUNC( AttributeBinding, writeAttributeBinding )
+
+static void readArrayData( osgDB::InputStream& is, osg::Geometry::ArrayData& data )
+{
+    bool hasArray = false;
+    is >> osgDB::PROPERTY("Array") >> hasArray;
+    if ( hasArray ) data.array = is.readArray();
+    
+    bool hasIndices = false;
+    is >> osgDB::PROPERTY("Indices") >> hasIndices;
+    if ( hasIndices ) data.indices = dynamic_cast<osg::IndexArray*>( is.readArray() );
+    
+    is >> osgDB::PROPERTY("Binding");
+    data.binding = (osg::Geometry::AttributeBinding)readAttributeBinding(is);
+    
+    int normalizeValue = 0;
+    is >> osgDB::PROPERTY("Normalize") >> normalizeValue;
+    data.normalize = normalizeValue;
+}
+
+static void writeArrayData( osgDB::OutputStream& os, const osg::Geometry::ArrayData& data )
+{
+    os << osgDB::PROPERTY("Array") << data.array.valid();
+    if ( data.array.valid() ) os << data.array.get();
+    else os << std::endl;
+    
+    os << osgDB::PROPERTY("Indices") << data.indices.valid();
+    if ( data.indices.valid() ) os << data.indices.get();
+    else os << std::endl;
+    
+    os << osgDB::PROPERTY("Binding"); writeAttributeBinding(os, data.binding); os << std::endl;
+    os << osgDB::PROPERTY("Normalize") << (int)data.normalize << std::endl;
+}
+
+#define ADD_ARRAYDATA_FUNCTIONS( PROP ) \
+    static bool check##PROP( const osg::Geometry& geom ) \
+    { return geom.get##PROP().array.valid(); } \
+    static bool read##PROP( osgDB::InputStream& is, osg::Geometry& geom ) { \
+        osg::Geometry::ArrayData data; \
+        is >> osgDB::BEGIN_BRACKET; readArrayData(is, data); \
+        is >> osgDB::END_BRACKET; \
+        geom.set##PROP(data); \
+        return true; \
+    } \
+    static bool write##PROP( osgDB::OutputStream& os, const osg::Geometry& geom ) { \
+        os << osgDB::BEGIN_BRACKET << std::endl; \
+        writeArrayData(os, geom.get##PROP()); \
+        os << osgDB::END_BRACKET << std::endl; \
+        return true; \
+    }
+
+ADD_ARRAYDATA_FUNCTIONS( VertexData )
+ADD_ARRAYDATA_FUNCTIONS( NormalData )
+ADD_ARRAYDATA_FUNCTIONS( ColorData )
+ADD_ARRAYDATA_FUNCTIONS( SecondaryColorData )
+ADD_ARRAYDATA_FUNCTIONS( FogCoordData )
+
+#define ADD_ARRAYLIST_FUNCTIONS( PROP, LISTNAME ) \
+    static bool check##PROP( const osg::Geometry& geom ) \
+    { return geom.get##LISTNAME().size()>0; } \
+    static bool read##PROP( osgDB::InputStream& is, osg::Geometry& geom ) { \
+        unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; \
+        for ( unsigned int i=0; i<size; ++i ) { \
+            osg::Geometry::ArrayData data; \
+            is >> osgDB::PROPERTY("Data") >> osgDB::BEGIN_BRACKET; \
+            readArrayData(is, data); \
+            is >> osgDB::END_BRACKET; geom.set##PROP(i, data); } \
+        is >> osgDB::END_BRACKET; \
+        return true; \
+    } \
+    static bool write##PROP( osgDB::OutputStream& os, const osg::Geometry& geom ) { \
+        const osg::Geometry::ArrayDataList& LISTNAME = geom.get##LISTNAME(); \
+        os << LISTNAME.size() << osgDB::BEGIN_BRACKET << std::endl; \
+        for ( osg::Geometry::ArrayDataList::const_iterator itr=LISTNAME.begin(); \
+              itr!=LISTNAME.end(); ++itr ) { \
+            os << osgDB::PROPERTY("Data") << osgDB::BEGIN_BRACKET << std::endl; \
+            writeArrayData(os, *itr); os << osgDB::END_BRACKET << std::endl; \
+        } \
+        os << osgDB::END_BRACKET << std::endl; \
+        return true; \
+    }
+
+ADD_ARRAYLIST_FUNCTIONS( TexCoordData, TexCoordArrayList )
+ADD_ARRAYLIST_FUNCTIONS( VertexAttribData, VertexAttribArrayList )
+
+REGISTER_OBJECT_WRAPPER( Geometry,
+                         new osg::Geometry,
+                         osg::Geometry,
+                         "osg::Object osg::Drawable osg::Geometry" )
+{
+    ADD_LIST_SERIALIZER( PrimitiveSetList, osg::Geometry::PrimitiveSetList );  // _primitives
+    ADD_USER_SERIALIZER( VertexData );  // _vertexData
+    ADD_USER_SERIALIZER( NormalData );  // _normalData
+    ADD_USER_SERIALIZER( ColorData );  // _colorData
+    ADD_USER_SERIALIZER( SecondaryColorData );  // _secondaryColorData
+    ADD_USER_SERIALIZER( FogCoordData );  // _fogCoordData
+    ADD_USER_SERIALIZER( TexCoordData );  // _texCoordList
+    ADD_USER_SERIALIZER( VertexAttribData );  // _vertexAttribList
+    ADD_BOOL_SERIALIZER( FastPathHint, true );  // _fastPathHint
+    ADD_OBJECT_SERIALIZER( InternalOptimizedGeometry, osg::Geometry, NULL );  // _internalOptimizedGeometry
+}

src/osgWrappers/serializers/osg/Group.cpp

@@ -0,0 +1,41 @@
+#include <osg/Group>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static bool checkChildren( const osg::Group& node )
+{
+    return node.getNumChildren()>0;
+}
+
+static bool readChildren( osgDB::InputStream& is, osg::Group& node )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        osg::Node* child = dynamic_cast<osg::Node*>( is.readObject() );
+        if ( child ) node.addChild( child );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeChildren( osgDB::OutputStream& os, const osg::Group& node )
+{
+    unsigned int size = node.getNumChildren();
+    os << size << osgDB::BEGIN_BRACKET << std::endl;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        os << node.getChild(i);
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( Group,
+                         new osg::Group,
+                         osg::Group,
+                         "osg::Object osg::Node osg::Group" )
+{
+    ADD_USER_SERIALIZER( Children );  // _children
+}

src/osgWrappers/serializers/osg/HeightField.cpp

@@ -0,0 +1,73 @@
+#include <osg/Shape>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+// _columns, _rows
+static bool checkArea( const osg::HeightField& shape )
+{
+    return true;
+}
+
+static bool readArea( osgDB::InputStream& is, osg::HeightField& shape )
+{
+    unsigned int numCols, numRows;
+    is >> numCols >> numRows;
+    shape.allocate( numCols, numRows );
+    return true;
+}
+
+static bool writeArea( osgDB::OutputStream& os, const osg::HeightField& shape )
+{
+    os << shape.getNumColumns() << shape.getNumRows() << std::endl;
+    return true;
+}
+
+// _heights
+static bool checkHeights( const osg::HeightField& shape )
+{
+    return shape.getFloatArray()!=NULL;
+}
+
+static bool readHeights( osgDB::InputStream& is, osg::HeightField& shape )
+{
+    bool hasArray; is >> hasArray;
+    if ( !hasArray ) return true;
+    
+    osg::FloatArray* array = dynamic_cast<osg::FloatArray*>( is.readArray() );
+    if ( array )
+    {
+        unsigned int numCols = shape.getNumColumns(), numRows = shape.getNumRows();
+        if ( array->size()<numRows*numCols ) return false;
+        
+        unsigned int index = 0;
+        for ( unsigned int r=0; r<numRows; ++r )
+        {
+            for ( unsigned int c=0; c<numCols; ++c )
+                shape.setHeight( c, r, (*array)[index++] );
+        }
+    }
+    return true;
+}
+
+static bool writeHeights( osgDB::OutputStream& os, const osg::HeightField& shape )
+{
+    os << (shape.getFloatArray()!=NULL);
+    os.writeArray( shape.getFloatArray() );
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( HeightField,
+                         new osg::HeightField,
+                         osg::HeightField,
+                         "osg::Object osg::Shape osg::HeightField" )
+{
+    ADD_USER_SERIALIZER( Area );  // _columns, _rows
+    ADD_VEC3_SERIALIZER( Origin, osg::Vec3() );  // _origin
+    ADD_FLOAT_SERIALIZER( XInterval, 0.0f );  // _dx
+    ADD_FLOAT_SERIALIZER( YInterval, 0.0f );  // _dy
+    ADD_FLOAT_SERIALIZER( SkirtHeight, 0.0f );  // _skirtHeight
+    ADD_UINT_SERIALIZER( BorderWidth, 0 );  // _borderWidth
+    ADD_QUAT_SERIALIZER( Rotation, osg::Quat() );  // _rotation
+    ADD_USER_SERIALIZER( Heights );  // _heights
+}

src/osgWrappers/serializers/osg/Hint.cpp

@@ -0,0 +1,13 @@
+#include <osg/Hint>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Hint,
+                         new osg::Hint,
+                         osg::Hint,
+                         "osg::Object osg::StateAttribute osg::Hint" )
+{
+    ADD_GLENUM_SERIALIZER( Target, GLenum, GL_NONE );  // _target
+    ADD_GLENUM_SERIALIZER( Mode, GLenum, GL_DONT_CARE );  // _mode
+}

src/osgWrappers/serializers/osg/Image.cpp

@@ -0,0 +1,12 @@
+#include <osg/Image>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Image,
+                         new osg::Image,
+                         osg::Image,
+                         "osg::Object osg::Image" )
+{
+    // Everything is done in OutputStream and InputStream classes
+}

src/osgWrappers/serializers/osg/ImageSequence.cpp

@@ -0,0 +1,86 @@
+#include <osg/ImageSequence>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+// _fileNames
+static bool checkFileNames( const osg::ImageSequence& image )
+{
+    return image.getNumImageFiles()>0;
+}
+
+static bool readFileNames( osgDB::InputStream& is, osg::ImageSequence& image )
+{
+    unsigned int files = 0; is >> files >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<files; ++i )
+    {
+        std::string filename; is.readWrappedString( filename );
+        image.addImageFile( filename );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeFileNames( osgDB::OutputStream& os, const osg::ImageSequence& image )
+{
+    const osg::ImageSequence::FileNames& files = image.getFileNames();
+    os << files.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::ImageSequence::FileNames::const_iterator itr=files.begin();
+          itr!=files.end(); ++itr )
+    {
+        os.writeWrappedString( *itr );
+        os << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+// _images
+static bool checkImages( const osg::ImageSequence& image )
+{
+    return image.getNumImages()>0;
+}
+
+static bool readImages( osgDB::InputStream& is, osg::ImageSequence& image )
+{
+    unsigned int images = 0; is >> images >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<images; ++i )
+    {
+        osg::Image* img = dynamic_cast<osg::Image*>( is.readObject() );
+        if ( img ) image.addImage( img );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeImages( osgDB::OutputStream& os, const osg::ImageSequence& image )
+{
+    const osg::ImageSequence::Images& images = image.getImages();
+    os << images.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::ImageSequence::Images::const_iterator itr=images.begin();
+          itr!=images.end(); ++itr )
+    {
+        os.writeObject( (*itr).get() );
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( ImageSequence,
+                         new osg::ImageSequence,
+                         osg::ImageSequence,
+                         "osg::Object osg::Image osg::ImageStream osg::ImageSequence" )
+{
+    ADD_DOUBLE_SERIALIZER( ReferenceTime, DBL_MAX );  // _referenceTime
+    ADD_DOUBLE_SERIALIZER( TimeMultiplier, 1.0 );  // _timeMultiplier
+    
+    BEGIN_ENUM_SERIALIZER( Mode, PRE_LOAD_ALL_IMAGES );
+        ADD_ENUM_VALUE( PRE_LOAD_ALL_IMAGES );
+        ADD_ENUM_VALUE( PAGE_AND_RETAIN_IMAGES );
+        ADD_ENUM_VALUE( PAGE_AND_DISCARD_USED_IMAGES );
+    END_ENUM_SERIALIZER();  // _mode
+    
+    ADD_DOUBLE_SERIALIZER( Length, 1.0 );  // _length
+    ADD_USER_SERIALIZER( FileNames );  // _fileNames
+    ADD_USER_SERIALIZER( Images );  // _images
+}

src/osgWrappers/serializers/osg/ImageStream.cpp

@@ -0,0 +1,17 @@
+#include <osg/ImageStream>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( ImageStream,
+                         new osg::ImageStream,
+                         osg::ImageStream,
+                         "osg::Object osg::Image osg::ImageStream" )
+{
+    BEGIN_ENUM_SERIALIZER( LoopingMode, NO_LOOPING );
+        ADD_ENUM_VALUE( NO_LOOPING );
+        ADD_ENUM_VALUE( LOOPING );
+    END_ENUM_SERIALIZER();  // _loopingMode
+    
+    ADD_LIST_SERIALIZER( AudioStreams, osg::ImageStream::AudioStreams );  // _audioStreams
+}

src/osgWrappers/serializers/osg/LOD.cpp

@@ -0,0 +1,76 @@
+#include <osg/LOD>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+// _userDefinedCenter, _radius
+static bool checkUserCenter( const osg::LOD& node )
+{
+    return node.getCenterMode()==osg::LOD::USER_DEFINED_CENTER;
+}
+
+static bool readUserCenter( osgDB::InputStream& is, osg::LOD& node )
+{
+    osg::Vec3d center; double radius;
+    is >> center >> radius;
+    node.setCenter( center ); node.setRadius( radius );
+    return true;
+}
+
+static bool writeUserCenter( osgDB::OutputStream& os, const osg::LOD& node )
+{
+    os << osg::Vec3d(node.getCenter()) << (double)node.getRadius() << std::endl;
+    return true;
+}
+
+// _rangeList
+static bool checkRangeList( const osg::LOD& node )
+{
+    return node.getNumRanges()>0;
+}
+
+static bool readRangeList( osgDB::InputStream& is, osg::LOD& node )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        float min, max;
+        is >> min >> max;
+        node.setRange( i, min, max );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeRangeList( osgDB::OutputStream& os, const osg::LOD& node )
+{
+    const osg::LOD::RangeList& ranges = node.getRangeList();
+    os << ranges.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::LOD::RangeList::const_iterator itr=ranges.begin();
+          itr!=ranges.end(); ++itr )
+    {
+        os << itr->first << itr->second << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( LOD,
+                         new osg::LOD,
+                         osg::LOD,
+                         "osg::Object osg::Node osg::Group osg::LOD" )
+{
+    BEGIN_ENUM_SERIALIZER( CenterMode, USE_BOUNDING_SPHERE_CENTER );
+        ADD_ENUM_VALUE( USE_BOUNDING_SPHERE_CENTER );
+        ADD_ENUM_VALUE( USER_DEFINED_CENTER );
+    END_ENUM_SERIALIZER();  // _centerMode
+    
+    ADD_USER_SERIALIZER( UserCenter );  // _userDefinedCenter, _radius
+    
+    BEGIN_ENUM_SERIALIZER( RangeMode, DISTANCE_FROM_EYE_POINT );
+        ADD_ENUM_VALUE( DISTANCE_FROM_EYE_POINT );
+        ADD_ENUM_VALUE( PIXEL_SIZE_ON_SCREEN );
+    END_ENUM_SERIALIZER();  // _rangeMode
+    
+    ADD_USER_SERIALIZER( RangeList );  // _rangeList
+}

src/osgWrappers/serializers/osg/Light.cpp

@@ -0,0 +1,22 @@
+#include <osg/Light>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Light,
+                         new osg::Light,
+                         osg::Light,
+                         "osg::Object osg::StateAttribute osg::Light" )
+{
+    ADD_INT_SERIALIZER( LightNum, 0 );  // _lightnum
+    ADD_VEC4_SERIALIZER( Ambient, osg::Vec4() );  // _ambient
+    ADD_VEC4_SERIALIZER( Diffuse, osg::Vec4() );  // _diffuse
+    ADD_VEC4_SERIALIZER( Specular, osg::Vec4() );  // _specular
+    ADD_VEC4_SERIALIZER( Position, osg::Vec4() );  // _position
+    ADD_VEC3_SERIALIZER( Direction, osg::Vec3() );  // _direction
+    ADD_FLOAT_SERIALIZER( ConstantAttenuation, 1.0f );  // _constant_attenuation
+    ADD_FLOAT_SERIALIZER( LinearAttenuation, 0.0f );  // _linear_attenuation
+    ADD_FLOAT_SERIALIZER( QuadraticAttenuation, 0.0f );  // _quadratic_attenuation
+    ADD_FLOAT_SERIALIZER( SpotExponent, 0.0f );  // _spot_exponent
+    ADD_FLOAT_SERIALIZER( SpotCutoff, 180.0f );  // _spot_cutoff
+}

src/osgWrappers/serializers/osg/LightModel.cpp

@@ -0,0 +1,20 @@
+#include <osg/LightModel>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( LightModel,
+                         new osg::LightModel,
+                         osg::LightModel,
+                         "osg::Object osg::StateAttribute osg::LightModel" )
+{
+    ADD_VEC4_SERIALIZER( AmbientIntensity, osg::Vec4() );  // _ambient
+    
+    BEGIN_ENUM_SERIALIZER( ColorControl, SINGLE_COLOR );
+        ADD_ENUM_VALUE( SEPARATE_SPECULAR_COLOR );
+        ADD_ENUM_VALUE( SINGLE_COLOR );
+    END_ENUM_SERIALIZER();  // _colorControl
+    
+    ADD_BOOL_SERIALIZER( LocalViewer, false );  // _localViewer
+    ADD_BOOL_SERIALIZER( TwoSided, false );  // _twoSided
+}

src/osgWrappers/serializers/osg/LightSource.cpp

@@ -0,0 +1,17 @@
+#include <osg/LightSource>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( LightSource,
+                         new osg::LightSource,
+                         osg::LightSource,
+                         "osg::Object osg::Node osg::Group osg::LightSource" )
+{
+    ADD_OBJECT_SERIALIZER( Light, osg::Light, NULL );  // _light
+    
+    BEGIN_ENUM_SERIALIZER( ReferenceFrame, RELATIVE_RF );
+        ADD_ENUM_VALUE( RELATIVE_RF );
+        ADD_ENUM_VALUE( ABSOLUTE_RF );
+    END_ENUM_SERIALIZER();  // _referenceFrame
+}

src/osgWrappers/serializers/osg/LineStipple.cpp

@@ -0,0 +1,13 @@
+#include <osg/LineStipple>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( LineStipple,
+                         new osg::LineStipple,
+                         osg::LineStipple,
+                         "osg::Object osg::StateAttribute osg::LineStipple" )
+{
+    ADD_INT_SERIALIZER( Factor, 1 );  // _factor
+    ADD_HEXSHORT_SERIALIZER( Pattern, 0xffff );  // _pattern
+}

src/osgWrappers/serializers/osg/LineWidth.cpp

@@ -0,0 +1,12 @@
+#include <osg/LineWidth>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( LineWidth,
+                         new osg::LineWidth,
+                         osg::LineWidth,
+                         "osg::Object osg::StateAttribute osg::LineWidth" )
+{
+    ADD_FLOAT_SERIALIZER( Width, 1.0f );  // _width
+}

src/osgWrappers/serializers/osg/LogicOp.cpp

@@ -0,0 +1,29 @@
+#include <osg/LogicOp>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( LogicOp,
+                         new osg::LogicOp,
+                         osg::LogicOp,
+                         "osg::Object osg::StateAttribute osg::LogicOp" )
+{
+    BEGIN_ENUM_SERIALIZER( Opcode, COPY );
+        ADD_ENUM_VALUE( CLEAR );
+        ADD_ENUM_VALUE( SET );
+        ADD_ENUM_VALUE( COPY );
+        ADD_ENUM_VALUE( COPY_INVERTED );
+        ADD_ENUM_VALUE( NOOP );
+        ADD_ENUM_VALUE( INVERT );
+        ADD_ENUM_VALUE( AND );
+        ADD_ENUM_VALUE( NAND );
+        ADD_ENUM_VALUE( OR );
+        ADD_ENUM_VALUE( NOR );
+        ADD_ENUM_VALUE( XOR );
+        ADD_ENUM_VALUE( EQUIV );
+        ADD_ENUM_VALUE( AND_REVERSE );
+        ADD_ENUM_VALUE( AND_INVERTED );
+        ADD_ENUM_VALUE( OR_REVERSE );
+        ADD_ENUM_VALUE( OR_INVERTED );
+    END_ENUM_SERIALIZER();  // _opcode
+}

src/osgWrappers/serializers/osg/Material.cpp

@@ -0,0 +1,53 @@
+#include <osg/Material>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+#define MATERIAL_FUNC( PROP, TYPE ) \
+    static bool check##PROP( const osg::Material& attr ) { return true; } \
+    static bool read##PROP( osgDB::InputStream& is, osg::Material& attr ) { \
+        bool frontAndBack; TYPE value1, value2; \
+        is >> frontAndBack; \
+        is >> osgDB::PROPERTY("Front") >> value1; \
+        is >> osgDB::PROPERTY("Back") >> value2; \
+        if ( frontAndBack ) \
+            attr.set##PROP(osg::Material::FRONT_AND_BACK, value1); \
+        else { \
+            attr.set##PROP(osg::Material::FRONT, value1); \
+            attr.set##PROP(osg::Material::BACK, value2); \
+        } \
+        return true; \
+    } \
+    static bool write##PROP( osgDB::OutputStream& os, const osg::Material& attr ) { \
+        os << attr.get##PROP##FrontAndBack(); \
+        os << osgDB::PROPERTY("Front") << TYPE(attr.get##PROP(osg::Material::FRONT)); \
+        os << osgDB::PROPERTY("Back") << TYPE(attr.get##PROP(osg::Material::BACK)) << std::endl; \
+        return true; \
+    }
+
+MATERIAL_FUNC( Ambient, osg::Vec4f )
+MATERIAL_FUNC( Diffuse, osg::Vec4f )
+MATERIAL_FUNC( Specular, osg::Vec4f )
+MATERIAL_FUNC( Emission, osg::Vec4f )
+MATERIAL_FUNC( Shininess, float )
+
+REGISTER_OBJECT_WRAPPER( Material,
+                         new osg::Material,
+                         osg::Material,
+                         "osg::Object osg::StateAttribute osg::Material" )
+{
+    BEGIN_ENUM_SERIALIZER( ColorMode, OFF );
+        ADD_ENUM_VALUE( AMBIENT );
+        ADD_ENUM_VALUE( DIFFUSE );
+        ADD_ENUM_VALUE( SPECULAR );
+        ADD_ENUM_VALUE( EMISSION );
+        ADD_ENUM_VALUE( AMBIENT_AND_DIFFUSE );
+        ADD_ENUM_VALUE( OFF );
+    END_ENUM_SERIALIZER();  // _colorMode
+    
+    ADD_USER_SERIALIZER( Ambient );  // _ambient
+    ADD_USER_SERIALIZER( Diffuse );  // _diffuse
+    ADD_USER_SERIALIZER( Specular );  // _specular
+    ADD_USER_SERIALIZER( Emission );  // _emission
+    ADD_USER_SERIALIZER( Shininess );  // _shininess
+}

src/osgWrappers/serializers/osg/MatrixTransform.cpp

@@ -0,0 +1,12 @@
+#include <osg/MatrixTransform>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( MatrixTransform,
+                         new osg::MatrixTransform,
+                         osg::MatrixTransform,
+                         "osg::Object osg::Node osg::Group osg::Transform osg::MatrixTransform" )
+{
+    ADD_MATRIX_SERIALIZER( Matrix, osg::Matrix() );  // _matrix
+}

src/osgWrappers/serializers/osg/Multisample.cpp

@@ -0,0 +1,19 @@
+#include <osg/Multisample>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Multisample,
+                         new osg::Multisample,
+                         osg::Multisample,
+                         "osg::Object osg::StateAttribute osg::Multisample" )
+{
+    ADD_FLOAT_SERIALIZER( Coverage, 0.0f );  // _coverage
+    ADD_BOOL_SERIALIZER( Invert, false );  // _invert
+    
+    BEGIN_ENUM_SERIALIZER2( Hint, osg::Multisample::Mode, DONT_CARE );
+        ADD_ENUM_VALUE( FASTEST );
+        ADD_ENUM_VALUE( NICEST );
+        ADD_ENUM_VALUE( DONT_CARE );
+    END_ENUM_SERIALIZER();  // _mode
+}

src/osgWrappers/serializers/osg/Node.cpp

@@ -0,0 +1,82 @@
+#include <osg/Node>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+// _initialBound
+static bool checkInitialBound( const osg::Node& node )
+{
+    return node.getInitialBound().valid();
+}
+
+static bool readInitialBound( osgDB::InputStream& is, osg::Node& node )
+{
+    osg::Vec3d center;
+    double radius;
+    bool valid;
+    is >> valid >> osgDB::BEGIN_BRACKET;
+    is >> osgDB::PROPERTY("Center") >> center;
+    is >> osgDB::PROPERTY("Radius") >> radius >> osgDB::END_BRACKET;
+    node.setInitialBound( osg::BoundingSphere(center, radius) );
+    return true;
+}
+
+static bool writeInitialBound( osgDB::OutputStream& os, const osg::Node& node )
+{
+    const osg::BoundingSphere& bs = node.getInitialBound();
+    os << bs.valid() << osgDB::BEGIN_BRACKET << std::endl;
+    os << osgDB::PROPERTY("Center") << osg::Vec3d(bs.center()) << std::endl;
+    os << osgDB::PROPERTY("Radius") << double(bs.radius()) << std::endl;
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+// _descriptions
+static bool checkDescriptions( const osg::Node& node )
+{
+    return node.getDescriptions().size()>0;
+}
+
+static bool readDescriptions( osgDB::InputStream& is, osg::Node& node )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        std::string value;
+        is.readWrappedString( value );
+        node.addDescription( value );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeDescriptions( osgDB::OutputStream& os, const osg::Node& node )
+{
+    const osg::Node::DescriptionList& slist = node.getDescriptions();
+    os << slist.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::Node::DescriptionList::const_iterator itr=slist.begin();
+          itr!=slist.end(); ++itr )
+    {
+        os.writeWrappedString( *itr );
+        os << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( Node,
+                         new osg::Node,
+                         osg::Node,
+                         "osg::Object osg::Node" )
+{
+    ADD_USER_SERIALIZER( InitialBound );  // _initialBound
+    ADD_OBJECT_SERIALIZER( ComputeBoundingSphereCallback,
+                           osg::Node::ComputeBoundingSphereCallback, NULL );  // _computeBoundCallback
+    ADD_OBJECT_SERIALIZER( UpdateCallback, osg::NodeCallback, NULL );  // _updateCallback
+    ADD_OBJECT_SERIALIZER( EventCallback, osg::NodeCallback, NULL );  // _eventCallback
+    ADD_OBJECT_SERIALIZER( CullCallback, osg::NodeCallback, NULL );  // _cullCallback
+    ADD_BOOL_SERIALIZER( CullingActive, true );  // _cullingActive
+    ADD_HEXINT_SERIALIZER( NodeMask, 0xffffffff );  // _nodeMask
+    ADD_USER_SERIALIZER( Descriptions );  // _descriptions
+    ADD_OBJECT_SERIALIZER( StateSet, osg::StateSet, NULL );  // _stateset
+}

src/osgWrappers/serializers/osg/NodeCallback.cpp

@@ -0,0 +1,18 @@
+#undef OBJECT_CAST
+#define OBJECT_CAST dynamic_cast
+
+#include <osg/Node>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( NodeCallback,
+                         new osg::NodeCallback,
+                         osg::NodeCallback,
+                         "osg::Object osg::NodeCallback" )
+{
+    ADD_OBJECT_SERIALIZER( NestedCallback, osg::NodeCallback, NULL );  // _nestedCallback
+}
+
+#undef OBJECT_CAST
+#define OBJECT_CAST static_cast

src/osgWrappers/serializers/osg/NodeTrackerCallback.cpp

@@ -0,0 +1,18 @@
+#undef OBJECT_CAST
+#define OBJECT_CAST dynamic_cast
+
+#include <osg/NodeTrackerCallback>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( NodeTrackerCallback,
+                         new osg::NodeTrackerCallback,
+                         osg::NodeTrackerCallback,
+                         "osg::Object osg::NodeCallback osg::NodeTrackerCallback" )
+{
+    ADD_OBJECT_SERIALIZER( TrackNode, osg::Node, NULL );  // _trackNodePath
+}
+
+#undef OBJECT_CAST
+#define OBJECT_CAST static_cast

src/osgWrappers/serializers/osg/Object.cpp

@@ -0,0 +1,18 @@
+#include <osg/Object>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Object,
+                         /*new osg::Object*/NULL,
+                         osg::Object,
+                         "osg::Object" )
+{
+    ADD_STRING_SERIALIZER( Name, "" );  // _name
+    
+    BEGIN_ENUM_SERIALIZER( DataVariance, UNSPECIFIED );
+        ADD_ENUM_VALUE( STATIC );
+        ADD_ENUM_VALUE( DYNAMIC );
+        ADD_ENUM_VALUE( UNSPECIFIED );
+    END_ENUM_SERIALIZER();  // _dataVariance
+}

src/osgWrappers/serializers/osg/OccluderNode.cpp

@@ -0,0 +1,12 @@
+#include <osg/OccluderNode>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( OccluderNode,
+                         new osg::OccluderNode,
+                         osg::OccluderNode,
+                         "osg::Object osg::Node osg::Group osg::OccluderNode" )
+{
+    ADD_OBJECT_SERIALIZER( Occluder, osg::ConvexPlanarOccluder, NULL );  // _occluder
+}

src/osgWrappers/serializers/osg/OcclusionQueryNode.cpp

@@ -0,0 +1,15 @@
+#include <osg/OcclusionQueryNode>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( OcclusionQueryNode,
+                         new osg::OcclusionQueryNode,
+                         osg::OcclusionQueryNode,
+                         "osg::Object osg::Node osg::Group osg::OcclusionQueryNode" )
+{
+    ADD_BOOL_SERIALIZER( QueriesEnabled, true );  // _enabled
+    ADD_UINT_SERIALIZER( VisibilityThreshold, 0 );  // _visThreshold
+    ADD_INT_SERIALIZER( QueryFrameCount, 0 );  // _queryFrameCount
+    ADD_BOOL_SERIALIZER( DebugDisplay, false );  // _debugBB
+}

src/osgWrappers/serializers/osg/PagedLOD.cpp

@@ -0,0 +1,58 @@
+#include <osg/PagedLOD>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static bool checkRangeDataList( const osg::PagedLOD& node )
+{
+    return node.getNumFileNames()>0;
+}
+
+static bool readRangeDataList( osgDB::InputStream& is, osg::PagedLOD& node )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        std::string name; is.readWrappedString( name );
+        float offset, scale;
+        double timeStamp;
+        int frameNumber;
+        is >> offset >> scale >> timeStamp >> frameNumber;
+        
+        node.setFileName( i, name );
+        node.setPriorityOffset( i, offset );
+        node.setPriorityScale( i, scale );
+        node.setTimeStamp( i, timeStamp );
+        node.setFrameNumber( i, frameNumber );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeRangeDataList( osgDB::OutputStream& os, const osg::PagedLOD& node )
+{
+    unsigned int size = node.getNumFileNames();
+    os << size << osgDB::BEGIN_BRACKET << std::endl;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        os.writeWrappedString( node.getFileName(i) );
+        os << node.getPriorityOffset(i) << node.getPriorityScale(i)
+           << node.getTimeStamp(i) << node.getFrameNumber(i) << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( PagedLOD,
+                         new osg::PagedLOD,
+                         osg::PagedLOD,
+                         "osg::Object osg::Node osg::LOD osg::PagedLOD" )
+{
+    // Note: osg::Group is not in the list to prevent recording dynamic loaded children
+    
+    ADD_STRING_SERIALIZER( DatabasePath, "" );  // _databasePath
+    ADD_INT_SERIALIZER( FrameNumberOfLastTraversal, 0 );  // _frameNumberOfLastTraversal
+    ADD_UINT_SERIALIZER( NumChildrenThatCannotBeExpired, 0 );  // _numChildrenThatCannotBeExpired
+    ADD_BOOL_SERIALIZER( DisableExternalChildrenPaging, false );  // _disableExternalChildrenPaging
+    ADD_USER_SERIALIZER( RangeDataList );  // _perRangeDataList
+}

src/osgWrappers/serializers/osg/Point.cpp

@@ -0,0 +1,16 @@
+#include <osg/Point>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Point,
+                         new osg::Point,
+                         osg::Point,
+                         "osg::Object osg::StateAttribute osg::Point" )
+{
+    ADD_FLOAT_SERIALIZER( Size, 0.0f );  // _size
+    ADD_FLOAT_SERIALIZER( FadeThresholdSize, 0.0f );  // _fadeThresholdSize
+    ADD_VEC3_SERIALIZER( DistanceAttenuation, osg::Vec3() );  // _distanceAttenuation
+    ADD_FLOAT_SERIALIZER( MinSize, 0.0f );  // _minSize
+    ADD_FLOAT_SERIALIZER( MaxSize, 0.0f );  // _maxSize
+}

src/osgWrappers/serializers/osg/PointSprite.cpp

@@ -0,0 +1,15 @@
+#include <osg/PointSprite>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( PointSprite,
+                         new osg::PointSprite,
+                         osg::PointSprite,
+                         "osg::Object osg::StateAttribute osg::PointSprite" )
+{
+    BEGIN_ENUM_SERIALIZER( CoordOriginMode, UPPER_LEFT );
+        ADD_ENUM_VALUE( UPPER_LEFT );
+        ADD_ENUM_VALUE( LOWER_LEFT );
+    END_ENUM_SERIALIZER();  // _coordOriginMode
+}

src/osgWrappers/serializers/osg/PolygonMode.cpp

@@ -0,0 +1,58 @@
+#include <osg/PolygonMode>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+BEGIN_USER_TABLE( Mode, osg::PolygonMode );
+    ADD_USER_VALUE( POINT );
+    ADD_USER_VALUE( LINE );
+    ADD_USER_VALUE( FILL );
+END_USER_TABLE()
+
+USER_READ_FUNC( Mode, readModeValue )
+USER_WRITE_FUNC( Mode, writeModeValue )
+
+// _modeFront, _modeBack
+static bool checkMode( const osg::PolygonMode& attr )
+{
+    return true;
+}
+
+static bool readMode( osgDB::InputStream& is, osg::PolygonMode& attr )
+{
+    bool frontAndBack;
+    is >> osgDB::PROPERTY("UseFrontAndBack") >> frontAndBack;
+    is >> osgDB::PROPERTY("Front"); int value1 = readModeValue(is);
+    is >> osgDB::PROPERTY("Back"); int value2 = readModeValue(is);
+    
+    if ( frontAndBack )
+        attr.setMode( osg::PolygonMode::FRONT_AND_BACK, (osg::PolygonMode::Mode)value1 );
+    else
+    {
+        attr.setMode(osg::PolygonMode::FRONT, (osg::PolygonMode::Mode)value1);
+        attr.setMode(osg::PolygonMode::BACK, (osg::PolygonMode::Mode)value2);
+    }
+    return true;
+}
+
+static bool writeMode( osgDB::OutputStream& os, const osg::PolygonMode& attr )
+{
+    os << osgDB::PROPERTY("UseFrontAndBack") << attr.getFrontAndBack() << std::endl;
+    
+    os << osgDB::PROPERTY("Front");
+    writeModeValue( os, (int)attr.getMode(osg::PolygonMode::FRONT) );
+    os << std::endl;
+    
+    os << osgDB::PROPERTY("Back");
+    writeModeValue( os, (int)attr.getMode(osg::PolygonMode::BACK) );
+    os << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( PolygonMode,
+                         new osg::PolygonMode,
+                         osg::PolygonMode,
+                         "osg::Object osg::StateAttribute osg::PolygonMode" )
+{
+    ADD_USER_SERIALIZER( Mode );  // _modeFront, _modeBack
+}

src/osgWrappers/serializers/osg/PolygonOffset.cpp

@@ -0,0 +1,13 @@
+#include <osg/PolygonOffset>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( PolygonOffset,
+                         new osg::PolygonOffset,
+                         osg::PolygonOffset,
+                         "osg::Object osg::StateAttribute osg::PolygonOffset" )
+{
+    ADD_FLOAT_SERIALIZER( Factor, 0.0f );  // _factor
+    ADD_FLOAT_SERIALIZER( Units, 0.0f );  // _units
+}

src/osgWrappers/serializers/osg/PolygonStipple.cpp

@@ -0,0 +1,58 @@
+#include <osg/PolygonStipple>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static bool checkMask( const osg::PolygonStipple& attr )
+{
+    return true;
+}
+
+static bool readMask( osgDB::InputStream& is, osg::PolygonStipple& attr )
+{
+    char mask[128] = {0};
+    if ( is.isBinary() )
+    {
+        unsigned int size; is >> size;
+        is.readCharArray( mask, size );
+    }
+    else
+    {
+        is >> osgDB::BEGIN_BRACKET;
+        for ( unsigned int i=0; i<128; ++i )
+        {
+            is >> std::hex >> mask[i] >> std::dec;
+        }
+        is >> osgDB::END_BRACKET;
+    }
+    attr.setMask( (GLubyte*)mask );
+    return true;
+}
+
+static bool writeMask( osgDB::OutputStream& os, const osg::PolygonStipple& attr )
+{
+    if ( os.isBinary() )
+    {
+        os << (unsigned int)128;
+        os.writeCharArray( (char*)attr.getMask(), 128 );
+    }
+    else
+    {
+        const GLubyte* mask = attr.getMask();
+        os << osgDB::BEGIN_BRACKET << std::endl;
+        for ( unsigned int i=0; i<128; ++i )
+        {
+            os << std::hex << mask[i] << std::dec << std::endl;
+        }
+        os << osgDB::END_BRACKET << std::endl;
+    }
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( PolygonStipple,
+                         new osg::PolygonStipple,
+                         osg::PolygonStipple,
+                         "osg::Object osg::StateAttribute osg::PolygonStipple" )
+{
+    ADD_USER_SERIALIZER( Mask );  // _mask
+}

src/osgWrappers/serializers/osg/PositionAttitudeTransform.cpp

@@ -0,0 +1,15 @@
+#include <osg/PositionAttitudeTransform>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( PositionAttitudeTransform,
+                         new osg::PositionAttitudeTransform,
+                         osg::PositionAttitudeTransform,
+                         "osg::Object osg::Node osg::Group osg::Transform osg::PositionAttitudeTransform" )
+{
+    ADD_VEC3D_SERIALIZER( Position, osg::Vec3d() );  // _position
+    ADD_QUAT_SERIALIZER( Attitude, osg::Quat() );  // _attitude
+    ADD_VEC3D_SERIALIZER( Scale, osg::Vec3d() );  // _scale
+    ADD_VEC3D_SERIALIZER( PivotPoint, osg::Vec3d() );  // _pivotPoint
+}

src/osgWrappers/serializers/osg/Program.cpp

@@ -0,0 +1,91 @@
+#include <osg/Program>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+#define PROGRAM_LIST_FUNC( PROP, TYPE, DATA ) \
+    static bool check##PROP(const osg::Program& attr) \
+    { return attr.get##TYPE().size()>0; } \
+    static bool read##PROP(osgDB::InputStream& is, osg::Program& attr) { \
+        unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; \
+        for ( unsigned int i=0; i<size; ++i ) { \
+            std::string key; unsigned int value; \
+            is >> key >> value; attr.add##DATA(key, value); \
+        } \
+        is >> osgDB::END_BRACKET; \
+        return true; \
+    } \
+    static bool write##PROP( osgDB::OutputStream& os, const osg::Program& attr ) \
+    { \
+        const osg::Program::TYPE& plist = attr.get##TYPE(); \
+        os << plist.size() << osgDB::BEGIN_BRACKET << std::endl; \
+        for ( osg::Program::TYPE::const_iterator itr=plist.begin(); \
+              itr!=plist.end(); ++itr ) { \
+            os << itr->first << itr->second << std::endl; \
+        } \
+        os << osgDB::END_BRACKET << std::endl; \
+        return true; \
+    }
+
+PROGRAM_LIST_FUNC( AttribBinding, AttribBindingList, BindAttribLocation )
+PROGRAM_LIST_FUNC( FragDataBinding, FragDataBindingList, BindFragDataLocation )
+
+#define PROGRAM_PARAMETER_FUNC( PROP, NAME ) \
+    static bool check##PROP(const osg::Program& attr) \
+    { return attr.getParameter(NAME)!=GL_NONE; } \
+    static bool read##PROP(osgDB::InputStream& is, osg::Program& attr) { \
+        int value; is >> osgDB::PROPERTY(#NAME) >> value; \
+        attr.setParameter(NAME, value); \
+        return true; \
+    } \
+    static bool write##PROP(osgDB::OutputStream& os, const osg::Program& attr) { \
+        os << osgDB::PROPERTY(#NAME) << (int)attr.getParameter(NAME) << std::endl; \
+        return true; \
+    }
+
+PROGRAM_PARAMETER_FUNC( GeometryVerticesOut, GL_GEOMETRY_VERTICES_OUT_EXT )
+PROGRAM_PARAMETER_FUNC( GeometryInputType, GL_GEOMETRY_INPUT_TYPE_EXT )
+PROGRAM_PARAMETER_FUNC( GeometryOutputType, GL_GEOMETRY_OUTPUT_TYPE_EXT )
+
+// _shaderList
+static bool checkShaders( const osg::Program& attr )
+{
+    return attr.getNumShaders()>0;
+}
+
+static bool readShaders( osgDB::InputStream& is, osg::Program& attr )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        osg::Shader* shader = dynamic_cast<osg::Shader*>( is.readObject() );
+        if ( shader ) attr.addShader( shader );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeShaders( osgDB::OutputStream& os, const osg::Program& attr )
+{
+    unsigned int size = attr.getNumShaders();
+    os << size << osgDB::BEGIN_BRACKET << std::endl;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        os << attr.getShader(i);
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( Program,
+                         new osg::Program,
+                         osg::Program,
+                         "osg::Object osg::StateAttribute osg::Program" )
+{
+    ADD_USER_SERIALIZER( AttribBinding );  // _attribBindingList
+    ADD_USER_SERIALIZER( FragDataBinding );  // _fragDataBindingList
+    ADD_USER_SERIALIZER( Shaders );  // _shaderList
+    ADD_USER_SERIALIZER( GeometryVerticesOut );  // _geometryVerticesOut
+    ADD_USER_SERIALIZER( GeometryInputType );  // _geometryInputType
+    ADD_USER_SERIALIZER( GeometryOutputType );  // _geometryOutputType
+}

src/osgWrappers/serializers/osg/Projection.cpp

@@ -0,0 +1,12 @@
+#include <osg/Projection>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Projection,
+                         new osg::Projection,
+                         osg::Projection,
+                         "osg::Object osg::Node osg::Group osg::Projection" )
+{
+    ADD_MATRIX_SERIALIZER( Matrix, osg::Matrix() );  // _matrix
+}

src/osgWrappers/serializers/osg/ProxyNode.cpp

@@ -0,0 +1,79 @@
+#include <osg/ProxyNode>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+// _filenameList
+static bool checkFileNames( const osg::ProxyNode& node )
+{
+    return node.getNumFileNames()>0;
+}
+
+static bool readFileNames( osgDB::InputStream& is, osg::ProxyNode& node )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        std::string value;
+        is.readWrappedString( value );
+        node.setFileName( i, value );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeFileNames( osgDB::OutputStream& os, const osg::ProxyNode& node )
+{
+    os << node.getNumFileNames() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( unsigned int i=0; i<node.getNumFileNames(); ++i )
+    {
+        os.writeWrappedString( node.getFileName(i) );
+        os << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+// _userDefinedCenter, _radius
+static bool checkUserCenter( const osg::ProxyNode& node )
+{
+    return node.getCenterMode()==osg::ProxyNode::USER_DEFINED_CENTER;
+}
+
+static bool readUserCenter( osgDB::InputStream& is, osg::ProxyNode& node )
+{
+    osg::Vec3d center; double radius;
+    is >> center >> radius;
+    node.setCenter( center ); node.setRadius( radius );
+    return true;
+}
+
+static bool writeUserCenter( osgDB::OutputStream& os, const osg::ProxyNode& node )
+{
+    os << osg::Vec3d(node.getCenter()) << (double)node.getRadius() << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( ProxyNode,
+                         new osg::ProxyNode,
+                         osg::ProxyNode,
+                         "osg::Object osg::Node osg::ProxyNode" )
+{
+    // Note: osg::Group is not in the list to prevent recording dynamic loaded children
+    
+    ADD_USER_SERIALIZER( FileNames );  // _filenameList
+    ADD_STRING_SERIALIZER( DatabasePath, "" );  // _databasePath
+    
+    BEGIN_ENUM_SERIALIZER( LoadingExternalReferenceMode, LOAD_IMMEDIATELY );
+        ADD_ENUM_VALUE( LOAD_IMMEDIATELY );
+        ADD_ENUM_VALUE( DEFER_LOADING_TO_DATABASE_PAGER );
+        ADD_ENUM_VALUE( NO_AUTOMATIC_LOADING );
+    END_ENUM_SERIALIZER();  // _loadingExtReference
+    
+    BEGIN_ENUM_SERIALIZER( CenterMode, USE_BOUNDING_SPHERE_CENTER );
+        ADD_ENUM_VALUE( USE_BOUNDING_SPHERE_CENTER );
+        ADD_ENUM_VALUE( USER_DEFINED_CENTER );
+    END_ENUM_SERIALIZER();  // _centerMode
+    
+    ADD_USER_SERIALIZER( UserCenter );  // _userDefinedCenter, _radius
+}

src/osgWrappers/serializers/osg/Scissor.cpp

@@ -0,0 +1,31 @@
+#include <osg/Scissor>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static bool checkArea( const osg::Scissor& attr )
+{
+    return true;
+}
+
+static bool readArea( osgDB::InputStream& is, osg::Scissor& attr )
+{
+    int x, y, w, h;
+    is >> x >> y >> w >> h;
+    attr.setScissor( x, y, w, h );
+    return true;
+}
+
+static bool writeArea( osgDB::OutputStream& os, const osg::Scissor& attr )
+{
+    os << attr.x() << attr.y() << attr.width() << attr.height() << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( Scissor,
+                         new osg::Scissor,
+                         osg::Scissor,
+                         "osg::Object osg::StateAttribute osg::Scissor" )
+{
+    ADD_USER_SERIALIZER( Area );  // _x, _y, _width, _height
+}

src/osgWrappers/serializers/osg/Sequence.cpp

@@ -0,0 +1,34 @@
+#include <osg/Sequence>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Sequence,
+                         new osg::Sequence,
+                         osg::Sequence,
+                         "osg::Object osg::Node osg::Group osg::Sequence" )
+{
+    ADD_LIST_SERIALIZER( TimeList, std::vector<double> );  // _frameTime
+    
+    BEGIN_ENUM_SERIALIZER( LoopMode, LOOP );
+        ADD_ENUM_VALUE( LOOP );
+        ADD_ENUM_VALUE( SWING );
+    END_ENUM_SERIALIZER();  // _loopMode
+    
+    ADD_INT_SERIALIZER( Begin, 0 );  // _begin
+    ADD_INT_SERIALIZER( End, -1 );  // _end
+    ADD_FLOAT_SERIALIZER( Speed, 0.0f );  // _speed
+    ADD_INT_SERIALIZER( NumRepeats, -1 );  // _nreps
+    ADD_DOUBLE_SERIALIZER( DefaultTime, 1.0 );  // _defaultTime
+    ADD_DOUBLE_SERIALIZER( LastFrameTime, 0.0 );  // _lastFrameTime
+    
+    BEGIN_ENUM_SERIALIZER2( Mode, osg::Sequence::SequenceMode, STOP );
+        ADD_ENUM_VALUE( START );
+        ADD_ENUM_VALUE( STOP );
+        ADD_ENUM_VALUE( PAUSE );
+        ADD_ENUM_VALUE( RESUME );
+    END_ENUM_SERIALIZER();  // _mode
+    
+    ADD_BOOL_SERIALIZER( Sync, false );  // _sync
+    ADD_BOOL_SERIALIZER( ClearOnStop, false );  // _clearOnStop
+}

src/osgWrappers/serializers/osg/ShadeModel.cpp

@@ -0,0 +1,15 @@
+#include <osg/ShadeModel>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( ShadeModel,
+                         new osg::ShadeModel,
+                         osg::ShadeModel,
+                         "osg::Object osg::StateAttribute osg::ShadeModel" )
+{
+    BEGIN_ENUM_SERIALIZER( Mode, SMOOTH );
+        ADD_ENUM_VALUE( FLAT );
+        ADD_ENUM_VALUE( SMOOTH );
+    END_ENUM_SERIALIZER();  // _mode
+}

src/osgWrappers/serializers/osg/Shader.cpp

@@ -0,0 +1,61 @@
+#include <osg/Shader>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static bool checkShaderSource( const osg::Shader& shader )
+{
+    return !shader.getShaderSource().empty();
+}
+
+static bool readShaderSource( osgDB::InputStream& is, osg::Shader& shader )
+{
+    std::string code;
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        std::string line;
+        is.readWrappedString( line );
+        code.append( line ); code.append( 1, '\n' );
+    }
+    is >> osgDB::END_BRACKET;
+    shader.setShaderSource( code );
+    return true;
+}
+
+static bool writeShaderSource( osgDB::OutputStream& os, const osg::Shader& shader )
+{
+    std::vector<std::string> lines;
+    std::istringstream iss( shader.getShaderSource() );
+    std::string line;
+    while ( std::getline(iss, line) )
+    {
+        lines.push_back( line );
+    }
+    
+    os << lines.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( std::vector<std::string>::const_iterator itr=lines.begin();
+          itr!=lines.end(); ++itr )
+    {
+        os.writeWrappedString( *itr );
+        os << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( Shader,
+                         new osg::Shader,
+                         osg::Shader,
+                         "osg::Object osg::Shader" )
+{
+    BEGIN_ENUM_SERIALIZER3( Type, UNDEFINED );
+        ADD_ENUM_VALUE( VERTEX );
+        ADD_ENUM_VALUE( FRAGMENT );
+        ADD_ENUM_VALUE( GEOMETRY );
+        ADD_ENUM_VALUE( UNDEFINED );
+    END_ENUM_SERIALIZER();  // _type
+    
+    ADD_USER_SERIALIZER( ShaderSource );  // _shaderSource
+    ADD_OBJECT_SERIALIZER( ShaderBinary, osg::ShaderBinary, NULL );  // _shaderBinary
+}

src/osgWrappers/serializers/osg/ShaderBinary.cpp

@@ -0,0 +1,58 @@
+#include <osg/Shader>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/Serializer>
+
+static bool checkData( const osg::ShaderBinary& sb )
+{
+    return sb.getSize()>0;
+}
+
+static bool readData( osgDB::InputStream& is, osg::ShaderBinary& sb )
+{
+    unsigned int size; is >> size;
+    char* data = new char[size];
+    if ( is.isBinary() )
+    {
+        is.readCharArray( data, size );
+    }
+    else
+    {
+        is >> osgDB::BEGIN_BRACKET;
+        for ( unsigned int i=0; i<size; ++i )
+        {
+            is >> std::hex >> data[i] >> std::dec;
+        }
+        is >> osgDB::END_BRACKET;
+    }
+    sb.assign( size, (unsigned char*)data );
+    delete data;
+    return true;
+}
+
+static bool writeData( osgDB::OutputStream& os, const osg::ShaderBinary& sb )
+{
+    if ( os.isBinary() )
+    {
+        os << (unsigned int)sb.getSize();
+        os.writeCharArray( (char*)sb.getData(), sb.getSize() );
+    }
+    else
+    {
+        const unsigned char* data = sb.getData();
+        os << osgDB::BEGIN_BRACKET << std::endl;
+        for ( unsigned int i=0; i<sb.getSize(); ++i )
+        {
+            os << std::hex << data[i] << std::dec << std::endl;
+        }
+        os << osgDB::END_BRACKET << std::endl;
+    }
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( ShaderBinary,
+                         new osg::ShaderBinary,
+                         osg::ShaderBinary,
+                         "osg::Object osg::ShaderBinary" )
+{
+    ADD_USER_SERIALIZER( Data );  // _data
+}

src/osgWrappers/serializers/osg/Shape.cpp

@@ -0,0 +1,11 @@
+#include <osg/Shape>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Shape,
+                         /*new osg::Shape*/NULL,
+                         osg::Shape,
+                         "osg::Object osg::Shape" )
+{
+}

src/osgWrappers/serializers/osg/ShapeDrawable.cpp

@@ -0,0 +1,13 @@
+#include <osg/ShapeDrawable>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( ShapeDrawable,
+                         new osg::ShapeDrawable,
+                         osg::ShapeDrawable,
+                         "osg::Object osg::Drawable osg::ShapeDrawable" )
+{
+    ADD_VEC4_SERIALIZER( Color, osg::Vec4() );  // _color
+    ADD_OBJECT_SERIALIZER( TessellationHints, osg::TessellationHints, NULL );  // _tessellationHints
+}

src/osgWrappers/serializers/osg/Sphere.cpp

@@ -0,0 +1,13 @@
+#include <osg/Shape>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Sphere,
+                         new osg::Sphere,
+                         osg::Sphere,
+                         "osg::Object osg::Shape osg::Sphere" )
+{
+    ADD_VEC3_SERIALIZER( Center, osg::Vec3() );  // _center
+    ADD_FLOAT_SERIALIZER( Radius, 0.0f );  // _radius
+}

src/osgWrappers/serializers/osg/StateAttribute.cpp

@@ -0,0 +1,13 @@
+#include <osg/StateAttribute>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( StateAttribute,
+                         /*new osg::StateAttribute*/NULL,
+                         osg::StateAttribute,
+                         "osg::Object osg::StateAttribute" )
+{
+    ADD_OBJECT_SERIALIZER( UpdateCallback, osg::StateAttributeCallback, NULL );  // _updateCallback
+    ADD_OBJECT_SERIALIZER( EventCallback, osg::StateAttributeCallback, NULL );  // _eventCallback
+}

src/osgWrappers/serializers/osg/StateSet.cpp

@@ -0,0 +1,306 @@
+#include <osg/StateSet>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+static int readValue( osgDB::InputStream& is )
+{
+    int value = osg::StateAttribute::INHERIT;
+    if ( is.isBinary() )
+        is >> value;
+    else
+    {
+        std::string enumValue;
+        is >> enumValue;
+        if ( enumValue=="OFF" ) value = osg::StateAttribute::OFF;
+        else if ( enumValue=="ON" ) value = osg::StateAttribute::ON;
+        else if ( enumValue=="INHERIT" ) value = osg::StateAttribute::INHERIT;
+        else if ( enumValue=="OFF|OVERRIDE" )
+            value = osg::StateAttribute::OFF|osg::StateAttribute::OVERRIDE;
+        else if ( enumValue=="OFF|PROTECTED" )
+            value = osg::StateAttribute::OFF|osg::StateAttribute::PROTECTED;
+        else if ( enumValue=="ON|OVERRIDE" )
+            value = osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE;
+        else if ( enumValue=="ON|PROTECTED" )
+            value = osg::StateAttribute::ON|osg::StateAttribute::PROTECTED;
+    }
+    return value;
+}
+
+static void readModes( osgDB::InputStream& is, osg::StateSet::ModeList& modes )
+{
+    unsigned int size = 0; is >> size;
+    if ( size>0 )
+    {
+        is >> osgDB::BEGIN_BRACKET;
+        for ( unsigned int i=0; i<size; ++i )
+        {
+            DEF_GLENUM(mode); is >> mode;
+            int value = readValue( is );
+            modes[mode.get()] = (osg::StateAttribute::Values)value;
+        }
+        is >> osgDB::END_BRACKET;
+    }
+}
+
+static void readAttributes( osgDB::InputStream& is, osg::StateSet::AttributeList& attrs )
+{
+    unsigned int size = 0; is >> size;
+    if ( size>0 )
+    {
+        is >> osgDB::BEGIN_BRACKET;
+        for ( unsigned int i=0; i<size; ++i )
+        {
+            osg::StateAttribute* sa = dynamic_cast<osg::StateAttribute*>( is.readObject() );
+            is >> osgDB::PROPERTY("Value");
+            int value = readValue( is );
+            if ( sa )
+                attrs[sa->getTypeMemberPair()] = osg::StateSet::RefAttributePair(sa,value);
+        }
+            is >> osgDB::END_BRACKET;
+        }
+}
+
+static void writeValue( osgDB::OutputStream& os, int value )
+{
+    if ( os.isBinary() )
+        os << value;
+    else
+    {
+        if ( value==osg::StateAttribute::OFF ) os << std::string("OFF");
+        else if ( value==osg::StateAttribute::ON ) os << std::string("ON");
+        else if ( value==osg::StateAttribute::INHERIT ) os << std::string("INHERIT");
+        else if ( value==osg::StateAttribute::OFF+osg::StateAttribute::OVERRIDE )
+            os << std::string("OFF|OVERRIDE");
+        else if ( value==osg::StateAttribute::OFF+osg::StateAttribute::PROTECTED )
+            os << std::string("OFF|PROTECTED");
+        else if ( value==osg::StateAttribute::ON+osg::StateAttribute::OVERRIDE )
+            os << std::string("ON|OVERRIDE");
+        else if ( value==osg::StateAttribute::ON+osg::StateAttribute::PROTECTED )
+            os << std::string("ON|PROTECTED");
+        else os << std::string("INHERIT");
+    }
+}
+
+static void writeModes( osgDB::OutputStream& os, const osg::StateSet::ModeList& modes )
+{
+    os << modes.size();
+    if ( modes.size()>0 )
+    {
+        os << osgDB::BEGIN_BRACKET << std::endl;
+        for ( osg::StateSet::ModeList::const_iterator itr=modes.begin();
+              itr!=modes.end(); ++itr )
+        {
+            os << GLENUM(itr->first);
+            writeValue(os, itr->second);
+            os << std::endl;
+        }
+        os << osgDB::END_BRACKET;
+    }
+    os << std::endl;
+}
+
+static void writeAttributes( osgDB::OutputStream& os, const osg::StateSet::AttributeList& attrs )
+{
+    os << attrs.size();
+    if ( attrs.size()>0 )
+    {
+        os << osgDB::BEGIN_BRACKET << std::endl;
+        for ( osg::StateSet::AttributeList::const_iterator itr=attrs.begin();
+              itr!=attrs.end(); ++itr )
+        {
+            os << itr->second.first.get();
+            os << osgDB::PROPERTY("Value");
+            writeValue(os, itr->second.second);
+            os << std::endl;
+        }
+        os << osgDB::END_BRACKET;
+    }
+    os << std::endl;
+}
+
+// _modeList
+static bool checkModeList( const osg::StateSet& ss )
+{
+    return ss.getModeList().size()>0;
+}
+
+static bool readModeList( osgDB::InputStream& is, osg::StateSet& ss )
+{
+    osg::StateSet::ModeList modes; readModes( is, modes );
+    for ( osg::StateSet::ModeList::iterator itr=modes.begin();
+          itr!=modes.end(); ++itr )
+    {
+        ss.setMode( itr->first, itr->second );
+    }
+    return true;
+}
+
+static bool writeModeList( osgDB::OutputStream& os, const osg::StateSet& ss )
+{
+    writeModes( os, ss.getModeList() );
+    return true;
+}
+
+// _attributeList
+static bool checkAttributeList( const osg::StateSet& ss )
+{
+    return ss.getAttributeList().size()>0;
+}
+
+static bool readAttributeList( osgDB::InputStream& is, osg::StateSet& ss )
+{
+    osg::StateSet::AttributeList attrs; readAttributes( is, attrs );
+    for ( osg::StateSet::AttributeList::iterator itr=attrs.begin();
+          itr!=attrs.end(); ++itr )
+    {
+        ss.setAttribute( itr->second.first, itr->second.second );
+    }
+    return true;
+}
+
+static bool writeAttributeList( osgDB::OutputStream& os, const osg::StateSet& ss )
+{
+    writeAttributes( os, ss.getAttributeList() );
+    return true;
+}
+
+// _textureModeList
+static bool checkTextureModeList( const osg::StateSet& ss )
+{
+    return ss.getTextureModeList().size()>0;
+}
+
+static bool readTextureModeList( osgDB::InputStream& is, osg::StateSet& ss )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    osg::StateSet::ModeList modes;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        is >> osgDB::PROPERTY("Data");
+        readModes( is, modes );
+        for ( osg::StateSet::ModeList::iterator itr=modes.begin();
+              itr!=modes.end(); ++itr )
+        {
+            ss.setTextureMode( i, itr->first, itr->second );
+        }
+        modes.clear();
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeTextureModeList( osgDB::OutputStream& os, const osg::StateSet& ss )
+{
+    const osg::StateSet::TextureModeList& tml = ss.getTextureModeList();
+    os << tml.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::StateSet::TextureModeList::const_iterator itr=tml.begin();
+          itr!=tml.end(); ++itr )
+    {
+        os << osgDB::PROPERTY("Data");
+        writeModes( os, *itr );
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+// _textureAttributeList
+static bool checkTextureAttributeList( const osg::StateSet& ss )
+{
+    return ss.getTextureAttributeList().size()>0;
+}
+
+static bool readTextureAttributeList( osgDB::InputStream& is, osg::StateSet& ss )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    osg::StateSet::AttributeList attrs;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        is >> osgDB::PROPERTY("Data");
+        readAttributes( is, attrs );
+        for ( osg::StateSet::AttributeList::iterator itr=attrs.begin();
+              itr!=attrs.end(); ++itr )
+        {
+            ss.setTextureAttribute( i, itr->second.first, itr->second.second );
+        }
+        attrs.clear();
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeTextureAttributeList( osgDB::OutputStream& os, const osg::StateSet& ss )
+{
+    const osg::StateSet::TextureAttributeList& tal = ss.getTextureAttributeList();
+    os << tal.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::StateSet::TextureAttributeList::const_iterator itr=tal.begin();
+          itr!=tal.end(); ++itr )
+    {
+        os << osgDB::PROPERTY("Data");
+        writeAttributes( os, *itr );
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+// _uniformList
+static bool checkUniformList( const osg::StateSet& ss )
+{
+    return ss.getUniformList().size()>0;
+}
+
+static bool readUniformList( osgDB::InputStream& is, osg::StateSet& ss )
+{
+    unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET;
+    for ( unsigned int i=0; i<size; ++i )
+    {
+        osg::Uniform* uniform = dynamic_cast<osg::Uniform*>( is.readObject() );
+        is >> osgDB::PROPERTY("Value");
+        int value = readValue( is );
+        if ( uniform )
+            ss.addUniform( uniform, (osg::StateAttribute::Values)value );
+    }
+    is >> osgDB::END_BRACKET;
+    return true;
+}
+
+static bool writeUniformList( osgDB::OutputStream& os, const osg::StateSet& ss )
+{
+    const osg::StateSet::UniformList& ul = ss.getUniformList();
+    os << ul.size() << osgDB::BEGIN_BRACKET << std::endl;
+    for ( osg::StateSet::UniformList::const_iterator itr=ul.begin();
+          itr!=ul.end(); ++itr )
+    {
+        os << itr->second.first.get();
+        os << osgDB::PROPERTY("Value");
+        writeValue(os, itr->second.second);
+        os << std::endl;
+    }
+    os << osgDB::END_BRACKET << std::endl;
+    return true;
+}
+
+REGISTER_OBJECT_WRAPPER( StateSet,
+                         new osg::StateSet,
+                         osg::StateSet,
+                         "osg::Object osg::StateSet" )
+{
+    ADD_USER_SERIALIZER( ModeList );  // _modeList
+    ADD_USER_SERIALIZER( AttributeList );  // _attributeList
+    ADD_USER_SERIALIZER( TextureModeList );  // _textureModeList
+    ADD_USER_SERIALIZER( TextureAttributeList );  // _textureAttributeList
+    ADD_USER_SERIALIZER( UniformList );  // _uniformList
+    ADD_INT_SERIALIZER( RenderingHint, osg::StateSet::DEFAULT_BIN );  // _renderingHint
+    
+    BEGIN_ENUM_SERIALIZER( RenderBinMode, INHERIT_RENDERBIN_DETAILS );
+        ADD_ENUM_VALUE( INHERIT_RENDERBIN_DETAILS );
+        ADD_ENUM_VALUE( USE_RENDERBIN_DETAILS );
+        ADD_ENUM_VALUE( OVERRIDE_RENDERBIN_DETAILS );
+    END_ENUM_SERIALIZER();  // _binMode
+    
+    ADD_INT_SERIALIZER( BinNumber, 0 );  // _binNum
+    ADD_STRING_SERIALIZER( BinName, "" );  // _binName
+    ADD_BOOL_SERIALIZER( NestRenderBins, true );  // _nestRenderBins
+    ADD_OBJECT_SERIALIZER( UpdateCallback, osg::StateSet::Callback, NULL );  // _updateCallback
+    ADD_OBJECT_SERIALIZER( EventCallback, osg::StateSet::Callback, NULL );  // _eventCallback
+}

src/osgWrappers/serializers/osg/Stencil.cpp

@@ -0,0 +1,59 @@
+#include <osg/Stencil>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Stencil,
+                         new osg::Stencil,
+                         osg::Stencil,
+                         "osg::Object osg::StateAttribute osg::Stencil" )
+{
+    BEGIN_ENUM_SERIALIZER( Function, ALWAYS );
+        ADD_ENUM_VALUE( NEVER );
+        ADD_ENUM_VALUE( LESS );
+        ADD_ENUM_VALUE( EQUAL );
+        ADD_ENUM_VALUE( LEQUAL );
+        ADD_ENUM_VALUE( GREATER );
+        ADD_ENUM_VALUE( NOTEQUAL );
+        ADD_ENUM_VALUE( GEQUAL );
+        ADD_ENUM_VALUE( ALWAYS );
+    END_ENUM_SERIALIZER();  // _func
+    
+    ADD_INT_SERIALIZER( FunctionRef, 0 );  // _funcRef
+    ADD_HEXINT_SERIALIZER( FunctionMask, ~0u );  // _funcMask
+    
+    BEGIN_ENUM_SERIALIZER2( StencilFailOperation, osg::Stencil::Operation, KEEP );
+        ADD_ENUM_VALUE( KEEP );
+        ADD_ENUM_VALUE( ZERO );
+        ADD_ENUM_VALUE( REPLACE );
+        ADD_ENUM_VALUE( INCR );
+        ADD_ENUM_VALUE( DECR );
+        ADD_ENUM_VALUE( INVERT );
+        ADD_ENUM_VALUE( INCR_WRAP );
+        ADD_ENUM_VALUE( DECR_WRAP );
+    END_ENUM_SERIALIZER();  // _sfail
+    
+    BEGIN_ENUM_SERIALIZER2( StencilPassAndDepthFailOperation, osg::Stencil::Operation, KEEP );
+        ADD_ENUM_VALUE( KEEP );
+        ADD_ENUM_VALUE( ZERO );
+        ADD_ENUM_VALUE( REPLACE );
+        ADD_ENUM_VALUE( INCR );
+        ADD_ENUM_VALUE( DECR );
+        ADD_ENUM_VALUE( INVERT );
+        ADD_ENUM_VALUE( INCR_WRAP );
+        ADD_ENUM_VALUE( DECR_WRAP );
+    END_ENUM_SERIALIZER();  // _zfail
+    
+    BEGIN_ENUM_SERIALIZER2( StencilPassAndDepthPassOperation, osg::Stencil::Operation, KEEP );
+        ADD_ENUM_VALUE( KEEP );
+        ADD_ENUM_VALUE( ZERO );
+        ADD_ENUM_VALUE( REPLACE );
+        ADD_ENUM_VALUE( INCR );
+        ADD_ENUM_VALUE( DECR );
+        ADD_ENUM_VALUE( INVERT );
+        ADD_ENUM_VALUE( INCR_WRAP );
+        ADD_ENUM_VALUE( DECR_WRAP );
+    END_ENUM_SERIALIZER();  // _zpass
+    
+    ADD_HEXINT_SERIALIZER( WriteMask, ~0u );  // _writeMask
+}

src/osgWrappers/serializers/osg/StencilTwoSided.cpp

@@ -0,0 +1,79 @@
+#include <osg/StencilTwoSided>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+BEGIN_USER_TABLE( Function, osg::StencilTwoSided );
+    ADD_USER_VALUE( NEVER );
+    ADD_USER_VALUE( LESS );
+    ADD_USER_VALUE( EQUAL );
+    ADD_USER_VALUE( LEQUAL );
+    ADD_USER_VALUE( GREATER );
+    ADD_USER_VALUE( NOTEQUAL );
+    ADD_USER_VALUE( GEQUAL );
+    ADD_USER_VALUE( ALWAYS );
+END_USER_TABLE()
+
+USER_READ_FUNC( Function, readFunction )
+USER_WRITE_FUNC( Function, writeFunction )
+
+BEGIN_USER_TABLE( Operation, osg::StencilTwoSided );
+    ADD_USER_VALUE( KEEP );
+    ADD_USER_VALUE( ZERO );
+    ADD_USER_VALUE( REPLACE );
+    ADD_USER_VALUE( INCR );
+    ADD_USER_VALUE( DECR );
+    ADD_USER_VALUE( INVERT );
+    ADD_USER_VALUE( INCR_WRAP );
+    ADD_USER_VALUE( DECR_WRAP );
+END_USER_TABLE()
+
+USER_READ_FUNC( Operation, readOperation )
+USER_WRITE_FUNC( Operation, writeOperation )
+
+#define STENCIL_INT_VALUE_FUNC( PROP, TYPE ) \
+    static bool check##PROP( const osg::StencilTwoSided& attr ) { return true; } \
+    static bool read##PROP( osgDB::InputStream& is, osg::StencilTwoSided& attr ) { \
+        TYPE value1; is >> osgDB::PROPERTY("Front") >> value1; \
+        TYPE value2; is >> osgDB::PROPERTY("Back") >> value2; \
+        attr.set##PROP(osg::StencilTwoSided::FRONT, value1); \
+        attr.set##PROP(osg::StencilTwoSided::BACK, value2); return true; } \
+    static bool write##PROP( osgDB::OutputStream& os, const osg::StencilTwoSided& attr ) { \
+        os << osgDB::PROPERTY("Front") << attr.get##PROP(osg::StencilTwoSided::FRONT); \
+        os << osgDB::PROPERTY("Back") << attr.get##PROP(osg::StencilTwoSided::BACK); \
+        os << std::endl; return true; }
+
+#define STENCIL_USER_VALUE_FUNC( PROP, TYPE ) \
+    static bool check##PROP( const osg::StencilTwoSided& attr ) { return true; } \
+    static bool read##PROP( osgDB::InputStream& is, osg::StencilTwoSided& attr ) { \
+        is >> osgDB::PROPERTY("Front"); int value1 = read##TYPE(is); \
+        is >> osgDB::PROPERTY("Back"); int value2 = read##TYPE(is); \
+        attr.set##PROP(osg::StencilTwoSided::FRONT, (osg::StencilTwoSided::TYPE)value1); \
+        attr.set##PROP(osg::StencilTwoSided::BACK, (osg::StencilTwoSided::TYPE)value2); \
+        return true; } \
+    static bool write##PROP( osgDB::OutputStream& os, const osg::StencilTwoSided& attr ) { \
+        os << osgDB::PROPERTY("Front"); write##TYPE(os, (int)attr.get##PROP(osg::StencilTwoSided::FRONT)); \
+        os << osgDB::PROPERTY("Back"); write##TYPE(os, (int)attr.get##PROP(osg::StencilTwoSided::BACK)); \
+        os << std::endl; return true; }
+
+STENCIL_USER_VALUE_FUNC( Function, Function )
+STENCIL_INT_VALUE_FUNC( FunctionRef, int )
+STENCIL_INT_VALUE_FUNC( FunctionMask, unsigned int )
+STENCIL_USER_VALUE_FUNC( StencilFailOperation, Operation )
+STENCIL_USER_VALUE_FUNC( StencilPassAndDepthFailOperation, Operation )
+STENCIL_USER_VALUE_FUNC( StencilPassAndDepthPassOperation, Operation )
+STENCIL_INT_VALUE_FUNC( WriteMask, unsigned int )
+
+REGISTER_OBJECT_WRAPPER( StencilTwoSided,
+                         new osg::StencilTwoSided,
+                         osg::StencilTwoSided,
+                         "osg::Object osg::StateAttribute osg::StencilTwoSided" )
+{
+    ADD_USER_SERIALIZER( Function );  // _func
+    ADD_USER_SERIALIZER( FunctionRef );  // _funcRef
+    ADD_USER_SERIALIZER( FunctionMask );  // _funcMask
+    ADD_USER_SERIALIZER( StencilFailOperation );  // _sfail
+    ADD_USER_SERIALIZER( StencilPassAndDepthFailOperation );  // _zfail
+    ADD_USER_SERIALIZER( StencilPassAndDepthPassOperation );  // _zpass
+    ADD_USER_SERIALIZER( WriteMask );  // _writeMask
+}

src/osgWrappers/serializers/osg/Switch.cpp

@@ -0,0 +1,13 @@
+#include <osg/Switch>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( Switch,
+                         new osg::Switch,
+                         osg::Switch,
+                         "osg::Object osg::Node osg::Group osg::Switch" )
+{
+    ADD_BOOL_SERIALIZER( NewChildDefaultValue, true );  // _newChildDefaultValue
+    ADD_LIST_SERIALIZER( ValueList, osg::Switch::ValueList );  // _values
+}

src/osgWrappers/serializers/osg/TessellationHints.cpp

@@ -0,0 +1,25 @@
+#include <osg/ShapeDrawable>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( TessellationHints,
+                         new osg::TessellationHints,
+                         osg::TessellationHints,
+                         "osg::Object osg::TessellationHints" )
+{
+    BEGIN_ENUM_SERIALIZER( TessellationMode, USE_SHAPE_DEFAULTS );
+        ADD_ENUM_VALUE( USE_SHAPE_DEFAULTS );
+        ADD_ENUM_VALUE( USE_TARGET_NUM_FACES );
+    END_ENUM_SERIALIZER();  // _TessellationMode
+    
+    ADD_FLOAT_SERIALIZER( DetailRatio, 1.0f );  // _detailRatio
+    ADD_UINT_SERIALIZER( TargetNumFaces, 100 );  // _targetNumFaces
+    ADD_BOOL_SERIALIZER( CreateFrontFace, true );  // _createFrontFace
+    ADD_BOOL_SERIALIZER( CreateBackFace, false );  // _createBackFace
+    ADD_BOOL_SERIALIZER( CreateNormals, true );  // _createNormals
+    ADD_BOOL_SERIALIZER( CreateTextureCoords, false );  // _createTextureCoords
+    ADD_BOOL_SERIALIZER( CreateTop, true );  // _createTop
+    ADD_BOOL_SERIALIZER( CreateBody, true );  // _createBody
+    ADD_BOOL_SERIALIZER( CreateBottom, true );  // _createBottom
+}

src/osgWrappers/serializers/osg/TexEnv.cpp

@@ -0,0 +1,20 @@
+#include <osg/TexEnv>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( TexEnv,
+                         new osg::TexEnv,
+                         osg::TexEnv,
+                         "osg::Object osg::StateAttribute osg::TexEnv" )
+{
+    BEGIN_ENUM_SERIALIZER( Mode, MODULATE );
+        ADD_ENUM_VALUE( DECAL );
+        ADD_ENUM_VALUE( MODULATE );
+        ADD_ENUM_VALUE( BLEND );
+        ADD_ENUM_VALUE( REPLACE );
+        ADD_ENUM_VALUE( ADD );
+    END_ENUM_SERIALIZER();  // _mode
+    
+    ADD_VEC4_SERIALIZER( Color, osg::Vec4() );  // _color
+}

src/osgWrappers/serializers/osg/TexEnvCombine.cpp

@@ -0,0 +1,28 @@
+#include <osg/TexEnvCombine>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( TexEnvCombine,
+                         new osg::TexEnvCombine,
+                         osg::TexEnvCombine,
+                         "osg::Object osg::StateAttribute osg::TexEnvCombine" )
+{
+    ADD_GLENUM_SERIALIZER( Combine_RGB, GLint, GL_NONE );  // _combine_RGB
+    ADD_GLENUM_SERIALIZER( Combine_Alpha, GLint, GL_NONE );  // _combine_Alpha
+    ADD_GLENUM_SERIALIZER( Source0_RGB, GLint, GL_NONE );  // _source0_RGB
+    ADD_GLENUM_SERIALIZER( Source1_RGB, GLint, GL_NONE );  // _source1_RGB
+    ADD_GLENUM_SERIALIZER( Source2_RGB, GLint, GL_NONE );  // _source2_RGB
+    ADD_GLENUM_SERIALIZER( Source0_Alpha, GLint, GL_NONE );  // _source0_Alpha
+    ADD_GLENUM_SERIALIZER( Source1_Alpha, GLint, GL_NONE );  // _source1_Alpha
+    ADD_GLENUM_SERIALIZER( Source2_Alpha, GLint, GL_NONE );  // _source2_Alpha
+    ADD_GLENUM_SERIALIZER( Operand0_RGB, GLint, GL_NONE );  // _operand0_RGB
+    ADD_GLENUM_SERIALIZER( Operand1_RGB, GLint, GL_NONE );  // _operand1_RGB
+    ADD_GLENUM_SERIALIZER( Operand2_RGB, GLint, GL_NONE );  // _operand2_RGB
+    ADD_GLENUM_SERIALIZER( Operand0_Alpha, GLint, GL_NONE );  // _operand0_Alpha
+    ADD_GLENUM_SERIALIZER( Operand1_Alpha, GLint, GL_NONE );  // _operand1_Alpha
+    ADD_GLENUM_SERIALIZER( Operand2_Alpha, GLint, GL_NONE );  // _operand2_Alpha
+    ADD_FLOAT_SERIALIZER( Scale_RGB, 1.0f );  // _scale_RGB
+    ADD_FLOAT_SERIALIZER( Scale_Alpha, 1.0f );  // _scale_Alpha
+    ADD_VEC4_SERIALIZER( ConstantColor, osg::Vec4() );  // _constantColor
+}

src/osgWrappers/serializers/osg/TexEnvFilter.cpp

@@ -0,0 +1,12 @@
+#include <osg/TexEnvFilter>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( TexEnvFilter,
+                         new osg::TexEnvFilter,
+                         osg::TexEnvFilter,
+                         "osg::Object osg::StateAttribute osg::TexEnvFilter" )
+{
+    ADD_FLOAT_SERIALIZER( LodBias, 0.0f );  // _lodBias
+}

src/osgWrappers/serializers/osg/TexGen.cpp

@@ -0,0 +1,40 @@
+#include <osg/TexGen>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+#define PLANE_FUNCTION( PROP, COORD ) \
+    static bool check##PROP( const osg::TexGen& tex ) { return true; } \
+    static bool read##PROP( osgDB::InputStream& is, osg::TexGen& tex ) { \
+        osg::Plane plane; is >> plane; \
+        tex.setPlane(COORD, plane); \
+        return true; \
+    } \
+    static bool write##PROP( osgDB::OutputStream& os, const osg::TexGen& tex ) { \
+        os << tex.getPlane(COORD) << std::endl; \
+        return true; \
+    }
+
+PLANE_FUNCTION( PlaneS, osg::TexGen::S )
+PLANE_FUNCTION( PlaneT, osg::TexGen::T )
+PLANE_FUNCTION( PlaneR, osg::TexGen::R )
+PLANE_FUNCTION( PlaneQ, osg::TexGen::Q )
+
+REGISTER_OBJECT_WRAPPER( TexGen,
+                         new osg::TexGen,
+                         osg::TexGen,
+                         "osg::Object osg::StateAttribute osg::TexGen" )
+{
+    BEGIN_ENUM_SERIALIZER( Mode, OBJECT_LINEAR );
+        ADD_ENUM_VALUE( OBJECT_LINEAR );
+        ADD_ENUM_VALUE( EYE_LINEAR );
+        ADD_ENUM_VALUE( SPHERE_MAP );
+        ADD_ENUM_VALUE( NORMAL_MAP );
+        ADD_ENUM_VALUE( REFLECTION_MAP );
+    END_ENUM_SERIALIZER();  // _mode
+    
+    ADD_USER_SERIALIZER( PlaneS );
+    ADD_USER_SERIALIZER( PlaneT );
+    ADD_USER_SERIALIZER( PlaneR );
+    ADD_USER_SERIALIZER( PlaneQ );  //_plane_s, _plane_t, _plane_r, _plane_q
+}

src/osgWrappers/serializers/osg/TexGenNode.cpp

@@ -0,0 +1,18 @@
+#include <osg/TexGenNode>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+REGISTER_OBJECT_WRAPPER( TexGenNode,
+                         new osg::TexGenNode,
+                         osg::TexGenNode,
+                         "osg::Object osg::Node osg::Group osg::TexGenNode" )
+{
+    ADD_UINT_SERIALIZER( TextureUnit, 0 );  // _textureUnit
+    ADD_OBJECT_SERIALIZER( TexGen, osg::TexGen, NULL );  // _texgen
+    
+    BEGIN_ENUM_SERIALIZER( ReferenceFrame, RELATIVE_RF );
+        ADD_ENUM_VALUE( RELATIVE_RF );
+        ADD_ENUM_VALUE( ABSOLUTE_RF );
+    END_ENUM_SERIALIZER();  // _referenceFrame
+}