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

Revision 11903, 29.6 kB (checked in by robert, 3 years ago)

Refactored the versioning of serializers so it now uses a _firstVersion and _lastVersion make it possible
to specify what range of versions support each serializer.

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 _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_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    };
129
130    BaseSerializer() : _firstVersion(0), _lastVersion(INT_MAX) {}
131
132    virtual bool read( InputStream&, osg::Object& ) = 0;
133    virtual bool write( OutputStream&, const osg::Object& ) = 0;
134    virtual const std::string& getName() const = 0;
135
136protected:
137    int _firstVersion;  // Library version when the serializer is first introduced
138    int _lastVersion;  // Library version when the serializer is last required.
139};
140
141template<typename C>
142class UserSerializer : public BaseSerializer
143{
144public:
145    typedef bool (*Checker)( const C& );
146    typedef bool (*Reader)( InputStream&, C& );
147    typedef bool (*Writer)( OutputStream&, const C& );
148   
149    UserSerializer( const char* name, Checker cf, Reader rf, Writer wf )
150    : _name(name), _checker(cf), _reader(rf), _writer(wf) {}
151   
152    virtual bool read( InputStream& is, osg::Object& obj )
153    {
154        C& object = OBJECT_CAST<C&>(obj);
155        if ( is.isBinary() )
156        {
157            bool ok = false; is >> ok;
158            if ( !ok ) return true;
159        }
160        else
161        {
162            if ( !is.matchString(_name) )
163                return true;
164        }
165        return (*_reader)(is, object);
166    }
167   
168    virtual bool write( OutputStream& os, const osg::Object& obj )
169    {
170        const C& object = OBJECT_CAST<const C&>(obj);
171        bool ok = (*_checker)(object);
172        if ( os.isBinary() )
173        {
174            os << ok;
175            if ( !ok ) return true;
176        }
177        else
178        {
179            if ( !ok ) return true;
180            os << PROPERTY(_name.c_str());
181        }
182        return (*_writer)(os, object);
183    }
184   
185    virtual const std::string& getName() const { return _name; }
186   
187protected:
188    std::string _name;
189    Checker _checker;
190   
191public:
192    Reader _reader;
193    Writer _writer;
194};
195
196template<typename P>
197class TemplateSerializer : public BaseSerializer
198{
199public:
200    TemplateSerializer( const char* name )
201    : _name(name) {}
202   
203    virtual bool read( InputStream& is, osg::Object& obj ) = 0;
204    virtual bool write( OutputStream& os, const osg::Object& obj ) = 0;
205    virtual const std::string& getName() const { return _name; }
206   
207protected:
208    std::string _name;
209    P _defaultValue;
210};
211
212template<typename C, typename P>
213class PropByValSerializer : public TemplateSerializer<P>
214{
215public:
216    typedef TemplateSerializer<P> ParentType;
217    typedef P (C::*Getter)() const;
218    typedef void (C::*Setter)( P );
219   
220    PropByValSerializer( const char* name, P def, Getter gf, Setter sf, bool useHex=false )
221    : ParentType(name), _getter(gf), _setter(sf), _useHex(useHex)
222     { ParentType::_defaultValue = def; }
223   
224    virtual bool read( InputStream& is, osg::Object& obj )
225    {
226        C& object = OBJECT_CAST<C&>(obj);
227        P value;
228        if ( is.isBinary() )
229        {
230            is >> value;
231            if ( ParentType::_defaultValue!=value )
232                (object.*_setter)( value );
233        }
234        else if ( is.matchString(ParentType::_name) )
235        {
236            if ( _useHex ) is >> std::hex;
237            is >> value;
238            if ( _useHex ) is >> std::dec;
239            (object.*_setter)( value );
240        }
241        return true;
242    }
243   
244    virtual bool write( OutputStream& os, const osg::Object& obj )
245    {
246        const C& object = OBJECT_CAST<const C&>(obj);
247        P value = (object.*_getter)();
248        if ( os.isBinary() )
249        {
250            os << value;
251        }
252        else if ( ParentType::_defaultValue!=value )
253        {
254            os << PROPERTY((ParentType::_name).c_str());
255            if ( _useHex ) os << std::hex;
256            os << value;
257            if ( _useHex ) os << std::dec;
258            os << std::endl;
259        }
260        return true;
261    }
262   
263public:
264    Getter _getter;
265    Setter _setter;
266   
267protected:
268    bool _useHex;
269};
270
271template<typename C, typename P>
272class PropByRefSerializer : public TemplateSerializer<P>
273{
274public:
275    typedef TemplateSerializer<P> ParentType;
276    typedef const P& CP;
277    typedef CP (C::*Getter)() const;
278    typedef void (C::*Setter)( CP );
279   
280    PropByRefSerializer( const char* name, CP def, Getter gf, Setter sf )
281    : ParentType(name), _getter(gf), _setter(sf)
282     { ParentType::_defaultValue = def; }
283   
284    virtual bool read( InputStream& is, osg::Object& obj )
285    {
286        C& object = OBJECT_CAST<C&>(obj);
287        P value;
288        if ( is.isBinary() )
289        {
290            is >> value;
291            if ( ParentType::_defaultValue!=value )
292                (object.*_setter)( value );
293        }
294        else if ( is.matchString(ParentType::_name) )
295        {
296            is >> value;
297            (object.*_setter)( value );
298        }
299        return true;
300    }
301   
302    virtual bool write( OutputStream& os, const osg::Object& obj )
303    {
304        const C& object = OBJECT_CAST<const C&>(obj);
305        CP value = (object.*_getter)();
306        if ( os.isBinary() )
307        {
308            os << value;
309        }
310        else if ( ParentType::_defaultValue!=value )
311        {
312            os << PROPERTY((ParentType::_name).c_str()) << value << std::endl;
313        }
314        return true;
315    }
316   
317public:
318    Getter _getter;
319    Setter _setter;
320};
321
322template<typename C>
323class MatrixSerializer : public TemplateSerializer<osg::Matrix>
324{
325public:
326    typedef TemplateSerializer<osg::Matrix> ParentType;
327    typedef const osg::Matrix& (C::*Getter)() const;
328    typedef void (C::*Setter)( const osg::Matrix& );
329   
330    MatrixSerializer( const char* name, const osg::Matrix& def, Getter gf, Setter sf )
331    : ParentType(name), _getter(gf), _setter(sf)
332     { ParentType::_defaultValue = def; }
333   
334    virtual bool read( InputStream& is, osg::Object& obj )
335    {
336        C& object = OBJECT_CAST<C&>(obj);
337        osg::Matrix value;
338        if ( is.isBinary() )
339        {
340            readMatrixImplementation( is, value );
341            if ( ParentType::_defaultValue!=value )
342                (object.*_setter)( value );
343        }
344        else if ( is.matchString(ParentType::_name) )
345        {
346            readMatrixImplementation( is, value );
347            (object.*_setter)( value );
348        }
349        return true;
350    }
351   
352    virtual bool write( OutputStream& os, const osg::Object& obj )
353    {
354
355        const C& object = OBJECT_CAST<const C&>(obj);
356        const osg::Matrix& value = (object.*_getter)();
357        if ( os.isBinary() )
358        {
359            OSG_NOTICE<<"MatrixSerializer::write() binary"<<std::endl;
360            os << value;
361        }
362        else if ( ParentType::_defaultValue!=value )
363        {
364            OSG_NOTICE<<"MatrixSerializer::write() ascii, ParentType::_name="<<ParentType::_name<<std::endl;
365            os << PROPERTY((ParentType::_name).c_str()) << value << std::endl;
366        }
367        return true;
368    }
369   
370protected:
371    void readMatrixImplementation( InputStream& is, osg::Matrix& matrix )
372    {
373#if 1
374        is >> matrix;
375#else
376        if ( is.getUseFloatMatrix() )
377        {
378            osg::Matrixf realValue; is >> realValue;
379            matrix = realValue;
380        }
381        else
382        {
383            osg::Matrixd realValue; is >> realValue;
384            matrix = realValue;
385        }
386#endif
387    }
388   
389public:
390    Getter _getter;
391    Setter _setter;
392};
393
394template<typename C, typename P>
395class GLenumSerializer : public TemplateSerializer<P>
396{
397public:
398    typedef TemplateSerializer<P> ParentType;
399    typedef P (C::*Getter)() const;
400    typedef void (C::*Setter)( P );
401   
402    GLenumSerializer( const char* name, P def, Getter gf, Setter sf )
403    : ParentType(name), _getter(gf), _setter(sf)
404     { ParentType::_defaultValue = def; }
405   
406    virtual bool read( InputStream& is, osg::Object& obj )
407    {
408        C& object = OBJECT_CAST<C&>(obj);
409        if ( is.isBinary() )
410        {
411            GLenum value; is >> value;
412            if ( ParentType::_defaultValue!=static_cast<P>(value) )
413                (object.*_setter)( static_cast<P>(value) );
414        }
415        else if ( is.matchString(ParentType::_name) )
416        {
417            DEF_GLENUM(value); is >> value;
418            (object.*_setter)( static_cast<P>(value.get()) );
419        }
420        return true;
421    }
422   
423    virtual bool write( OutputStream& os, const osg::Object& obj )
424    {
425        const C& object = OBJECT_CAST<const C&>(obj);
426        const P value = (object.*_getter)();
427        if ( os.isBinary() )
428        {
429            os << static_cast<GLenum>(value);
430        }
431        else if ( ParentType::_defaultValue!=value )
432        {
433            os << PROPERTY((ParentType::_name).c_str()) << GLENUM(value) << std::endl;
434        }
435        return true;
436    }
437   
438public:
439    Getter _getter;
440    Setter _setter;
441};
442
443template<typename C>
444class StringSerializer : public TemplateSerializer<std::string>
445{
446public:
447    typedef TemplateSerializer<std::string> ParentType;
448    typedef const std::string& (C::*Getter)() const;
449    typedef void (C::*Setter)( const std::string& );
450   
451    StringSerializer( const char* name, const std::string& def, Getter gf, Setter sf )
452    : ParentType(name), _getter(gf), _setter(sf)
453     { ParentType::_defaultValue = def; }
454   
455    virtual bool read( InputStream& is, osg::Object& obj )
456    {
457        C& object = OBJECT_CAST<C&>(obj);
458        std::string value;
459        if ( is.isBinary() )
460        {
461            is >> value;
462            if ( ParentType::_defaultValue!=value )
463                (object.*_setter)( value );
464        }
465        else if ( is.matchString(ParentType::_name) )
466        {
467            is.readWrappedString( value );
468            if ( !value.empty() )
469                (object.*_setter)( value );
470        }
471        return true;
472    }
473   
474    virtual bool write( OutputStream& os, const osg::Object& obj )
475    {
476        const C& object = OBJECT_CAST<const C&>(obj);
477        const std::string& value = (object.*_getter)();
478        if ( os.isBinary() )
479        {
480            os << value;
481        }
482        else if ( ParentType::_defaultValue!=value )
483        {
484            os << PROPERTY((ParentType::_name).c_str());
485            os.writeWrappedString( value );
486            os << std::endl;
487        }
488        return true;
489    }
490   
491public:
492    Getter _getter;
493    Setter _setter;
494};
495
496template<typename C, typename P>
497class ObjectSerializer : public TemplateSerializer<P*>
498{
499public:
500    typedef TemplateSerializer<P*> ParentType;
501    typedef const P* (C::*Getter)() const;
502    typedef void (C::*Setter)( P* );
503   
504    ObjectSerializer( const char* name, P* def, Getter gf, Setter sf )
505    : ParentType(name), _getter(gf), _setter(sf)
506     { ParentType::_defaultValue = def; }
507   
508    virtual bool read( InputStream& is, osg::Object& obj )
509    {
510        C& object = OBJECT_CAST<C&>(obj);
511        bool hasObject = false;
512        if ( is.isBinary() )
513        {
514            is >> hasObject;
515            if ( hasObject )
516            {
517                P* value = dynamic_cast<P*>( is.readObject() );
518                if ( ParentType::_defaultValue!=value )
519                    (object.*_setter)( value );
520            }
521        }
522        else if ( is.matchString(ParentType::_name) )
523        {
524            is >> hasObject;
525            if ( hasObject )
526            {
527                is >> BEGIN_BRACKET;
528                P* value = dynamic_cast<P*>( is.readObject() );
529                if ( ParentType::_defaultValue!=value )
530                    (object.*_setter)( value );
531                is >> END_BRACKET;
532            }
533        }
534        return true;
535    }
536   
537    virtual bool write( OutputStream& os, const osg::Object& obj )
538    {
539        const C& object = OBJECT_CAST<const C&>(obj);
540        const P* value = (object.*_getter)();
541        bool hasObject = (value!=NULL);
542        if ( os.isBinary() )
543        {
544            os << hasObject;
545            os.writeObject( value );
546        }
547        else if ( ParentType::_defaultValue!=value )
548        {
549            os << PROPERTY((ParentType::_name).c_str()) << hasObject;
550            if ( hasObject )
551            {
552                os << BEGIN_BRACKET << std::endl;
553                os.writeObject( value );
554                os << END_BRACKET;
555            }
556            os << std::endl;
557        }
558        return true;
559    }
560   
561public:
562    Getter _getter;
563    Setter _setter;
564};
565
566template<typename C, typename P>
567class ImageSerializer : public TemplateSerializer<P*>
568{
569public:
570    typedef TemplateSerializer<P*> ParentType;
571    typedef const P* (C::*Getter)() const;
572    typedef void (C::*Setter)( P* );
573   
574    ImageSerializer( const char* name, P* def, Getter gf, Setter sf )
575    : ParentType(name), _getter(gf), _setter(sf)
576     { ParentType::_defaultValue = def; }
577   
578    virtual bool read( InputStream& is, osg::Object& obj )
579    {
580        C& object = OBJECT_CAST<C&>(obj);
581        bool hasObject = false;
582        if ( is.isBinary() )
583        {
584            is >> hasObject;
585            if ( hasObject )
586            {
587                P* value = dynamic_cast<P*>( is.readImage() );
588                if ( ParentType::_defaultValue!=value )
589                    (object.*_setter)( value );
590            }
591        }
592        else if ( is.matchString(ParentType::_name) )
593        {
594            is >> hasObject;
595            if ( hasObject )
596            {
597                is >> BEGIN_BRACKET;
598                P* value = dynamic_cast<P*>( is.readImage() );
599                if ( ParentType::_defaultValue!=value )
600                    (object.*_setter)( value );
601                is >> END_BRACKET;
602            }
603        }
604        return true;
605    }
606   
607    virtual bool write( OutputStream& os, const osg::Object& obj )
608    {
609        const C& object = OBJECT_CAST<const C&>(obj);
610        const P* value = (object.*_getter)();
611        bool hasObject = (value!=NULL);
612        if ( os.isBinary() )
613        {
614            os << hasObject;
615            os.writeImage( value );
616        }
617        else if ( ParentType::_defaultValue!=value )
618        {
619            os << PROPERTY((ParentType::_name).c_str()) << hasObject;
620            if ( hasObject )
621            {
622                os << BEGIN_BRACKET << std::endl;
623                os.writeImage( value );
624                os << END_BRACKET;
625            }
626            os << std::endl;
627        }
628        return true;
629    }
630   
631public:
632    Getter _getter;
633    Setter _setter;
634};
635
636template<typename C, typename P, typename B>
637class EnumSerializer : public TemplateSerializer<P>
638{
639public:
640    typedef TemplateSerializer<P> ParentType;
641    typedef P (C::*Getter)() const;
642    typedef B (C::*Setter)( P );
643   
644    EnumSerializer( const char* name, P def, Getter gf, Setter sf )
645    : ParentType(name), _getter(gf), _setter(sf)
646     { ParentType::_defaultValue = def; }
647   
648    void add( const char* str, P value )
649    { _lookup.add(str, static_cast<IntLookup::Value>(value)); }
650   
651    P getValue( const char* str )
652    { return static_cast<P>(_lookup.getValue(str)); }
653   
654    const std::string& getString( P value )
655    { return _lookup.getString(static_cast<IntLookup::Value>(value)); }
656   
657    virtual bool read( InputStream& is, osg::Object& obj )
658    {
659        C& object = OBJECT_CAST<C&>(obj);
660        IntLookup::Value value;
661        if ( is.isBinary() )
662        {
663            is >> value;
664            if ( ParentType::_defaultValue!=static_cast<P>(value) )
665                (object.*_setter)( static_cast<P>(value) );
666        }
667        else if ( is.matchString(ParentType::_name) )
668        {
669            std::string str; is >> str;
670            (object.*_setter)( getValue(str.c_str()) );
671        }
672        return true;
673    }
674   
675    virtual bool write( osgDB::OutputStream& os, const osg::Object& obj )
676    {
677        const C& object = OBJECT_CAST<const C&>(obj);
678        const P value = (object.*_getter)();
679        if ( os.isBinary() )
680        {
681            os << (IntLookup::Value)value;
682        }
683        else if ( ParentType::_defaultValue!=value )
684        {
685            os << PROPERTY((ParentType::_name).c_str()) << getString(value) << std::endl;
686        }
687        return true;
688    }
689   
690public:
691    Getter _getter;
692    Setter _setter;
693   
694protected:
695    IntLookup _lookup;
696};
697
698template<typename C, typename P>
699class ListSerializer : public TemplateSerializer<P>
700{
701public:
702    typedef TemplateSerializer<P> ParentType;
703    typedef typename P::value_type ValueType;
704    typedef typename P::const_iterator ConstIterator;
705    typedef const P& (C::*Getter)() const;
706    typedef void (C::*Setter)( const P& );
707   
708    ListSerializer( const char* name, Getter gf, Setter sf )
709    : ParentType(name), _getter(gf), _setter(sf) {}
710   
711    virtual bool read( InputStream& is, osg::Object& obj )
712    {
713        C& object = OBJECT_CAST<C&>(obj);
714        unsigned int size = 0;
715        P list;
716        if ( is.isBinary() )
717        {
718            is >> size;
719            for ( unsigned int i=0; i<size; ++i )
720            {
721                ValueType value;
722                is >> value;
723                list.push_back( value );
724            }
725            if ( size>0 ) (object.*_setter)( list );
726        }
727        else if ( is.matchString(ParentType::_name) )
728        {
729            is >> size;
730            if ( size>0 ) is >> BEGIN_BRACKET;
731            for ( unsigned int i=0; i<size; ++i )
732            {
733                ValueType value;
734                is >> value;
735                list.push_back( value );
736            }
737            if ( size>0 )
738            {
739                is >> END_BRACKET;
740                (object.*_setter)( list );
741            }
742        }
743        return true;
744    }
745   
746    virtual bool write( OutputStream& os, const osg::Object& obj )
747    {
748        const C& object = OBJECT_CAST<const C&>(obj);
749        const P& list = (object.*_getter)();
750        unsigned int size = (unsigned int)list.size();
751        if ( os.isBinary() )
752        {
753            os << size;
754            for ( ConstIterator itr=list.begin();
755                  itr!=list.end(); ++itr )
756            {
757                os << (*itr);
758            }
759        }
760        else if ( size>0 )
761        {
762            os << PROPERTY((ParentType::_name).c_str()) << size << BEGIN_BRACKET << std::endl;
763            for ( ConstIterator itr=list.begin();
764                  itr!=list.end(); ++itr )
765            {
766                os << (*itr);
767            }
768            os << std::endl;
769            os << END_BRACKET << std::endl;
770        }
771        return true;
772    }
773   
774public:
775    Getter _getter;
776    Setter _setter;
777};
778
779// ADDING MANIPULATORS
780#define ADD_SERIALIZER(S) \
781    wrapper->addSerializer( (S) )
782
783#define ADD_USER_SERIALIZER(PROP) \
784    wrapper->addSerializer( new osgDB::UserSerializer<MyClass>( \
785        #PROP, &check##PROP, &read##PROP, &write##PROP), osgDB::BaseSerializer::RW_USER )
786
787#define ADD_BOOL_SERIALIZER(PROP, DEF) \
788    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, bool >( \
789        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_BOOL )
790
791#define ADD_SHORT_SERIALIZER(PROP, DEF) \
792    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, short >( \
793        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_SHORT )
794
795#define ADD_USHORT_SERIALIZER(PROP, DEF) \
796    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, unsigned short >( \
797        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_USHORT )
798
799#define ADD_HEXSHORT_SERIALIZER(PROP, DEF) \
800    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, unsigned short >( \
801        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP, true), osgDB::BaseSerializer::RW_USHORT )
802
803#define ADD_INT_SERIALIZER(PROP, DEF) \
804    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, int >( \
805        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_INT )
806
807#define ADD_UINT_SERIALIZER(PROP, DEF) \
808    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, unsigned int >( \
809        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_UINT )
810       
811#define ADD_GLINT_SERIALIZER(PROP, DEF) \
812    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, GLint >( \
813        #PROP, ((int)(DEF)), &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_INT )
814
815#define ADD_HEXINT_SERIALIZER(PROP, DEF) \
816    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, unsigned int >( \
817        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP, true), osgDB::BaseSerializer::RW_UINT )
818
819#define ADD_FLOAT_SERIALIZER(PROP, DEF) \
820    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, float >( \
821        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_FLOAT )
822
823#define ADD_DOUBLE_SERIALIZER(PROP, DEF) \
824    wrapper->addSerializer( new osgDB::PropByValSerializer< MyClass, double >( \
825        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_DOUBLE )
826
827#define ADD_VEC2F_SERIALIZER(PROP, DEF) \
828    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec2f >( \
829        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC2F )
830
831#define ADD_VEC2D_SERIALIZER(PROP, DEF) \
832    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec2d >( \
833        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC2D )
834
835#define ADD_VEC2_SERIALIZER(PROP, DEF) ADD_VEC2F_SERIALIZER(PROP, DEF)
836
837#define ADD_VEC3F_SERIALIZER(PROP, DEF) \
838    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec3f >( \
839        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC3F )
840
841#define ADD_VEC3D_SERIALIZER(PROP, DEF) \
842    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec3d >( \
843        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC3D )
844
845#define ADD_VEC3_SERIALIZER(PROP, DEF) ADD_VEC3F_SERIALIZER(PROP, DEF)
846
847#define ADD_VEC4F_SERIALIZER(PROP, DEF) \
848    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec4f >( \
849        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC4F )
850
851#define ADD_VEC4D_SERIALIZER(PROP, DEF) \
852    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Vec4d >( \
853        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_VEC4D )
854
855#define ADD_VEC4_SERIALIZER(PROP, DEF) ADD_VEC4F_SERIALIZER(PROP, DEF)
856
857#define ADD_QUAT_SERIALIZER(PROP, DEF) \
858    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Quat >( \
859        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_QUAT )
860
861#define ADD_PLANE_SERIALIZER(PROP, DEF) \
862    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Plane >( \
863        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_PLANE )
864
865#define ADD_MATRIXF_SERIALIZER(PROP, DEF) \
866    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Matrixf >( \
867        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_MATRIXF )
868
869#define ADD_MATRIXD_SERIALIZER(PROP, DEF) \
870    wrapper->addSerializer( new osgDB::PropByRefSerializer< MyClass, osg::Matrixd >( \
871        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_MATRIXD )
872
873#define ADD_MATRIX_SERIALIZER(PROP, DEF) \
874    wrapper->addSerializer( new osgDB::MatrixSerializer< MyClass >( \
875        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_MATRIX )
876
877#define ADD_GLENUM_SERIALIZER(PROP, TYPE, DEF) \
878    wrapper->addSerializer( new osgDB::GLenumSerializer< MyClass, TYPE >( \
879        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_GLENUM )
880
881#define ADD_STRING_SERIALIZER(PROP, DEF) \
882    wrapper->addSerializer( new osgDB::StringSerializer< MyClass >( \
883        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_STRING )
884
885#define ADD_OBJECT_SERIALIZER(PROP, TYPE, DEF) \
886    wrapper->addSerializer( new osgDB::ObjectSerializer< MyClass, TYPE >( \
887        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_OBJECT )
888
889#define ADD_IMAGE_SERIALIZER(PROP, TYPE, DEF) \
890    wrapper->addSerializer( new osgDB::ImageSerializer< MyClass, TYPE >( \
891        #PROP, DEF, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_IMAGE )
892
893#define ADD_LIST_SERIALIZER(PROP, TYPE) \
894    wrapper->addSerializer( new osgDB::ListSerializer< MyClass, TYPE >( \
895        #PROP, &MyClass::get##PROP, &MyClass::set##PROP), osgDB::BaseSerializer::RW_LIST )
896
897#define BEGIN_ENUM_SERIALIZER(PROP, DEF) \
898    { typedef osgDB::EnumSerializer<MyClass, MyClass::PROP, void> MySerializer; \
899    osg::ref_ptr<MySerializer> serializer = new MySerializer( \
900        #PROP, MyClass::DEF, &MyClass::get##PROP, &MyClass::set##PROP)
901
902#define BEGIN_ENUM_SERIALIZER2(PROP, TYPE, DEF) \
903    { typedef osgDB::EnumSerializer<MyClass, TYPE, void> MySerializer; \
904    osg::ref_ptr<MySerializer> serializer = new MySerializer( \
905        #PROP, MyClass::DEF, &MyClass::get##PROP, &MyClass::set##PROP)
906
907#define BEGIN_ENUM_SERIALIZER3(PROP, DEF) \
908    { typedef osgDB::EnumSerializer<MyClass, MyClass::PROP, bool> MySerializer; \
909    osg::ref_ptr<MySerializer> serializer = new MySerializer( \
910        #PROP, MyClass::DEF, &MyClass::get##PROP, &MyClass::set##PROP)
911
912#define BEGIN_ENUM_SERIALIZER4(PROPERTIES_CLASS, PROP, DEF) \
913    { typedef osgDB::EnumSerializer<MyClass, PROPERTIES_CLASS::PROP, void> MySerializer; \
914    osg::ref_ptr<MySerializer> serializer = new MySerializer( \
915        #PROP, PROPERTIES_CLASS::DEF, &MyClass::get##PROP, &MyClass::set##PROP)
916
917#define ADD_ENUM_VALUE(VALUE) \
918    serializer->add(#VALUE, MyClass::VALUE)
919
920#define ADD_ENUM_CLASS_VALUE(CLASS, VALUE) \
921    serializer->add(#VALUE, CLASS::VALUE)
922
923#define END_ENUM_SERIALIZER() \
924    wrapper->addSerializer(serializer.get(), osgDB::BaseSerializer::RW_ENUM); }
925
926// VERSION CONTROL OPERATORS
927#define UPDATE_TO_VERSION(VER) \
928    wrapper->setUpdatedVersion( (VER) );
929
930#define REMOVE_SERIALIZER(PROP) \
931    wrapper->markSerializerAsRemoved( #PROP );
932
933}
934
935#endif
Note: See TracBrowser for help on using the browser.