From 56cf703094ae826de5ae8e5963e7aa142239857f Mon Sep 17 00:00:00 2001 From: Robert Osfield Date: Thu, 28 Jan 2010 08:59:23 +0000 Subject: [PATCH] Added files back in with the execution bit correctly disabled. --- src/osgWrappers/serializers/osg/AlphaFunc.cpp | 23 ++ .../serializers/osg/AnimationPath.cpp | 75 +++++ .../serializers/osg/AnimationPathCallback.cpp | 23 ++ src/osgWrappers/serializers/osg/AudioSink.cpp | 11 + .../serializers/osg/AudioStream.cpp | 11 + .../serializers/osg/AutoTransform.cpp | 27 ++ src/osgWrappers/serializers/osg/Billboard.cpp | 50 +++ .../serializers/osg/BlendColor.cpp | 12 + .../serializers/osg/BlendEquation.cpp | 32 ++ src/osgWrappers/serializers/osg/BlendFunc.cpp | 15 + src/osgWrappers/serializers/osg/Box.cpp | 14 + src/osgWrappers/serializers/osg/Camera.cpp | 271 ++++++++++++++++ .../serializers/osg/CameraView.cpp | 22 ++ src/osgWrappers/serializers/osg/Capsule.cpp | 15 + .../serializers/osg/ClampColor.cpp | 14 + src/osgWrappers/serializers/osg/ClearNode.cpp | 63 ++++ src/osgWrappers/serializers/osg/ClipNode.cpp | 17 + src/osgWrappers/serializers/osg/ClipPlane.cpp | 13 + .../osg/ClusterCullingCallback.cpp | 21 ++ src/osgWrappers/serializers/osg/ColorMask.cpp | 15 + .../serializers/osg/ColorMatrix.cpp | 12 + .../serializers/osg/CompositeShape.cpp | 42 +++ src/osgWrappers/serializers/osg/Cone.cpp | 15 + .../serializers/osg/ConvexHull.cpp | 11 + .../serializers/osg/ConvexPlanarOccluder.cpp | 90 ++++++ .../serializers/osg/CoordinateSystemNode.cpp | 14 + src/osgWrappers/serializers/osg/CullFace.cpp | 16 + src/osgWrappers/serializers/osg/Cylinder.cpp | 15 + src/osgWrappers/serializers/osg/Depth.cpp | 25 ++ .../serializers/osg/DrawPixels.cpp | 36 +++ src/osgWrappers/serializers/osg/Drawable.cpp | 50 +++ .../serializers/osg/EllipsoidModel.cpp | 13 + src/osgWrappers/serializers/osg/Fog.cpp | 22 ++ .../serializers/osg/FragmentProgram.cpp | 78 +++++ src/osgWrappers/serializers/osg/FrontFace.cpp | 15 + src/osgWrappers/serializers/osg/Geode.cpp | 41 +++ src/osgWrappers/serializers/osg/Geometry.cpp | 115 +++++++ src/osgWrappers/serializers/osg/Group.cpp | 41 +++ .../serializers/osg/HeightField.cpp | 69 ++++ src/osgWrappers/serializers/osg/Hint.cpp | 13 + src/osgWrappers/serializers/osg/Image.cpp | 12 + .../serializers/osg/ImageSequence.cpp | 86 +++++ .../serializers/osg/ImageStream.cpp | 17 + src/osgWrappers/serializers/osg/LOD.cpp | 76 +++++ src/osgWrappers/serializers/osg/Light.cpp | 22 ++ .../serializers/osg/LightModel.cpp | 20 ++ .../serializers/osg/LightSource.cpp | 17 + .../serializers/osg/LineStipple.cpp | 13 + src/osgWrappers/serializers/osg/LineWidth.cpp | 12 + src/osgWrappers/serializers/osg/LogicOp.cpp | 29 ++ src/osgWrappers/serializers/osg/Material.cpp | 53 +++ .../serializers/osg/MatrixTransform.cpp | 12 + .../serializers/osg/Multisample.cpp | 19 ++ src/osgWrappers/serializers/osg/Node.cpp | 82 +++++ .../serializers/osg/NodeCallback.cpp | 18 ++ .../serializers/osg/NodeTrackerCallback.cpp | 18 ++ src/osgWrappers/serializers/osg/Object.cpp | 18 ++ .../serializers/osg/OccluderNode.cpp | 12 + .../serializers/osg/OcclusionQueryNode.cpp | 15 + src/osgWrappers/serializers/osg/PagedLOD.cpp | 58 ++++ src/osgWrappers/serializers/osg/Point.cpp | 16 + .../serializers/osg/PointSprite.cpp | 15 + .../serializers/osg/PolygonMode.cpp | 58 ++++ .../serializers/osg/PolygonOffset.cpp | 13 + .../serializers/osg/PolygonStipple.cpp | 58 ++++ .../osg/PositionAttitudeTransform.cpp | 15 + src/osgWrappers/serializers/osg/Program.cpp | 91 ++++++ .../serializers/osg/Projection.cpp | 12 + src/osgWrappers/serializers/osg/ProxyNode.cpp | 79 +++++ src/osgWrappers/serializers/osg/Scissor.cpp | 31 ++ src/osgWrappers/serializers/osg/Sequence.cpp | 34 ++ .../serializers/osg/ShadeModel.cpp | 15 + src/osgWrappers/serializers/osg/Shader.cpp | 61 ++++ .../serializers/osg/ShaderBinary.cpp | 58 ++++ src/osgWrappers/serializers/osg/Shape.cpp | 11 + .../serializers/osg/ShapeDrawable.cpp | 13 + src/osgWrappers/serializers/osg/Sphere.cpp | 13 + .../serializers/osg/StateAttribute.cpp | 13 + src/osgWrappers/serializers/osg/StateSet.cpp | 306 ++++++++++++++++++ src/osgWrappers/serializers/osg/Stencil.cpp | 59 ++++ .../serializers/osg/StencilTwoSided.cpp | 79 +++++ src/osgWrappers/serializers/osg/Switch.cpp | 13 + .../serializers/osg/TessellationHints.cpp | 25 ++ src/osgWrappers/serializers/osg/TexEnv.cpp | 20 ++ .../serializers/osg/TexEnvCombine.cpp | 28 ++ .../serializers/osg/TexEnvFilter.cpp | 12 + src/osgWrappers/serializers/osg/TexGen.cpp | 40 +++ .../serializers/osg/TexGenNode.cpp | 18 ++ src/osgWrappers/serializers/osg/TexMat.cpp | 13 + src/osgWrappers/serializers/osg/Texture.cpp | 123 +++++++ src/osgWrappers/serializers/osg/Texture1D.cpp | 13 + src/osgWrappers/serializers/osg/Texture2D.cpp | 14 + .../serializers/osg/Texture2DArray.cpp | 44 +++ src/osgWrappers/serializers/osg/Texture3D.cpp | 15 + .../serializers/osg/TextureCubeMap.cpp | 48 +++ .../serializers/osg/TextureRectangle.cpp | 14 + .../serializers/osg/TransferFunction.cpp | 11 + .../serializers/osg/TransferFunction1D.cpp | 44 +++ src/osgWrappers/serializers/osg/Transform.cpp | 16 + .../serializers/osg/TriangleMesh.cpp | 29 ++ src/osgWrappers/serializers/osg/Uniform.cpp | 117 +++++++ .../serializers/osg/VertexProgram.cpp | 78 +++++ src/osgWrappers/serializers/osg/Viewport.cpp | 31 ++ 103 files changed, 3902 insertions(+) create mode 100644 src/osgWrappers/serializers/osg/AlphaFunc.cpp create mode 100644 src/osgWrappers/serializers/osg/AnimationPath.cpp create mode 100644 src/osgWrappers/serializers/osg/AnimationPathCallback.cpp create mode 100644 src/osgWrappers/serializers/osg/AudioSink.cpp create mode 100644 src/osgWrappers/serializers/osg/AudioStream.cpp create mode 100644 src/osgWrappers/serializers/osg/AutoTransform.cpp create mode 100644 src/osgWrappers/serializers/osg/Billboard.cpp create mode 100644 src/osgWrappers/serializers/osg/BlendColor.cpp create mode 100644 src/osgWrappers/serializers/osg/BlendEquation.cpp create mode 100644 src/osgWrappers/serializers/osg/BlendFunc.cpp create mode 100644 src/osgWrappers/serializers/osg/Box.cpp create mode 100644 src/osgWrappers/serializers/osg/Camera.cpp create mode 100644 src/osgWrappers/serializers/osg/CameraView.cpp create mode 100644 src/osgWrappers/serializers/osg/Capsule.cpp create mode 100644 src/osgWrappers/serializers/osg/ClampColor.cpp create mode 100644 src/osgWrappers/serializers/osg/ClearNode.cpp create mode 100644 src/osgWrappers/serializers/osg/ClipNode.cpp create mode 100644 src/osgWrappers/serializers/osg/ClipPlane.cpp create mode 100644 src/osgWrappers/serializers/osg/ClusterCullingCallback.cpp create mode 100644 src/osgWrappers/serializers/osg/ColorMask.cpp create mode 100644 src/osgWrappers/serializers/osg/ColorMatrix.cpp create mode 100644 src/osgWrappers/serializers/osg/CompositeShape.cpp create mode 100644 src/osgWrappers/serializers/osg/Cone.cpp create mode 100644 src/osgWrappers/serializers/osg/ConvexHull.cpp create mode 100644 src/osgWrappers/serializers/osg/ConvexPlanarOccluder.cpp create mode 100644 src/osgWrappers/serializers/osg/CoordinateSystemNode.cpp create mode 100644 src/osgWrappers/serializers/osg/CullFace.cpp create mode 100644 src/osgWrappers/serializers/osg/Cylinder.cpp create mode 100644 src/osgWrappers/serializers/osg/Depth.cpp create mode 100644 src/osgWrappers/serializers/osg/DrawPixels.cpp create mode 100644 src/osgWrappers/serializers/osg/Drawable.cpp create mode 100644 src/osgWrappers/serializers/osg/EllipsoidModel.cpp create mode 100644 src/osgWrappers/serializers/osg/Fog.cpp create mode 100644 src/osgWrappers/serializers/osg/FragmentProgram.cpp create mode 100644 src/osgWrappers/serializers/osg/FrontFace.cpp create mode 100644 src/osgWrappers/serializers/osg/Geode.cpp create mode 100644 src/osgWrappers/serializers/osg/Geometry.cpp create mode 100644 src/osgWrappers/serializers/osg/Group.cpp create mode 100644 src/osgWrappers/serializers/osg/HeightField.cpp create mode 100644 src/osgWrappers/serializers/osg/Hint.cpp create mode 100644 src/osgWrappers/serializers/osg/Image.cpp create mode 100644 src/osgWrappers/serializers/osg/ImageSequence.cpp create mode 100644 src/osgWrappers/serializers/osg/ImageStream.cpp create mode 100644 src/osgWrappers/serializers/osg/LOD.cpp create mode 100644 src/osgWrappers/serializers/osg/Light.cpp create mode 100644 src/osgWrappers/serializers/osg/LightModel.cpp create mode 100644 src/osgWrappers/serializers/osg/LightSource.cpp create mode 100644 src/osgWrappers/serializers/osg/LineStipple.cpp create mode 100644 src/osgWrappers/serializers/osg/LineWidth.cpp create mode 100644 src/osgWrappers/serializers/osg/LogicOp.cpp create mode 100644 src/osgWrappers/serializers/osg/Material.cpp create mode 100644 src/osgWrappers/serializers/osg/MatrixTransform.cpp create mode 100644 src/osgWrappers/serializers/osg/Multisample.cpp create mode 100644 src/osgWrappers/serializers/osg/Node.cpp create mode 100644 src/osgWrappers/serializers/osg/NodeCallback.cpp create mode 100644 src/osgWrappers/serializers/osg/NodeTrackerCallback.cpp create mode 100644 src/osgWrappers/serializers/osg/Object.cpp create mode 100644 src/osgWrappers/serializers/osg/OccluderNode.cpp create mode 100644 src/osgWrappers/serializers/osg/OcclusionQueryNode.cpp create mode 100644 src/osgWrappers/serializers/osg/PagedLOD.cpp create mode 100644 src/osgWrappers/serializers/osg/Point.cpp create mode 100644 src/osgWrappers/serializers/osg/PointSprite.cpp create mode 100644 src/osgWrappers/serializers/osg/PolygonMode.cpp create mode 100644 src/osgWrappers/serializers/osg/PolygonOffset.cpp create mode 100644 src/osgWrappers/serializers/osg/PolygonStipple.cpp create mode 100644 src/osgWrappers/serializers/osg/PositionAttitudeTransform.cpp create mode 100644 src/osgWrappers/serializers/osg/Program.cpp create mode 100644 src/osgWrappers/serializers/osg/Projection.cpp create mode 100644 src/osgWrappers/serializers/osg/ProxyNode.cpp create mode 100644 src/osgWrappers/serializers/osg/Scissor.cpp create mode 100644 src/osgWrappers/serializers/osg/Sequence.cpp create mode 100644 src/osgWrappers/serializers/osg/ShadeModel.cpp create mode 100644 src/osgWrappers/serializers/osg/Shader.cpp create mode 100644 src/osgWrappers/serializers/osg/ShaderBinary.cpp create mode 100644 src/osgWrappers/serializers/osg/Shape.cpp create mode 100644 src/osgWrappers/serializers/osg/ShapeDrawable.cpp create mode 100644 src/osgWrappers/serializers/osg/Sphere.cpp create mode 100644 src/osgWrappers/serializers/osg/StateAttribute.cpp create mode 100644 src/osgWrappers/serializers/osg/StateSet.cpp create mode 100644 src/osgWrappers/serializers/osg/Stencil.cpp create mode 100644 src/osgWrappers/serializers/osg/StencilTwoSided.cpp create mode 100644 src/osgWrappers/serializers/osg/Switch.cpp create mode 100644 src/osgWrappers/serializers/osg/TessellationHints.cpp create mode 100644 src/osgWrappers/serializers/osg/TexEnv.cpp create mode 100644 src/osgWrappers/serializers/osg/TexEnvCombine.cpp create mode 100644 src/osgWrappers/serializers/osg/TexEnvFilter.cpp create mode 100644 src/osgWrappers/serializers/osg/TexGen.cpp create mode 100644 src/osgWrappers/serializers/osg/TexGenNode.cpp create mode 100644 src/osgWrappers/serializers/osg/TexMat.cpp create mode 100644 src/osgWrappers/serializers/osg/Texture.cpp create mode 100644 src/osgWrappers/serializers/osg/Texture1D.cpp create mode 100644 src/osgWrappers/serializers/osg/Texture2D.cpp create mode 100644 src/osgWrappers/serializers/osg/Texture2DArray.cpp create mode 100644 src/osgWrappers/serializers/osg/Texture3D.cpp create mode 100644 src/osgWrappers/serializers/osg/TextureCubeMap.cpp create mode 100644 src/osgWrappers/serializers/osg/TextureRectangle.cpp create mode 100644 src/osgWrappers/serializers/osg/TransferFunction.cpp create mode 100644 src/osgWrappers/serializers/osg/TransferFunction1D.cpp create mode 100644 src/osgWrappers/serializers/osg/Transform.cpp create mode 100644 src/osgWrappers/serializers/osg/TriangleMesh.cpp create mode 100644 src/osgWrappers/serializers/osg/Uniform.cpp create mode 100644 src/osgWrappers/serializers/osg/VertexProgram.cpp create mode 100644 src/osgWrappers/serializers/osg/Viewport.cpp diff --git a/src/osgWrappers/serializers/osg/AlphaFunc.cpp b/src/osgWrappers/serializers/osg/AlphaFunc.cpp new file mode 100644 index 000000000..ca7107745 --- /dev/null +++ b/src/osgWrappers/serializers/osg/AlphaFunc.cpp @@ -0,0 +1,23 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( AlphaFunc, + new osg::AlphaFunc, + osg::AlphaFunc, + "osg::Object osg::StateAttribute osg::AlphaFunc" ) +{ + BEGIN_ENUM_SERIALIZER2( Function, osg::AlphaFunc::ComparisonFunction, ALWAYS ); + ADD_ENUM_VALUE( NEVER ); + ADD_ENUM_VALUE( LESS ); + ADD_ENUM_VALUE( EQUAL ); + ADD_ENUM_VALUE( LEQUAL ); + ADD_ENUM_VALUE( GREATER ); + ADD_ENUM_VALUE( NOTEQUAL ); + ADD_ENUM_VALUE( GEQUAL ); + ADD_ENUM_VALUE( ALWAYS ); + END_ENUM_SERIALIZER(); // _comparisonFunc + + ADD_FLOAT_SERIALIZER( ReferenceValue, 1.0f ); // _referenceValue +} diff --git a/src/osgWrappers/serializers/osg/AnimationPath.cpp b/src/osgWrappers/serializers/osg/AnimationPath.cpp new file mode 100644 index 000000000..f16ee054b --- /dev/null +++ b/src/osgWrappers/serializers/osg/AnimationPath.cpp @@ -0,0 +1,75 @@ +#undef OBJECT_CAST +#define OBJECT_CAST dynamic_cast + +#include +#include +#include +#include + +static bool checkTimeControlPointMap( const osg::AnimationPath& path ) +{ + return path.getTimeControlPointMap().size()>0; +} + +static bool readTimeControlPointMap( osgDB::InputStream& is, osg::AnimationPath& path ) +{ + unsigned int size = 0; is >> size; + if ( size>0 ) + { + is >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> osgDB::PROPERTY("Time") >> time >> osgDB::BEGIN_BRACKET; + is >> osgDB::PROPERTY("Position") >> pos; + is >> osgDB::PROPERTY("Rotation") >> rot; + is >> osgDB::PROPERTY("Scale") >> scale; + is >> osgDB::END_BRACKET; + path.insert( time, osg::AnimationPath::ControlPoint(pos, rot, scale) ); + } + is >> osgDB::END_BRACKET; + } + return true; +} + +static bool writeTimeControlPointMap( osgDB::OutputStream& os, const osg::AnimationPath& path ) +{ + const osg::AnimationPath::TimeControlPointMap& map = path.getTimeControlPointMap(); + os << map.size(); + if ( map.size()>0 ) + { + os << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::AnimationPath::TimeControlPointMap::const_iterator itr=map.begin(); + itr!=map.end(); ++itr ) + { + const osg::AnimationPath::ControlPoint& pt = itr->second; + os << osgDB::PROPERTY("Time") << itr->first << osgDB::BEGIN_BRACKET << std::endl; + os << osgDB::PROPERTY("Position") << pt.getPosition() << std::endl; + os << osgDB::PROPERTY("Rotation") << pt.getRotation() << std::endl; + os << osgDB::PROPERTY("Scale") << pt.getScale() << std::endl; + os << osgDB::END_BRACKET << std::endl; + } + os << osgDB::END_BRACKET; + } + os << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( AnimationPath, + new osg::AnimationPath, + osg::AnimationPath, + "osg::Object osg::AnimationPath" ) +{ + ADD_USER_SERIALIZER( TimeControlPointMap ); // _timeControlPointMap + + BEGIN_ENUM_SERIALIZER( LoopMode, NO_LOOPING ); + ADD_ENUM_VALUE( SWING ); + ADD_ENUM_VALUE( LOOP ); + ADD_ENUM_VALUE( NO_LOOPING ); + END_ENUM_SERIALIZER(); //_loopMode +} + +#undef OBJECT_CAST +#define OBJECT_CAST static_cast diff --git a/src/osgWrappers/serializers/osg/AnimationPathCallback.cpp b/src/osgWrappers/serializers/osg/AnimationPathCallback.cpp new file mode 100644 index 000000000..a05c0775c --- /dev/null +++ b/src/osgWrappers/serializers/osg/AnimationPathCallback.cpp @@ -0,0 +1,23 @@ +#undef OBJECT_CAST +#define OBJECT_CAST dynamic_cast + +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( AnimationPathCallback, + new osg::AnimationPathCallback, + osg::AnimationPathCallback, + "osg::Object osg::NodeCallback osg::AnimationPathCallback" ) +{ + ADD_OBJECT_SERIALIZER( AnimationPath, osg::AnimationPath, NULL ); // _animationPath + ADD_VEC3D_SERIALIZER( PivotPoint, osg::Vec3d() ); // _pivotPoint + ADD_BOOL_SERIALIZER( UseInverseMatrix, false ); // _useInverseMatrix + ADD_DOUBLE_SERIALIZER( TimeOffset, 0.0 ); // _timeOffset + ADD_DOUBLE_SERIALIZER( TimeMultiplier, 1.0 ); // _timeMultiplier + ADD_BOOL_SERIALIZER( Pause, false ); // _pause +} + +#undef OBJECT_CAST +#define OBJECT_CAST static_cast diff --git a/src/osgWrappers/serializers/osg/AudioSink.cpp b/src/osgWrappers/serializers/osg/AudioSink.cpp new file mode 100644 index 000000000..fd050e416 --- /dev/null +++ b/src/osgWrappers/serializers/osg/AudioSink.cpp @@ -0,0 +1,11 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( AudioSink, + /*new osg::AudioSink*/NULL, + osg::AudioSink, + "osg::Object osg::AudioSink" ) +{ +} diff --git a/src/osgWrappers/serializers/osg/AudioStream.cpp b/src/osgWrappers/serializers/osg/AudioStream.cpp new file mode 100644 index 000000000..01a49623d --- /dev/null +++ b/src/osgWrappers/serializers/osg/AudioStream.cpp @@ -0,0 +1,11 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( AudioStream, + /*new osg::AudioStream*/NULL, + osg::AudioStream, + "osg::Object osg::AudioStream" ) +{ +} diff --git a/src/osgWrappers/serializers/osg/AutoTransform.cpp b/src/osgWrappers/serializers/osg/AutoTransform.cpp new file mode 100644 index 000000000..7466cafbb --- /dev/null +++ b/src/osgWrappers/serializers/osg/AutoTransform.cpp @@ -0,0 +1,27 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( AutoTransform, + new osg::AutoTransform, + osg::AutoTransform, + "osg::Object osg::Node osg::Group osg::Transform osg::AutoTransform" ) +{ + ADD_DOUBLE_SERIALIZER( MinimumScale, 0.0 ); // _minimumScale + ADD_DOUBLE_SERIALIZER( MaximumScale, 0.0 ); // _maximumScale + ADD_VEC3D_SERIALIZER( Position, osg::Vec3d() ); // _position + ADD_VEC3D_SERIALIZER( Scale, osg::Vec3d() ); // _scale + ADD_VEC3D_SERIALIZER( PivotPoint, osg::Vec3d() ); // _pivotPoint + ADD_FLOAT_SERIALIZER( AutoUpdateEyeMovementTolerance, 0.0f ); // _autoUpdateEyeMovementTolerance + + BEGIN_ENUM_SERIALIZER( AutoRotateMode, NO_ROTATION ); + ADD_ENUM_VALUE( NO_ROTATION ); + ADD_ENUM_VALUE( ROTATE_TO_SCREEN ); + ADD_ENUM_VALUE( ROTATE_TO_CAMERA ); + END_ENUM_SERIALIZER(); // _autoRotateMode + + ADD_BOOL_SERIALIZER( AutoScaleToScreen, false ); // _autoScaleToScreen + ADD_QUAT_SERIALIZER( Rotation, osg::Quat() ); // _rotation + ADD_FLOAT_SERIALIZER( AutoScaleTransitionWidthRatio, 0.25f ); // _autoScaleTransitionWidthRatio +} diff --git a/src/osgWrappers/serializers/osg/Billboard.cpp b/src/osgWrappers/serializers/osg/Billboard.cpp new file mode 100644 index 000000000..3ed585463 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Billboard.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#include + +static bool checkPositionList( const osg::Billboard& node ) +{ + return node.getPositionList().size()>0; +} + +static bool readPositionList( osgDB::InputStream& is, osg::Billboard& node ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> pos; + node.setPosition( i, pos ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writePositionList( osgDB::OutputStream& os, const osg::Billboard& node ) +{ + const osg::Billboard::PositionList& posList = node.getPositionList(); + os << posList.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::Billboard::PositionList::const_iterator itr=posList.begin(); + itr!=posList.end(); ++itr ) + { + os << osg::Vec3d(*itr) << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( Billboard, + new osg::Billboard, + osg::Billboard, + "osg::Object osg::Node osg::Geode osg::Billboard" ) +{ + BEGIN_ENUM_SERIALIZER( Mode, AXIAL_ROT ); + ADD_ENUM_VALUE( POINT_ROT_EYE ); + ADD_ENUM_VALUE( POINT_ROT_WORLD ); + ADD_ENUM_VALUE( AXIAL_ROT ); + END_ENUM_SERIALIZER(); // _mode + + ADD_VEC3_SERIALIZER( Axis, osg::Vec3f() ); // _axis + ADD_VEC3_SERIALIZER( Normal, osg::Vec3f() ); // _normal + ADD_USER_SERIALIZER( PositionList ); // _positionList +} diff --git a/src/osgWrappers/serializers/osg/BlendColor.cpp b/src/osgWrappers/serializers/osg/BlendColor.cpp new file mode 100644 index 000000000..6567111a0 --- /dev/null +++ b/src/osgWrappers/serializers/osg/BlendColor.cpp @@ -0,0 +1,12 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( BlendColor, + new osg::BlendColor, + osg::BlendColor, + "osg::Object osg::StateAttribute osg::BlendColor" ) +{ + ADD_VEC4_SERIALIZER( ConstantColor, osg::Vec4() ); // _constantColor +} diff --git a/src/osgWrappers/serializers/osg/BlendEquation.cpp b/src/osgWrappers/serializers/osg/BlendEquation.cpp new file mode 100644 index 000000000..539f72f43 --- /dev/null +++ b/src/osgWrappers/serializers/osg/BlendEquation.cpp @@ -0,0 +1,32 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( BlendEquation, + new osg::BlendEquation, + osg::BlendEquation, + "osg::Object osg::StateAttribute osg::BlendEquation" ) +{ + BEGIN_ENUM_SERIALIZER2( EquationRGB, osg::BlendEquation::Equation, FUNC_ADD ); + ADD_ENUM_VALUE( RGBA_MIN ); + ADD_ENUM_VALUE( RGBA_MAX ); + ADD_ENUM_VALUE( ALPHA_MIN ); + ADD_ENUM_VALUE( ALPHA_MAX ); + ADD_ENUM_VALUE( LOGIC_OP ); + ADD_ENUM_VALUE( FUNC_ADD ); + ADD_ENUM_VALUE( FUNC_SUBTRACT ); + ADD_ENUM_VALUE( FUNC_REVERSE_SUBTRACT ); + END_ENUM_SERIALIZER(); // _equationRGB + + BEGIN_ENUM_SERIALIZER2( EquationAlpha, osg::BlendEquation::Equation, FUNC_ADD ); + ADD_ENUM_VALUE( RGBA_MIN ); + ADD_ENUM_VALUE( RGBA_MAX ); + ADD_ENUM_VALUE( ALPHA_MIN ); + ADD_ENUM_VALUE( ALPHA_MAX ); + ADD_ENUM_VALUE( LOGIC_OP ); + ADD_ENUM_VALUE( FUNC_ADD ); + ADD_ENUM_VALUE( FUNC_SUBTRACT ); + ADD_ENUM_VALUE( FUNC_REVERSE_SUBTRACT ); + END_ENUM_SERIALIZER(); // _equationAlpha +} diff --git a/src/osgWrappers/serializers/osg/BlendFunc.cpp b/src/osgWrappers/serializers/osg/BlendFunc.cpp new file mode 100644 index 000000000..aa196d9e0 --- /dev/null +++ b/src/osgWrappers/serializers/osg/BlendFunc.cpp @@ -0,0 +1,15 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( BlendFunc, + new osg::BlendFunc, + osg::BlendFunc, + "osg::Object osg::StateAttribute osg::BlendFunc" ) +{ + ADD_GLENUM_SERIALIZER( SourceRGB, GLenum, GL_NONE ); // _source_factor + ADD_GLENUM_SERIALIZER( SourceAlpha, GLenum, GL_NONE ); // _source_factor_alpha + ADD_GLENUM_SERIALIZER( DestinationRGB, GLenum, GL_NONE ); // _destination_factor + ADD_GLENUM_SERIALIZER( DestinationAlpha, GLenum, GL_NONE ); // _destination_factor_alpha +} diff --git a/src/osgWrappers/serializers/osg/Box.cpp b/src/osgWrappers/serializers/osg/Box.cpp new file mode 100644 index 000000000..af5f40f2a --- /dev/null +++ b/src/osgWrappers/serializers/osg/Box.cpp @@ -0,0 +1,14 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Box, + new osg::Box, + osg::Box, + "osg::Object osg::Shape osg::Box" ) +{ + ADD_VEC3_SERIALIZER( Center, osg::Vec3() ); // _center + ADD_VEC3_SERIALIZER( HalfLengths, osg::Vec3() ); // _halfLengths + ADD_QUAT_SERIALIZER( Rotation, osg::Quat() ); // _rotation +} diff --git a/src/osgWrappers/serializers/osg/Camera.cpp b/src/osgWrappers/serializers/osg/Camera.cpp new file mode 100644 index 000000000..b55b28924 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Camera.cpp @@ -0,0 +1,271 @@ +#include +#include +#include +#include + +BEGIN_USER_TABLE( RenderOrder, osg::Camera ); + ADD_USER_VALUE( PRE_RENDER ); + ADD_USER_VALUE( NESTED_RENDER ); + ADD_USER_VALUE( POST_RENDER ); +END_USER_TABLE() + +USER_READ_FUNC( RenderOrder, readOrderValue ) +USER_WRITE_FUNC( RenderOrder, writeOrderValue ) + +BEGIN_USER_TABLE( BufferComponent, osg::Camera ); + ADD_USER_VALUE( DEPTH_BUFFER ); + ADD_USER_VALUE( STENCIL_BUFFER ); + ADD_USER_VALUE( PACKED_DEPTH_STENCIL_BUFFER ); + ADD_USER_VALUE( COLOR_BUFFER ); + ADD_USER_VALUE( COLOR_BUFFER0 ); + ADD_USER_VALUE( COLOR_BUFFER1 ); + ADD_USER_VALUE( COLOR_BUFFER2 ); + ADD_USER_VALUE( COLOR_BUFFER3 ); + ADD_USER_VALUE( COLOR_BUFFER4 ); + ADD_USER_VALUE( COLOR_BUFFER5 ); + ADD_USER_VALUE( COLOR_BUFFER6 ); + ADD_USER_VALUE( COLOR_BUFFER7 ); + ADD_USER_VALUE( COLOR_BUFFER8 ); + ADD_USER_VALUE( COLOR_BUFFER9 ); + ADD_USER_VALUE( COLOR_BUFFER10 ); + ADD_USER_VALUE( COLOR_BUFFER11 ); + ADD_USER_VALUE( COLOR_BUFFER12 ); + ADD_USER_VALUE( COLOR_BUFFER13 ); + ADD_USER_VALUE( COLOR_BUFFER14 ); + ADD_USER_VALUE( COLOR_BUFFER15 ); +END_USER_TABLE() + +USER_READ_FUNC( BufferComponent, readBufferComponent ) +USER_WRITE_FUNC( BufferComponent, writeBufferComponent ) + +static osg::Camera::Attachment readBufferAttachment( osgDB::InputStream& is ) +{ + osg::Camera::Attachment attachment; + char type = -1; is >> osgDB::PROPERTY("Type") >> type; + if ( type==0 ) + { + is >> osgDB::PROPERTY("InternalFormat") >> attachment._internalFormat; + return attachment; + } + else if ( type==1 ) + { + is >> osgDB::PROPERTY("Image"); + attachment._image = dynamic_cast( is.readObject() ); + } + else if ( type==2 ) + { + is >> osgDB::PROPERTY("Texture"); + attachment._texture = dynamic_cast( is.readObject() ); + is >> osgDB::PROPERTY("Level") >> attachment._level; + is >> osgDB::PROPERTY("Face") >> attachment._face; + is >> osgDB::PROPERTY("MipMapGeneration") >> attachment._mipMapGeneration; + } + else + return attachment; + + is >> osgDB::PROPERTY("MultisampleSamples") >> attachment._multisampleSamples; + is >> osgDB::PROPERTY("MultisampleColorSamples") >> attachment._multisampleColorSamples; + return attachment; +} + +static void writeBufferAttachment( osgDB::OutputStream& os, const osg::Camera::Attachment& attachment ) +{ + os << osgDB::PROPERTY("Type"); + if ( attachment._internalFormat!=GL_NONE ) + { + os << (char)0 << std::endl; + os << osgDB::PROPERTY("InternalFormat") << GLENUM(attachment._internalFormat) << std::endl; + return; + } + else if ( attachment._image.valid() ) + { + os << (char)1 << std::endl; + os << osgDB::PROPERTY("Image") << attachment._image.get(); + } + else if ( attachment._texture.valid() ) + { + os << (char)2 << std::endl; + os << osgDB::PROPERTY("Texture") << attachment._texture.get(); + os << osgDB::PROPERTY("Level") << attachment._level << std::endl; + os << osgDB::PROPERTY("Face") << attachment._face << std::endl; + os << osgDB::PROPERTY("MipMapGeneration") << attachment._mipMapGeneration << std::endl; + } + else + { + os << (char)-1 << std::endl; + return; + } + + os << osgDB::PROPERTY("MultisampleSamples") << attachment._multisampleSamples << std::endl; + os << osgDB::PROPERTY("MultisampleColorSamples") << attachment._multisampleColorSamples << std::endl; +} + +// _clearMask +static bool checkClearMask( const osg::Camera& node ) +{ + return node.getClearMask()!=(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); +} + +static bool readClearMask( osgDB::InputStream& is, osg::Camera& node ) +{ + GLbitfield mask = 0; + if ( is.isBinary() ) + { + int maskValue; is >> maskValue; + mask = (GLbitfield)maskValue; + } + else + { + std::string maskSetString; is >> maskSetString; + osgDB::StringList maskList; osgDB::split( maskSetString, maskList, '|' ); + for ( unsigned int i=0; i> orderNumber; + node.setRenderOrder( static_cast(order), orderNumber ); + return true; +} + +static bool writeRenderOrder( osgDB::OutputStream& os, const osg::Camera& node ) +{ + writeOrderValue( os, (int)node.getRenderOrder() ); + os << node.getRenderOrderNum() << std::endl; + return true; +} + +// _bufferAttachmentMap +static bool checkBufferAttachmentMap( const osg::Camera& node ) +{ + return node.getBufferAttachmentMap().size()>0; +} + +static bool readBufferAttachmentMap( osgDB::InputStream& is, osg::Camera& node ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> osgDB::PROPERTY("Attachment"); + osg::Camera::BufferComponent bufferComponent = + static_cast( readBufferComponent(is) ); + is >> osgDB::BEGIN_BRACKET; + osg::Camera::Attachment attachment = readBufferAttachment(is); + is >> osgDB::END_BRACKET; + + if ( attachment._internalFormat!=GL_NONE ) + { + node.attach( bufferComponent, attachment._internalFormat ); + } + else if ( attachment._image.valid() ) + { + node.attach( bufferComponent, attachment._image.get(), + attachment._multisampleSamples, attachment._multisampleColorSamples ); + } + else if ( attachment._texture.valid() ) + { + node.attach( bufferComponent, attachment._texture.get(), + attachment._level, attachment._face, attachment._mipMapGeneration, + attachment._multisampleSamples, attachment._multisampleColorSamples ); + } + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeBufferAttachmentMap( osgDB::OutputStream& os, const osg::Camera& node ) +{ + const osg::Camera::BufferAttachmentMap& map = node.getBufferAttachmentMap(); + os << map.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::Camera::BufferAttachmentMap::const_iterator itr=map.begin(); + itr!=map.end(); ++itr ) + { + os << osgDB::PROPERTY("Attachment"); writeBufferComponent( os, itr->first ); + os << osgDB::BEGIN_BRACKET << std::endl; + writeBufferAttachment( os, itr->second ); + os << osgDB::END_BRACKET << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( Camera, + new osg::Camera, + osg::Camera, + "osg::Object osg::Node osg::Group osg::Transform osg::Camera" ) +{ + ADD_BOOL_SERIALIZER( AllowEventFocus, true ); // _allowEventFocus + ADD_USER_SERIALIZER( ClearMask ); // _clearMask + ADD_VEC4_SERIALIZER( ClearColor, osg::Vec4() ); // _clearColor + ADD_VEC4_SERIALIZER( ClearAccum, osg::Vec4() ); // _clearAccum + ADD_DOUBLE_SERIALIZER( ClearDepth, 1.0 ); // _clearDepth + ADD_INT_SERIALIZER( ClearStencil, 0 ); // _clearStencil + ADD_OBJECT_SERIALIZER( ColorMask, osg::ColorMask, NULL ); // _colorMask + ADD_OBJECT_SERIALIZER( Viewport, osg::Viewport, NULL ); // _viewport + + BEGIN_ENUM_SERIALIZER( TransformOrder, PRE_MULTIPLY ); + ADD_ENUM_VALUE( PRE_MULTIPLY ); + ADD_ENUM_VALUE( POST_MULTIPLY ); + END_ENUM_SERIALIZER(); // _transformOrder + + BEGIN_ENUM_SERIALIZER( ProjectionResizePolicy, HORIZONTAL ); + ADD_ENUM_VALUE( FIXED ); + ADD_ENUM_VALUE( HORIZONTAL ); + ADD_ENUM_VALUE( VERTICAL ); + END_ENUM_SERIALIZER(); // _projectionResizePolicy + + ADD_MATRIXD_SERIALIZER( ProjectionMatrix, osg::Matrixd() ); // _projectionMatrix + ADD_MATRIXD_SERIALIZER( ViewMatrix, osg::Matrixd() ); // _viewMatrix + ADD_USER_SERIALIZER( RenderOrder ); // _renderOrder & _renderOrderNum + ADD_GLENUM_SERIALIZER( DrawBuffer, GLenum, GL_NONE ); // _drawBuffer + ADD_GLENUM_SERIALIZER( ReadBuffer, GLenum, GL_NONE ); // _readBuffer + + BEGIN_ENUM_SERIALIZER( RenderTargetImplementation, FRAME_BUFFER ); + ADD_ENUM_VALUE( FRAME_BUFFER_OBJECT ); + ADD_ENUM_VALUE( PIXEL_BUFFER_RTT ); + ADD_ENUM_VALUE( PIXEL_BUFFER ); + ADD_ENUM_VALUE( FRAME_BUFFER ); + ADD_ENUM_VALUE( SEPERATE_WINDOW ); + END_ENUM_SERIALIZER(); // _renderTargetImplementation + + ADD_USER_SERIALIZER( BufferAttachmentMap ); // _bufferAttachmentMap + ADD_OBJECT_SERIALIZER( InitialDrawCallback, osg::Camera::DrawCallback, NULL ); // _initialDrawCallback + ADD_OBJECT_SERIALIZER( PreDrawCallback, osg::Camera::DrawCallback, NULL ); // _preDrawCallback + ADD_OBJECT_SERIALIZER( PostDrawCallback, osg::Camera::DrawCallback, NULL ); // _postDrawCallback + ADD_OBJECT_SERIALIZER( FinalDrawCallback, osg::Camera::DrawCallback, NULL ); // _finalDrawCallback +} diff --git a/src/osgWrappers/serializers/osg/CameraView.cpp b/src/osgWrappers/serializers/osg/CameraView.cpp new file mode 100644 index 000000000..17b3ed037 --- /dev/null +++ b/src/osgWrappers/serializers/osg/CameraView.cpp @@ -0,0 +1,22 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( CameraView, + new osg::CameraView, + osg::CameraView, + "osg::Object osg::Node osg::Group osg::Transform osg::CameraView" ) +{ + ADD_VEC3D_SERIALIZER( Position, osg::Vec3d() ); // _position + ADD_QUAT_SERIALIZER( Attitude, osg::Quat() ); // _attitude + ADD_DOUBLE_SERIALIZER( FieldOfView, 60.0 ); // _fieldOfView + + BEGIN_ENUM_SERIALIZER( FieldOfViewMode, VERTICAL ); + ADD_ENUM_VALUE( UNCONSTRAINED ); + ADD_ENUM_VALUE( HORIZONTAL ); + ADD_ENUM_VALUE( VERTICAL ); + END_ENUM_SERIALIZER(); // _fieldOfViewMode + + ADD_DOUBLE_SERIALIZER( FocalLength, 0.0 ); // _focalLength +} diff --git a/src/osgWrappers/serializers/osg/Capsule.cpp b/src/osgWrappers/serializers/osg/Capsule.cpp new file mode 100644 index 000000000..bd7b14ca6 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Capsule.cpp @@ -0,0 +1,15 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Capsule, + new osg::Capsule, + osg::Capsule, + "osg::Object osg::Shape osg::Capsule" ) +{ + ADD_VEC3_SERIALIZER( Center, osg::Vec3() ); // _center + ADD_FLOAT_SERIALIZER( Radius, 0.0f ); // _radius + ADD_FLOAT_SERIALIZER( Height, 0.0f ); // _height + ADD_QUAT_SERIALIZER( Rotation, osg::Quat() ); // _rotation +} diff --git a/src/osgWrappers/serializers/osg/ClampColor.cpp b/src/osgWrappers/serializers/osg/ClampColor.cpp new file mode 100644 index 000000000..0ac608ed7 --- /dev/null +++ b/src/osgWrappers/serializers/osg/ClampColor.cpp @@ -0,0 +1,14 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( ClampColor, + new osg::ClampColor, + osg::ClampColor, + "osg::Object osg::StateAttribute osg::ClampColor" ) +{ + ADD_GLENUM_SERIALIZER( ClampVertexColor, GLenum, GL_FIXED_ONLY ); // _clampVertexColor + ADD_GLENUM_SERIALIZER( ClampFragmentColor, GLenum, GL_FIXED_ONLY ); // _clampFragmentColor + ADD_GLENUM_SERIALIZER( ClampReadColor, GLenum, GL_FIXED_ONLY ); // _clampReadColor +} diff --git a/src/osgWrappers/serializers/osg/ClearNode.cpp b/src/osgWrappers/serializers/osg/ClearNode.cpp new file mode 100644 index 000000000..08da79bb5 --- /dev/null +++ b/src/osgWrappers/serializers/osg/ClearNode.cpp @@ -0,0 +1,63 @@ +#include +#include +#include +#include + +// _clearMask +static bool checkClearMask( const osg::ClearNode& node ) +{ + return node.getClearMask()!=(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); +} + +static bool readClearMask( osgDB::InputStream& is, osg::ClearNode& node ) +{ + GLbitfield mask = GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT; + if ( is.isBinary() ) + { + int maskValue; is >> maskValue; + mask = (GLbitfield)maskValue; + } + else + { + std::string maskSetString; is >> maskSetString; + osgDB::StringList maskList; osgDB::split( maskSetString, maskList, '|' ); + for ( unsigned int i=0; i +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( ClipNode, + new osg::ClipNode, + osg::ClipNode, + "osg::Object osg::Node osg::Group osg::ClipNode" ) +{ + ADD_LIST_SERIALIZER( ClipPlaneList, osg::ClipNode::ClipPlaneList ); // _planes + + BEGIN_ENUM_SERIALIZER( ReferenceFrame, RELATIVE_RF ); + ADD_ENUM_VALUE( RELATIVE_RF ); + ADD_ENUM_VALUE( ABSOLUTE_RF ); + END_ENUM_SERIALIZER(); // _referenceFrame +} diff --git a/src/osgWrappers/serializers/osg/ClipPlane.cpp b/src/osgWrappers/serializers/osg/ClipPlane.cpp new file mode 100644 index 000000000..f995b1abc --- /dev/null +++ b/src/osgWrappers/serializers/osg/ClipPlane.cpp @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( ClipPlane, + new osg::ClipPlane, + osg::ClipPlane, + "osg::Object osg::StateAttribute osg::ClipPlane" ) +{ + ADD_VEC4D_SERIALIZER( ClipPlane, osg::Vec4d() ); // _clipPlane + ADD_UINT_SERIALIZER( ClipPlaneNum, 0 ); // _clipPlaneNum +} diff --git a/src/osgWrappers/serializers/osg/ClusterCullingCallback.cpp b/src/osgWrappers/serializers/osg/ClusterCullingCallback.cpp new file mode 100644 index 000000000..d9e55673a --- /dev/null +++ b/src/osgWrappers/serializers/osg/ClusterCullingCallback.cpp @@ -0,0 +1,21 @@ +#undef OBJECT_CAST +#define OBJECT_CAST dynamic_cast + +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( ClusterCullingCallback, + new osg::ClusterCullingCallback, + osg::ClusterCullingCallback, + "osg::Object osg::NodeCallback osg::ClusterCullingCallback" ) +{ + ADD_VEC3_SERIALIZER( ControlPoint, osg::Vec3() ); // _controlPoint + ADD_VEC3_SERIALIZER( Normal, osg::Vec3() ); // _normal + ADD_FLOAT_SERIALIZER( Radius, -1.0f ); // _radius + ADD_FLOAT_SERIALIZER( Deviation, -1.0f ); // _deviation +} + +#undef OBJECT_CAST +#define OBJECT_CAST static_cast diff --git a/src/osgWrappers/serializers/osg/ColorMask.cpp b/src/osgWrappers/serializers/osg/ColorMask.cpp new file mode 100644 index 000000000..5778abadf --- /dev/null +++ b/src/osgWrappers/serializers/osg/ColorMask.cpp @@ -0,0 +1,15 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( ColorMask, + new osg::ColorMask, + osg::ColorMask, + "osg::Object osg::StateAttribute osg::ColorMask" ) +{ + ADD_BOOL_SERIALIZER( RedMask, true ); // _red + ADD_BOOL_SERIALIZER( GreenMask, true ); // _green + ADD_BOOL_SERIALIZER( BlueMask, true ); // _blue + ADD_BOOL_SERIALIZER( AlphaMask, true ); // _alpha +} diff --git a/src/osgWrappers/serializers/osg/ColorMatrix.cpp b/src/osgWrappers/serializers/osg/ColorMatrix.cpp new file mode 100644 index 000000000..6bd7dddaa --- /dev/null +++ b/src/osgWrappers/serializers/osg/ColorMatrix.cpp @@ -0,0 +1,12 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( ColorMatrix, + new osg::ColorMatrix, + osg::ColorMatrix, + "osg::Object osg::StateAttribute osg::ColorMatrix" ) +{ + ADD_MATRIX_SERIALIZER( Matrix, osg::Matrix() ); // _matrix +} diff --git a/src/osgWrappers/serializers/osg/CompositeShape.cpp b/src/osgWrappers/serializers/osg/CompositeShape.cpp new file mode 100644 index 000000000..4b040fd08 --- /dev/null +++ b/src/osgWrappers/serializers/osg/CompositeShape.cpp @@ -0,0 +1,42 @@ +#include +#include +#include +#include + +static bool checkChildren( const osg::CompositeShape& shape ) +{ + return shape.getNumChildren()>0; +} + +static bool readChildren( osgDB::InputStream& is, osg::CompositeShape& shape ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i( is.readObject() ); + if ( child ) shape.addChild( child ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeChildren( osgDB::OutputStream& os, const osg::CompositeShape& shape ) +{ + unsigned int size = shape.getNumChildren(); + os << size << osgDB::BEGIN_BRACKET << std::endl; + for ( unsigned int i=0; i +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Cone, + new osg::Cone, + osg::Cone, + "osg::Object osg::Shape osg::Cone" ) +{ + ADD_VEC3_SERIALIZER( Center, osg::Vec3() ); // _center + ADD_FLOAT_SERIALIZER( Radius, 0.0f ); // _radius + ADD_FLOAT_SERIALIZER( Height, 0.0f ); // _height + ADD_QUAT_SERIALIZER( Rotation, osg::Quat() ); // _rotation +} diff --git a/src/osgWrappers/serializers/osg/ConvexHull.cpp b/src/osgWrappers/serializers/osg/ConvexHull.cpp new file mode 100644 index 000000000..3860b749f --- /dev/null +++ b/src/osgWrappers/serializers/osg/ConvexHull.cpp @@ -0,0 +1,11 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( ConvexHull, + new osg::ConvexHull, + osg::ConvexHull, + "osg::Object osg::Shape osg::TriangleMesh osg::ConvexHull" ) +{ +} diff --git a/src/osgWrappers/serializers/osg/ConvexPlanarOccluder.cpp b/src/osgWrappers/serializers/osg/ConvexPlanarOccluder.cpp new file mode 100644 index 000000000..3546be1d7 --- /dev/null +++ b/src/osgWrappers/serializers/osg/ConvexPlanarOccluder.cpp @@ -0,0 +1,90 @@ +#include +#include +#include +#include + +static void readConvexPlanarPolygon( osgDB::InputStream& is, osg::ConvexPlanarPolygon& polygon ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> vertex; + polygon.add( vertex ); + } + is >> osgDB::END_BRACKET; +} + +static void writeConvexPlanarPolygon( osgDB::OutputStream& os, const osg::ConvexPlanarPolygon& polygon ) +{ + const osg::ConvexPlanarPolygon::VertexList& vertices = polygon.getVertexList(); + os << vertices.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::ConvexPlanarPolygon::VertexList::const_iterator itr=vertices.begin(); + itr!=vertices.end(); ++itr ) + { + os << osg::Vec3d(*itr) << std::endl; + } + os << osgDB::END_BRACKET << std::endl; +} + +// _occluder +static bool checkOccluder( const osg::ConvexPlanarOccluder& obj ) +{ + return obj.getOccluder().getVertexList().size()>0; +} + +static bool readOccluder( osgDB::InputStream& is, osg::ConvexPlanarOccluder& obj ) +{ + osg::ConvexPlanarPolygon polygon; + readConvexPlanarPolygon( is, polygon ); + obj.setOccluder( polygon ); + return true; +} + +static bool writeOccluder( osgDB::OutputStream& os, const osg::ConvexPlanarOccluder& obj ) +{ + writeConvexPlanarPolygon( os, obj.getOccluder() ); + return true; +} + +// _holeList +static bool checkHoles( const osg::ConvexPlanarOccluder& obj ) +{ + return obj.getHoleList().size()>0; +} + +static bool readHoles( osgDB::InputStream& is, osg::ConvexPlanarOccluder& obj ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> osgDB::PROPERTY("Polygon"); + readConvexPlanarPolygon( is, polygon ); + obj.addHole( polygon ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeHoles( osgDB::OutputStream& os, const osg::ConvexPlanarOccluder& obj ) +{ + const osg::ConvexPlanarOccluder::HoleList& holes = obj.getHoleList(); + os << holes.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::ConvexPlanarOccluder::HoleList::const_iterator itr=holes.begin(); + itr!=holes.end(); ++itr ) + { + os << osgDB::PROPERTY("Polygon"); + writeConvexPlanarPolygon( os, *itr ); + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( ConvexPlanarOccluder, + new osg::ConvexPlanarOccluder, + osg::ConvexPlanarOccluder, + "osg::Object osg::ConvexPlanarOccluder" ) +{ + ADD_USER_SERIALIZER( Occluder ); // _occluder + ADD_USER_SERIALIZER( Holes ); // _holeList +} diff --git a/src/osgWrappers/serializers/osg/CoordinateSystemNode.cpp b/src/osgWrappers/serializers/osg/CoordinateSystemNode.cpp new file mode 100644 index 000000000..2680861b4 --- /dev/null +++ b/src/osgWrappers/serializers/osg/CoordinateSystemNode.cpp @@ -0,0 +1,14 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( CoordinateSystemNode, + new osg::CoordinateSystemNode, + osg::CoordinateSystemNode, + "osg::Object osg::Node osg::Group osg::CoordinateSystemNode" ) +{ + ADD_STRING_SERIALIZER( Format, "" ); // _format + ADD_STRING_SERIALIZER( CoordinateSystem, "" ); // _cs + ADD_OBJECT_SERIALIZER( EllipsoidModel, osg::EllipsoidModel, NULL ); // _ellipsoidModel +} diff --git a/src/osgWrappers/serializers/osg/CullFace.cpp b/src/osgWrappers/serializers/osg/CullFace.cpp new file mode 100644 index 000000000..0f1fca657 --- /dev/null +++ b/src/osgWrappers/serializers/osg/CullFace.cpp @@ -0,0 +1,16 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( CullFace, + new osg::CullFace, + osg::CullFace, + "osg::Object osg::StateAttribute osg::CullFace" ) +{ + BEGIN_ENUM_SERIALIZER( Mode, BACK ); + ADD_ENUM_VALUE( FRONT ); + ADD_ENUM_VALUE( BACK ); + ADD_ENUM_VALUE( FRONT_AND_BACK ); + END_ENUM_SERIALIZER(); // _mode +} diff --git a/src/osgWrappers/serializers/osg/Cylinder.cpp b/src/osgWrappers/serializers/osg/Cylinder.cpp new file mode 100644 index 000000000..d90d00e01 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Cylinder.cpp @@ -0,0 +1,15 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Cylinder, + new osg::Cylinder, + osg::Cylinder, + "osg::Object osg::Shape osg::Cylinder" ) +{ + ADD_VEC3_SERIALIZER( Center, osg::Vec3() ); // _center + ADD_FLOAT_SERIALIZER( Radius, 0.0f ); // _radius + ADD_FLOAT_SERIALIZER( Height, 0.0f ); // _height + ADD_QUAT_SERIALIZER( Rotation, osg::Quat() ); // _rotation +} diff --git a/src/osgWrappers/serializers/osg/Depth.cpp b/src/osgWrappers/serializers/osg/Depth.cpp new file mode 100644 index 000000000..c16f953f8 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Depth.cpp @@ -0,0 +1,25 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Depth, + new osg::Depth, + osg::Depth, + "osg::Object osg::StateAttribute osg::Depth" ) +{ + BEGIN_ENUM_SERIALIZER( Function, LESS ); + ADD_ENUM_VALUE( NEVER ); + ADD_ENUM_VALUE( LESS ); + ADD_ENUM_VALUE( EQUAL ); + ADD_ENUM_VALUE( LEQUAL ); + ADD_ENUM_VALUE( GREATER ); + ADD_ENUM_VALUE( NOTEQUAL ); + ADD_ENUM_VALUE( GEQUAL ); + ADD_ENUM_VALUE( ALWAYS ); + END_ENUM_SERIALIZER(); // _func + + ADD_DOUBLE_SERIALIZER( ZNear, 0.0 ); // _zNear + ADD_DOUBLE_SERIALIZER( ZFar, 1.0 ); // _zFar + ADD_BOOL_SERIALIZER( WriteMask, true ); // _depthWriteMask +} diff --git a/src/osgWrappers/serializers/osg/DrawPixels.cpp b/src/osgWrappers/serializers/osg/DrawPixels.cpp new file mode 100644 index 000000000..4746aa314 --- /dev/null +++ b/src/osgWrappers/serializers/osg/DrawPixels.cpp @@ -0,0 +1,36 @@ +#include +#include +#include +#include + +static bool checkArea( const osg::DrawPixels& drawable ) +{ + return drawable.getUseSubImage(); +} + +static bool readArea( osgDB::InputStream& is, osg::DrawPixels& drawable ) +{ + unsigned int x, y, w, h; + is >> x >> y >> w >> h; + drawable.setSubImageDimensions( x, y, w, h ); + return true; +} + +static bool writeArea( osgDB::OutputStream& os, const osg::DrawPixels& drawable ) +{ + unsigned int x, y, w, h; + drawable.getSubImageDimensions( x, y, w, h ); + os << x << y << w << h << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( DrawPixels, + new osg::DrawPixels, + osg::DrawPixels, + "osg::Object osg::Drawable osg::DrawPixels" ) +{ + ADD_VEC3_SERIALIZER( Position, osg::Vec3() ); // _position + ADD_IMAGE_SERIALIZER( Image, osg::Image, NULL ); // _image + ADD_BOOL_SERIALIZER( UseSubImage, false ); // _useSubImage + ADD_USER_SERIALIZER( Area ); // _offsetX, _offsetY, _width, _height +} diff --git a/src/osgWrappers/serializers/osg/Drawable.cpp b/src/osgWrappers/serializers/osg/Drawable.cpp new file mode 100644 index 000000000..a9d14db49 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Drawable.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#include + +static bool checkInitialBound( const osg::Drawable& drawable ) +{ + return drawable.getInitialBound().valid(); +} + +static bool readInitialBound( osgDB::InputStream& is, osg::Drawable& drawable ) +{ + osg::Vec3d min, max; + is >> osgDB::BEGIN_BRACKET; + is >> osgDB::PROPERTY("Minimum") >> min; + is >> osgDB::PROPERTY("Maximum") >> max; + is >> osgDB::END_BRACKET; + drawable.setInitialBound( osg::BoundingBox(min, max) ); + return true; +} + +static bool writeInitialBound( osgDB::OutputStream& os, const osg::Drawable& drawable ) +{ + const osg::BoundingBox& bb = drawable.getInitialBound(); + os << osgDB::BEGIN_BRACKET << std::endl; + os << osgDB::PROPERTY("Minimum") << osg::Vec3d(bb._min) << std::endl; + os << osgDB::PROPERTY("Maximum") << osg::Vec3d(bb._max) << std::endl; + os << osgDB::END_BRACKET; + os << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( Drawable, + /*new osg::Drawable*/NULL, + osg::Drawable, + "osg::Object osg::Drawable" ) +{ + ADD_OBJECT_SERIALIZER( StateSet, osg::StateSet, NULL ); // _stateset + ADD_USER_SERIALIZER( InitialBound ); // _initialBound + ADD_OBJECT_SERIALIZER( ComputeBoundingBoxCallback, + osg::Drawable::ComputeBoundingBoxCallback, NULL ); // _computeBoundCallback + ADD_OBJECT_SERIALIZER( Shape, osg::Shape, NULL ); // _shape + ADD_BOOL_SERIALIZER( SupportsDisplayList, true ); // _supportsDisplayList + ADD_BOOL_SERIALIZER( UseDisplayList, true ); // _useDisplayList + ADD_BOOL_SERIALIZER( UseVertexBufferObjects, false ); // _useVertexBufferObjects + ADD_OBJECT_SERIALIZER( UpdateCallback, osg::Drawable::UpdateCallback, NULL ); // _updateCallback + ADD_OBJECT_SERIALIZER( EventCallback, osg::Drawable::EventCallback, NULL ); // _eventCallback + ADD_OBJECT_SERIALIZER( CullCallback, osg::Drawable::CullCallback, NULL ); // _cullCallback + ADD_OBJECT_SERIALIZER( DrawCallback, osg::Drawable::DrawCallback, NULL ); // _drawCallback +} diff --git a/src/osgWrappers/serializers/osg/EllipsoidModel.cpp b/src/osgWrappers/serializers/osg/EllipsoidModel.cpp new file mode 100644 index 000000000..060193841 --- /dev/null +++ b/src/osgWrappers/serializers/osg/EllipsoidModel.cpp @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( EllipsoidModel, + new osg::EllipsoidModel, + osg::EllipsoidModel, + "osg::Object osg::EllipsoidModel" ) +{ + ADD_DOUBLE_SERIALIZER( RadiusEquator, 0.0 ); // _radiusEquator + ADD_DOUBLE_SERIALIZER( RadiusPolar, 0.0 ); // _radiusPolar +} diff --git a/src/osgWrappers/serializers/osg/Fog.cpp b/src/osgWrappers/serializers/osg/Fog.cpp new file mode 100644 index 000000000..e367b2066 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Fog.cpp @@ -0,0 +1,22 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Fog, + new osg::Fog, + osg::Fog, + "osg::Object osg::StateAttribute osg::Fog" ) +{ + BEGIN_ENUM_SERIALIZER( Mode, LINEAR ); + ADD_ENUM_VALUE( LINEAR ); + ADD_ENUM_VALUE( EXP ); + ADD_ENUM_VALUE( EXP2 ); + END_ENUM_SERIALIZER(); // _mode + + ADD_FLOAT_SERIALIZER( Start, 0.0f ); // _start + ADD_FLOAT_SERIALIZER( End, 1.0f ); // _end + ADD_FLOAT_SERIALIZER( Density, 1.0f ); // _density + ADD_VEC4_SERIALIZER( Color, osg::Vec4() ); // _color + ADD_GLENUM_SERIALIZER( FogCoordinateSource, GLint, GL_NONE ); // _fogCoordinateSource +} diff --git a/src/osgWrappers/serializers/osg/FragmentProgram.cpp b/src/osgWrappers/serializers/osg/FragmentProgram.cpp new file mode 100644 index 000000000..c142c4b6d --- /dev/null +++ b/src/osgWrappers/serializers/osg/FragmentProgram.cpp @@ -0,0 +1,78 @@ +#include +#include +#include +#include + +// _programLocalParameters +static bool checkLocalParameters( const osg::FragmentProgram& fp ) +{ + return fp.getLocalParameters().size()>0; +} + +static bool readLocalParameters( osgDB::InputStream& is, osg::FragmentProgram& fp ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> key >> value; + fp.setProgramLocalParameter( key, value ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeLocalParameters( osgDB::OutputStream& os, const osg::FragmentProgram& fp ) +{ + const osg::FragmentProgram::LocalParamList& params = fp.getLocalParameters(); + os << params.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::FragmentProgram::LocalParamList::const_iterator itr=params.begin(); + itr!=params.end(); ++itr ) + { + os << itr->first << osg::Vec4d(itr->second) << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +// _matrixList +static bool checkMatrices( const osg::FragmentProgram& fp ) +{ + return fp.getMatrices().size()>0; +} + +static bool readMatrices( osgDB::InputStream& is, osg::FragmentProgram& fp ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> key >> value; + fp.setMatrix( key, value ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeMatrices( osgDB::OutputStream& os, const osg::FragmentProgram& fp ) +{ + const osg::FragmentProgram::MatrixList& matrices = fp.getMatrices(); + os << matrices.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::FragmentProgram::MatrixList::const_iterator itr=matrices.begin(); + itr!=matrices.end(); ++itr ) + { + os << (unsigned int)itr->first << osg::Matrixd(itr->second) << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( FragmentProgram, + new osg::FragmentProgram, + osg::FragmentProgram, + "osg::Object osg::StateAttribute osg::FragmentProgram" ) +{ + ADD_STRING_SERIALIZER( FragmentProgram, "" ); // _fragmentProgram + ADD_USER_SERIALIZER( LocalParameters ); // _programLocalParameters + ADD_USER_SERIALIZER( Matrices ); // _matrixList +} diff --git a/src/osgWrappers/serializers/osg/FrontFace.cpp b/src/osgWrappers/serializers/osg/FrontFace.cpp new file mode 100644 index 000000000..2090c81b5 --- /dev/null +++ b/src/osgWrappers/serializers/osg/FrontFace.cpp @@ -0,0 +1,15 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( FrontFace, + new osg::FrontFace, + osg::FrontFace, + "osg::Object osg::StateAttribute osg::FrontFace" ) +{ + BEGIN_ENUM_SERIALIZER( Mode, COUNTER_CLOCKWISE ); + ADD_ENUM_VALUE( CLOCKWISE ); + ADD_ENUM_VALUE( COUNTER_CLOCKWISE ); + END_ENUM_SERIALIZER(); // _mode +} diff --git a/src/osgWrappers/serializers/osg/Geode.cpp b/src/osgWrappers/serializers/osg/Geode.cpp new file mode 100644 index 000000000..e50563f07 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Geode.cpp @@ -0,0 +1,41 @@ +#include +#include +#include +#include + +static bool checkDrawables( const osg::Geode& node ) +{ + return node.getNumDrawables()>0; +} + +static bool readDrawables( osgDB::InputStream& is, osg::Geode& node ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i( is.readObject() ); + if ( drawable ) node.addDrawable( drawable ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeDrawables( osgDB::OutputStream& os, const osg::Geode& node ) +{ + unsigned int size = node.getNumDrawables(); + os << size << osgDB::BEGIN_BRACKET << std::endl; + for ( unsigned int i=0; i +#include +#include +#include + +BEGIN_USER_TABLE( AttributeBinding, osg::Geometry ); + ADD_USER_VALUE( BIND_OFF ); + ADD_USER_VALUE( BIND_OVERALL ); + ADD_USER_VALUE( BIND_PER_PRIMITIVE_SET ); + ADD_USER_VALUE( BIND_PER_PRIMITIVE ); + ADD_USER_VALUE( BIND_PER_VERTEX ); +END_USER_TABLE() + +USER_READ_FUNC( AttributeBinding, readAttributeBinding ) +USER_WRITE_FUNC( AttributeBinding, writeAttributeBinding ) + +static void readArrayData( osgDB::InputStream& is, osg::Geometry::ArrayData& data ) +{ + bool hasArray = false; + is >> osgDB::PROPERTY("Array") >> hasArray; + if ( hasArray ) data.array = is.readArray(); + + bool hasIndices = false; + is >> osgDB::PROPERTY("Indices") >> hasIndices; + if ( hasIndices ) data.indices = dynamic_cast( is.readArray() ); + + is >> osgDB::PROPERTY("Binding"); + data.binding = (osg::Geometry::AttributeBinding)readAttributeBinding(is); + + int normalizeValue = 0; + is >> osgDB::PROPERTY("Normalize") >> normalizeValue; + data.normalize = normalizeValue; +} + +static void writeArrayData( osgDB::OutputStream& os, const osg::Geometry::ArrayData& data ) +{ + os << osgDB::PROPERTY("Array") << data.array.valid(); + if ( data.array.valid() ) os << data.array.get(); + else os << std::endl; + + os << osgDB::PROPERTY("Indices") << data.indices.valid(); + if ( data.indices.valid() ) os << data.indices.get(); + else os << std::endl; + + os << osgDB::PROPERTY("Binding"); writeAttributeBinding(os, data.binding); os << std::endl; + os << osgDB::PROPERTY("Normalize") << (int)data.normalize << std::endl; +} + +#define ADD_ARRAYDATA_FUNCTIONS( PROP ) \ + static bool check##PROP( const osg::Geometry& geom ) \ + { return geom.get##PROP().array.valid(); } \ + static bool read##PROP( osgDB::InputStream& is, osg::Geometry& geom ) { \ + osg::Geometry::ArrayData data; \ + is >> osgDB::BEGIN_BRACKET; readArrayData(is, data); \ + is >> osgDB::END_BRACKET; \ + geom.set##PROP(data); \ + return true; \ + } \ + static bool write##PROP( osgDB::OutputStream& os, const osg::Geometry& geom ) { \ + os << osgDB::BEGIN_BRACKET << std::endl; \ + writeArrayData(os, geom.get##PROP()); \ + os << osgDB::END_BRACKET << std::endl; \ + return true; \ + } + +ADD_ARRAYDATA_FUNCTIONS( VertexData ) +ADD_ARRAYDATA_FUNCTIONS( NormalData ) +ADD_ARRAYDATA_FUNCTIONS( ColorData ) +ADD_ARRAYDATA_FUNCTIONS( SecondaryColorData ) +ADD_ARRAYDATA_FUNCTIONS( FogCoordData ) + +#define ADD_ARRAYLIST_FUNCTIONS( PROP, LISTNAME ) \ + static bool check##PROP( const osg::Geometry& geom ) \ + { return geom.get##LISTNAME().size()>0; } \ + static bool read##PROP( osgDB::InputStream& is, osg::Geometry& geom ) { \ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; \ + for ( unsigned int i=0; i> osgDB::PROPERTY("Data") >> osgDB::BEGIN_BRACKET; \ + readArrayData(is, data); \ + is >> osgDB::END_BRACKET; geom.set##PROP(i, data); } \ + is >> osgDB::END_BRACKET; \ + return true; \ + } \ + static bool write##PROP( osgDB::OutputStream& os, const osg::Geometry& geom ) { \ + const osg::Geometry::ArrayDataList& LISTNAME = geom.get##LISTNAME(); \ + os << LISTNAME.size() << osgDB::BEGIN_BRACKET << std::endl; \ + for ( osg::Geometry::ArrayDataList::const_iterator itr=LISTNAME.begin(); \ + itr!=LISTNAME.end(); ++itr ) { \ + os << osgDB::PROPERTY("Data") << osgDB::BEGIN_BRACKET << std::endl; \ + writeArrayData(os, *itr); os << osgDB::END_BRACKET << std::endl; \ + } \ + os << osgDB::END_BRACKET << std::endl; \ + return true; \ + } + +ADD_ARRAYLIST_FUNCTIONS( TexCoordData, TexCoordArrayList ) +ADD_ARRAYLIST_FUNCTIONS( VertexAttribData, VertexAttribArrayList ) + +REGISTER_OBJECT_WRAPPER( Geometry, + new osg::Geometry, + osg::Geometry, + "osg::Object osg::Drawable osg::Geometry" ) +{ + ADD_LIST_SERIALIZER( PrimitiveSetList, osg::Geometry::PrimitiveSetList ); // _primitives + ADD_USER_SERIALIZER( VertexData ); // _vertexData + ADD_USER_SERIALIZER( NormalData ); // _normalData + ADD_USER_SERIALIZER( ColorData ); // _colorData + ADD_USER_SERIALIZER( SecondaryColorData ); // _secondaryColorData + ADD_USER_SERIALIZER( FogCoordData ); // _fogCoordData + ADD_USER_SERIALIZER( TexCoordData ); // _texCoordList + ADD_USER_SERIALIZER( VertexAttribData ); // _vertexAttribList + ADD_BOOL_SERIALIZER( FastPathHint, true ); // _fastPathHint + ADD_OBJECT_SERIALIZER( InternalOptimizedGeometry, osg::Geometry, NULL ); // _internalOptimizedGeometry +} diff --git a/src/osgWrappers/serializers/osg/Group.cpp b/src/osgWrappers/serializers/osg/Group.cpp new file mode 100644 index 000000000..0325be560 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Group.cpp @@ -0,0 +1,41 @@ +#include +#include +#include +#include + +static bool checkChildren( const osg::Group& node ) +{ + return node.getNumChildren()>0; +} + +static bool readChildren( osgDB::InputStream& is, osg::Group& node ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i( is.readObject() ); + if ( child ) node.addChild( child ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeChildren( osgDB::OutputStream& os, const osg::Group& node ) +{ + unsigned int size = node.getNumChildren(); + os << size << osgDB::BEGIN_BRACKET << std::endl; + for ( unsigned int i=0; i +#include +#include +#include + +// _columns, _rows +static bool checkArea( const osg::HeightField& shape ) +{ + return true; +} + +static bool readArea( osgDB::InputStream& is, osg::HeightField& shape ) +{ + unsigned int numCols, numRows; + is >> numCols >> numRows; + shape.allocate( numCols, numRows ); + return true; +} + +static bool writeArea( osgDB::OutputStream& os, const osg::HeightField& shape ) +{ + os << shape.getNumColumns() << shape.getNumRows() << std::endl; + return true; +} + +// _heights +static bool checkHeights( const osg::HeightField& shape ) +{ + return shape.getFloatArray()!=NULL; +} + +static bool readHeights( osgDB::InputStream& is, osg::HeightField& shape ) +{ + osg::FloatArray* array = dynamic_cast( is.readArray() ); + if ( array ) + { + unsigned int numCols = shape.getNumColumns(), numRows = shape.getNumRows(); + if ( array->size() +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Hint, + new osg::Hint, + osg::Hint, + "osg::Object osg::StateAttribute osg::Hint" ) +{ + ADD_GLENUM_SERIALIZER( Target, GLenum, GL_NONE ); // _target + ADD_GLENUM_SERIALIZER( Mode, GLenum, GL_DONT_CARE ); // _mode +} diff --git a/src/osgWrappers/serializers/osg/Image.cpp b/src/osgWrappers/serializers/osg/Image.cpp new file mode 100644 index 000000000..d5b1fa5b0 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Image.cpp @@ -0,0 +1,12 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Image, + new osg::Image, + osg::Image, + "osg::Object osg::Image" ) +{ + // Everything is done in OutputStream and InputStream classes +} diff --git a/src/osgWrappers/serializers/osg/ImageSequence.cpp b/src/osgWrappers/serializers/osg/ImageSequence.cpp new file mode 100644 index 000000000..0c2c5e0ae --- /dev/null +++ b/src/osgWrappers/serializers/osg/ImageSequence.cpp @@ -0,0 +1,86 @@ +#include +#include +#include +#include + +// _fileNames +static bool checkFileNames( const osg::ImageSequence& image ) +{ + return image.getNumImageFiles()>0; +} + +static bool readFileNames( osgDB::InputStream& is, osg::ImageSequence& image ) +{ + unsigned int files = 0; is >> files >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> osgDB::END_BRACKET; + return true; +} + +static bool writeFileNames( osgDB::OutputStream& os, const osg::ImageSequence& image ) +{ + const osg::ImageSequence::FileNames& files = image.getFileNames(); + os << files.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::ImageSequence::FileNames::const_iterator itr=files.begin(); + itr!=files.end(); ++itr ) + { + os.writeWrappedString( *itr ); + os << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +// _images +static bool checkImages( const osg::ImageSequence& image ) +{ + return image.getNumImages()>0; +} + +static bool readImages( osgDB::InputStream& is, osg::ImageSequence& image ) +{ + unsigned int images = 0; is >> images >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i( is.readObject() ); + if ( img ) image.addImage( img ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeImages( osgDB::OutputStream& os, const osg::ImageSequence& image ) +{ + const osg::ImageSequence::Images& images = image.getImages(); + os << images.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::ImageSequence::Images::const_iterator itr=images.begin(); + itr!=images.end(); ++itr ) + { + os.writeObject( (*itr).get() ); + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( ImageSequence, + new osg::ImageSequence, + osg::ImageSequence, + "osg::Object osg::Image osg::ImageStream osg::ImageSequence" ) +{ + ADD_DOUBLE_SERIALIZER( ReferenceTime, DBL_MAX ); // _referenceTime + ADD_DOUBLE_SERIALIZER( TimeMultiplier, 1.0 ); // _timeMultiplier + + BEGIN_ENUM_SERIALIZER( Mode, PRE_LOAD_ALL_IMAGES ); + ADD_ENUM_VALUE( PRE_LOAD_ALL_IMAGES ); + ADD_ENUM_VALUE( PAGE_AND_RETAIN_IMAGES ); + ADD_ENUM_VALUE( PAGE_AND_DISCARD_USED_IMAGES ); + END_ENUM_SERIALIZER(); // _mode + + ADD_DOUBLE_SERIALIZER( Length, 1.0 ); // _length + ADD_USER_SERIALIZER( FileNames ); // _fileNames + ADD_USER_SERIALIZER( Images ); // _images +} diff --git a/src/osgWrappers/serializers/osg/ImageStream.cpp b/src/osgWrappers/serializers/osg/ImageStream.cpp new file mode 100644 index 000000000..2b44eb45e --- /dev/null +++ b/src/osgWrappers/serializers/osg/ImageStream.cpp @@ -0,0 +1,17 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( ImageStream, + new osg::ImageStream, + osg::ImageStream, + "osg::Object osg::Image osg::ImageStream" ) +{ + BEGIN_ENUM_SERIALIZER( LoopingMode, NO_LOOPING ); + ADD_ENUM_VALUE( NO_LOOPING ); + ADD_ENUM_VALUE( LOOPING ); + END_ENUM_SERIALIZER(); // _loopingMode + + ADD_LIST_SERIALIZER( AudioStreams, osg::ImageStream::AudioStreams ); // _audioStreams +} diff --git a/src/osgWrappers/serializers/osg/LOD.cpp b/src/osgWrappers/serializers/osg/LOD.cpp new file mode 100644 index 000000000..965358a0d --- /dev/null +++ b/src/osgWrappers/serializers/osg/LOD.cpp @@ -0,0 +1,76 @@ +#include +#include +#include +#include + +// _userDefinedCenter, _radius +static bool checkUserCenter( const osg::LOD& node ) +{ + return node.getCenterMode()==osg::LOD::USER_DEFINED_CENTER; +} + +static bool readUserCenter( osgDB::InputStream& is, osg::LOD& node ) +{ + osg::Vec3d center; double radius; + is >> center >> radius; + node.setCenter( center ); node.setRadius( radius ); + return true; +} + +static bool writeUserCenter( osgDB::OutputStream& os, const osg::LOD& node ) +{ + os << osg::Vec3d(node.getCenter()) << (double)node.getRadius() << std::endl; + return true; +} + +// _rangeList +static bool checkRangeList( const osg::LOD& node ) +{ + return node.getNumRanges()>0; +} + +static bool readRangeList( osgDB::InputStream& is, osg::LOD& node ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> min >> max; + node.setRange( i, min, max ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeRangeList( osgDB::OutputStream& os, const osg::LOD& node ) +{ + const osg::LOD::RangeList& ranges = node.getRangeList(); + os << ranges.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::LOD::RangeList::const_iterator itr=ranges.begin(); + itr!=ranges.end(); ++itr ) + { + os << itr->first << itr->second << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( LOD, + new osg::LOD, + osg::LOD, + "osg::Object osg::Node osg::Group osg::LOD" ) +{ + BEGIN_ENUM_SERIALIZER( CenterMode, USE_BOUNDING_SPHERE_CENTER ); + ADD_ENUM_VALUE( USE_BOUNDING_SPHERE_CENTER ); + ADD_ENUM_VALUE( USER_DEFINED_CENTER ); + END_ENUM_SERIALIZER(); // _centerMode + + ADD_USER_SERIALIZER( UserCenter ); // _userDefinedCenter, _radius + + BEGIN_ENUM_SERIALIZER( RangeMode, DISTANCE_FROM_EYE_POINT ); + ADD_ENUM_VALUE( DISTANCE_FROM_EYE_POINT ); + ADD_ENUM_VALUE( PIXEL_SIZE_ON_SCREEN ); + END_ENUM_SERIALIZER(); // _rangeMode + + ADD_USER_SERIALIZER( RangeList ); // _rangeList +} diff --git a/src/osgWrappers/serializers/osg/Light.cpp b/src/osgWrappers/serializers/osg/Light.cpp new file mode 100644 index 000000000..d2d37894a --- /dev/null +++ b/src/osgWrappers/serializers/osg/Light.cpp @@ -0,0 +1,22 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Light, + new osg::Light, + osg::Light, + "osg::Object osg::StateAttribute osg::Light" ) +{ + ADD_INT_SERIALIZER( LightNum, 0 ); // _lightnum + ADD_VEC4_SERIALIZER( Ambient, osg::Vec4() ); // _ambient + ADD_VEC4_SERIALIZER( Diffuse, osg::Vec4() ); // _diffuse + ADD_VEC4_SERIALIZER( Specular, osg::Vec4() ); // _specular + ADD_VEC4_SERIALIZER( Position, osg::Vec4() ); // _position + ADD_VEC3_SERIALIZER( Direction, osg::Vec3() ); // _direction + ADD_FLOAT_SERIALIZER( ConstantAttenuation, 1.0f ); // _constant_attenuation + ADD_FLOAT_SERIALIZER( LinearAttenuation, 0.0f ); // _linear_attenuation + ADD_FLOAT_SERIALIZER( QuadraticAttenuation, 0.0f ); // _quadratic_attenuation + ADD_FLOAT_SERIALIZER( SpotExponent, 0.0f ); // _spot_exponent + ADD_FLOAT_SERIALIZER( SpotCutoff, 180.0f ); // _spot_cutoff +} diff --git a/src/osgWrappers/serializers/osg/LightModel.cpp b/src/osgWrappers/serializers/osg/LightModel.cpp new file mode 100644 index 000000000..35e24e382 --- /dev/null +++ b/src/osgWrappers/serializers/osg/LightModel.cpp @@ -0,0 +1,20 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( LightModel, + new osg::LightModel, + osg::LightModel, + "osg::Object osg::StateAttribute osg::LightModel" ) +{ + ADD_VEC4_SERIALIZER( AmbientIntensity, osg::Vec4() ); // _ambient + + BEGIN_ENUM_SERIALIZER( ColorControl, SINGLE_COLOR ); + ADD_ENUM_VALUE( SEPARATE_SPECULAR_COLOR ); + ADD_ENUM_VALUE( SINGLE_COLOR ); + END_ENUM_SERIALIZER(); // _colorControl + + ADD_BOOL_SERIALIZER( LocalViewer, false ); // _localViewer + ADD_BOOL_SERIALIZER( TwoSided, false ); // _twoSided +} diff --git a/src/osgWrappers/serializers/osg/LightSource.cpp b/src/osgWrappers/serializers/osg/LightSource.cpp new file mode 100644 index 000000000..3bdd7afbe --- /dev/null +++ b/src/osgWrappers/serializers/osg/LightSource.cpp @@ -0,0 +1,17 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( LightSource, + new osg::LightSource, + osg::LightSource, + "osg::Object osg::Node osg::Group osg::LightSource" ) +{ + ADD_OBJECT_SERIALIZER( Light, osg::Light, NULL ); // _light + + BEGIN_ENUM_SERIALIZER( ReferenceFrame, RELATIVE_RF ); + ADD_ENUM_VALUE( RELATIVE_RF ); + ADD_ENUM_VALUE( ABSOLUTE_RF ); + END_ENUM_SERIALIZER(); // _referenceFrame +} diff --git a/src/osgWrappers/serializers/osg/LineStipple.cpp b/src/osgWrappers/serializers/osg/LineStipple.cpp new file mode 100644 index 000000000..73d65cefa --- /dev/null +++ b/src/osgWrappers/serializers/osg/LineStipple.cpp @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( LineStipple, + new osg::LineStipple, + osg::LineStipple, + "osg::Object osg::StateAttribute osg::LineStipple" ) +{ + ADD_INT_SERIALIZER( Factor, 1 ); // _factor + ADD_HEXSHORT_SERIALIZER( Pattern, 0xffff ); // _pattern +} diff --git a/src/osgWrappers/serializers/osg/LineWidth.cpp b/src/osgWrappers/serializers/osg/LineWidth.cpp new file mode 100644 index 000000000..17611a38c --- /dev/null +++ b/src/osgWrappers/serializers/osg/LineWidth.cpp @@ -0,0 +1,12 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( LineWidth, + new osg::LineWidth, + osg::LineWidth, + "osg::Object osg::StateAttribute osg::LineWidth" ) +{ + ADD_FLOAT_SERIALIZER( Width, 1.0f ); // _width +} diff --git a/src/osgWrappers/serializers/osg/LogicOp.cpp b/src/osgWrappers/serializers/osg/LogicOp.cpp new file mode 100644 index 000000000..949737a5e --- /dev/null +++ b/src/osgWrappers/serializers/osg/LogicOp.cpp @@ -0,0 +1,29 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( LogicOp, + new osg::LogicOp, + osg::LogicOp, + "osg::Object osg::StateAttribute osg::LogicOp" ) +{ + BEGIN_ENUM_SERIALIZER( Opcode, COPY ); + ADD_ENUM_VALUE( CLEAR ); + ADD_ENUM_VALUE( SET ); + ADD_ENUM_VALUE( COPY ); + ADD_ENUM_VALUE( COPY_INVERTED ); + ADD_ENUM_VALUE( NOOP ); + ADD_ENUM_VALUE( INVERT ); + ADD_ENUM_VALUE( AND ); + ADD_ENUM_VALUE( NAND ); + ADD_ENUM_VALUE( OR ); + ADD_ENUM_VALUE( NOR ); + ADD_ENUM_VALUE( XOR ); + ADD_ENUM_VALUE( EQUIV ); + ADD_ENUM_VALUE( AND_REVERSE ); + ADD_ENUM_VALUE( AND_INVERTED ); + ADD_ENUM_VALUE( OR_REVERSE ); + ADD_ENUM_VALUE( OR_INVERTED ); + END_ENUM_SERIALIZER(); // _opcode +} diff --git a/src/osgWrappers/serializers/osg/Material.cpp b/src/osgWrappers/serializers/osg/Material.cpp new file mode 100644 index 000000000..c89f1f93b --- /dev/null +++ b/src/osgWrappers/serializers/osg/Material.cpp @@ -0,0 +1,53 @@ +#include +#include +#include +#include + +#define MATERIAL_FUNC( PROP, TYPE ) \ + static bool check##PROP( const osg::Material& attr ) { return true; } \ + static bool read##PROP( osgDB::InputStream& is, osg::Material& attr ) { \ + bool frontAndBack; TYPE value1, value2; \ + is >> frontAndBack; \ + is >> osgDB::PROPERTY("Front") >> value1; \ + is >> osgDB::PROPERTY("Back") >> value2; \ + if ( frontAndBack ) \ + attr.set##PROP(osg::Material::FRONT_AND_BACK, value1); \ + else { \ + attr.set##PROP(osg::Material::FRONT, value1); \ + attr.set##PROP(osg::Material::BACK, value2); \ + } \ + return true; \ + } \ + static bool write##PROP( osgDB::OutputStream& os, const osg::Material& attr ) { \ + os << attr.get##PROP##FrontAndBack(); \ + os << osgDB::PROPERTY("Front") << TYPE(attr.get##PROP(osg::Material::FRONT)); \ + os << osgDB::PROPERTY("Back") << TYPE(attr.get##PROP(osg::Material::BACK)) << std::endl; \ + return true; \ + } + +MATERIAL_FUNC( Ambient, osg::Vec4f ) +MATERIAL_FUNC( Diffuse, osg::Vec4f ) +MATERIAL_FUNC( Specular, osg::Vec4f ) +MATERIAL_FUNC( Emission, osg::Vec4f ) +MATERIAL_FUNC( Shininess, float ) + +REGISTER_OBJECT_WRAPPER( Material, + new osg::Material, + osg::Material, + "osg::Object osg::StateAttribute osg::Material" ) +{ + BEGIN_ENUM_SERIALIZER( ColorMode, OFF ); + ADD_ENUM_VALUE( AMBIENT ); + ADD_ENUM_VALUE( DIFFUSE ); + ADD_ENUM_VALUE( SPECULAR ); + ADD_ENUM_VALUE( EMISSION ); + ADD_ENUM_VALUE( AMBIENT_AND_DIFFUSE ); + ADD_ENUM_VALUE( OFF ); + END_ENUM_SERIALIZER(); // _colorMode + + ADD_USER_SERIALIZER( Ambient ); // _ambient + ADD_USER_SERIALIZER( Diffuse ); // _diffuse + ADD_USER_SERIALIZER( Specular ); // _specular + ADD_USER_SERIALIZER( Emission ); // _emission + ADD_USER_SERIALIZER( Shininess ); // _shininess +} diff --git a/src/osgWrappers/serializers/osg/MatrixTransform.cpp b/src/osgWrappers/serializers/osg/MatrixTransform.cpp new file mode 100644 index 000000000..a87dda996 --- /dev/null +++ b/src/osgWrappers/serializers/osg/MatrixTransform.cpp @@ -0,0 +1,12 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( MatrixTransform, + new osg::MatrixTransform, + osg::MatrixTransform, + "osg::Object osg::Node osg::Group osg::Transform osg::MatrixTransform" ) +{ + ADD_MATRIX_SERIALIZER( Matrix, osg::Matrix() ); // _matrix +} diff --git a/src/osgWrappers/serializers/osg/Multisample.cpp b/src/osgWrappers/serializers/osg/Multisample.cpp new file mode 100644 index 000000000..2eea911a3 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Multisample.cpp @@ -0,0 +1,19 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Multisample, + new osg::Multisample, + osg::Multisample, + "osg::Object osg::StateAttribute osg::Multisample" ) +{ + ADD_FLOAT_SERIALIZER( Coverage, 0.0f ); // _coverage + ADD_BOOL_SERIALIZER( Invert, false ); // _invert + + BEGIN_ENUM_SERIALIZER2( Hint, osg::Multisample::Mode, DONT_CARE ); + ADD_ENUM_VALUE( FASTEST ); + ADD_ENUM_VALUE( NICEST ); + ADD_ENUM_VALUE( DONT_CARE ); + END_ENUM_SERIALIZER(); // _mode +} diff --git a/src/osgWrappers/serializers/osg/Node.cpp b/src/osgWrappers/serializers/osg/Node.cpp new file mode 100644 index 000000000..53c137b36 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Node.cpp @@ -0,0 +1,82 @@ +#include +#include +#include +#include + +// _initialBound +static bool checkInitialBound( const osg::Node& node ) +{ + return node.getInitialBound().valid(); +} + +static bool readInitialBound( osgDB::InputStream& is, osg::Node& node ) +{ + osg::Vec3d center; + double radius; + is >> osgDB::BEGIN_BRACKET; + is >> osgDB::PROPERTY("Center") >> center; + is >> osgDB::PROPERTY("Radius") >> radius; + is >> osgDB::END_BRACKET; + node.setInitialBound( osg::BoundingSphere(center, radius) ); + return true; +} + +static bool writeInitialBound( osgDB::OutputStream& os, const osg::Node& node ) +{ + const osg::BoundingSphere& bs = node.getInitialBound(); + os << osgDB::BEGIN_BRACKET << std::endl; + os << osgDB::PROPERTY("Center") << osg::Vec3d(bs.center()) << std::endl; + os << osgDB::PROPERTY("Radius") << double(bs.radius()) << std::endl; + os << osgDB::END_BRACKET << std::endl; + return true; +} + +// _descriptions +static bool checkDescriptions( const osg::Node& node ) +{ + return node.getDescriptions().size()>0; +} + +static bool readDescriptions( osgDB::InputStream& is, osg::Node& node ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> osgDB::END_BRACKET; + return true; +} + +static bool writeDescriptions( osgDB::OutputStream& os, const osg::Node& node ) +{ + const osg::Node::DescriptionList& slist = node.getDescriptions(); + os << slist.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::Node::DescriptionList::const_iterator itr=slist.begin(); + itr!=slist.end(); ++itr ) + { + os.writeWrappedString( *itr ); + os << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( Node, + new osg::Node, + osg::Node, + "osg::Object osg::Node" ) +{ + ADD_USER_SERIALIZER( InitialBound ); // _initialBound + ADD_OBJECT_SERIALIZER( ComputeBoundingSphereCallback, + osg::Node::ComputeBoundingSphereCallback, NULL ); // _computeBoundCallback + ADD_OBJECT_SERIALIZER( UpdateCallback, osg::NodeCallback, NULL ); // _updateCallback + ADD_OBJECT_SERIALIZER( EventCallback, osg::NodeCallback, NULL ); // _eventCallback + ADD_OBJECT_SERIALIZER( CullCallback, osg::NodeCallback, NULL ); // _cullCallback + ADD_BOOL_SERIALIZER( CullingActive, true ); // _cullingActive + ADD_HEXINT_SERIALIZER( NodeMask, 0xffffffff ); // _nodeMask + ADD_USER_SERIALIZER( Descriptions ); // _descriptions + ADD_OBJECT_SERIALIZER( StateSet, osg::StateSet, NULL ); // _stateset +} diff --git a/src/osgWrappers/serializers/osg/NodeCallback.cpp b/src/osgWrappers/serializers/osg/NodeCallback.cpp new file mode 100644 index 000000000..0b7806a9d --- /dev/null +++ b/src/osgWrappers/serializers/osg/NodeCallback.cpp @@ -0,0 +1,18 @@ +#undef OBJECT_CAST +#define OBJECT_CAST dynamic_cast + +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( NodeCallback, + new osg::NodeCallback, + osg::NodeCallback, + "osg::Object osg::NodeCallback" ) +{ + ADD_OBJECT_SERIALIZER( NestedCallback, osg::NodeCallback, NULL ); // _nestedCallback +} + +#undef OBJECT_CAST +#define OBJECT_CAST static_cast diff --git a/src/osgWrappers/serializers/osg/NodeTrackerCallback.cpp b/src/osgWrappers/serializers/osg/NodeTrackerCallback.cpp new file mode 100644 index 000000000..b43d25b12 --- /dev/null +++ b/src/osgWrappers/serializers/osg/NodeTrackerCallback.cpp @@ -0,0 +1,18 @@ +#undef OBJECT_CAST +#define OBJECT_CAST dynamic_cast + +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( NodeTrackerCallback, + new osg::NodeTrackerCallback, + osg::NodeTrackerCallback, + "osg::Object osg::NodeCallback osg::NodeTrackerCallback" ) +{ + ADD_OBJECT_SERIALIZER( TrackNode, osg::Node, NULL ); // _trackNodePath +} + +#undef OBJECT_CAST +#define OBJECT_CAST static_cast diff --git a/src/osgWrappers/serializers/osg/Object.cpp b/src/osgWrappers/serializers/osg/Object.cpp new file mode 100644 index 000000000..3af02866f --- /dev/null +++ b/src/osgWrappers/serializers/osg/Object.cpp @@ -0,0 +1,18 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Object, + /*new osg::Object*/NULL, + osg::Object, + "osg::Object" ) +{ + ADD_STRING_SERIALIZER( Name, "" ); // _name + + BEGIN_ENUM_SERIALIZER( DataVariance, UNSPECIFIED ); + ADD_ENUM_VALUE( STATIC ); + ADD_ENUM_VALUE( DYNAMIC ); + ADD_ENUM_VALUE( UNSPECIFIED ); + END_ENUM_SERIALIZER(); // _dataVariance +} diff --git a/src/osgWrappers/serializers/osg/OccluderNode.cpp b/src/osgWrappers/serializers/osg/OccluderNode.cpp new file mode 100644 index 000000000..1a82d2839 --- /dev/null +++ b/src/osgWrappers/serializers/osg/OccluderNode.cpp @@ -0,0 +1,12 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( OccluderNode, + new osg::OccluderNode, + osg::OccluderNode, + "osg::Object osg::Node osg::Group osg::OccluderNode" ) +{ + ADD_OBJECT_SERIALIZER( Occluder, osg::ConvexPlanarOccluder, NULL ); // _occluder +} diff --git a/src/osgWrappers/serializers/osg/OcclusionQueryNode.cpp b/src/osgWrappers/serializers/osg/OcclusionQueryNode.cpp new file mode 100644 index 000000000..3c8bd7eac --- /dev/null +++ b/src/osgWrappers/serializers/osg/OcclusionQueryNode.cpp @@ -0,0 +1,15 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( OcclusionQueryNode, + new osg::OcclusionQueryNode, + osg::OcclusionQueryNode, + "osg::Object osg::Node osg::Group osg::OcclusionQueryNode" ) +{ + ADD_BOOL_SERIALIZER( QueriesEnabled, true ); // _enabled + ADD_UINT_SERIALIZER( VisibilityThreshold, 0 ); // _visThreshold + ADD_INT_SERIALIZER( QueryFrameCount, 0 ); // _queryFrameCount + ADD_BOOL_SERIALIZER( DebugDisplay, false ); // _debugBB +} diff --git a/src/osgWrappers/serializers/osg/PagedLOD.cpp b/src/osgWrappers/serializers/osg/PagedLOD.cpp new file mode 100644 index 000000000..6e286ec29 --- /dev/null +++ b/src/osgWrappers/serializers/osg/PagedLOD.cpp @@ -0,0 +1,58 @@ +#include +#include +#include +#include + +static bool checkRangeDataList( const osg::PagedLOD& node ) +{ + return node.getNumFileNames()>0; +} + +static bool readRangeDataList( osgDB::InputStream& is, osg::PagedLOD& node ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> offset >> scale >> timeStamp >> frameNumber; + + node.setFileName( i, name ); + node.setPriorityOffset( i, offset ); + node.setPriorityScale( i, scale ); + node.setTimeStamp( i, timeStamp ); + node.setFrameNumber( i, frameNumber ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeRangeDataList( osgDB::OutputStream& os, const osg::PagedLOD& node ) +{ + unsigned int size = node.getNumFileNames(); + os << size << osgDB::BEGIN_BRACKET << std::endl; + for ( unsigned int i=0; i +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Point, + new osg::Point, + osg::Point, + "osg::Object osg::StateAttribute osg::Point" ) +{ + ADD_FLOAT_SERIALIZER( Size, 0.0f ); // _size + ADD_FLOAT_SERIALIZER( FadeThresholdSize, 0.0f ); // _fadeThresholdSize + ADD_VEC3_SERIALIZER( DistanceAttenuation, osg::Vec3() ); // _distanceAttenuation + ADD_FLOAT_SERIALIZER( MinSize, 0.0f ); // _minSize + ADD_FLOAT_SERIALIZER( MaxSize, 0.0f ); // _maxSize +} diff --git a/src/osgWrappers/serializers/osg/PointSprite.cpp b/src/osgWrappers/serializers/osg/PointSprite.cpp new file mode 100644 index 000000000..ab2f8ce81 --- /dev/null +++ b/src/osgWrappers/serializers/osg/PointSprite.cpp @@ -0,0 +1,15 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( PointSprite, + new osg::PointSprite, + osg::PointSprite, + "osg::Object osg::StateAttribute osg::PointSprite" ) +{ + BEGIN_ENUM_SERIALIZER( CoordOriginMode, UPPER_LEFT ); + ADD_ENUM_VALUE( UPPER_LEFT ); + ADD_ENUM_VALUE( LOWER_LEFT ); + END_ENUM_SERIALIZER(); // _coordOriginMode +} diff --git a/src/osgWrappers/serializers/osg/PolygonMode.cpp b/src/osgWrappers/serializers/osg/PolygonMode.cpp new file mode 100644 index 000000000..8cdb0c21e --- /dev/null +++ b/src/osgWrappers/serializers/osg/PolygonMode.cpp @@ -0,0 +1,58 @@ +#include +#include +#include +#include + +BEGIN_USER_TABLE( Mode, osg::PolygonMode ); + ADD_USER_VALUE( POINT ); + ADD_USER_VALUE( LINE ); + ADD_USER_VALUE( FILL ); +END_USER_TABLE() + +USER_READ_FUNC( Mode, readModeValue ) +USER_WRITE_FUNC( Mode, writeModeValue ) + +// _modeFront, _modeBack +static bool checkMode( const osg::PolygonMode& attr ) +{ + return true; +} + +static bool readMode( osgDB::InputStream& is, osg::PolygonMode& attr ) +{ + bool frontAndBack; + is >> osgDB::PROPERTY("UseFrontAndBack") >> frontAndBack; + is >> osgDB::PROPERTY("Front"); int value1 = readModeValue(is); + is >> osgDB::PROPERTY("Back"); int value2 = readModeValue(is); + + if ( frontAndBack ) + attr.setMode( osg::PolygonMode::FRONT_AND_BACK, (osg::PolygonMode::Mode)value1 ); + else + { + attr.setMode(osg::PolygonMode::FRONT, (osg::PolygonMode::Mode)value1); + attr.setMode(osg::PolygonMode::BACK, (osg::PolygonMode::Mode)value2); + } + return true; +} + +static bool writeMode( osgDB::OutputStream& os, const osg::PolygonMode& attr ) +{ + os << osgDB::PROPERTY("UseFrontAndBack") << attr.getFrontAndBack() << std::endl; + + os << osgDB::PROPERTY("Front"); + writeModeValue( os, (int)attr.getMode(osg::PolygonMode::FRONT) ); + os << std::endl; + + os << osgDB::PROPERTY("Back"); + writeModeValue( os, (int)attr.getMode(osg::PolygonMode::BACK) ); + os << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( PolygonMode, + new osg::PolygonMode, + osg::PolygonMode, + "osg::Object osg::StateAttribute osg::PolygonMode" ) +{ + ADD_USER_SERIALIZER( Mode ); // _modeFront, _modeBack +} diff --git a/src/osgWrappers/serializers/osg/PolygonOffset.cpp b/src/osgWrappers/serializers/osg/PolygonOffset.cpp new file mode 100644 index 000000000..bf63ba5f4 --- /dev/null +++ b/src/osgWrappers/serializers/osg/PolygonOffset.cpp @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( PolygonOffset, + new osg::PolygonOffset, + osg::PolygonOffset, + "osg::Object osg::StateAttribute osg::PolygonOffset" ) +{ + ADD_FLOAT_SERIALIZER( Factor, 0.0f ); // _factor + ADD_FLOAT_SERIALIZER( Units, 0.0f ); // _units +} diff --git a/src/osgWrappers/serializers/osg/PolygonStipple.cpp b/src/osgWrappers/serializers/osg/PolygonStipple.cpp new file mode 100644 index 000000000..d4084e350 --- /dev/null +++ b/src/osgWrappers/serializers/osg/PolygonStipple.cpp @@ -0,0 +1,58 @@ +#include +#include +#include +#include + +static bool checkMask( const osg::PolygonStipple& attr ) +{ + return true; +} + +static bool readMask( osgDB::InputStream& is, osg::PolygonStipple& attr ) +{ + char mask[128] = {0}; + if ( is.isBinary() ) + { + unsigned int size; is >> size; + is.readCharArray( mask, size ); + } + else + { + is >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i<128; ++i ) + { + is >> std::hex >> mask[i] >> std::dec; + } + is >> osgDB::END_BRACKET; + } + attr.setMask( (GLubyte*)mask ); + return true; +} + +static bool writeMask( osgDB::OutputStream& os, const osg::PolygonStipple& attr ) +{ + if ( os.isBinary() ) + { + os << (unsigned int)128; + os.writeCharArray( (char*)attr.getMask(), 128 ); + } + else + { + const GLubyte* mask = attr.getMask(); + os << osgDB::BEGIN_BRACKET << std::endl; + for ( unsigned int i=0; i<128; ++i ) + { + os << std::hex << mask[i] << std::dec << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + } + return true; +} + +REGISTER_OBJECT_WRAPPER( PolygonStipple, + new osg::PolygonStipple, + osg::PolygonStipple, + "osg::Object osg::StateAttribute osg::PolygonStipple" ) +{ + ADD_USER_SERIALIZER( Mask ); // _mask +} diff --git a/src/osgWrappers/serializers/osg/PositionAttitudeTransform.cpp b/src/osgWrappers/serializers/osg/PositionAttitudeTransform.cpp new file mode 100644 index 000000000..fe6a0db4c --- /dev/null +++ b/src/osgWrappers/serializers/osg/PositionAttitudeTransform.cpp @@ -0,0 +1,15 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( PositionAttitudeTransform, + new osg::PositionAttitudeTransform, + osg::PositionAttitudeTransform, + "osg::Object osg::Node osg::Group osg::Transform osg::PositionAttitudeTransform" ) +{ + ADD_VEC3D_SERIALIZER( Position, osg::Vec3d() ); // _position + ADD_QUAT_SERIALIZER( Attitude, osg::Quat() ); // _attitude + ADD_VEC3D_SERIALIZER( Scale, osg::Vec3d() ); // _scale + ADD_VEC3D_SERIALIZER( PivotPoint, osg::Vec3d() ); // _pivotPoint +} diff --git a/src/osgWrappers/serializers/osg/Program.cpp b/src/osgWrappers/serializers/osg/Program.cpp new file mode 100644 index 000000000..78f35f9b9 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Program.cpp @@ -0,0 +1,91 @@ +#include +#include +#include +#include + +#define PROGRAM_LIST_FUNC( PROP, TYPE, DATA ) \ + static bool check##PROP(const osg::Program& attr) \ + { return attr.get##TYPE().size()>0; } \ + static bool read##PROP(osgDB::InputStream& is, osg::Program& attr) { \ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; \ + for ( unsigned int i=0; i> key >> value; attr.add##DATA(key, value); \ + } \ + is >> osgDB::END_BRACKET; \ + return true; \ + } \ + static bool write##PROP( osgDB::OutputStream& os, const osg::Program& attr ) \ + { \ + const osg::Program::TYPE& plist = attr.get##TYPE(); \ + os << plist.size() << osgDB::BEGIN_BRACKET << std::endl; \ + for ( osg::Program::TYPE::const_iterator itr=plist.begin(); \ + itr!=plist.end(); ++itr ) { \ + os << itr->first << itr->second << std::endl; \ + } \ + os << osgDB::END_BRACKET << std::endl; \ + return true; \ + } + +PROGRAM_LIST_FUNC( AttribBinding, AttribBindingList, BindAttribLocation ) +PROGRAM_LIST_FUNC( FragDataBinding, FragDataBindingList, BindFragDataLocation ) + +#define PROGRAM_PARAMETER_FUNC( PROP, NAME ) \ + static bool check##PROP(const osg::Program& attr) \ + { return attr.getParameter(NAME)!=GL_NONE; } \ + static bool read##PROP(osgDB::InputStream& is, osg::Program& attr) { \ + int value; is >> osgDB::PROPERTY(#NAME) >> value; \ + attr.setParameter(NAME, value); \ + return true; \ + } \ + static bool write##PROP(osgDB::OutputStream& os, const osg::Program& attr) { \ + os << osgDB::PROPERTY(#NAME) << (int)attr.getParameter(NAME) << std::endl; \ + return true; \ + } + +PROGRAM_PARAMETER_FUNC( GeometryVerticesOut, GL_GEOMETRY_VERTICES_OUT_EXT ) +PROGRAM_PARAMETER_FUNC( GeometryInputType, GL_GEOMETRY_INPUT_TYPE_EXT ) +PROGRAM_PARAMETER_FUNC( GeometryOutputType, GL_GEOMETRY_OUTPUT_TYPE_EXT ) + +// _shaderList +static bool checkShaders( const osg::Program& attr ) +{ + return attr.getNumShaders()>0; +} + +static bool readShaders( osgDB::InputStream& is, osg::Program& attr ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i( is.readObject() ); + if ( shader ) attr.addShader( shader ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeShaders( osgDB::OutputStream& os, const osg::Program& attr ) +{ + unsigned int size = attr.getNumShaders(); + os << size << osgDB::BEGIN_BRACKET << std::endl; + for ( unsigned int i=0; i +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Projection, + new osg::Projection, + osg::Projection, + "osg::Object osg::Node osg::Group osg::Projection" ) +{ + ADD_MATRIX_SERIALIZER( Matrix, osg::Matrix() ); // _matrix +} diff --git a/src/osgWrappers/serializers/osg/ProxyNode.cpp b/src/osgWrappers/serializers/osg/ProxyNode.cpp new file mode 100644 index 000000000..881365f1d --- /dev/null +++ b/src/osgWrappers/serializers/osg/ProxyNode.cpp @@ -0,0 +1,79 @@ +#include +#include +#include +#include + +// _filenameList +static bool checkFileNames( const osg::ProxyNode& node ) +{ + return node.getNumFileNames()>0; +} + +static bool readFileNames( osgDB::InputStream& is, osg::ProxyNode& node ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> osgDB::END_BRACKET; + return true; +} + +static bool writeFileNames( osgDB::OutputStream& os, const osg::ProxyNode& node ) +{ + os << node.getNumFileNames() << osgDB::BEGIN_BRACKET << std::endl; + for ( unsigned int i=0; i> center >> radius; + node.setCenter( center ); node.setRadius( radius ); + return true; +} + +static bool writeUserCenter( osgDB::OutputStream& os, const osg::ProxyNode& node ) +{ + os << osg::Vec3d(node.getCenter()) << (double)node.getRadius() << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( ProxyNode, + new osg::ProxyNode, + osg::ProxyNode, + "osg::Object osg::Node osg::ProxyNode" ) +{ + // Note: osg::Group is not in the list to prevent recording dynamic loaded children + + ADD_USER_SERIALIZER( FileNames ); // _filenameList + ADD_STRING_SERIALIZER( DatabasePath, "" ); // _databasePath + + BEGIN_ENUM_SERIALIZER( LoadingExternalReferenceMode, LOAD_IMMEDIATELY ); + ADD_ENUM_VALUE( LOAD_IMMEDIATELY ); + ADD_ENUM_VALUE( DEFER_LOADING_TO_DATABASE_PAGER ); + ADD_ENUM_VALUE( NO_AUTOMATIC_LOADING ); + END_ENUM_SERIALIZER(); // _loadingExtReference + + BEGIN_ENUM_SERIALIZER( CenterMode, USE_BOUNDING_SPHERE_CENTER ); + ADD_ENUM_VALUE( USE_BOUNDING_SPHERE_CENTER ); + ADD_ENUM_VALUE( USER_DEFINED_CENTER ); + END_ENUM_SERIALIZER(); // _centerMode + + ADD_USER_SERIALIZER( UserCenter ); // _userDefinedCenter, _radius +} diff --git a/src/osgWrappers/serializers/osg/Scissor.cpp b/src/osgWrappers/serializers/osg/Scissor.cpp new file mode 100644 index 000000000..fe8e09362 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Scissor.cpp @@ -0,0 +1,31 @@ +#include +#include +#include +#include + +static bool checkArea( const osg::Scissor& attr ) +{ + return true; +} + +static bool readArea( osgDB::InputStream& is, osg::Scissor& attr ) +{ + int x, y, w, h; + is >> x >> y >> w >> h; + attr.setScissor( x, y, w, h ); + return true; +} + +static bool writeArea( osgDB::OutputStream& os, const osg::Scissor& attr ) +{ + os << attr.x() << attr.y() << attr.width() << attr.height() << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( Scissor, + new osg::Scissor, + osg::Scissor, + "osg::Object osg::StateAttribute osg::Scissor" ) +{ + ADD_USER_SERIALIZER( Area ); // _x, _y, _width, _height +} diff --git a/src/osgWrappers/serializers/osg/Sequence.cpp b/src/osgWrappers/serializers/osg/Sequence.cpp new file mode 100644 index 000000000..5ee6fa0e4 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Sequence.cpp @@ -0,0 +1,34 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Sequence, + new osg::Sequence, + osg::Sequence, + "osg::Object osg::Node osg::Group osg::Sequence" ) +{ + ADD_LIST_SERIALIZER( TimeList, std::vector ); // _frameTime + + BEGIN_ENUM_SERIALIZER( LoopMode, LOOP ); + ADD_ENUM_VALUE( LOOP ); + ADD_ENUM_VALUE( SWING ); + END_ENUM_SERIALIZER(); // _loopMode + + ADD_INT_SERIALIZER( Begin, 0 ); // _begin + ADD_INT_SERIALIZER( End, -1 ); // _end + ADD_FLOAT_SERIALIZER( Speed, 0.0f ); // _speed + ADD_INT_SERIALIZER( NumRepeats, -1 ); // _nreps + ADD_DOUBLE_SERIALIZER( DefaultTime, 1.0 ); // _defaultTime + ADD_DOUBLE_SERIALIZER( LastFrameTime, 0.0 ); // _lastFrameTime + + BEGIN_ENUM_SERIALIZER2( Mode, osg::Sequence::SequenceMode, STOP ); + ADD_ENUM_VALUE( START ); + ADD_ENUM_VALUE( STOP ); + ADD_ENUM_VALUE( PAUSE ); + ADD_ENUM_VALUE( RESUME ); + END_ENUM_SERIALIZER(); // _mode + + ADD_BOOL_SERIALIZER( Sync, false ); // _sync + ADD_BOOL_SERIALIZER( ClearOnStop, false ); // _clearOnStop +} diff --git a/src/osgWrappers/serializers/osg/ShadeModel.cpp b/src/osgWrappers/serializers/osg/ShadeModel.cpp new file mode 100644 index 000000000..422ed832d --- /dev/null +++ b/src/osgWrappers/serializers/osg/ShadeModel.cpp @@ -0,0 +1,15 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( ShadeModel, + new osg::ShadeModel, + osg::ShadeModel, + "osg::Object osg::StateAttribute osg::ShadeModel" ) +{ + BEGIN_ENUM_SERIALIZER( Mode, SMOOTH ); + ADD_ENUM_VALUE( FLAT ); + ADD_ENUM_VALUE( SMOOTH ); + END_ENUM_SERIALIZER(); // _mode +} diff --git a/src/osgWrappers/serializers/osg/Shader.cpp b/src/osgWrappers/serializers/osg/Shader.cpp new file mode 100644 index 000000000..2084637f8 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Shader.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +#include + +static bool checkShaderSource( const osg::Shader& shader ) +{ + return !shader.getShaderSource().empty(); +} + +static bool readShaderSource( osgDB::InputStream& is, osg::Shader& shader ) +{ + std::string code; + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> osgDB::END_BRACKET; + shader.setShaderSource( code ); + return true; +} + +static bool writeShaderSource( osgDB::OutputStream& os, const osg::Shader& shader ) +{ + std::vector lines; + std::istringstream iss( shader.getShaderSource() ); + std::string line; + while ( std::getline(iss, line) ) + { + lines.push_back( line ); + } + + os << lines.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( std::vector::const_iterator itr=lines.begin(); + itr!=lines.end(); ++itr ) + { + os.writeWrappedString( *itr ); + os << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( Shader, + new osg::Shader, + osg::Shader, + "osg::Object osg::Shader" ) +{ + BEGIN_ENUM_SERIALIZER3( Type, UNDEFINED ); + ADD_ENUM_VALUE( VERTEX ); + ADD_ENUM_VALUE( FRAGMENT ); + ADD_ENUM_VALUE( GEOMETRY ); + ADD_ENUM_VALUE( UNDEFINED ); + END_ENUM_SERIALIZER(); // _type + + ADD_USER_SERIALIZER( ShaderSource ); // _shaderSource + ADD_OBJECT_SERIALIZER( ShaderBinary, osg::ShaderBinary, NULL ); // _shaderBinary +} diff --git a/src/osgWrappers/serializers/osg/ShaderBinary.cpp b/src/osgWrappers/serializers/osg/ShaderBinary.cpp new file mode 100644 index 000000000..d00adee0f --- /dev/null +++ b/src/osgWrappers/serializers/osg/ShaderBinary.cpp @@ -0,0 +1,58 @@ +#include +#include +#include + +static bool checkData( const osg::ShaderBinary& sb ) +{ + return sb.getSize()>0; +} + +static bool readData( osgDB::InputStream& is, osg::ShaderBinary& sb ) +{ + unsigned int size; is >> size; + char* data = new char[size]; + if ( is.isBinary() ) + { + is.readCharArray( data, size ); + } + else + { + is >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> std::hex >> data[i] >> std::dec; + } + is >> osgDB::END_BRACKET; + } + sb.assign( size, (unsigned char*)data ); + delete data; + return true; +} + +static bool writeData( osgDB::OutputStream& os, const osg::ShaderBinary& sb ) +{ + if ( os.isBinary() ) + { + os << (unsigned int)sb.getSize(); + os.writeCharArray( (char*)sb.getData(), sb.getSize() ); + } + else + { + const unsigned char* data = sb.getData(); + os << osgDB::BEGIN_BRACKET << std::endl; + for ( unsigned int i=0; i +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Shape, + /*new osg::Shape*/NULL, + osg::Shape, + "osg::Object osg::Shape" ) +{ +} diff --git a/src/osgWrappers/serializers/osg/ShapeDrawable.cpp b/src/osgWrappers/serializers/osg/ShapeDrawable.cpp new file mode 100644 index 000000000..68548fcbf --- /dev/null +++ b/src/osgWrappers/serializers/osg/ShapeDrawable.cpp @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( ShapeDrawable, + new osg::ShapeDrawable, + osg::ShapeDrawable, + "osg::Object osg::Drawable osg::ShapeDrawable" ) +{ + ADD_VEC4_SERIALIZER( Color, osg::Vec4() ); // _color + ADD_OBJECT_SERIALIZER( TessellationHints, osg::TessellationHints, NULL ); // _tessellationHints +} diff --git a/src/osgWrappers/serializers/osg/Sphere.cpp b/src/osgWrappers/serializers/osg/Sphere.cpp new file mode 100644 index 000000000..c686dcf50 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Sphere.cpp @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Sphere, + new osg::Sphere, + osg::Sphere, + "osg::Object osg::Shape osg::Sphere" ) +{ + ADD_VEC3_SERIALIZER( Center, osg::Vec3() ); // _center + ADD_FLOAT_SERIALIZER( Radius, 0.0f ); // _radius +} diff --git a/src/osgWrappers/serializers/osg/StateAttribute.cpp b/src/osgWrappers/serializers/osg/StateAttribute.cpp new file mode 100644 index 000000000..9c26e73c9 --- /dev/null +++ b/src/osgWrappers/serializers/osg/StateAttribute.cpp @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( StateAttribute, + /*new osg::StateAttribute*/NULL, + osg::StateAttribute, + "osg::Object osg::StateAttribute" ) +{ + ADD_OBJECT_SERIALIZER( UpdateCallback, osg::StateAttributeCallback, NULL ); // _updateCallback + ADD_OBJECT_SERIALIZER( EventCallback, osg::StateAttributeCallback, NULL ); // _eventCallback +} diff --git a/src/osgWrappers/serializers/osg/StateSet.cpp b/src/osgWrappers/serializers/osg/StateSet.cpp new file mode 100644 index 000000000..be40343af --- /dev/null +++ b/src/osgWrappers/serializers/osg/StateSet.cpp @@ -0,0 +1,306 @@ +#include +#include +#include +#include + +static int readValue( osgDB::InputStream& is ) +{ + int value = osg::StateAttribute::INHERIT; + if ( is.isBinary() ) + is >> value; + else + { + std::string enumValue; + is >> enumValue; + if ( enumValue=="OFF" ) value = osg::StateAttribute::OFF; + else if ( enumValue=="ON" ) value = osg::StateAttribute::ON; + else if ( enumValue=="INHERIT" ) value = osg::StateAttribute::INHERIT; + else if ( enumValue=="OFF|OVERRIDE" ) + value = osg::StateAttribute::OFF|osg::StateAttribute::OVERRIDE; + else if ( enumValue=="OFF|PROTECTED" ) + value = osg::StateAttribute::OFF|osg::StateAttribute::PROTECTED; + else if ( enumValue=="ON|OVERRIDE" ) + value = osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE; + else if ( enumValue=="ON|PROTECTED" ) + value = osg::StateAttribute::ON|osg::StateAttribute::PROTECTED; + } + return value; +} + +static void readModes( osgDB::InputStream& is, osg::StateSet::ModeList& modes ) +{ + unsigned int size = 0; is >> size; + if ( size>0 ) + { + is >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> mode; + int value = readValue( is ); + modes[mode.get()] = (osg::StateAttribute::Values)value; + } + is >> osgDB::END_BRACKET; + } +} + +static void readAttributes( osgDB::InputStream& is, osg::StateSet::AttributeList& attrs ) +{ + unsigned int size = 0; is >> size; + if ( size>0 ) + { + is >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i( is.readObject() ); + is >> osgDB::PROPERTY("Value"); + int value = readValue( is ); + if ( sa ) + attrs[sa->getTypeMemberPair()] = osg::StateSet::RefAttributePair(sa,value); + } + is >> osgDB::END_BRACKET; + } +} + +static void writeValue( osgDB::OutputStream& os, int value ) +{ + if ( os.isBinary() ) + os << value; + else + { + if ( value==osg::StateAttribute::OFF ) os << std::string("OFF"); + else if ( value==osg::StateAttribute::ON ) os << std::string("ON"); + else if ( value==osg::StateAttribute::INHERIT ) os << std::string("INHERIT"); + else if ( value==osg::StateAttribute::OFF+osg::StateAttribute::OVERRIDE ) + os << std::string("OFF|OVERRIDE"); + else if ( value==osg::StateAttribute::OFF+osg::StateAttribute::PROTECTED ) + os << std::string("OFF|PROTECTED"); + else if ( value==osg::StateAttribute::ON+osg::StateAttribute::OVERRIDE ) + os << std::string("ON|OVERRIDE"); + else if ( value==osg::StateAttribute::ON+osg::StateAttribute::PROTECTED ) + os << std::string("ON|PROTECTED"); + else os << std::string("INHERIT"); + } +} + +static void writeModes( osgDB::OutputStream& os, const osg::StateSet::ModeList& modes ) +{ + os << modes.size(); + if ( modes.size()>0 ) + { + os << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::StateSet::ModeList::const_iterator itr=modes.begin(); + itr!=modes.end(); ++itr ) + { + os << GLENUM(itr->first); + writeValue(os, itr->second); + os << std::endl; + } + os << osgDB::END_BRACKET; + } + os << std::endl; +} + +static void writeAttributes( osgDB::OutputStream& os, const osg::StateSet::AttributeList& attrs ) +{ + os << attrs.size(); + if ( attrs.size()>0 ) + { + os << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::StateSet::AttributeList::const_iterator itr=attrs.begin(); + itr!=attrs.end(); ++itr ) + { + os << itr->second.first.get(); + os << osgDB::PROPERTY("Value"); + writeValue(os, itr->second.second); + os << std::endl; + } + os << osgDB::END_BRACKET; + } + os << std::endl; +} + +// _modeList +static bool checkModeList( const osg::StateSet& ss ) +{ + return ss.getModeList().size()>0; +} + +static bool readModeList( osgDB::InputStream& is, osg::StateSet& ss ) +{ + osg::StateSet::ModeList modes; readModes( is, modes ); + for ( osg::StateSet::ModeList::iterator itr=modes.begin(); + itr!=modes.end(); ++itr ) + { + ss.setMode( itr->first, itr->second ); + } + return true; +} + +static bool writeModeList( osgDB::OutputStream& os, const osg::StateSet& ss ) +{ + writeModes( os, ss.getModeList() ); + return true; +} + +// _attributeList +static bool checkAttributeList( const osg::StateSet& ss ) +{ + return ss.getAttributeList().size()>0; +} + +static bool readAttributeList( osgDB::InputStream& is, osg::StateSet& ss ) +{ + osg::StateSet::AttributeList attrs; readAttributes( is, attrs ); + for ( osg::StateSet::AttributeList::iterator itr=attrs.begin(); + itr!=attrs.end(); ++itr ) + { + ss.setAttribute( itr->second.first.get(), itr->second.second ); + } + return true; +} + +static bool writeAttributeList( osgDB::OutputStream& os, const osg::StateSet& ss ) +{ + writeAttributes( os, ss.getAttributeList() ); + return true; +} + +// _textureModeList +static bool checkTextureModeList( const osg::StateSet& ss ) +{ + return ss.getTextureModeList().size()>0; +} + +static bool readTextureModeList( osgDB::InputStream& is, osg::StateSet& ss ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + osg::StateSet::ModeList modes; + for ( unsigned int i=0; i> osgDB::PROPERTY("Data"); + readModes( is, modes ); + for ( osg::StateSet::ModeList::iterator itr=modes.begin(); + itr!=modes.end(); ++itr ) + { + ss.setTextureMode( i, itr->first, itr->second ); + } + modes.clear(); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeTextureModeList( osgDB::OutputStream& os, const osg::StateSet& ss ) +{ + const osg::StateSet::TextureModeList& tml = ss.getTextureModeList(); + os << tml.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::StateSet::TextureModeList::const_iterator itr=tml.begin(); + itr!=tml.end(); ++itr ) + { + os << osgDB::PROPERTY("Data"); + writeModes( os, *itr ); + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +// _textureAttributeList +static bool checkTextureAttributeList( const osg::StateSet& ss ) +{ + return ss.getTextureAttributeList().size()>0; +} + +static bool readTextureAttributeList( osgDB::InputStream& is, osg::StateSet& ss ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + osg::StateSet::AttributeList attrs; + for ( unsigned int i=0; i> osgDB::PROPERTY("Data"); + readAttributes( is, attrs ); + for ( osg::StateSet::AttributeList::iterator itr=attrs.begin(); + itr!=attrs.end(); ++itr ) + { + ss.setTextureAttribute( i, itr->second.first.get(), itr->second.second ); + } + attrs.clear(); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeTextureAttributeList( osgDB::OutputStream& os, const osg::StateSet& ss ) +{ + const osg::StateSet::TextureAttributeList& tal = ss.getTextureAttributeList(); + os << tal.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::StateSet::TextureAttributeList::const_iterator itr=tal.begin(); + itr!=tal.end(); ++itr ) + { + os << osgDB::PROPERTY("Data"); + writeAttributes( os, *itr ); + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +// _uniformList +static bool checkUniformList( const osg::StateSet& ss ) +{ + return ss.getUniformList().size()>0; +} + +static bool readUniformList( osgDB::InputStream& is, osg::StateSet& ss ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i( is.readObject() ); + is >> osgDB::PROPERTY("Value"); + int value = readValue( is ); + if ( uniform ) + ss.addUniform( uniform, (osg::StateAttribute::Values)value ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeUniformList( osgDB::OutputStream& os, const osg::StateSet& ss ) +{ + const osg::StateSet::UniformList& ul = ss.getUniformList(); + os << ul.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::StateSet::UniformList::const_iterator itr=ul.begin(); + itr!=ul.end(); ++itr ) + { + os << itr->second.first.get(); + os << osgDB::PROPERTY("Value"); + writeValue(os, itr->second.second); + os << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( StateSet, + new osg::StateSet, + osg::StateSet, + "osg::Object osg::StateSet" ) +{ + ADD_USER_SERIALIZER( ModeList ); // _modeList + ADD_USER_SERIALIZER( AttributeList ); // _attributeList + ADD_USER_SERIALIZER( TextureModeList ); // _textureModeList + ADD_USER_SERIALIZER( TextureAttributeList ); // _textureAttributeList + ADD_USER_SERIALIZER( UniformList ); // _uniformList + ADD_INT_SERIALIZER( RenderingHint, osg::StateSet::DEFAULT_BIN ); // _renderingHint + + BEGIN_ENUM_SERIALIZER( RenderBinMode, INHERIT_RENDERBIN_DETAILS ); + ADD_ENUM_VALUE( INHERIT_RENDERBIN_DETAILS ); + ADD_ENUM_VALUE( USE_RENDERBIN_DETAILS ); + ADD_ENUM_VALUE( OVERRIDE_RENDERBIN_DETAILS ); + END_ENUM_SERIALIZER(); // _binMode + + ADD_INT_SERIALIZER( BinNumber, 0 ); // _binNum + ADD_STRING_SERIALIZER( BinName, "" ); // _binName + ADD_BOOL_SERIALIZER( NestRenderBins, true ); // _nestRenderBins + ADD_OBJECT_SERIALIZER( UpdateCallback, osg::StateSet::Callback, NULL ); // _updateCallback + ADD_OBJECT_SERIALIZER( EventCallback, osg::StateSet::Callback, NULL ); // _eventCallback +} diff --git a/src/osgWrappers/serializers/osg/Stencil.cpp b/src/osgWrappers/serializers/osg/Stencil.cpp new file mode 100644 index 000000000..c702e37af --- /dev/null +++ b/src/osgWrappers/serializers/osg/Stencil.cpp @@ -0,0 +1,59 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Stencil, + new osg::Stencil, + osg::Stencil, + "osg::Object osg::StateAttribute osg::Stencil" ) +{ + BEGIN_ENUM_SERIALIZER( Function, ALWAYS ); + ADD_ENUM_VALUE( NEVER ); + ADD_ENUM_VALUE( LESS ); + ADD_ENUM_VALUE( EQUAL ); + ADD_ENUM_VALUE( LEQUAL ); + ADD_ENUM_VALUE( GREATER ); + ADD_ENUM_VALUE( NOTEQUAL ); + ADD_ENUM_VALUE( GEQUAL ); + ADD_ENUM_VALUE( ALWAYS ); + END_ENUM_SERIALIZER(); // _func + + ADD_INT_SERIALIZER( FunctionRef, 0 ); // _funcRef + ADD_HEXINT_SERIALIZER( FunctionMask, ~0u ); // _funcMask + + BEGIN_ENUM_SERIALIZER2( StencilFailOperation, osg::Stencil::Operation, KEEP ); + ADD_ENUM_VALUE( KEEP ); + ADD_ENUM_VALUE( ZERO ); + ADD_ENUM_VALUE( REPLACE ); + ADD_ENUM_VALUE( INCR ); + ADD_ENUM_VALUE( DECR ); + ADD_ENUM_VALUE( INVERT ); + ADD_ENUM_VALUE( INCR_WRAP ); + ADD_ENUM_VALUE( DECR_WRAP ); + END_ENUM_SERIALIZER(); // _sfail + + BEGIN_ENUM_SERIALIZER2( StencilPassAndDepthFailOperation, osg::Stencil::Operation, KEEP ); + ADD_ENUM_VALUE( KEEP ); + ADD_ENUM_VALUE( ZERO ); + ADD_ENUM_VALUE( REPLACE ); + ADD_ENUM_VALUE( INCR ); + ADD_ENUM_VALUE( DECR ); + ADD_ENUM_VALUE( INVERT ); + ADD_ENUM_VALUE( INCR_WRAP ); + ADD_ENUM_VALUE( DECR_WRAP ); + END_ENUM_SERIALIZER(); // _zfail + + BEGIN_ENUM_SERIALIZER2( StencilPassAndDepthPassOperation, osg::Stencil::Operation, KEEP ); + ADD_ENUM_VALUE( KEEP ); + ADD_ENUM_VALUE( ZERO ); + ADD_ENUM_VALUE( REPLACE ); + ADD_ENUM_VALUE( INCR ); + ADD_ENUM_VALUE( DECR ); + ADD_ENUM_VALUE( INVERT ); + ADD_ENUM_VALUE( INCR_WRAP ); + ADD_ENUM_VALUE( DECR_WRAP ); + END_ENUM_SERIALIZER(); // _zpass + + ADD_HEXINT_SERIALIZER( WriteMask, ~0u ); // _writeMask +} diff --git a/src/osgWrappers/serializers/osg/StencilTwoSided.cpp b/src/osgWrappers/serializers/osg/StencilTwoSided.cpp new file mode 100644 index 000000000..4f88953c8 --- /dev/null +++ b/src/osgWrappers/serializers/osg/StencilTwoSided.cpp @@ -0,0 +1,79 @@ +#include +#include +#include +#include + +BEGIN_USER_TABLE( Function, osg::StencilTwoSided ); + ADD_USER_VALUE( NEVER ); + ADD_USER_VALUE( LESS ); + ADD_USER_VALUE( EQUAL ); + ADD_USER_VALUE( LEQUAL ); + ADD_USER_VALUE( GREATER ); + ADD_USER_VALUE( NOTEQUAL ); + ADD_USER_VALUE( GEQUAL ); + ADD_USER_VALUE( ALWAYS ); +END_USER_TABLE() + +USER_READ_FUNC( Function, readFunction ) +USER_WRITE_FUNC( Function, writeFunction ) + +BEGIN_USER_TABLE( Operation, osg::StencilTwoSided ); + ADD_USER_VALUE( KEEP ); + ADD_USER_VALUE( ZERO ); + ADD_USER_VALUE( REPLACE ); + ADD_USER_VALUE( INCR ); + ADD_USER_VALUE( DECR ); + ADD_USER_VALUE( INVERT ); + ADD_USER_VALUE( INCR_WRAP ); + ADD_USER_VALUE( DECR_WRAP ); +END_USER_TABLE() + +USER_READ_FUNC( Operation, readOperation ) +USER_WRITE_FUNC( Operation, writeOperation ) + +#define STENCIL_INT_VALUE_FUNC( PROP, TYPE ) \ + static bool check##PROP( const osg::StencilTwoSided& attr ) { return true; } \ + static bool read##PROP( osgDB::InputStream& is, osg::StencilTwoSided& attr ) { \ + TYPE value1; is >> osgDB::PROPERTY("Front") >> value1; \ + TYPE value2; is >> osgDB::PROPERTY("Back") >> value2; \ + attr.set##PROP(osg::StencilTwoSided::FRONT, value1); \ + attr.set##PROP(osg::StencilTwoSided::BACK, value2); return true; } \ + static bool write##PROP( osgDB::OutputStream& os, const osg::StencilTwoSided& attr ) { \ + os << osgDB::PROPERTY("Front") << attr.get##PROP(osg::StencilTwoSided::FRONT); \ + os << osgDB::PROPERTY("Back") << attr.get##PROP(osg::StencilTwoSided::BACK); \ + os << std::endl; return true; } + +#define STENCIL_USER_VALUE_FUNC( PROP, TYPE ) \ + static bool check##PROP( const osg::StencilTwoSided& attr ) { return true; } \ + static bool read##PROP( osgDB::InputStream& is, osg::StencilTwoSided& attr ) { \ + is >> osgDB::PROPERTY("Front"); int value1 = read##TYPE(is); \ + is >> osgDB::PROPERTY("Back"); int value2 = read##TYPE(is); \ + attr.set##PROP(osg::StencilTwoSided::FRONT, (osg::StencilTwoSided::TYPE)value1); \ + attr.set##PROP(osg::StencilTwoSided::BACK, (osg::StencilTwoSided::TYPE)value2); \ + return true; } \ + static bool write##PROP( osgDB::OutputStream& os, const osg::StencilTwoSided& attr ) { \ + os << osgDB::PROPERTY("Front"); write##TYPE(os, (int)attr.get##PROP(osg::StencilTwoSided::FRONT)); \ + os << osgDB::PROPERTY("Back"); write##TYPE(os, (int)attr.get##PROP(osg::StencilTwoSided::BACK)); \ + os << std::endl; return true; } + +STENCIL_USER_VALUE_FUNC( Function, Function ) +STENCIL_INT_VALUE_FUNC( FunctionRef, int ) +STENCIL_INT_VALUE_FUNC( FunctionMask, unsigned int ) +STENCIL_USER_VALUE_FUNC( StencilFailOperation, Operation ) +STENCIL_USER_VALUE_FUNC( StencilPassAndDepthFailOperation, Operation ) +STENCIL_USER_VALUE_FUNC( StencilPassAndDepthPassOperation, Operation ) +STENCIL_INT_VALUE_FUNC( WriteMask, unsigned int ) + +REGISTER_OBJECT_WRAPPER( StencilTwoSided, + new osg::StencilTwoSided, + osg::StencilTwoSided, + "osg::Object osg::StateAttribute osg::StencilTwoSided" ) +{ + ADD_USER_SERIALIZER( Function ); // _func + ADD_USER_SERIALIZER( FunctionRef ); // _funcRef + ADD_USER_SERIALIZER( FunctionMask ); // _funcMask + ADD_USER_SERIALIZER( StencilFailOperation ); // _sfail + ADD_USER_SERIALIZER( StencilPassAndDepthFailOperation ); // _zfail + ADD_USER_SERIALIZER( StencilPassAndDepthPassOperation ); // _zpass + ADD_USER_SERIALIZER( WriteMask ); // _writeMask +} diff --git a/src/osgWrappers/serializers/osg/Switch.cpp b/src/osgWrappers/serializers/osg/Switch.cpp new file mode 100644 index 000000000..df2c53afe --- /dev/null +++ b/src/osgWrappers/serializers/osg/Switch.cpp @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Switch, + new osg::Switch, + osg::Switch, + "osg::Object osg::Node osg::Group osg::Switch" ) +{ + ADD_BOOL_SERIALIZER( NewChildDefaultValue, true ); // _newChildDefaultValue + ADD_LIST_SERIALIZER( ValueList, osg::Switch::ValueList ); // _values +} diff --git a/src/osgWrappers/serializers/osg/TessellationHints.cpp b/src/osgWrappers/serializers/osg/TessellationHints.cpp new file mode 100644 index 000000000..09d28e064 --- /dev/null +++ b/src/osgWrappers/serializers/osg/TessellationHints.cpp @@ -0,0 +1,25 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( TessellationHints, + new osg::TessellationHints, + osg::TessellationHints, + "osg::Object osg::TessellationHints" ) +{ + BEGIN_ENUM_SERIALIZER( TessellationMode, USE_SHAPE_DEFAULTS ); + ADD_ENUM_VALUE( USE_SHAPE_DEFAULTS ); + ADD_ENUM_VALUE( USE_TARGET_NUM_FACES ); + END_ENUM_SERIALIZER(); // _TessellationMode + + ADD_FLOAT_SERIALIZER( DetailRatio, 1.0f ); // _detailRatio + ADD_UINT_SERIALIZER( TargetNumFaces, 100 ); // _targetNumFaces + ADD_BOOL_SERIALIZER( CreateFrontFace, true ); // _createFrontFace + ADD_BOOL_SERIALIZER( CreateBackFace, false ); // _createBackFace + ADD_BOOL_SERIALIZER( CreateNormals, true ); // _createNormals + ADD_BOOL_SERIALIZER( CreateTextureCoords, false ); // _createTextureCoords + ADD_BOOL_SERIALIZER( CreateTop, true ); // _createTop + ADD_BOOL_SERIALIZER( CreateBody, true ); // _createBody + ADD_BOOL_SERIALIZER( CreateBottom, true ); // _createBottom +} diff --git a/src/osgWrappers/serializers/osg/TexEnv.cpp b/src/osgWrappers/serializers/osg/TexEnv.cpp new file mode 100644 index 000000000..ce2e7ebdd --- /dev/null +++ b/src/osgWrappers/serializers/osg/TexEnv.cpp @@ -0,0 +1,20 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( TexEnv, + new osg::TexEnv, + osg::TexEnv, + "osg::Object osg::StateAttribute osg::TexEnv" ) +{ + BEGIN_ENUM_SERIALIZER( Mode, MODULATE ); + ADD_ENUM_VALUE( DECAL ); + ADD_ENUM_VALUE( MODULATE ); + ADD_ENUM_VALUE( BLEND ); + ADD_ENUM_VALUE( REPLACE ); + ADD_ENUM_VALUE( ADD ); + END_ENUM_SERIALIZER(); // _mode + + ADD_VEC4_SERIALIZER( Color, osg::Vec4() ); // _color +} diff --git a/src/osgWrappers/serializers/osg/TexEnvCombine.cpp b/src/osgWrappers/serializers/osg/TexEnvCombine.cpp new file mode 100644 index 000000000..6c0138c92 --- /dev/null +++ b/src/osgWrappers/serializers/osg/TexEnvCombine.cpp @@ -0,0 +1,28 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( TexEnvCombine, + new osg::TexEnvCombine, + osg::TexEnvCombine, + "osg::Object osg::StateAttribute osg::TexEnvCombine" ) +{ + ADD_GLENUM_SERIALIZER( Combine_RGB, GLint, GL_NONE ); // _combine_RGB + ADD_GLENUM_SERIALIZER( Combine_Alpha, GLint, GL_NONE ); // _combine_Alpha + ADD_GLENUM_SERIALIZER( Source0_RGB, GLint, GL_NONE ); // _source0_RGB + ADD_GLENUM_SERIALIZER( Source1_RGB, GLint, GL_NONE ); // _source1_RGB + ADD_GLENUM_SERIALIZER( Source2_RGB, GLint, GL_NONE ); // _source2_RGB + ADD_GLENUM_SERIALIZER( Source0_Alpha, GLint, GL_NONE ); // _source0_Alpha + ADD_GLENUM_SERIALIZER( Source1_Alpha, GLint, GL_NONE ); // _source1_Alpha + ADD_GLENUM_SERIALIZER( Source2_Alpha, GLint, GL_NONE ); // _source2_Alpha + ADD_GLENUM_SERIALIZER( Operand0_RGB, GLint, GL_NONE ); // _operand0_RGB + ADD_GLENUM_SERIALIZER( Operand1_RGB, GLint, GL_NONE ); // _operand1_RGB + ADD_GLENUM_SERIALIZER( Operand2_RGB, GLint, GL_NONE ); // _operand2_RGB + ADD_GLENUM_SERIALIZER( Operand0_Alpha, GLint, GL_NONE ); // _operand0_Alpha + ADD_GLENUM_SERIALIZER( Operand1_Alpha, GLint, GL_NONE ); // _operand1_Alpha + ADD_GLENUM_SERIALIZER( Operand2_Alpha, GLint, GL_NONE ); // _operand2_Alpha + ADD_FLOAT_SERIALIZER( Scale_RGB, 1.0f ); // _scale_RGB + ADD_FLOAT_SERIALIZER( Scale_Alpha, 1.0f ); // _scale_Alpha + ADD_VEC4_SERIALIZER( ConstantColor, osg::Vec4() ); // _constantColor +} diff --git a/src/osgWrappers/serializers/osg/TexEnvFilter.cpp b/src/osgWrappers/serializers/osg/TexEnvFilter.cpp new file mode 100644 index 000000000..f0ec00c46 --- /dev/null +++ b/src/osgWrappers/serializers/osg/TexEnvFilter.cpp @@ -0,0 +1,12 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( TexEnvFilter, + new osg::TexEnvFilter, + osg::TexEnvFilter, + "osg::Object osg::StateAttribute osg::TexEnvFilter" ) +{ + ADD_FLOAT_SERIALIZER( LodBias, 0.0f ); // _lodBias +} diff --git a/src/osgWrappers/serializers/osg/TexGen.cpp b/src/osgWrappers/serializers/osg/TexGen.cpp new file mode 100644 index 000000000..d4b6455ae --- /dev/null +++ b/src/osgWrappers/serializers/osg/TexGen.cpp @@ -0,0 +1,40 @@ +#include +#include +#include +#include + +#define PLANE_FUNCTION( PROP, COORD ) \ + static bool check##PROP( const osg::TexGen& tex ) { return true; } \ + static bool read##PROP( osgDB::InputStream& is, osg::TexGen& tex ) { \ + osg::Plane plane; is >> plane; \ + tex.setPlane(COORD, plane); \ + return true; \ + } \ + static bool write##PROP( osgDB::OutputStream& os, const osg::TexGen& tex ) { \ + os << tex.getPlane(COORD) << std::endl; \ + return true; \ + } + +PLANE_FUNCTION( PlaneS, osg::TexGen::S ) +PLANE_FUNCTION( PlaneT, osg::TexGen::T ) +PLANE_FUNCTION( PlaneR, osg::TexGen::R ) +PLANE_FUNCTION( PlaneQ, osg::TexGen::Q ) + +REGISTER_OBJECT_WRAPPER( TexGen, + new osg::TexGen, + osg::TexGen, + "osg::Object osg::StateAttribute osg::TexGen" ) +{ + BEGIN_ENUM_SERIALIZER( Mode, OBJECT_LINEAR ); + ADD_ENUM_VALUE( OBJECT_LINEAR ); + ADD_ENUM_VALUE( EYE_LINEAR ); + ADD_ENUM_VALUE( SPHERE_MAP ); + ADD_ENUM_VALUE( NORMAL_MAP ); + ADD_ENUM_VALUE( REFLECTION_MAP ); + END_ENUM_SERIALIZER(); // _mode + + ADD_USER_SERIALIZER( PlaneS ); + ADD_USER_SERIALIZER( PlaneT ); + ADD_USER_SERIALIZER( PlaneR ); + ADD_USER_SERIALIZER( PlaneQ ); //_plane_s, _plane_t, _plane_r, _plane_q +} diff --git a/src/osgWrappers/serializers/osg/TexGenNode.cpp b/src/osgWrappers/serializers/osg/TexGenNode.cpp new file mode 100644 index 000000000..78c2aa2bc --- /dev/null +++ b/src/osgWrappers/serializers/osg/TexGenNode.cpp @@ -0,0 +1,18 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( TexGenNode, + new osg::TexGenNode, + osg::TexGenNode, + "osg::Object osg::Node osg::Group osg::TexGenNode" ) +{ + ADD_UINT_SERIALIZER( TextureUnit, 0 ); // _textureUnit + ADD_OBJECT_SERIALIZER( TexGen, osg::TexGen, NULL ); // _texgen + + BEGIN_ENUM_SERIALIZER( ReferenceFrame, RELATIVE_RF ); + ADD_ENUM_VALUE( RELATIVE_RF ); + ADD_ENUM_VALUE( ABSOLUTE_RF ); + END_ENUM_SERIALIZER(); // _referenceFrame +} diff --git a/src/osgWrappers/serializers/osg/TexMat.cpp b/src/osgWrappers/serializers/osg/TexMat.cpp new file mode 100644 index 000000000..7a3932f86 --- /dev/null +++ b/src/osgWrappers/serializers/osg/TexMat.cpp @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( TexMat, + new osg::TexMat, + osg::TexMat, + "osg::Object osg::StateAttribute osg::TexMat" ) +{ + ADD_MATRIX_SERIALIZER( Matrix, osg::Matrix() ); // _matrix + ADD_BOOL_SERIALIZER( ScaleByTextureRectangleSize, false ); // _scaleByTextureRectangleSize +} diff --git a/src/osgWrappers/serializers/osg/Texture.cpp b/src/osgWrappers/serializers/osg/Texture.cpp new file mode 100644 index 000000000..f56d967f6 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Texture.cpp @@ -0,0 +1,123 @@ +#include +#include +#include +#include + +#define WRAP_FUNCTIONS( PROP, VALUE ) \ + static bool check##PROP( const osg::Texture& tex ) { return true; } \ + static bool read##PROP( osgDB::InputStream& is, osg::Texture& tex ) { \ + DEF_GLENUM(mode); is >> mode; \ + tex.setWrap( VALUE, (osg::Texture::WrapMode)mode.get() ); \ + return true; \ + } \ + static bool write##PROP( osgDB::OutputStream& os, const osg::Texture& tex ) { \ + os << GLENUM(tex.getWrap(VALUE)) << std::endl; \ + return true; \ + } + +WRAP_FUNCTIONS( WRAP_S, osg::Texture::WRAP_S ) +WRAP_FUNCTIONS( WRAP_T, osg::Texture::WRAP_T ) +WRAP_FUNCTIONS( WRAP_R, osg::Texture::WRAP_R ) + +#define FILTER_FUNCTIONS( PROP, VALUE ) \ + static bool check##PROP( const osg::Texture& tex ) { return true; } \ + static bool read##PROP( osgDB::InputStream& is, osg::Texture& tex ) { \ + DEF_GLENUM(mode); is >> mode; \ + tex.setFilter( VALUE, (osg::Texture::FilterMode)mode.get() ); \ + return true; \ + } \ + static bool write##PROP( osgDB::OutputStream& os, const osg::Texture& tex ) { \ + os << GLENUM(tex.getFilter(VALUE)) << std::endl; \ + return true; \ + } + +FILTER_FUNCTIONS( MIN_FILTER, osg::Texture::MIN_FILTER ) +FILTER_FUNCTIONS( MAG_FILTER, osg::Texture::MAG_FILTER ) + +#define GL_FORMAT_FUNCTIONS( PROP ) \ + static bool check##PROP( const osg::Texture& tex ) { \ + return tex.get##PROP()!=GL_NONE; \ + } \ + static bool read##PROP( osgDB::InputStream& is, osg::Texture& tex ) { \ + DEF_GLENUM(mode); is >> mode; tex.set##PROP( mode.get() ); \ + return true; \ + } \ + static bool write##PROP( osgDB::OutputStream& os, const osg::Texture& tex ) { \ + os << GLENUM(tex.get##PROP()) << std::endl; \ + return true; \ + } + +GL_FORMAT_FUNCTIONS( SourceFormat ) +GL_FORMAT_FUNCTIONS( SourceType ) + +static bool checkInternalFormat( const osg::Texture& tex ) +{ return tex.getInternalFormatMode()==osg::Texture::USE_USER_DEFINED_FORMAT; } + +static bool readInternalFormat( osgDB::InputStream& is, osg::Texture& tex ) +{ + DEF_GLENUM(mode); is >> mode; + if ( tex.getInternalFormatMode()==osg::Texture::USE_USER_DEFINED_FORMAT ) + tex.setInternalFormat( mode.get() ); + return true; +} + +static bool writeInternalFormat( osgDB::OutputStream& os, const osg::Texture& tex ) +{ + if ( os.isBinary() && tex.getInternalFormatMode()!=osg::Texture::USE_USER_DEFINED_FORMAT ) + os << GLENUM(GL_NONE) << std::endl; // Avoid use of OpenGL extensions + else + os << GLENUM(tex.getInternalFormat()) << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( Texture, + /*new osg::Texture*/NULL, + osg::Texture, + "osg::Object osg::StateAttribute osg::Texture" ) +{ + ADD_USER_SERIALIZER( WRAP_S ); // _wrap_s + ADD_USER_SERIALIZER( WRAP_T ); // _wrap_t + ADD_USER_SERIALIZER( WRAP_R ); // _wrap_r + ADD_USER_SERIALIZER( MIN_FILTER ); // _min_filter + ADD_USER_SERIALIZER( MAG_FILTER ); // _mag_filter + ADD_FLOAT_SERIALIZER( MaxAnisotropy, 1.0f ); // _maxAnisotropy + ADD_BOOL_SERIALIZER( UseHardwareMipMapGeneration, true ); // _useHardwareMipMapGeneration + ADD_BOOL_SERIALIZER( UnRefImageDataAfterApply, false ); // _unrefImageDataAfterApply + ADD_BOOL_SERIALIZER( ClientStorageHint, false ); // _clientStorageHint + ADD_BOOL_SERIALIZER( ResizeNonPowerOfTwoHint, false ); // _resizeNonPowerOfTwoHint + ADD_VEC4D_SERIALIZER( BorderColor, osg::Vec4d(0.0,0.0,0.0,0.0) ); // _borderColor + ADD_INT_SERIALIZER( BorderWidth, 0 ); // _borderWidth + + BEGIN_ENUM_SERIALIZER( InternalFormatMode, USE_IMAGE_DATA_FORMAT ); + ADD_ENUM_VALUE( USE_IMAGE_DATA_FORMAT ); + ADD_ENUM_VALUE( USE_USER_DEFINED_FORMAT ); + ADD_ENUM_VALUE( USE_ARB_COMPRESSION ); + ADD_ENUM_VALUE( USE_S3TC_DXT1_COMPRESSION ); + ADD_ENUM_VALUE( USE_S3TC_DXT3_COMPRESSION ); + ADD_ENUM_VALUE( USE_S3TC_DXT5_COMPRESSION ); + END_ENUM_SERIALIZER(); // _internalFormatMode + + ADD_USER_SERIALIZER( InternalFormat ); // _internalFormat + ADD_USER_SERIALIZER( SourceFormat ); // _sourceFormat + ADD_USER_SERIALIZER( SourceType ); // _sourceType + ADD_BOOL_SERIALIZER( ShadowComparison, false ); // _use_shadow_comparison + + BEGIN_ENUM_SERIALIZER( ShadowCompareFunc, LEQUAL ); + ADD_ENUM_VALUE( NEVER ); + ADD_ENUM_VALUE( LESS ); + ADD_ENUM_VALUE( EQUAL ); + ADD_ENUM_VALUE( LEQUAL ); + ADD_ENUM_VALUE( GREATER ); + ADD_ENUM_VALUE( NOTEQUAL ); + ADD_ENUM_VALUE( GEQUAL ); + ADD_ENUM_VALUE( ALWAYS ); + END_ENUM_SERIALIZER(); // _shadow_compare_func + + BEGIN_ENUM_SERIALIZER( ShadowTextureMode, LUMINANCE ); + ADD_ENUM_VALUE( LUMINANCE ); + ADD_ENUM_VALUE( INTENSITY ); + ADD_ENUM_VALUE( ALPHA ); + END_ENUM_SERIALIZER(); // _shadow_texture_mode + + ADD_FLOAT_SERIALIZER( ShadowAmbient, 0.0f ); // _shadow_ambient +} diff --git a/src/osgWrappers/serializers/osg/Texture1D.cpp b/src/osgWrappers/serializers/osg/Texture1D.cpp new file mode 100644 index 000000000..59bbce610 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Texture1D.cpp @@ -0,0 +1,13 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Texture1D, + new osg::Texture1D, + osg::Texture1D, + "osg::Object osg::StateAttribute osg::Texture osg::Texture1D" ) +{ + ADD_IMAGE_SERIALIZER( Image, osg::Image, NULL ); // _image + ADD_INT_SERIALIZER( TextureWidth, 0 ); // _textureWidth +} diff --git a/src/osgWrappers/serializers/osg/Texture2D.cpp b/src/osgWrappers/serializers/osg/Texture2D.cpp new file mode 100644 index 000000000..1d988f7e8 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Texture2D.cpp @@ -0,0 +1,14 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Texture2D, + new osg::Texture2D, + osg::Texture2D, + "osg::Object osg::StateAttribute osg::Texture osg::Texture2D" ) +{ + ADD_IMAGE_SERIALIZER( Image, osg::Image, NULL ); // _image + ADD_INT_SERIALIZER( TextureWidth, 0 ); // _textureWidth + ADD_INT_SERIALIZER( TextureHeight, 0 ); // _textureHeight +} diff --git a/src/osgWrappers/serializers/osg/Texture2DArray.cpp b/src/osgWrappers/serializers/osg/Texture2DArray.cpp new file mode 100644 index 000000000..0c6855409 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Texture2DArray.cpp @@ -0,0 +1,44 @@ +#include +#include +#include +#include + +static bool checkImages( const osg::Texture2DArray& tex ) +{ + return tex.getNumImages()>0; +} + +static bool readImages( osgDB::InputStream& is, osg::Texture2DArray& tex ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> osgDB::END_BRACKET; + return true; +} + +static bool writeImages( osgDB::OutputStream& os, const osg::Texture2DArray& tex ) +{ + unsigned int size = tex.getNumImages(); + os << size << osgDB::BEGIN_BRACKET << std::endl; + for ( unsigned int i=0; i +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Texture3D, + new osg::Texture3D, + osg::Texture3D, + "osg::Object osg::StateAttribute osg::Texture osg::Texture3D" ) +{ + ADD_IMAGE_SERIALIZER( Image, osg::Image, NULL ); // _image + ADD_INT_SERIALIZER( TextureWidth, 0 ); // _textureWidth + ADD_INT_SERIALIZER( TextureHeight, 0 ); // _textureHeight + ADD_INT_SERIALIZER( TextureDepth, 0 ); // _textureDepth +} diff --git a/src/osgWrappers/serializers/osg/TextureCubeMap.cpp b/src/osgWrappers/serializers/osg/TextureCubeMap.cpp new file mode 100644 index 000000000..e7c5b8d88 --- /dev/null +++ b/src/osgWrappers/serializers/osg/TextureCubeMap.cpp @@ -0,0 +1,48 @@ +#include +#include +#include +#include + +#define FACE_IMAGE_FUNCTION( PROP, FACE ) \ + static bool check##PROP( const osg::TextureCubeMap& tex ) { return true; } \ + static bool read##PROP( osgDB::InputStream& is, osg::TextureCubeMap& tex ) { \ + bool hasImage; is >> hasImage; \ + if ( hasImage ) { \ + is >> osgDB::BEGIN_BRACKET; tex.setImage(FACE, is.readImage()); \ + is >> osgDB::END_BRACKET; \ + } \ + return true; \ + } \ + static bool write##PROP( osgDB::OutputStream& os, const osg::TextureCubeMap& tex ) { \ + const osg::Image* image = tex.getImage(FACE); \ + os << (image!=NULL); \ + if ( image!=NULL ) { \ + os << osgDB::BEGIN_BRACKET << std::endl << image; \ + os << osgDB::END_BRACKET; \ + } \ + os << std::endl; \ + return true; \ + } + +FACE_IMAGE_FUNCTION( PosX, osg::TextureCubeMap::POSITIVE_X ) +FACE_IMAGE_FUNCTION( NegX, osg::TextureCubeMap::NEGATIVE_X ) +FACE_IMAGE_FUNCTION( PosY, osg::TextureCubeMap::POSITIVE_Y ) +FACE_IMAGE_FUNCTION( NegY, osg::TextureCubeMap::NEGATIVE_Y ) +FACE_IMAGE_FUNCTION( PosZ, osg::TextureCubeMap::POSITIVE_Z ) +FACE_IMAGE_FUNCTION( NegZ, osg::TextureCubeMap::NEGATIVE_Z ) + +REGISTER_OBJECT_WRAPPER( TextureCubeMap, + new osg::TextureCubeMap, + osg::TextureCubeMap, + "osg::Object osg::StateAttribute osg::Texture osg::TextureCubeMap" ) +{ + ADD_USER_SERIALIZER( PosX ); + ADD_USER_SERIALIZER( NegX ); + ADD_USER_SERIALIZER( PosY ); + ADD_USER_SERIALIZER( NegY ); + ADD_USER_SERIALIZER( PosZ ); + ADD_USER_SERIALIZER( NegZ ); // _images + + ADD_INT_SERIALIZER( TextureWidth, 0 ); // _textureWidth + ADD_INT_SERIALIZER( TextureHeight, 0 ); // _textureHeight +} diff --git a/src/osgWrappers/serializers/osg/TextureRectangle.cpp b/src/osgWrappers/serializers/osg/TextureRectangle.cpp new file mode 100644 index 000000000..6dac66f57 --- /dev/null +++ b/src/osgWrappers/serializers/osg/TextureRectangle.cpp @@ -0,0 +1,14 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( TextureRectangle, + new osg::TextureRectangle, + osg::TextureRectangle, + "osg::Object osg::StateAttribute osg::Texture osg::TextureRectangle" ) +{ + ADD_IMAGE_SERIALIZER( Image, osg::Image, NULL ); // _image + ADD_INT_SERIALIZER( TextureWidth, 0 ); // _textureWidth + ADD_INT_SERIALIZER( TextureHeight, 0 ); // _textureHeight +} diff --git a/src/osgWrappers/serializers/osg/TransferFunction.cpp b/src/osgWrappers/serializers/osg/TransferFunction.cpp new file mode 100644 index 000000000..1b4f35ae7 --- /dev/null +++ b/src/osgWrappers/serializers/osg/TransferFunction.cpp @@ -0,0 +1,11 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( TransferFunction, + new osg::TransferFunction, + osg::TransferFunction, + "osg::Object osg::TransferFunction" ) +{ +} diff --git a/src/osgWrappers/serializers/osg/TransferFunction1D.cpp b/src/osgWrappers/serializers/osg/TransferFunction1D.cpp new file mode 100644 index 000000000..be3d2da44 --- /dev/null +++ b/src/osgWrappers/serializers/osg/TransferFunction1D.cpp @@ -0,0 +1,44 @@ +#include +#include +#include +#include + +static bool checkColorMap( const osg::TransferFunction1D& func ) +{ + return func.getColorMap().size()>0; +} + +static bool readColorMap( osgDB::InputStream& is, osg::TransferFunction1D& func ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> key >> value; + func.setColor( key, value ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeColorMap( osgDB::OutputStream& os, const osg::TransferFunction1D& func ) +{ + const osg::TransferFunction1D::ColorMap& map = func.getColorMap(); + os << map.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::TransferFunction1D::ColorMap::const_iterator itr=map.begin(); + itr!=map.end(); ++itr ) + { + os << itr->first << itr->second << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( TransferFunction1D, + new osg::TransferFunction1D, + osg::TransferFunction1D, + "osg::Object osg::TransferFunction osg::TransferFunction1D" ) +{ + ADD_USER_SERIALIZER( ColorMap ); // _colorMap +} diff --git a/src/osgWrappers/serializers/osg/Transform.cpp b/src/osgWrappers/serializers/osg/Transform.cpp new file mode 100644 index 000000000..4d224b8ca --- /dev/null +++ b/src/osgWrappers/serializers/osg/Transform.cpp @@ -0,0 +1,16 @@ +#include +#include +#include +#include + +REGISTER_OBJECT_WRAPPER( Transform, + new osg::Transform, + osg::Transform, + "osg::Object osg::Node osg::Group osg::Transform" ) +{ + BEGIN_ENUM_SERIALIZER( ReferenceFrame, RELATIVE_RF ); + ADD_ENUM_VALUE( RELATIVE_RF ); + ADD_ENUM_VALUE( ABSOLUTE_RF ); + ADD_ENUM_VALUE( ABSOLUTE_RF_INHERIT_VIEWPOINT ); + END_ENUM_SERIALIZER(); // _referenceFrame +} diff --git a/src/osgWrappers/serializers/osg/TriangleMesh.cpp b/src/osgWrappers/serializers/osg/TriangleMesh.cpp new file mode 100644 index 000000000..7a8f21fbb --- /dev/null +++ b/src/osgWrappers/serializers/osg/TriangleMesh.cpp @@ -0,0 +1,29 @@ +#include +#include +#include +#include + +#define ARRAY_FUNCTIONS( PROP, TYPE ) \ + static bool check##PROP(const osg::TriangleMesh& shape) { \ + return shape.get##PROP()!=NULL; \ + } \ + static bool read##PROP(osgDB::InputStream& is, osg::TriangleMesh& shape) { \ + shape.set##PROP( dynamic_cast(is.readArray()) ); \ + return true; \ + } \ + static bool write##PROP(osgDB::OutputStream& os, const osg::TriangleMesh& shape) { \ + os << shape.get##PROP(); \ + return true; \ + } + +ARRAY_FUNCTIONS( Vertices, osg::Vec3Array ) +ARRAY_FUNCTIONS( Indices, osg::IndexArray ) + +REGISTER_OBJECT_WRAPPER( TriangleMesh, + new osg::TriangleMesh, + osg::TriangleMesh, + "osg::Object osg::Shape osg::TriangleMesh" ) +{ + ADD_USER_SERIALIZER( Vertices ); // _vertices + ADD_USER_SERIALIZER( Indices ); // _indices +} diff --git a/src/osgWrappers/serializers/osg/Uniform.cpp b/src/osgWrappers/serializers/osg/Uniform.cpp new file mode 100644 index 000000000..bfa4cb4cd --- /dev/null +++ b/src/osgWrappers/serializers/osg/Uniform.cpp @@ -0,0 +1,117 @@ +#include +#include +#include +#include + +static bool checkElements( const osg::Uniform& uniform ) +{ + return uniform.getNumElements()>0; +} + +static bool readElements( osgDB::InputStream& is, osg::Uniform& uniform ) +{ + bool hasArray; is >> hasArray; + if ( hasArray ) + { + osg::Array* array = is.readArray(); + switch ( array->getType() ) + { + case osg::Array::FloatArrayType: + uniform.setArray( static_cast(array) ); break; + case osg::Array::IntArrayType: + uniform.setArray( static_cast(array) ); break; + case osg::Array::UIntArrayType: + uniform.setArray( static_cast(array) ); break; + default: break; + } + } + return true; +} + +static bool writeElements( osgDB::OutputStream& os, const osg::Uniform& uniform ) +{ + if ( uniform.getFloatArray()!=NULL ) + { + os << (uniform.getFloatArray()!=NULL); + os.writeArray( uniform.getFloatArray() ); + } + else if ( uniform.getIntArray()!=NULL ) + { + os << (uniform.getIntArray()!=NULL); + os.writeArray( uniform.getIntArray() ); + } + else + { + os << (uniform.getUIntArray()!=NULL); + os.writeArray( uniform.getUIntArray() ); + } + return true; +} + +REGISTER_OBJECT_WRAPPER( Uniform, + new osg::Uniform, + osg::Uniform, + "osg::Object osg::Uniform" ) +{ + BEGIN_ENUM_SERIALIZER3( Type, UNDEFINED ); + ADD_ENUM_VALUE( FLOAT ); + ADD_ENUM_VALUE( FLOAT_VEC2 ); + ADD_ENUM_VALUE( FLOAT_VEC3 ); + ADD_ENUM_VALUE( FLOAT_VEC4 ); + ADD_ENUM_VALUE( INT ); + ADD_ENUM_VALUE( INT_VEC2 ); + ADD_ENUM_VALUE( INT_VEC3 ); + ADD_ENUM_VALUE( INT_VEC4 ); + ADD_ENUM_VALUE( BOOL ); + ADD_ENUM_VALUE( BOOL_VEC2 ); + ADD_ENUM_VALUE( BOOL_VEC3 ); + ADD_ENUM_VALUE( BOOL_VEC4 ); + ADD_ENUM_VALUE( FLOAT_MAT2 ); + ADD_ENUM_VALUE( FLOAT_MAT3 ); + ADD_ENUM_VALUE( FLOAT_MAT4 ); + ADD_ENUM_VALUE( SAMPLER_1D ); + ADD_ENUM_VALUE( SAMPLER_2D ); + ADD_ENUM_VALUE( SAMPLER_3D ); + ADD_ENUM_VALUE( SAMPLER_CUBE ); + ADD_ENUM_VALUE( SAMPLER_1D_SHADOW ); + ADD_ENUM_VALUE( SAMPLER_2D_SHADOW ); + ADD_ENUM_VALUE( SAMPLER_1D_ARRAY ); + ADD_ENUM_VALUE( SAMPLER_2D_ARRAY ); + ADD_ENUM_VALUE( SAMPLER_1D_ARRAY_SHADOW ); + ADD_ENUM_VALUE( SAMPLER_2D_ARRAY_SHADOW ); + ADD_ENUM_VALUE( FLOAT_MAT2x3 ); + ADD_ENUM_VALUE( FLOAT_MAT2x4 ); + ADD_ENUM_VALUE( FLOAT_MAT3x2 ); + ADD_ENUM_VALUE( FLOAT_MAT3x4 ); + ADD_ENUM_VALUE( FLOAT_MAT4x2 ); + ADD_ENUM_VALUE( FLOAT_MAT4x3 ); + ADD_ENUM_VALUE( SAMPLER_BUFFER ); + ADD_ENUM_VALUE( SAMPLER_CUBE_SHADOW ); + ADD_ENUM_VALUE( UNSIGNED_INT ); + ADD_ENUM_VALUE( UNSIGNED_INT_VEC2 ); + ADD_ENUM_VALUE( UNSIGNED_INT_VEC3 ); + ADD_ENUM_VALUE( UNSIGNED_INT_VEC4 ); + ADD_ENUM_VALUE( INT_SAMPLER_1D ); + ADD_ENUM_VALUE( INT_SAMPLER_2D ); + ADD_ENUM_VALUE( INT_SAMPLER_3D ); + ADD_ENUM_VALUE( INT_SAMPLER_CUBE ); + ADD_ENUM_VALUE( INT_SAMPLER_2D_RECT ); + ADD_ENUM_VALUE( INT_SAMPLER_1D_ARRAY ); + ADD_ENUM_VALUE( INT_SAMPLER_2D_ARRAY ); + ADD_ENUM_VALUE( INT_SAMPLER_BUFFER ); + ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_1D ); + ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_2D ); + ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_3D ); + ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_CUBE ); + ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_2D_RECT ); + ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_1D_ARRAY ); + ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_2D_ARRAY ); + ADD_ENUM_VALUE( UNSIGNED_INT_SAMPLER_BUFFER ); + ADD_ENUM_VALUE( UNDEFINED ); + END_ENUM_SERIALIZER(); // _type + + ADD_UINT_SERIALIZER( NumElements, 0 ); // _numElements + ADD_USER_SERIALIZER( Elements ); // _floatArray, _intArray, _uintArray + ADD_OBJECT_SERIALIZER( UpdateCallback, osg::Uniform::Callback, NULL ); // _updateCallback + ADD_OBJECT_SERIALIZER( EventCallback, osg::Uniform::Callback, NULL ); // _eventCallback +} diff --git a/src/osgWrappers/serializers/osg/VertexProgram.cpp b/src/osgWrappers/serializers/osg/VertexProgram.cpp new file mode 100644 index 000000000..834fc96aa --- /dev/null +++ b/src/osgWrappers/serializers/osg/VertexProgram.cpp @@ -0,0 +1,78 @@ +#include +#include +#include +#include + +// _programLocalParameters +static bool checkLocalParameters( const osg::VertexProgram& vp ) +{ + return vp.getLocalParameters().size()>0; +} + +static bool readLocalParameters( osgDB::InputStream& is, osg::VertexProgram& vp ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> key >> value; + vp.setProgramLocalParameter( key, value ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeLocalParameters( osgDB::OutputStream& os, const osg::VertexProgram& vp ) +{ + const osg::VertexProgram::LocalParamList& params = vp.getLocalParameters(); + os << params.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::VertexProgram::LocalParamList::const_iterator itr=params.begin(); + itr!=params.end(); ++itr ) + { + os << itr->first << osg::Vec4d(itr->second) << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +// _matrixList +static bool checkMatrices( const osg::VertexProgram& vp ) +{ + return vp.getMatrices().size()>0; +} + +static bool readMatrices( osgDB::InputStream& is, osg::VertexProgram& vp ) +{ + unsigned int size = 0; is >> size >> osgDB::BEGIN_BRACKET; + for ( unsigned int i=0; i> key >> value; + vp.setMatrix( key, value ); + } + is >> osgDB::END_BRACKET; + return true; +} + +static bool writeMatrices( osgDB::OutputStream& os, const osg::VertexProgram& vp ) +{ + const osg::VertexProgram::MatrixList& matrices = vp.getMatrices(); + os << matrices.size() << osgDB::BEGIN_BRACKET << std::endl; + for ( osg::VertexProgram::MatrixList::const_iterator itr=matrices.begin(); + itr!=matrices.end(); ++itr ) + { + os << (unsigned int)itr->first << osg::Matrixd(itr->second) << std::endl; + } + os << osgDB::END_BRACKET << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( VertexProgram, + new osg::VertexProgram, + osg::VertexProgram, + "osg::Object osg::StateAttribute osg::VertexProgram" ) +{ + ADD_STRING_SERIALIZER( VertexProgram, "" ); // _fragmentProgram + ADD_USER_SERIALIZER( LocalParameters ); // _programLocalParameters + ADD_USER_SERIALIZER( Matrices ); // _matrixList +} diff --git a/src/osgWrappers/serializers/osg/Viewport.cpp b/src/osgWrappers/serializers/osg/Viewport.cpp new file mode 100644 index 000000000..15cc161e4 --- /dev/null +++ b/src/osgWrappers/serializers/osg/Viewport.cpp @@ -0,0 +1,31 @@ +#include +#include +#include +#include + +static bool checkArea( const osg::Viewport& attr ) +{ + return true; +} + +static bool readArea( osgDB::InputStream& is, osg::Viewport& attr ) +{ + double x, y, w, h; + is >> x >> y >> w >> h; + attr.setViewport( x, y, w, h ); + return true; +} + +static bool writeArea( osgDB::OutputStream& os, const osg::Viewport& attr ) +{ + os << attr.x() << attr.y() << attr.width() << attr.height() << std::endl; + return true; +} + +REGISTER_OBJECT_WRAPPER( Viewport, + new osg::Viewport, + osg::Viewport, + "osg::Object osg::StateAttribute osg::Viewport" ) +{ + ADD_USER_SERIALIZER( Area ); // _x, _y, _width, _height +}