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

Revision 13788, 36.9 kB (checked in by robert, 5 days ago)

Fixed comment

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