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

Revision 13041, 32.2 kB (checked in by robert, 2 years ago)

Ran script to remove trailing spaces and tabs

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