root/OpenSceneGraph/trunk/include/osgDB/Serializer @ 13584

Revision 13584, 36.6 kB (checked in by robert, 8 hours ago)

From Jason Beverage, "It looks like the Callback header got accidentally removed from the CMakeLists.txt in the submission yesterday for the geometry instancing example."

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 Robert Osfield
2 *
3 * This library is open source and may be redistributed and/or modified under
4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 * OpenSceneGraph Public License for more details.
12*/
13// Written by Wang Rui, (C) 2010
14
15#ifndef OSGDB__SERIALIZER
16#define OSGDB__SERIALIZER
17
18#include <osg/ref_ptr>
19#include <osg/Notify>
20#include <osg/Object>
21#include <osgDB/InputStream>
22#include <osgDB/OutputStream>
23
24#include <string>
25#include <sstream>
26#include <limits.h>
27
28namespace osgDB
29{
30
31#ifndef OBJECT_CAST
32    #define OBJECT_CAST static_cast
33#endif
34
35class IntLookup
36{
37public:
38    typedef int Value;
39    typedef std::map<std::string, Value> StringToValue;
40    typedef std::map<Value, std::string> ValueToString;
41
42    IntLookup() {}
43    unsigned int size() const { return static_cast<unsigned int>(_stringToValue.size()); }
44
45    void add( const char* str, Value value )
46    {
47        if ( _valueToString.find(value)!=_valueToString.end() )
48        {
49            osg::notify(osg::WARN) << "Duplicate enum value " << value
50                                   << " with old string: " << _valueToString[value]
51                                   << " and new string: " << str << std::endl;
52        }
53        _valueToString[value] = str;
54        _stringToValue[str] = value;
55    }
56
57    Value getValue( const char* str )
58    {
59        StringToValue::iterator itr = _stringToValue.find(str);
60        if ( itr==_stringToValue.end() )
61        {
62            Value value;
63            std::stringstream stream;
64            stream << str; stream >> value;
65            _stringToValue[str] = value;
66            return value;
67        }
68        return itr->second;
69    }
70
71    const std::string& getString( Value value )
72    {
73        ValueToString::iterator itr = _valueToString.find(value);
74        if ( itr==_valueToString.end() )
75        {
76            std::string str;
77            std::stringstream stream;
78            stream << value; stream >> str;
79            _valueToString[value] = str;
80            return _valueToString[value];
81        }
82        return itr->second;
83    }
84
85protected:
86    StringToValue _stringToValue;
87    ValueToString _valueToString;
88};
89
90class UserLookupTableProxy
91{
92public:
93    typedef void (*AddValueFunc)( IntLookup* lookup );
94    UserLookupTableProxy( AddValueFunc func ) { if ( func ) (*func)(&_lookup); }
95
96    IntLookup _lookup;
97};
98
99#define BEGIN_USER_TABLE(NAME, CLASS) \
100    static void add_user_value_func_##NAME(osgDB::IntLookup*); \
101    static osgDB::UserLookupTableProxy s_user_lookup_table_##NAME(&add_user_value_func_##NAME); \
102    static void add_user_value_func_##NAME(osgDB::IntLookup* lookup) { typedef CLASS MyClass
103#define ADD_USER_VALUE(VALUE) lookup->add(#VALUE, MyClass::VALUE)
104#define END_USER_TABLE() }
105
106#define USER_READ_FUNC(NAME, FUNCNAME) \
107    static int FUNCNAME(osgDB::InputStream& is) { \
108        int value; if (is.isBinary()) is >> value; \
109        else { std::string str; is >> str; \
110        value = (s_user_lookup_table_##NAME)._lookup.getValue(str.c_str()); } \
111        return value; }
112
113#define USER_WRITE_FUNC(NAME, FUNCNAME) \
114    static void FUNCNAME(osgDB::OutputStream& os, int value) { \
115        if (os.isBinary()) os << value; \
116        else os << (s_user_lookup_table_##NAME)._lookup.getString(value); } \
117
118class BaseSerializer : public osg::Referenced
119{
120    friend class ObjectWrapper;
121public:
122    enum Type
123    {
124        RW_UNDEFINED = 0, RW_USER, RW_OBJECT, RW_IMAGE, RW_LIST,
125        RW_BOOL, RW_CHAR, RW_UCHAR, RW_SHORT, RW_USHORT, RW_INT, RW_UINT, RW_FLOAT, RW_DOUBLE,
126        RW_VEC2F, RW_VEC2D, RW_VEC3F, RW_VEC3D, RW_VEC4F, RW_VEC4D, RW_QUAT, RW_PLANE,
127        RW_MATRIXF, RW_MATRIXD, RW_MATRIX, RW_GLENUM, RW_STRING, RW_ENUM,
128        RW_VEC2B, RW_VEC2UB, RW_VEC2S, RW_VEC2US, RW_VEC2I, RW_VEC2UI,
129        RW_VEC3B, RW_VEC3UB, RW_VEC3S, RW_VEC3US, RW_VEC3I, RW_VEC3UI,
130        RW_VEC4B, RW_VEC4UB, RW_VEC4S, RW_VEC4US, RW_VEC4I, RE_VEC4UI
131    };
132
133    BaseSerializer() : _firstVersion(0), _lastVersion(INT_MAX) {}
134
135    virtual bool read( InputStream&, osg::Object& ) = 0;
136    virtual bool write( OutputStream&, const osg::Object& ) = 0;
137    virtual const std::string& getName() const = 0;
138
139protected:
140    int _firstVersion;  // Library version when the serializer is first introduced
141    int _lastVersion;  // Library version when the serializer is last required.
142};
143
144template<typename C>
145class UserSerializer : public BaseSerializer
146{
147public:
148    typedef bool (*Checker)( const C& );
149    typedef bool (*Reader)( InputStream&, C& );
150    typedef bool (*Writer)( OutputStream&, const C& );
151
152    UserSerializer( const char* name, Checker cf, Reader rf, Writer wf )
153    : BaseSerializer(), _name(name), _checker(cf), _reader(rf), _writer(wf) {}
154
155    virtual bool read( InputStream& is, osg::Object& obj )
156    {
157        C& object = OBJECT_CAST<C&>(obj);
158        if ( is.isBinary() )
159        {
160            bool ok = false; is >> ok;
161            if ( !ok ) return true;
162        }
163        else
164        {
165            if ( !is.matchString(_name) )
166                return true;
167        }
168        return (*_reader)(is, object);
169    }
170
171    virtual bool write( OutputStream& os, const osg::Object& obj )
172    {
173        const C& object = OBJECT_CAST<const C&>(obj);
174        bool ok = (*_checker)(object);
175        if ( os.isBinary() )
176        {
177            os << ok;
178            if ( !ok ) return true;
179        }
180        else
181        {
182            if ( !ok ) return true;
183            os << os.PROPERTY(_name.c_str());
184        }
185        return (*_writer)(os, object);
186    }
187
188    virtual const std::string& getName() const { return _name; }
189
190protected:
191    std::string _name;
192    Checker _checker;
193
194public:
195    Reader _reader;
196    Writer _writer;
197};
198
199template<typename P>
200class TemplateSerializer : public BaseSerializer
201{
202public:
203
204    TemplateSerializer( const char* name, P def)
205    : BaseSerializer(), _name(name), _defaultValue(def) {}
206
207    virtual bool read( InputStream& is, osg::Object& obj ) = 0;
208    virtual bool write( OutputStream& os, const osg::Object& obj ) = 0;
209    virtual const std::string& getName() const { return _name; }
210
211protected:
212    std::string _name;
213    P _defaultValue;
214};
215
216template<typename C, typename P>
217class PropByValSerializer : public TemplateSerializer<P>
218{
219public:
220    typedef TemplateSerializer<P> ParentType;
221    typedef P (C::*Getter)() const;
222    typedef void (C::*Setter)( P );
223
224    PropByValSerializer( const char* name, P def, Getter gf, Setter sf, bool useHex=false )
225    : ParentType(name, def), _getter(gf), _setter(sf), _useHex(useHex) {}
226
227    virtual bool read( InputStream& is, osg::Object& obj )
228    {
229        C& object = OBJECT_CAST<C&>(obj);
230        P value;
231        if ( is.isBinary() )
232        {
233            is >> value;
234            if ( ParentType::_defaultValue!=value )
235                (object.*_setter)( value );
236        }
237        else if ( is.matchString(ParentType::_name) )
238        {
239            if ( _useHex ) is >> std::hex;
240            is >> value;
241            if ( _useHex ) is >> std::dec;
242            (object.*_setter)( value );
243        }
244        return true;
245    }
246
247    virtual bool write( OutputStream& os, const osg::Object& obj )
248    {
249        const C& object = OBJECT_CAST<const C&>(obj);
250        P value = (object.*_getter)();
251        if ( os.isBinary() )
252        {
253            os << value;
254        }
255        else if ( ParentType::_defaultValue!=value )
256        {
257            os << os.PROPERTY((ParentType::_name).c_str());
258            if ( _useHex ) { os << std::hex << std::showbase; }
259            os << value;
260            if ( _useHex ) os << std::dec << std::noshowbase;
261            os << std::endl;
262        }
263        return true;
264    }
265
266public:
267    Getter _getter;
268    Setter _setter;
269
270protected:
271    bool _useHex;
272};
273
274template<typename C, typename P>
275class PropByRefSerializer : public TemplateSerializer<P>
276{
277public:
278    typedef TemplateSerializer<P> ParentType;
279    typedef const P& CP;
280    typedef CP (C::*Getter)() const;
281    typedef void (C::*Setter)( CP );
282
283    PropByRefSerializer( const char* name, CP def, Getter gf, Setter sf )
284    : ParentType(name, def), _getter(gf), _setter(sf) {}
285
286    virtual bool read( InputStream& is, osg::Object& obj )
287    {
288        C& object = OBJECT_CAST<C&>(obj);
289        P value;
290        if ( is.isBinary() )
291        {
292            is >> value;
293            if ( ParentType::_defaultValue!=value )
294                (object.*_setter)( value );
295        }
296        else if ( is.matchString(ParentType::_name) )
297        {
298            is >> value;
299            (object.*_setter)( value );
300        }
301        return true;
302    }
303
304    virtual bool write( OutputStream& os, const osg::Object& obj )
305    {
306        const C& object = OBJECT_CAST<const C&>(obj);
307        CP value = (object.*_getter)();
308        if ( os.isBinary() )
309        {
310            os << value;
311        }
312        else if ( ParentType::_defaultValue!=value )
313        {
314            os << os.PROPERTY((ParentType::_name).c_str()) << value << std::endl;
315        }
316        return true;
317    }
318
319public:
320    Getter _getter;
321    Setter _setter;
322};
323
324template<typename C>
325class MatrixSerializer : public TemplateSerializer<osg::Matrix>
326{
327public:
328    typedef TemplateSerializer<osg::Matrix> ParentType;
329    typedef const osg::Matrix& (C::*Getter)() const;
330    typedef void (C::*Setter)( const osg::Matrix& );
331
332    MatrixSerializer( const char* name, const osg::Matrix& def, Getter gf, Setter sf )
333    : ParentType(name, def), _getter(gf), _setter(sf) {}
334
335    virtual bool read( InputStream& is, osg::Object& obj )
336    {
337        C& object = OBJECT_CAST<C&>(obj);
338        osg::Matrix value;
339        if ( is.isBinary() )
340        {
341            readMatrixImplementation( is, value );
342            if ( ParentType::_defaultValue!=value )
343                (object.*_setter)( value );
344        }
345        else if ( is.matchString(ParentType::_name) )
346        {
347            readMatrixImplementation( is, value );
348            (object.*_setter)( value );
349        }
350        return true;
351    }
352
353    virtual bool write( OutputStream& os, const osg::Object& obj )
354    {
355
356        const C& object = OBJECT_CAST<const C&>(obj);
357        const osg::Matrix& value = (object.*_getter)();
358        if ( os.isBinary() )
359        {
360            os << value;
361        }
362        else if ( ParentType::_defaultValue!=value )
363        {
364            os << os.PROPERTY((ParentType::_name).c_str()) << value << std::endl;
365        }
366        return true;
367    }
368
369protected:
370    void readMatrixImplementation( InputStream& is, osg::Matrix& matrix )
371    {
372#if 1
373        is >> matrix;
374#else
375        if ( is.getUseFloatMatrix() )
376        {
377            osg::Matrixf realValue; is >> realValue;
378            matrix = realValue;
379        }
380        else
381        {
382            osg::Matrixd realValue; is >> realValue;
383            matrix = realValue;
384        }
385#endif
386    }
387
388public:
389    Getter _getter;
390    Setter _setter;
391};
392
393template<typename C, typename P>
394class GLenumSerializer : public TemplateSerializer<P>
395{
396public:
397    typedef TemplateSerializer<P> ParentType;
398    typedef P (C::*Getter)() const;
399    typedef void (C::*Setter)( P );
400
401    GLenumSerializer( const char* name, P def, Getter gf, Setter sf )
402    : ParentType(name, def), _getter(gf), _setter(sf) {}
403
404    virtual bool read( InputStream& is, osg::Object& obj )
405    {
406        C& object = OBJECT_CAST<C&>(obj);
407        if ( is.isBinary() )
408        {
409            GLenum value; is >> value;
410            if ( ParentType::_defaultValue!=static_cast<P>(value) )
411                (object.*_setter)( static_cast<P>(value) );
412        }
413        else if ( is.matchString(ParentType::_name) )
414        {
415            DEF_GLENUM(value); is >> value;
416            (object.*_setter)( static_cast<P>(value.get()) );
417        }
418        return true;
419    }
420
421    virtual bool write( OutputStream& os, const osg::Object& obj )
422    {
423        const C& object = OBJECT_CAST<const C&>(obj);
424        const P value = (object.*_getter)();
425        if ( os.isBinary() )
426        {
427            os << static_cast<GLenum>(value);
428        }
429        else if ( ParentType::_defaultValue!=value )
430        {
431            os << os.PROPERTY((ParentType::_name).c_str()) << GLENUM(value) << std::endl;
432        }
433        return true;
434    }
435
436public:
437    Getter _getter;
438    Setter _setter;
439};
440
441template<typename C>
442class StringSerializer : public TemplateSerializer<std::string>
443{
444public:
445    typedef TemplateSerializer<std::string> ParentType;
446    typedef const std::string& (C::*Getter)() const;
447    typedef void (C::*Setter)( const std::string& );
448
449    StringSerializer( const char* name, const std::string& def, Getter gf, Setter sf )
450    : ParentType(name, def), _getter(gf), _setter(sf) {}
451
452    virtual bool read( InputStream& is, osg::Object& obj )
453    {
454        C& object = OBJECT_CAST<C&>(obj);
455        std::string value;
456        if ( is.isBinary() )
457        {
458            is >> value;
459            if ( ParentType::_defaultValue!=value )
460                (object.*_setter)( value );
461        }
462        else if ( is.matchString(ParentType::_name) )
463        {
464            is.readWrappedString( value );
465            if ( !value.empty() )
466                (object.*_setter)( value );
467        }
468        return true;
469    }
470
471    virtual bool write( OutputStream& os, const osg::Object& obj )
472    {
473        const C& object = OBJECT_CAST<const C&>(obj);
474        const std::string& value = (object.*_getter)();
475        if ( os.isBinary() )
476        {
477            os << value;
478        }
479        else if ( ParentType::_defaultValue!=value )
480        {
481            os << os.PROPERTY((ParentType::_name).c_str());
482            os.writeWrappedString( value );
483            os << std::endl;
484        }
485        return true;
486    }
487
488public:
489    Getter _getter;
490    Setter _setter;
491};
492
493template<typename C, typename P>
494class ObjectSerializer : public TemplateSerializer<P*>
495{
496public:
497    typedef TemplateSerializer<P*> ParentType;
498    typedef const P* (C::*Getter)() const;
499    typedef void (C::*Setter)( P* );
500
501    ObjectSerializer( const char* name, P* def, Getter gf, Setter sf )
502    : ParentType(name, def), _getter(gf), _setter(sf) {}
503
504    virtual bool read( InputStream& is, osg::Object& obj )
505    {
506        C& object = OBJECT_CAST<C&>(obj);
507        bool hasObject = false;
508        if ( is.isBinary() )
509        {
510            is >> hasObject;
511            if ( hasObject )
512            {
513                P* value = dynamic_cast<P*>( is.readObject() );
514                if ( ParentType::_defaultValue!=value )
515                    (object.*_setter)( value );
516            }
517        }
518        else if ( is.matchString(ParentType::_name) )
519        {
520            is >> hasObject;
521            if ( hasObject )
522            {
523                is >> is.BEGIN_BRACKET;
524                P* value = dynamic_cast<P*>( is.readObject() );
525                if ( ParentType::_defaultValue!=value )
526                    (object.*_setter)( value );
527                is >> is.END_BRACKET;
528            }
529        }
530        return true;
531    }
532
533    virtual bool write( OutputStream& os, const osg::Object& obj )
534    {
535        const C& object = OBJECT_CAST<const C&>(obj);
536        const P* value = (object.*_getter)();
537        bool hasObject = (value!=NULL);
538        if ( os.isBinary() )
539        {
540            os << hasObject;
541            os.writeObject( value );
542        }
543        else if ( ParentType::_defaultValue!=value )
544        {
545            os << os.PROPERTY((ParentType::_name).c_str()) << hasObject;
546            if ( hasObject )
547            {
548                os << os.BEGIN_BRACKET << std::endl;
549                os.writeObject( value );
550                os << os.END_BRACKET;
551            }
552            os << std::endl;
553        }
554        return true;
555    }
556
557public:
558    Getter _getter;
559    Setter _setter;
560};
561
562template<typename C, typename P>
563class ImageSerializer : public TemplateSerializer<P*>
564{
565public:
566    typedef TemplateSerializer<P*> ParentType;
567    typedef const P* (C::*Getter)() const;
568    typedef void (C::*Setter)( P* );
569
570    ImageSerializer( const char* name, P* def, Getter gf, Setter sf )
571    : ParentType(name, def), _getter(gf), _setter(sf) {}
572
573    virtual bool read( InputStream& is, osg::Object& obj )
574    {
575        C& object = OBJECT_CAST<C&>(obj);
576        bool hasObject = false;
577        if ( is.isBinary() )
578        {
579            is >> hasObject;
580            if ( hasObject )
581            {
582                P* value = dynamic_cast<P*>( is.readImage() );
583                if ( ParentType::_defaultValue!=value )
584                    (object.*_setter)( value );
585            }
586        }
587        else if ( is.matchString(ParentType::_name) )
588        {
589            is >> hasObject;
590            if ( hasObject )
591            {
592                is >> is.BEGIN_BRACKET;
593                P* value = dynamic_cast<P*>( is.readImage() );
594                if ( ParentType::_defaultValue!=value )
595                    (object.*_setter)( value );
596                is >> is.END_BRACKET;
597            }
598        }
599        return true;
600    }
601
602    virtual bool write( OutputStream& os, const osg::Object& obj )
603    {
604        const C& object = OBJECT_CAST<const C&>(obj);
605        const P* value = (object.*_getter)();
606        bool hasObject = (value!=NULL);
607        if ( os.isBinary() )
608        {
609            os << hasObject;
610            os.writeImage( value );
611        }
612        else if ( ParentType::_defaultValue!=value )
613        {
614            os << os.PROPERTY((ParentType::_name).c_str()) << hasObject;
615            if ( hasObject )
616            {
617                os << os.BEGIN_BRACKET << std::endl;
618                os.writeImage( value );
619                os << os.END_BRACKET;
620            }
621            os << std::endl;
622        }
623        return true;
624    }
625
626public:
627    Getter _getter;
628    Setter _setter;
629};
630
631template<typename C, typename P, typename B>
632class EnumSerializer : public TemplateSerializer<P>
633{
634public:
635    typedef TemplateSerializer<P> ParentType;
636    typedef P (C::*Getter)() const;
637    typedef B (C::*Setter)( P );
638
639    EnumSerializer( const char* name, P def, Getter gf, Setter sf )
640    : ParentType(name, def), _getter(gf), _setter(sf) {}
641
642    void add( const char* str, P value )
643    { _lookup.add(str, static_cast<IntLookup::Value>(value)); }
644
645    P getValue( const char* str )
646    { return static_cast<P>(_lookup.getValue(str)); }
647
648    const std::string& getString( P value )
649    { return _lookup.getString(static_cast<IntLookup::Value>(value)); }
650
651    virtual bool read( InputStream& is, osg::Object& obj )
652    {
653        C& object = OBJECT_CAST<C&>(obj);
654        IntLookup::Value value;
655        if ( is.isBinary() )
656        {
657            is >> value;
658            if ( ParentType::_defaultValue!=static_cast<P>(value) )
659                (object.*_setter)( static_cast<P>(value) );
660        }
661        else if ( is.matchString(ParentType::_name) )
662        {
663            std::string str; is >> str;
664            (object.*_setter)( getValue(str.c_str()) );
665        }
666        return true;
667    }
668
669    virtual bool write( osgDB::OutputStream& os, const osg::Object& obj )
670    {
671        const C& object = OBJECT_CAST<const C&>(obj);
672        const P value = (object.*_getter)();
673        if ( os.isBinary() )
674        {
675            os << (IntLookup::Value)value;
676        }
677        else if ( ParentType::_defaultValue!=value )
678        {
679            os << os.PROPERTY((ParentType::_name).c_str()) << getString(value) << std::endl;
680        }
681        return true;
682    }
683
684public:
685    Getter _getter;
686    Setter _setter;
687
688protected:
689    IntLookup _lookup;
690};
691
692
693template<typename C, typename P>
694class ListSerializer : public BaseSerializer
695{
696public:
697    typedef typename P::value_type ValueType;
698    typedef typename P::const_iterator ConstIterator;
699    typedef const P& (C::*Getter)() const;
700    typedef void (C::*Setter)( const P& );
701
702    ListSerializer( const char* name, Getter gf, Setter sf )
703    : _name(name), _getter(gf), _setter(sf) {}
704
705    virtual const std::string& getName() const { return _name; }
706
707    virtual bool read( InputStream& is, osg::Object& obj )
708    {
709        C& object = OBJECT_CAST<C&>(obj);
710        unsigned int size = 0;
711        P list;
712        if ( is.isBinary() )
713        {
714            is >> size;
715            for ( unsigned int i=0; i<size; ++i )
716            {
717                ValueType value;
718                is >> value;
719                list.push_back( value );
720            }
721            if ( size>0 ) (object.*_setter)( list );
722        }
723        else if ( is.matchString(_name) )
724        {
725            is >> size;
726            if ( size>0 ) is >> is.BEGIN_BRACKET;
727            for ( unsigned int i=0; i<size; ++i )
728            {
729                ValueType value;
730                is >> value;
731                list.push_back( value );
732            }
733            if ( size>0 )
734            {
735                is >> is.END_BRACKET;
736                (object.*_setter)( list );
737            }
738        }
739        return true;
740    }
741
742    virtual bool write( OutputStream& os, const osg::Object& obj )
743    {
744        const C& object = OBJECT_CAST<const C&>(obj);
745        const P& list = (object.*_getter)();
746        unsigned int size = (unsigned int)list.size();
747        if ( os.isBinary() )
748        {
749            os << size;
750            for ( ConstIterator itr=list.begin();
751                  itr!=list.end(); ++itr )
752            {
753                os << (*itr);
754            }
755        }
756        else if ( size>0 )
757        {
758            os << os.PROPERTY((_name).c_str()) << size << os.BEGIN_BRACKET << std::endl;
759            for ( ConstIterator itr=list.begin();
760                  itr!=list.end(); ++itr )
761            {
762                os << (*itr);
763            }
764            os << std::endl;
765            os << os.END_BRACKET << std::endl;
766        }
767        return true;
768    }
769
770public:
771    std::string _name;
772    Getter _getter;
773    Setter _setter;
774};
775
776// ADDING MANIPULATORS
777#define ADD_SERIALIZER(S) \
778    wrapper->addSerializer( (S) )
779
780#define ADD_USER_SERIALIZER(PROP) \
781    wrapper->addSerializer( new osgDB::UserSerializer<MyClass>( \
782        #PROP, &check##PROP, &read##PROP, &write##PROP), osgDB::BaseSerializer::RW_USER )
783
784#define ADD_BOOL_SERIALIZER(PROP, DEF) \
785    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, bool >( \
786        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_BOOL )
787
788#define ADD_CHAR_SERIALIZER(PROP, DEF) \
789    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, char >( \
790        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_CHAR )
791
792#define ADD_UCHAR_SERIALIZER(PROP, DEF) \
793    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, unsigned char >( \
794        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_UCHAR )
795
796#define ADD_SHORT_SERIALIZER(PROP, DEF) \
797    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, short >( \
798        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_SHORT )
799
800#define ADD_USHORT_SERIALIZER(PROP, DEF) \
801    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, unsigned short >( \
802        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_USHORT )
803
804#define ADD_HEXSHORT_SERIALIZER(PROP, DEF) \
805    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, unsigned short >( \
806        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP, true), osgDB::BaseSerializer::RW_USHORT )
807
808#define ADD_INT_SERIALIZER(PROP, DEF) \
809    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, int >( \
810        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_INT )
811
812#define ADD_UINT_SERIALIZER(PROP, DEF) \
813    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, unsigned int >( \
814        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_UINT )
815
816#define ADD_GLINT_SERIALIZER(PROP, DEF) \
817    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, GLint >( \
818        #PROP, ((int)(DEF)), &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_INT )
819
820#define ADD_HEXINT_SERIALIZER(PROP, DEF) \
821    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, unsigned int >( \
822        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP, true), osgDB::BaseSerializer::RW_UINT )
823
824#define ADD_FLOAT_SERIALIZER(PROP, DEF) \
825    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, float >( \
826        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_FLOAT )
827
828#define ADD_DOUBLE_SERIALIZER(PROP, DEF) \
829    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, double >( \
830        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_DOUBLE )
831
832#define ADD_REF_BOOL_SERIALIZER(PROP, DEF) \
833    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, bool >( \
834        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_BOOL )
835
836#define ADD_REF_CHAR_SERIALIZER(PROP, DEF) \
837    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, char >( \
838        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_CHAR )
839
840#define ADD_REF_UCHAR_SERIALIZER(PROP, DEF) \
841    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, unsigned char >( \
842        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_UCHAR )
843
844#define ADD_REF_SHORT_SERIALIZER(PROP, DEF) \
845    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, short >( \
846        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_SHORT )
847
848#define ADD_REF_USHORT_SERIALIZER(PROP, DEF) \
849    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, unsigned short >( \
850        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_USHORT )
851
852#define ADD_REF_HEXSHORT_SERIALIZER(PROP, DEF) \
853    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, unsigned short >( \
854        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP, true), osgDB::BaseSerializer::RW_USHORT )
855
856#define ADD_REF_INT_SERIALIZER(PROP, DEF) \
857    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, int >( \
858        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_INT )
859
860#define ADD_REF_UINT_SERIALIZER(PROP, DEF) \
861    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, unsigned int >( \
862        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_UINT )
863
864#define ADD_REF_GLINT_SERIALIZER(PROP, DEF) \
865    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, GLint >( \
866        #PROP, ((int)(DEF)), &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_INT )
867
868#define ADD_REF_HEXINT_SERIALIZER(PROP, DEF) \
869    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, unsigned int >( \
870        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP, true), osgDB::BaseSerializer::RW_UINT )
871
872#define ADD_REF_FLOAT_SERIALIZER(PROP, DEF) \
873    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, float >( \
874        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_FLOAT )
875
876#define ADD_REF_DOUBLE_SERIALIZER(PROP, DEF) \
877    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, double >( \
878        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_DOUBLE )
879
880
881#define ADD_VEC2B_SERIALIZER(PROP, DEF) \
882    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec2b >( \
883        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC2B )
884
885#define ADD_VEC2UB_SERIALIZER(PROP, DEF) \
886    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec2ub >( \
887        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC2UB )
888
889#define ADD_VEC2S_SERIALIZER(PROP, DEF) \
890    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec2s >( \
891        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC2S )
892
893#define ADD_VEC2US_SERIALIZER(PROP, DEF) \
894    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec2us >( \
895        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC2US )
896
897#define ADD_VEC2I_SERIALIZER(PROP, DEF) \
898    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec2i >( \
899        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC2I )
900
901#define ADD_VEC2UI_SERIALIZER(PROP, DEF) \
902    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec2ui >( \
903        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC2UI )
904
905#define ADD_VEC2F_SERIALIZER(PROP, DEF) \
906    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec2f >( \
907        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC2F )
908
909#define ADD_VEC2D_SERIALIZER(PROP, DEF) \
910    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec2d >( \
911        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC2D )
912
913#define ADD_VEC2_SERIALIZER(PROP, DEF) ADD_VEC2F_SERIALIZER(PROP, DEF)
914
915
916#define ADD_VEC3B_SERIALIZER(PROP, DEF) \
917    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec3b >( \
918        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC3B )
919
920#define ADD_VEC3UB_SERIALIZER(PROP, DEF) \
921    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec3ub >( \
922        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC3UB )
923
924#define ADD_VEC3S_SERIALIZER(PROP, DEF) \
925    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec3s >( \
926        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC3S )
927
928#define ADD_VEC3US_SERIALIZER(PROP, DEF) \
929    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec3us >( \
930        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC3US )
931
932#define ADD_VEC3I_SERIALIZER(PROP, DEF) \
933    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec3i >( \
934        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC3I )
935
936#define ADD_VEC3UI_SERIALIZER(PROP, DEF) \
937    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec3ui >( \
938        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC3UI )
939
940#define ADD_VEC3F_SERIALIZER(PROP, DEF) \
941    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec3f >( \
942        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC3F )
943
944#define ADD_VEC3D_SERIALIZER(PROP, DEF) \
945    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec3d >( \
946        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC3D )
947
948#define ADD_VEC3_SERIALIZER(PROP, DEF) ADD_VEC3F_SERIALIZER(PROP, DEF)
949
950#define ADD_VEC4B_SERIALIZER(PROP, DEF) \
951    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec4b >( \
952        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC4B )
953
954#define ADD_VEC4UB_SERIALIZER(PROP, DEF) \
955    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec4ub >( \
956        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC4UB )
957
958#define ADD_VEC4S_SERIALIZER(PROP, DEF) \
959    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec4s >( \
960        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC4S )
961
962#define ADD_VEC4US_SERIALIZER(PROP, DEF) \
963    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec4us >( \
964        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC4US )
965
966#define ADD_VEC4I_SERIALIZER(PROP, DEF) \
967    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec4i >( \
968        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC4I )
969
970#define ADD_VEC4UI_SERIALIZER(PROP, DEF) \
971    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec4ui >( \
972        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC4UI )
973
974#define ADD_VEC4F_SERIALIZER(PROP, DEF) \
975    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec4f >( \
976        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC4F )
977
978#define ADD_VEC4D_SERIALIZER(PROP, DEF) \
979    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec4d >( \
980        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC4D )
981
982#define ADD_VEC4_SERIALIZER(PROP, DEF) ADD_VEC4F_SERIALIZER(PROP, DEF)
983
984#define ADD_QUAT_SERIALIZER(PROP, DEF) \
985    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Quat >( \
986        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_QUAT )
987
988#define ADD_PLANE_SERIALIZER(PROP, DEF) \
989    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Plane >( \
990        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_PLANE )
991
992#define ADD_MATRIXF_SERIALIZER(PROP, DEF) \
993    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Matrixf >( \
994        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_MATRIXF )
995
996#define ADD_MATRIXD_SERIALIZER(PROP, DEF) \
997    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Matrixd >( \
998        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_MATRIXD )
999
1000#define ADD_MATRIX_SERIALIZER(PROP, DEF) \
1001    wrapper->addSerializer( new osgDB::MatrixSerializer< MyClass >( \
1002        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_MATRIX )
1003
1004#define ADD_GLENUM_SERIALIZER(PROP, TYPE, DEF) \
1005    wrapper->addSerializer( new osgDB::GLenumSerializer< MyClass, TYPE >( \
1006        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_GLENUM )
1007
1008#define ADD_STRING_SERIALIZER(PROP, DEF) \
1009    wrapper->addSerializer( new osgDB::StringSerializer< MyClass >( \
1010        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_STRING )
1011
1012#define ADD_OBJECT_SERIALIZER(PROP, TYPE, DEF) \
1013    wrapper->addSerializer( new osgDB::ObjectSerializer< MyClass, TYPE >( \
1014        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_OBJECT )
1015
1016#define ADD_IMAGE_SERIALIZER(PROP, TYPE, DEF) \
1017    wrapper->addSerializer( new osgDB::ImageSerializer< MyClass, TYPE >( \
1018        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_IMAGE )
1019
1020#define ADD_LIST_SERIALIZER(PROP, TYPE) \
1021    wrapper->addSerializer( new osgDB::ListSerializer< MyClass, TYPE >( \
1022        #PROP, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_LIST )
1023
1024#define BEGIN_ENUM_SERIALIZER(PROP, DEF) \
1025    { typedef osgDB::EnumSerializer<MyClass, MyClass::PROP, void> MySerializer; \
1026    osg::ref_ptr<MySerializer> serializer = new MySerializer( \
1027        #PROP, MyClass::DEF, &MyClass::get##PROP, &MyClass::set##PROP)
1028
1029#define BEGIN_ENUM_SERIALIZER2(PROP, TYPE, DEF) \
1030    { typedef osgDB::EnumSerializer<MyClass, TYPE, void> MySerializer; \
1031    osg::ref_ptr<MySerializer> serializer = new MySerializer( \
1032        #PROP, MyClass::DEF, &MyClass::get##PROP, &MyClass::set##PROP)
1033
1034#define BEGIN_ENUM_SERIALIZER3(PROP, DEF) \
1035    { typedef osgDB::EnumSerializer<MyClass, MyClass::PROP, bool> MySerializer; \
1036    osg::ref_ptr<MySerializer> serializer = new MySerializer( \
1037        #PROP, MyClass::DEF, &MyClass::get##PROP, &MyClass::set##PROP)
1038
1039#define BEGIN_ENUM_SERIALIZER4(PROPERTIES_CLASS, PROP, DEF) \
1040    { typedef osgDB::EnumSerializer<MyClass, PROPERTIES_CLASS::PROP, void> MySerializer; \
1041    osg::ref_ptr<MySerializer> serializer = new MySerializer( \
1042        #PROP, PROPERTIES_CLASS::DEF, &MyClass::get##PROP, &MyClass::set##PROP)
1043
1044#define ADD_ENUM_VALUE(VALUE) \
1045    serializer->add(#VALUE, MyClass::VALUE)
1046
1047#define ADD_ENUM_CLASS_VALUE(CLASS, VALUE) \
1048    serializer->add(#VALUE, CLASS::VALUE)
1049
1050#define END_ENUM_SERIALIZER() \
1051    wrapper->addSerializer(serializer.get(), osgDB::BaseSerializer::RW_ENUM); }
1052
1053// VERSION CONTROL OPERATORS
1054#define UPDATE_TO_VERSION(VER) \
1055    wrapper->setUpdatedVersion( (VER) );
1056
1057#define UPDATE_TO_VERSION_SCOPED(VER) \
1058    osgDB::UpdateWrapperVersionProxy uwvp(wrapper, (VER));
1059
1060#define REMOVE_SERIALIZER(PROP) \
1061    wrapper->markSerializerAsRemoved( #PROP );
1062
1063}
1064
1065#endif
Note: See TracBrowser for help on using the browser.