6490f1b6a5
Updated lua plugin to use new osgDB::PropertyInterface to run methods. Added addChild/removeChild() etc to Group.cpp, and addDrawable/removeDrawable() etc. to Geode.cpp serializers.
251 lines
9.0 KiB
C++
251 lines
9.0 KiB
C++
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 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.
|
|
*/
|
|
|
|
|
|
#ifndef OSGDB_PROPERTYINTERFACE
|
|
#define OSGDB_PROPERTYINTERFACE 1
|
|
|
|
#include <osgDB/ObjectWrapper>
|
|
#include <osgDB/Registry>
|
|
#include <osgPresentation/Group>
|
|
#include <osg/ValueObject>
|
|
|
|
namespace osgDB
|
|
{
|
|
|
|
template<typename T>
|
|
static osgDB::BaseSerializer::Type getTypeEnum()
|
|
{
|
|
return osgDB::BaseSerializer::RW_UNDEFINED;
|
|
}
|
|
|
|
template<typename T>
|
|
static osgDB::BaseSerializer::Type getTypeEnumFrom(T)
|
|
{
|
|
return getTypeEnum<T>();
|
|
}
|
|
|
|
template<typename T>
|
|
static const char* getTypeString()
|
|
{
|
|
return "UNDEFINED";
|
|
}
|
|
|
|
template<typename T>
|
|
static const char* getTypeStringFrom(T)
|
|
{
|
|
return getTypeString<T>();
|
|
}
|
|
|
|
extern OSGDB_EXPORT osgDB::BaseSerializer::Type getTypeEnumFromPtr(const osg::Object*);
|
|
extern OSGDB_EXPORT const char* getTypeStringFromPtr(const osg::Object*);
|
|
|
|
extern OSGDB_EXPORT osgDB::BaseSerializer::Type getTypeEnumFromPtr(const osg::Image*);
|
|
extern OSGDB_EXPORT const char* getTypeStringFromPtr(const osg::Image*);
|
|
|
|
|
|
#define DECLARE_TYPE(A,B) \
|
|
template<> osgDB::BaseSerializer::Type getTypeEnum<A>() { return osgDB::BaseSerializer::RW_##B; } \
|
|
template<> const char* getTypeString<A>() { return #B; }
|
|
|
|
DECLARE_TYPE(osg::Image*, IMAGE)
|
|
DECLARE_TYPE(osg::Object*, OBJECT)
|
|
|
|
DECLARE_TYPE(bool, BOOL)
|
|
DECLARE_TYPE(char, CHAR)
|
|
DECLARE_TYPE(unsigned char, UCHAR)
|
|
DECLARE_TYPE(short, SHORT)
|
|
DECLARE_TYPE(unsigned short, USHORT)
|
|
DECLARE_TYPE(int, INT)
|
|
DECLARE_TYPE(unsigned int, UINT)
|
|
DECLARE_TYPE(float, FLOAT)
|
|
DECLARE_TYPE(double, DOUBLE)
|
|
|
|
DECLARE_TYPE(osg::Vec2f, VEC2F)
|
|
DECLARE_TYPE(osg::Vec2d, VEC2D)
|
|
DECLARE_TYPE(osg::Vec3f, VEC3F)
|
|
DECLARE_TYPE(osg::Vec3d, VEC3D)
|
|
DECLARE_TYPE(osg::Vec4f, VEC4F)
|
|
DECLARE_TYPE(osg::Vec4d, VEC4D)
|
|
DECLARE_TYPE(osg::Quat, QUAT)
|
|
DECLARE_TYPE(osg::Plane, PLANE)
|
|
|
|
DECLARE_TYPE(osg::Matrixf, MATRIXF)
|
|
DECLARE_TYPE(osg::Matrixd, MATRIXD)
|
|
DECLARE_TYPE(std::string, STRING)
|
|
|
|
DECLARE_TYPE(osg::Vec2b, VEC2B)
|
|
DECLARE_TYPE(osg::Vec2ub, VEC2UB)
|
|
DECLARE_TYPE(osg::Vec2s, VEC2S)
|
|
DECLARE_TYPE(osg::Vec2us, VEC2US)
|
|
DECLARE_TYPE(osg::Vec2i, VEC2I)
|
|
DECLARE_TYPE(osg::Vec2ui, VEC2UI)
|
|
|
|
DECLARE_TYPE(osg::Vec3b, VEC3B)
|
|
DECLARE_TYPE(osg::Vec3ub, VEC3UB)
|
|
DECLARE_TYPE(osg::Vec3s, VEC3S)
|
|
DECLARE_TYPE(osg::Vec3us, VEC3US)
|
|
DECLARE_TYPE(osg::Vec3i, VEC3I)
|
|
DECLARE_TYPE(osg::Vec3ui, VEC3UI)
|
|
|
|
DECLARE_TYPE(osg::Vec4b, VEC4B)
|
|
DECLARE_TYPE(osg::Vec4ub, VEC4UB)
|
|
DECLARE_TYPE(osg::Vec4s, VEC4S)
|
|
DECLARE_TYPE(osg::Vec4us, VEC4US)
|
|
DECLARE_TYPE(osg::Vec4i, VEC4I)
|
|
DECLARE_TYPE(osg::Vec4ui, VEC4UI)
|
|
|
|
// forward decalare
|
|
class PropertyOutputIterator;
|
|
class PropertyInputIterator;
|
|
|
|
|
|
/** PropertyInterface provides a general means of checking for supported properties of classes, and getting/setting thoses properties.
|
|
Uses the osgDB serializers to do the actual object querry/get/set.
|
|
*/
|
|
class OSGDB_EXPORT PropertyInterface
|
|
{
|
|
public:
|
|
PropertyInterface();
|
|
|
|
|
|
/// get the Type of the specified property, return true if property is supported, otherwise false.
|
|
bool getPropertyType(const osg::Object* object, const std::string& propertyName, osgDB::BaseSerializer::Type& type) const;
|
|
|
|
/// return type of two types are compatible
|
|
bool areTypesCompatible(osgDB::BaseSerializer::Type lhs, osgDB::BaseSerializer::Type rhs) const;
|
|
|
|
|
|
/** create an object of specified type for provided compound class name in the form libraryName::className. */
|
|
osg::Object* createObject(const std::string& compounClassdName) const;
|
|
|
|
|
|
/// template method for getting property data, return true if property available and the type is compatible, otherwise returns false.
|
|
template<typename T>
|
|
bool getProperty(const osg::Object* object, const std::string& propertyName, T& value);
|
|
|
|
/// template method for setting property data, return true if property available and the type is compatible, otherwise returns false.
|
|
template<typename T>
|
|
bool setProperty(osg::Object* object, const std::string& propertyName, const T& value);
|
|
|
|
|
|
/// get the human readable name of type.
|
|
std::string getTypeName(osgDB::BaseSerializer::Type type) const;
|
|
|
|
/// get the enum value of type given the human readable name.
|
|
osgDB::BaseSerializer::Type getType(const std::string& typeName) const;
|
|
|
|
|
|
/// Properties supported for a single class
|
|
typedef std::map<std::string, osgDB::BaseSerializer::Type> PropertyMap;
|
|
|
|
/// Get the list of of properties supported by object
|
|
bool getSupportedProperties(const osg::Object* object, PropertyMap& properties, bool searchAssociates=true) const;
|
|
|
|
|
|
/// run method of object
|
|
bool run(void* objectPtr, const std::string& compoundClassName, const std::string& methodName, osg::Parameters& inputParameters, osg::Parameters& outputParameters) const;
|
|
|
|
/// run method of object
|
|
bool run(osg::Object* object, const std::string& methodName, osg::Parameters& inputParameters, osg::Parameters& outputParameters) const;
|
|
|
|
/// checked for support of specificed method
|
|
bool hasMethod(const std::string& compoundClassName, const std::string& methodName) const;
|
|
|
|
/// checked for support of specificed method
|
|
bool hasMethod(const osg::Object* object, const std::string& methodName) const;
|
|
|
|
|
|
/// Properties supported for a range of classes, used for white and black lists
|
|
typedef std::map<std::string, PropertyMap> ObjectPropertyMap;
|
|
|
|
/// Get the list of properties that are explictly defined as supported
|
|
ObjectPropertyMap& getWhiteList() { return _whiteList; }
|
|
|
|
/// Get the const list of properties that are explictly defined as supported
|
|
const ObjectPropertyMap& getWhiteList() const { return _whiteList; }
|
|
|
|
/// Get the list of properties that are explictly defined as not supported
|
|
ObjectPropertyMap& getBlackList() { return _blackList; }
|
|
|
|
/// Get the const list of properties that are explictly defined as not supported
|
|
const ObjectPropertyMap& getBlackList() const { return _blackList; }
|
|
|
|
protected:
|
|
|
|
bool copyPropertyDataFromObject(const osg::Object* object, const std::string& propertyName, void* valuePtr, unsigned int valueSize, osgDB::BaseSerializer::Type valueType);
|
|
|
|
bool copyPropertyDataToObject(osg::Object* object, const std::string& propertyName, const void* valuePtr, unsigned int valueSize, osgDB::BaseSerializer::Type valueType);
|
|
|
|
bool copyPropertyObjectFromObject(const osg::Object* object, const std::string& propertyName, void* valuePtr, unsigned int valueSize, osgDB::BaseSerializer::Type valueType);
|
|
|
|
bool copyPropertyObjectToObject(osg::Object* object, const std::string& propertyName, const void* valuePtr, unsigned int valueSize, osgDB::BaseSerializer::Type valueType);
|
|
|
|
osgDB::ObjectWrapper* getObjectWrapper(const osg::Object* object) const;
|
|
|
|
osgDB::BaseSerializer* getSerializer(const osg::Object* object, const std::string& propertyName, osgDB::BaseSerializer::Type& type) const;
|
|
|
|
osgDB::OutputStream _outputStream;
|
|
PropertyOutputIterator* _poi;
|
|
|
|
osgDB::InputStream _inputStream;
|
|
PropertyInputIterator* _pii;
|
|
|
|
typedef std::map<std::string, osgDB::BaseSerializer::Type> TypeNameToTypeMap;
|
|
typedef std::map<osgDB::BaseSerializer::Type, std::string> TypeToTypeNameMap;
|
|
|
|
TypeNameToTypeMap _typeNameToTypeMap;
|
|
TypeToTypeNameMap _typeToTypeNameMap;
|
|
|
|
ObjectPropertyMap _whiteList;
|
|
ObjectPropertyMap _blackList;
|
|
};
|
|
|
|
|
|
template<typename T>
|
|
bool PropertyInterface::getProperty(const osg::Object* object, const std::string& propertyName, T& value)
|
|
{
|
|
if (copyPropertyDataFromObject(object, propertyName, &value, sizeof(T), getTypeEnum<T>())) return true;
|
|
else return object->getUserValue(propertyName, value); // fallback to check user data for property
|
|
}
|
|
|
|
template<typename T>
|
|
bool PropertyInterface::setProperty(osg::Object* object, const std::string& propertyName, const T& value)
|
|
{
|
|
if (copyPropertyDataToObject(object, propertyName, &value, sizeof(T), getTypeEnum<T>())) return true;
|
|
else
|
|
{
|
|
// fallback to using user data to store property data
|
|
object->setUserValue(propertyName, value);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
typedef osg::Object* ObjectPtr;
|
|
|
|
template<>
|
|
inline bool PropertyInterface::getProperty(const osg::Object* object, const std::string& propertyName, ObjectPtr& value)
|
|
{
|
|
return copyPropertyObjectFromObject(object, propertyName, &value, sizeof(ObjectPtr), getTypeEnum<ObjectPtr>());
|
|
}
|
|
|
|
template<>
|
|
inline bool PropertyInterface::setProperty(osg::Object* object, const std::string& propertyName, const ObjectPtr& value)
|
|
{
|
|
return copyPropertyObjectToObject(object, propertyName, &value, sizeof(ObjectPtr), getTypeEnum<ObjectPtr>());
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|