Context Navigation

Serializer @ 13041

Revision 13041, 32.2 kB (checked in by robert, 14 months 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
28	namespace osgDB
29	{
30
31	#ifndef OBJECT_CAST
32	#define OBJECT_CAST static_cast
33	#endif
34
35	class IntLookup
36	{
37	public:
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
85	protected:
86	StringToValue _stringToValue;
87	ValueToString _valueToString;
88	};
89
90	class UserLookupTableProxy
91	{
92	public:
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
118	class BaseSerializer : public osg::Referenced
119	{
120	friend class ObjectWrapper;
121	public:
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
136	protected:
137	int _firstVersion; // Library version when the serializer is first introduced
138	int _lastVersion; // Library version when the serializer is last required.
139	};
140
141	template<typename C>
142	class UserSerializer : public BaseSerializer
143	{
144	public:
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
187	protected:
188	std::string _name;
189	Checker _checker;
190
191	public:
192	Reader _reader;
193	Writer _writer;
194	};
195
196	template<typename P>
197	class TemplateSerializer : public BaseSerializer
198	{
199	public:
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
208	protected:
209	std::string _name;
210	P _defaultValue;
211	};
212
213	template<typename C, typename P>
214	class PropByValSerializer : public TemplateSerializer<P>
215	{
216	public:
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
263	public:
264	Getter _getter;
265	Setter _setter;
266
267	protected:
268	bool _useHex;
269	};
270
271	template<typename C, typename P>
272	class PropByRefSerializer : public TemplateSerializer<P>
273	{
274	public:
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
316	public:
317	Getter _getter;
318	Setter _setter;
319	};
320
321	template<typename C>
322	class MatrixSerializer : public TemplateSerializer<osg::Matrix>
323	{
324	public:
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
366	protected:
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
385	public:
386	Getter _getter;
387	Setter _setter;
388	};
389
390	template<typename C, typename P>
391	class GLenumSerializer : public TemplateSerializer<P>
392	{
393	public:
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
433	public:
434	Getter _getter;
435	Setter _setter;
436	};
437
438	template<typename C>
439	class StringSerializer : public TemplateSerializer<std::string>
440	{
441	public:
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
485	public:
486	Getter _getter;
487	Setter _setter;
488	};
489
490	template<typename C, typename P>
491	class ObjectSerializer : public TemplateSerializer<P*>
492	{
493	public:
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
554	public:
555	Getter _getter;
556	Setter _setter;
557	};
558
559	template<typename C, typename P>
560	class ImageSerializer : public TemplateSerializer<P*>
561	{
562	public:
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
623	public:
624	Getter _getter;
625	Setter _setter;
626	};
627
628	template<typename C, typename P, typename B>
629	class EnumSerializer : public TemplateSerializer<P>
630	{
631	public:
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
681	public:
682	Getter _getter;
683	Setter _setter;
684
685	protected:
686	IntLookup _lookup;
687	};
688
689
690	template<typename C, typename P>
691	class ListSerializer : public BaseSerializer
692	{
693	public:
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
767	public:
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.

Download in other formats:

Original Format