ec6edf535d
//GLbitfield mask = GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT; This line was problematic since it produced incorrect result when let's say COLOR flag is serialized it should be null as in Camera serializer or in a proposed BitFlagsSerializer This line of code caused that whenever only GL_COLOR_BUFFER_BIT bit was written and on value read GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT was restored instead of GL_COLOR_BUFFER_BIT only. //GLbitfield mask = 0; //this resolves the issue same as in camera Also same bit-wise comparison bug was also present in write method. ------------------------------------------------------------------------------------- As you can see there are total 3 bit mask serializers in OSG and all 3 had bugs so I decided to add ADD_BITFLAGS_SERIALIZER and replace USER serializers in osg::Camera, osg::ClearNode and osgText::TextBase. I have made sure that bitflags serializer does not break backwards-compatibility since it uses same code as user serializer does in all 3 cases. (see tester.cpp on how compatibility test was performed)" git-svn-id: http://svn.openscenegraph.org/osg/OpenSceneGraph/trunk@14752 16af8721-9629-0410-8352-f15c8da7e697
267 lines
10 KiB
C++
267 lines
10 KiB
C++
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 Robert Osfield
|
|
*
|
|
* This library is open source and may be redistributed and/or modified under
|
|
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
|
* (at your option) any later version. The full license is in LICENSE file
|
|
* included with this distribution, and on the openscenegraph.org website.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* OpenSceneGraph Public License for more details.
|
|
*/
|
|
// Written by Wang Rui, (C) 2010
|
|
|
|
#ifndef OSGDB_OBJECTWRAPPER
|
|
#define OSGDB_OBJECTWRAPPER
|
|
|
|
#include <osgDB/Serializer>
|
|
#include <osg/ScriptEngine>
|
|
|
|
namespace osgDB
|
|
{
|
|
|
|
struct MethodObject : public osg::Referenced
|
|
{
|
|
typedef std::vector< osg::ref_ptr<osg::Object> > Parameters;
|
|
|
|
virtual bool run(void* objectPtr, osg::Parameters& inputParameters, osg::Parameters& outputParameters) const = 0;
|
|
|
|
virtual ~MethodObject() {}
|
|
};
|
|
|
|
class OSGDB_EXPORT BaseCompressor : public osg::Referenced
|
|
{
|
|
public:
|
|
BaseCompressor() {}
|
|
void setName( const std::string& name ) { _name = name; }
|
|
const std::string& getName() const { return _name; }
|
|
|
|
virtual bool compress( std::ostream&, const std::string& ) = 0;
|
|
virtual bool decompress( std::istream&, std::string& ) = 0;
|
|
|
|
protected:
|
|
std::string _name;
|
|
};
|
|
|
|
struct FinishedObjectReadCallback : public osg::Referenced
|
|
{
|
|
virtual void objectRead(osgDB::InputStream& is, osg::Object& obj) = 0;
|
|
};
|
|
|
|
class OSGDB_EXPORT ObjectWrapper : public osg::Referenced
|
|
{
|
|
public:
|
|
typedef std::vector< BaseSerializer::Type > TypeList;
|
|
typedef std::vector< osg::ref_ptr<BaseSerializer> > SerializerList;
|
|
typedef std::vector< osg::ref_ptr<FinishedObjectReadCallback> > FinishedObjectReadCallbackList;
|
|
typedef osg::Object* CreateInstanceFunc();
|
|
|
|
ObjectWrapper( CreateInstanceFunc* createInstanceFunc, const std::string& name,
|
|
const std::string& associates );
|
|
ObjectWrapper( CreateInstanceFunc* createInstanceFunc, const std::string& domain, const std::string& name,
|
|
const std::string& associates );
|
|
|
|
void setUpdatedVersion( int ver ) { _version = ver; }
|
|
int getUpdatedVersion() const { return _version; }
|
|
|
|
osg::Object* createInstance() const { return _createInstanceFunc(); }
|
|
const std::string& getDomain() const { return _domain; }
|
|
const std::string& getName() const { return _name; }
|
|
const StringList& getAssociates() const { return _associates; }
|
|
|
|
SerializerList& getSerializerList() { return _serializers; }
|
|
const SerializerList& getSerializerList() const { return _serializers; }
|
|
|
|
TypeList& getTypeList() { return _typeList; }
|
|
const TypeList& getTypeList() const { return _typeList; }
|
|
|
|
void addSerializer( BaseSerializer* s, BaseSerializer::Type t=BaseSerializer::RW_UNDEFINED );
|
|
void markSerializerAsRemoved( const std::string& name );
|
|
BaseSerializer* getLastSerializer() { return _serializers.empty() ? 0 : _serializers.back().get(); }
|
|
BaseSerializer* getSerializer( const std::string& name );
|
|
BaseSerializer* getSerializer( const std::string& name, BaseSerializer::Type& type);
|
|
|
|
void addFinishedObjectReadCallback ( FinishedObjectReadCallback* forc) { _finishedObjectReadCallbacks.push_back(forc); }
|
|
|
|
bool read( InputStream&, osg::Object& );
|
|
bool write( OutputStream&, const osg::Object& );
|
|
|
|
bool readSchema( const StringList& properties, const TypeList& types );
|
|
void writeSchema( StringList& properties, TypeList& types );
|
|
void resetSchema() { if ( _backupSerializers.size()>0 ) _serializers = _backupSerializers; }
|
|
|
|
void addMethodObject(const std::string& methodName, MethodObject* mo);
|
|
|
|
typedef std::multimap< std::string, osg::ref_ptr<MethodObject> > MethodObjectMap;
|
|
|
|
MethodObjectMap& getMethodObjectMap() { return _methodObjectMap; }
|
|
const MethodObjectMap& getMethodObjectMap() const { return _methodObjectMap; }
|
|
|
|
protected:
|
|
ObjectWrapper() : _version(0) {}
|
|
virtual ~ObjectWrapper() {}
|
|
|
|
CreateInstanceFunc* _createInstanceFunc;
|
|
std::string _domain;
|
|
std::string _name;
|
|
StringList _associates;
|
|
SerializerList _serializers;
|
|
SerializerList _backupSerializers;
|
|
TypeList _typeList;
|
|
FinishedObjectReadCallbackList _finishedObjectReadCallbacks;
|
|
MethodObjectMap _methodObjectMap;
|
|
int _version; // Last updated version of the wrapper
|
|
};
|
|
|
|
struct UpdateWrapperVersionProxy
|
|
{
|
|
UpdateWrapperVersionProxy( ObjectWrapper* w, int v ): _wrapper(w)
|
|
{
|
|
_lastVersion = w->getUpdatedVersion();
|
|
w->setUpdatedVersion(v);
|
|
}
|
|
|
|
~UpdateWrapperVersionProxy()
|
|
{
|
|
_wrapper->setUpdatedVersion(_lastVersion);
|
|
}
|
|
|
|
ObjectWrapper* _wrapper;
|
|
int _lastVersion;
|
|
};
|
|
|
|
class Registry;
|
|
|
|
class OSGDB_EXPORT ObjectWrapperManager : public osg::Referenced
|
|
{
|
|
public:
|
|
|
|
// Wrapper handlers
|
|
void addWrapper( ObjectWrapper* wrapper );
|
|
void removeWrapper( ObjectWrapper* wrapper );
|
|
ObjectWrapper* findWrapper( const std::string& name );
|
|
|
|
typedef std::map< std::string, osg::ref_ptr<ObjectWrapper> > WrapperMap;
|
|
WrapperMap& getWrapperMap() { return _wrappers; }
|
|
const WrapperMap& getWrapperMap() const { return _wrappers; }
|
|
|
|
// Compressor handlers
|
|
void addCompressor( BaseCompressor* compressor );
|
|
void removeCompressor( BaseCompressor* compressor );
|
|
BaseCompressor* findCompressor( const std::string& name );
|
|
|
|
typedef std::map< std::string, osg::ref_ptr<BaseCompressor> > CompressorMap;
|
|
CompressorMap& getCompressorMap() { return _compressors; }
|
|
const CompressorMap& getCompressorMap() const { return _compressors; }
|
|
|
|
typedef std::map<std::string, IntLookup> IntLookupMap;
|
|
IntLookup::Value getValue( const std::string& group, const std::string& str ) { return findLookup(group).getValue(str.c_str()); }
|
|
const std::string& getString( const std::string& group, IntLookup::Value value ) { return findLookup(group).getString(value); }
|
|
|
|
IntLookupMap& getLookupMap() { return _globalMap; }
|
|
const IntLookupMap& getLookupMap() const { return _globalMap; }
|
|
|
|
protected:
|
|
|
|
friend class osgDB::Registry;
|
|
|
|
ObjectWrapperManager();
|
|
virtual ~ObjectWrapperManager();
|
|
|
|
WrapperMap _wrappers;
|
|
CompressorMap _compressors;
|
|
|
|
IntLookup& findLookup( const std::string& group )
|
|
{
|
|
IntLookupMap::iterator itr = _globalMap.find(group);
|
|
if ( itr!=_globalMap.end() ) return itr->second;
|
|
else return _globalMap["GL"];
|
|
}
|
|
|
|
IntLookupMap _globalMap;
|
|
};
|
|
|
|
|
|
class OSGDB_EXPORT RegisterWrapperProxy
|
|
{
|
|
public:
|
|
typedef void (*AddPropFunc)( ObjectWrapper* );
|
|
|
|
RegisterWrapperProxy( ObjectWrapper::CreateInstanceFunc *createInstanceFunc, const std::string& name,
|
|
const std::string& associates, AddPropFunc func );
|
|
|
|
virtual ~RegisterWrapperProxy();
|
|
|
|
protected:
|
|
osg::ref_ptr<ObjectWrapper> _wrapper;
|
|
};
|
|
|
|
class OSGDB_EXPORT RegisterCustomWrapperProxy
|
|
{
|
|
public:
|
|
typedef void (*AddPropFunc)( const char*, ObjectWrapper* );
|
|
|
|
RegisterCustomWrapperProxy( ObjectWrapper::CreateInstanceFunc *createInstanceFunc, const std::string& domain, const std::string& name,
|
|
const std::string& associates, AddPropFunc func );
|
|
|
|
virtual ~RegisterCustomWrapperProxy();
|
|
|
|
protected:
|
|
osg::ref_ptr<ObjectWrapper> _wrapper;
|
|
};
|
|
|
|
#define REGISTER_OBJECT_WRAPPER(NAME, CREATEINSTANCE, CLASS, ASSOCIATES) \
|
|
extern "C" void wrapper_serializer_##NAME(void) {} \
|
|
extern void wrapper_propfunc_##NAME(osgDB::ObjectWrapper*); \
|
|
static osg::Object* wrapper_createinstancefunc##NAME() { return CREATEINSTANCE; } \
|
|
static osgDB::RegisterWrapperProxy wrapper_proxy_##NAME( \
|
|
wrapper_createinstancefunc##NAME, #CLASS, ASSOCIATES, &wrapper_propfunc_##NAME); \
|
|
typedef CLASS MyClass; \
|
|
void wrapper_propfunc_##NAME(osgDB::ObjectWrapper* wrapper)
|
|
|
|
#define REGISTER_OBJECT_WRAPPER2(NAME, CREATEINSTANCE, CLASS, CLASSNAME, ASSOCIATES) \
|
|
extern "C" void wrapper_serializer_##NAME(void) {} \
|
|
extern void wrapper_propfunc_##NAME(osgDB::ObjectWrapper*); \
|
|
static osg::Object* wrapper_createinstancefunc##NAME() { return CREATEINSTANCE; } \
|
|
static osgDB::RegisterWrapperProxy wrapper_proxy_##NAME( \
|
|
wrapper_createinstancefunc##NAME, CLASSNAME, ASSOCIATES, &wrapper_propfunc_##NAME); \
|
|
typedef CLASS MyClass; \
|
|
void wrapper_propfunc_##NAME(osgDB::ObjectWrapper* wrapper)
|
|
|
|
#define REGISTER_CUSTOM_OBJECT_WRAPPER(DOMAIN, NAME, CREATEINSTANCE, CLASS, ASSOCIATES) \
|
|
extern "C" void wrapper_serializer_##NAME(void) {} \
|
|
extern void wrapper_propfunc_##NAME(const char*, osgDB::ObjectWrapper*); \
|
|
static osg::Object* wrapper_createinstancefunc##NAME() { return CREATEINSTANCE; } \
|
|
static osgDB::RegisterCustomWrapperProxy wrapper_proxy_##NAME( \
|
|
wrapper_createinstancefunc##NAME, #DOMAIN, #CLASS, ASSOCIATES, &wrapper_propfunc_##NAME); \
|
|
typedef CLASS MyClass; \
|
|
void wrapper_propfunc_##NAME(const char* domain, osgDB::ObjectWrapper* wrapper)
|
|
|
|
#define REGISTER_CUSTOM_OBJECT_WRAPPER2(DOMAIN, NAME, CREATEINSTANCE, CLASS, CLASSNAME, ASSOCIATES) \
|
|
extern "C" void wrapper_serializer_##NAME(void) {} \
|
|
extern void wrapper_propfunc_##NAME(const char*, osgDB::ObjectWrapper*); \
|
|
static osg::Object* wrapper_createinstancefunc##NAME() { return CREATEINSTANCE; } \
|
|
static osgDB::RegisterCustomWrapperProxy wrapper_proxy_##NAME( \
|
|
wrapper_createinstancefunc##NAME, #DOMAIN, CLASSNAME, ASSOCIATES, &wrapper_propfunc_##NAME); \
|
|
typedef CLASS MyClass; \
|
|
void wrapper_propfunc_##NAME(const char* domain, osgDB::ObjectWrapper* wrapper)
|
|
|
|
class OSGDB_EXPORT RegisterCompressorProxy
|
|
{
|
|
public:
|
|
RegisterCompressorProxy( const std::string& name, BaseCompressor* compressor );
|
|
~RegisterCompressorProxy();
|
|
|
|
protected:
|
|
osg::ref_ptr<BaseCompressor> _compressor;
|
|
};
|
|
|
|
#define REGISTER_COMPRESSOR(NAME, CLASS) \
|
|
extern "C" void wrapper_compressor_##CLASS(void) {} \
|
|
static osgDB::RegisterCompressorProxy compressor_proxy_##CLASS(NAME, new CLASS);
|
|
|
|
}
|
|
|
|
#endif
|