void register_MCLGridRef_class(){
{ //::CEGUI::MCLGridRef
typedef bp::class_< CEGUI::MCLGridRef > MCLGridRef_exposer_t;
MCLGridRef_exposer_t MCLGridRef_exposer = MCLGridRef_exposer_t( "MCLGridRef", "*!\n\
\n\
Simple grid index structure.\n\
*\n", bp::init< CEGUI::uint, CEGUI::uint >(( bp::arg("r"), bp::arg("c") )) );
bp::scope MCLGridRef_scope( MCLGridRef_exposer );
MCLGridRef_exposer.def( bp::self != bp::self );
MCLGridRef_exposer.def( bp::self < bp::self );
MCLGridRef_exposer.def( bp::self <= bp::self );
{ //::CEGUI::MCLGridRef::operator=
typedef ::CEGUI::MCLGridRef & ( ::CEGUI::MCLGridRef::*assign_function_type )( ::CEGUI::MCLGridRef const & ) ;
MCLGridRef_exposer.def(
"assign"
, assign_function_type( &::CEGUI::MCLGridRef::operator= )
, ( bp::arg("rhs") )
, bp::return_self< >()
, "operators\n" );
}
MCLGridRef_exposer.def( bp::self == bp::self );
MCLGridRef_exposer.def( bp::self > bp::self );
MCLGridRef_exposer.def( bp::self >= bp::self );
MCLGridRef_exposer.def_readwrite( "column", &CEGUI::MCLGridRef::column );
MCLGridRef_exposer.def_readwrite( "row", &CEGUI::MCLGridRef::row );
}
}
void register_BufferObjectProfile_class(){
{ //::osg::BufferObjectProfile
typedef bp::class_< osg::BufferObjectProfile > BufferObjectProfile_exposer_t;
BufferObjectProfile_exposer_t BufferObjectProfile_exposer = BufferObjectProfile_exposer_t( "BufferObjectProfile", bp::init< >() );
bp::scope BufferObjectProfile_scope( BufferObjectProfile_exposer );
BufferObjectProfile_exposer.def( bp::init< GLenum, GLenum, unsigned int >(( bp::arg("target"), bp::arg("usage"), bp::arg("size") )) );
BufferObjectProfile_exposer.def( bp::init< osg::BufferObjectProfile const & >(( bp::arg("bpo") )) );
BufferObjectProfile_exposer.def( bp::self < bp::self );
{ //::osg::BufferObjectProfile::operator=
typedef ::osg::BufferObjectProfile & ( ::osg::BufferObjectProfile::*assign_function_type)( ::osg::BufferObjectProfile const & ) ;
BufferObjectProfile_exposer.def(
"assign"
, assign_function_type( &::osg::BufferObjectProfile::operator= )
, ( bp::arg("rhs") )
, bp::return_self< >() );
}
BufferObjectProfile_exposer.def( bp::self == bp::self );
{ //::osg::BufferObjectProfile::setProfile
typedef void ( ::osg::BufferObjectProfile::*setProfile_function_type)( ::GLenum,::GLenum,unsigned int ) ;
BufferObjectProfile_exposer.def(
"setProfile"
, setProfile_function_type( &::osg::BufferObjectProfile::setProfile )
, ( bp::arg("target"), bp::arg("usage"), bp::arg("size") ) );
}
BufferObjectProfile_exposer.def_readwrite( "_size", &osg::BufferObjectProfile::_size );
BufferObjectProfile_exposer.def_readwrite( "_target", &osg::BufferObjectProfile::_target );
BufferObjectProfile_exposer.def_readwrite( "_usage", &osg::BufferObjectProfile::_usage );
}
}
void register_Quat_class(){
{ //::osg::Quat
typedef bp::class_< osg::Quat > Quat_exposer_t;
Quat_exposer_t Quat_exposer = Quat_exposer_t( "Quat", "\n A quaternion class. It can be used to represent an orientation in 3D space.\n", bp::init< >() );
bp::scope Quat_scope( Quat_exposer );
Quat_exposer.def( bp::init< double, double, double, double >(( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("w") )) );
Quat_exposer.def( bp::init< osg::Vec4f const & >(( bp::arg("v") )) );
bp::implicitly_convertible< osg::Vec4f const &, osg::Quat >();
Quat_exposer.def( bp::init< osg::Vec4d const & >(( bp::arg("v") )) );
bp::implicitly_convertible< osg::Vec4d const &, osg::Quat >();
Quat_exposer.def( bp::init< double, osg::Vec3f const & >(( bp::arg("angle"), bp::arg("axis") )) );
Quat_exposer.def( bp::init< double, osg::Vec3d const & >(( bp::arg("angle"), bp::arg("axis") )) );
Quat_exposer.def( bp::init< double, osg::Vec3f const &, double, osg::Vec3f const &, double, osg::Vec3f const & >(( bp::arg("angle1"), bp::arg("axis1"), bp::arg("angle2"), bp::arg("axis2"), bp::arg("angle3"), bp::arg("axis3") )) );
Quat_exposer.def( bp::init< double, osg::Vec3d const &, double, osg::Vec3d const &, double, osg::Vec3d const & >(( bp::arg("angle1"), bp::arg("axis1"), bp::arg("angle2"), bp::arg("axis2"), bp::arg("angle3"), bp::arg("axis3") )) );
{ //::osg::Quat::asVec3
typedef ::osg::Vec3d ( ::osg::Quat::*asVec3_function_type )( ) const;
Quat_exposer.def(
"asVec3"
, asVec3_function_type( &::osg::Quat::asVec3 ) );
}
{ //::osg::Quat::asVec4
typedef ::osg::Vec4d ( ::osg::Quat::*asVec4_function_type )( ) const;
Quat_exposer.def(
"asVec4"
, asVec4_function_type( &::osg::Quat::asVec4 ) );
}
{ //::osg::Quat::conj
typedef ::osg::Quat ( ::osg::Quat::*conj_function_type )( ) const;
Quat_exposer.def(
"conj"
, conj_function_type( &::osg::Quat::conj )
, "\n Conjugate\n" );
}
{ //::osg::Quat::get
typedef void ( ::osg::Quat::*get_function_type )( ::osg::Matrixf & ) const;
Quat_exposer.def(
"get"
, get_function_type( &::osg::Quat::get )
, ( bp::arg("matrix") ) );
}
{ //::osg::Quat::get
typedef void ( ::osg::Quat::*get_function_type )( ::osg::Matrixd & ) const;
Quat_exposer.def(
"get"
, get_function_type( &::osg::Quat::get )
, ( bp::arg("matrix") ) );
}
{ //::osg::Quat::getRotate
typedef boost::python::tuple ( *getRotate_function_type )( ::osg::Quat const & );
Quat_exposer.def(
"getRotate"
, getRotate_function_type( &getRotate_7cd433cce0eabe855a9b774688d2845e )
, ( bp::arg("inst") )
, " Return the angle and vector represented by the quaternion." );
}
{ //::osg::Quat::inverse
typedef ::osg::Quat const ( ::osg::Quat::*inverse_function_type )( ) const;
Quat_exposer.def(
"inverse"
, inverse_function_type( &::osg::Quat::inverse )
, "\n Multiplicative inverse method: q^(-1) = q^*/(q.q^*)\n" );
}
{ //::osg::Quat::length
typedef double ( ::osg::Quat::*length_function_type )( ) const;
Quat_exposer.def(
"length"
, length_function_type( &::osg::Quat::length )
, "\n Length of the quaternion = sqrt( vec . vec )\n" );
}
{ //::osg::Quat::length2
typedef double ( ::osg::Quat::*length2_function_type )( ) const;
Quat_exposer.def(
"length2"
, length2_function_type( &::osg::Quat::length2 )
, "\n Length of the quaternion = vec . vec\n" );
}
{ //::osg::Quat::makeRotate
typedef void ( ::osg::Quat::*makeRotate_function_type )( double,double,double,double ) ;
Quat_exposer.def(
"makeRotate"
, makeRotate_function_type( &::osg::Quat::makeRotate )
, ( bp::arg("angle"), bp::arg("x"), bp::arg("y"), bp::arg("z") ) );
}
{ //::osg::Quat::makeRotate
typedef void ( ::osg::Quat::*makeRotate_function_type )( double,::osg::Vec3f const & ) ;
Quat_exposer.def(
"makeRotate"
, makeRotate_function_type( &::osg::Quat::makeRotate )
, ( bp::arg("angle"), bp::arg("vec") ) );
}
{ //::osg::Quat::makeRotate
typedef void ( ::osg::Quat::*makeRotate_function_type )( double,::osg::Vec3d const & ) ;
Quat_exposer.def(
"makeRotate"
, makeRotate_function_type( &::osg::Quat::makeRotate )
, ( bp::arg("angle"), bp::arg("vec") ) );
}
{ //::osg::Quat::makeRotate
typedef void ( ::osg::Quat::*makeRotate_function_type )( double,::osg::Vec3f const &,double,::osg::Vec3f const &,double,::osg::Vec3f const & ) ;
Quat_exposer.def(
"makeRotate"
, makeRotate_function_type( &::osg::Quat::makeRotate )
, ( bp::arg("angle1"), bp::arg("axis1"), bp::arg("angle2"), bp::arg("axis2"), bp::arg("angle3"), bp::arg("axis3") ) );
}
{ //::osg::Quat::makeRotate
typedef void ( ::osg::Quat::*makeRotate_function_type )( double,::osg::Vec3d const &,double,::osg::Vec3d const &,double,::osg::Vec3d const & ) ;
Quat_exposer.def(
"makeRotate"
, makeRotate_function_type( &::osg::Quat::makeRotate )
, ( bp::arg("angle1"), bp::arg("axis1"), bp::arg("angle2"), bp::arg("axis2"), bp::arg("angle3"), bp::arg("axis3") ) );
}
{ //::osg::Quat::makeRotate
typedef void ( ::osg::Quat::*makeRotate_function_type )( ::osg::Vec3f const &,::osg::Vec3f const & ) ;
Quat_exposer.def(
"makeRotate"
, makeRotate_function_type( &::osg::Quat::makeRotate )
, ( bp::arg("vec1"), bp::arg("vec2") )
, "\n Make a rotation Quat which will rotate vec1 to vec2.\n Generally take a dot product to get the angle between these\n and then use a cross product to get the rotation axis\n Watch out for the two special cases when the vectors\n are co-incident or opposite in direction.\n" );
}
{ //::osg::Quat::makeRotate
typedef void ( ::osg::Quat::*makeRotate_function_type )( ::osg::Vec3d const &,::osg::Vec3d const & ) ;
Quat_exposer.def(
"makeRotate"
, makeRotate_function_type( &::osg::Quat::makeRotate )
, ( bp::arg("vec1"), bp::arg("vec2") )
, "\n Make a rotation Quat which will rotate vec1 to vec2.\n Generally take a dot product to get the angle between these\n and then use a cross product to get the rotation axis\n Watch out for the two special cases of when the vectors\n are co-incident or opposite in direction.\n" );
}
{ //::osg::Quat::makeRotate_original
typedef void ( ::osg::Quat::*makeRotate_original_function_type )( ::osg::Vec3d const &,::osg::Vec3d const & ) ;
Quat_exposer.def(
"makeRotate_original"
, makeRotate_original_function_type( &::osg::Quat::makeRotate_original )
, ( bp::arg("vec1"), bp::arg("vec2") ) );
}
Quat_exposer.def( bp::self != bp::self );
Quat_exposer.def( bp::self * bp::other< double >() );
Quat_exposer.def( bp::self * bp::self );
Quat_exposer.def( bp::self * bp::other< osg::Vec3f >() );
Quat_exposer.def( bp::self * bp::other< osg::Vec3d >() );
Quat_exposer.def( bp::self *= bp::other< double >() );
Quat_exposer.def( bp::self *= bp::self );
Quat_exposer.def( bp::self + bp::self );
Quat_exposer.def( bp::self += bp::self );
Quat_exposer.def( bp::self - bp::self );
Quat_exposer.def( -bp::self );
Quat_exposer.def( bp::self -= bp::self );
Quat_exposer.def( bp::self / bp::other< double >() );
Quat_exposer.def( bp::self / bp::self );
Quat_exposer.def( bp::self /= bp::other< double >() );
Quat_exposer.def( bp::self /= bp::self );
Quat_exposer.def( bp::self < bp::self );
{ //::osg::Quat::operator=
typedef ::osg::Quat & ( ::osg::Quat::*assign_function_type )( ::osg::Quat const & ) ;
Quat_exposer.def(
"assign"
, assign_function_type( &::osg::Quat::operator= )
, ( bp::arg("v") )
, bp::return_self< >() );
}
Quat_exposer.def( bp::self == bp::self );
{ //::osg::Quat::operator[]
typedef double & ( ::osg::Quat::*__getitem___function_type )( int ) ;
Quat_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::Quat::operator[] )
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::osg::Quat::operator[]
typedef double ( ::osg::Quat::*__getitem___function_type )( int ) const;
Quat_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::Quat::operator[] )
, ( bp::arg("i") ) );
}
{ //::osg::Quat::set
typedef void ( ::osg::Quat::*set_function_type )( double,double,double,double ) ;
Quat_exposer.def(
"set"
, set_function_type( &::osg::Quat::set )
, ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("w") ) );
}
{ //::osg::Quat::set
typedef void ( ::osg::Quat::*set_function_type )( ::osg::Vec4f const & ) ;
Quat_exposer.def(
"set"
, set_function_type( &::osg::Quat::set )
, ( bp::arg("v") ) );
}
{ //::osg::Quat::set
typedef void ( ::osg::Quat::*set_function_type )( ::osg::Vec4d const & ) ;
Quat_exposer.def(
"set"
, set_function_type( &::osg::Quat::set )
, ( bp::arg("v") ) );
}
{ //::osg::Quat::set
typedef void ( ::osg::Quat::*set_function_type )( ::osg::Matrixf const & ) ;
Quat_exposer.def(
"set"
, set_function_type( &::osg::Quat::set )
, ( bp::arg("matrix") ) );
}
{ //::osg::Quat::set
typedef void ( ::osg::Quat::*set_function_type )( ::osg::Matrixd const & ) ;
Quat_exposer.def(
"set"
, set_function_type( &::osg::Quat::set )
, ( bp::arg("matrix") ) );
}
{ //::osg::Quat::slerp
typedef void ( ::osg::Quat::*slerp_function_type )( double,::osg::Quat const &,::osg::Quat const & ) ;
Quat_exposer.def(
"slerp"
, slerp_function_type( &::osg::Quat::slerp )
, ( bp::arg("t"), bp::arg("from"), bp::arg("to") )
, "\n Spherical Linear Interpolation.\n As t goes from 0 to 1, the Quat object goes from from to to.\n" );
}
{ //::osg::Quat::w
typedef double & ( ::osg::Quat::*w_function_type )( ) ;
Quat_exposer.def(
"w"
, w_function_type( &::osg::Quat::w )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::osg::Quat::w
typedef double ( ::osg::Quat::*w_function_type )( ) const;
Quat_exposer.def(
"w"
, w_function_type( &::osg::Quat::w ) );
}
{ //::osg::Quat::x
typedef double & ( ::osg::Quat::*x_function_type )( ) ;
Quat_exposer.def(
"x"
, x_function_type( &::osg::Quat::x )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::osg::Quat::x
typedef double ( ::osg::Quat::*x_function_type )( ) const;
Quat_exposer.def(
"x"
, x_function_type( &::osg::Quat::x ) );
}
{ //::osg::Quat::y
typedef double & ( ::osg::Quat::*y_function_type )( ) ;
Quat_exposer.def(
"y"
, y_function_type( &::osg::Quat::y )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::osg::Quat::y
typedef double ( ::osg::Quat::*y_function_type )( ) const;
Quat_exposer.def(
"y"
, y_function_type( &::osg::Quat::y ) );
}
{ //::osg::Quat::z
typedef double & ( ::osg::Quat::*z_function_type )( ) ;
Quat_exposer.def(
"z"
, z_function_type( &::osg::Quat::z )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::osg::Quat::z
typedef double ( ::osg::Quat::*z_function_type )( ) const;
Quat_exposer.def(
"z"
, z_function_type( &::osg::Quat::z ) );
}
{ //::osg::Quat::zeroRotation
typedef bool ( ::osg::Quat::*zeroRotation_function_type )( ) const;
Quat_exposer.def(
"zeroRotation"
, zeroRotation_function_type( &::osg::Quat::zeroRotation )
, "\n return true if the Quat represents a zero rotation, and therefore can be ignored in computations.\n" );
}
Quat_exposer.def( bp::self_ns::str( bp::self ) );
Quat_exposer.def( bp::self_ns::str(bp::self) );
Quat_exposer.def(bp::indexing::container_suite<
osg::Quat,
bp::indexing::all_methods,
OsgVec_algorithms<osg::Quat, osg::Quat::value_type, 4> >());
}
}
void register_PyHandle_class() {
{ //::PyHandle
typedef bp::class_< PyHandle_wrapper, bp::bases< CBaseHandle > > PyHandle_exposer_t;
PyHandle_exposer_t PyHandle_exposer = PyHandle_exposer_t( "PyHandle", bp::init< bp::api::object >(( bp::arg("ent") )) );
bp::scope PyHandle_scope( PyHandle_exposer );
bp::implicitly_convertible< bp::api::object, PyHandle >();
PyHandle_exposer.def( bp::init< int, int >(( bp::arg("iEntry"), bp::arg("iSerialNumber") )) );
{ //::PyHandle::Bool
typedef bool ( ::PyHandle::*__bool___function_type )( ) ;
PyHandle_exposer.def(
"__bool__"
, __bool___function_type( &::PyHandle::Bool ) );
}
{ //::PyHandle::GetAttr
typedef ::boost::python::api::object ( ::PyHandle::*__getattr___function_type )( char const * ) ;
PyHandle_exposer.def(
"__getattr__"
, __getattr___function_type( &::PyHandle::GetAttr )
, ( bp::arg("name") ) );
}
{ //::PyHandle::GetAttribute
typedef ::boost::python::api::object ( ::PyHandle::*__getattribute___function_type )( char const * ) ;
PyHandle_exposer.def(
"__getattribute__"
, __getattribute___function_type( &::PyHandle::GetAttribute )
, ( bp::arg("name") ) );
}
{ //::PyHandle::Hash
typedef ::Py_hash_t ( ::PyHandle::*__hash___function_type )( ) ;
PyHandle_exposer.def(
"__hash__"
, __hash___function_type( &::PyHandle::Hash ) );
}
{ //::PyHandle::PyGet
typedef ::boost::python::api::object ( ::PyHandle::*Get_function_type )( ) const;
PyHandle_exposer.def(
"Get"
, Get_function_type( &::PyHandle::PyGet ) );
}
{ //::PyHandle::Set
typedef void ( ::PyHandle::*Set_function_type )( ::boost::python::api::object ) ;
PyHandle_exposer.def(
"Set"
, Set_function_type( &::PyHandle::Set )
, ( bp::arg("ent") ) );
}
{ //::PyHandle::SetAttr
typedef void ( ::PyHandle::*__setattr___function_type )( char const *,::boost::python::api::object ) ;
PyHandle_exposer.def(
"__setattr__"
, __setattr___function_type( &::PyHandle::SetAttr )
, ( bp::arg("name"), bp::arg("v") ) );
}
{ //::PyHandle::Str
typedef ::boost::python::api::object ( ::PyHandle::*__str___function_type )( ) ;
PyHandle_exposer.def(
"__str__"
, __str___function_type( &::PyHandle::Str ) );
}
PyHandle_exposer.def( bp::self != bp::other< bp::api::object >() );
PyHandle_exposer.def( bp::self != bp::self );
{ //::PyHandle::operator=
typedef ::PyHandle const & ( ::PyHandle::*assign_function_type )( ::boost::python::api::object ) ;
PyHandle_exposer.def(
"assign"
, assign_function_type( &::PyHandle::operator= )
, ( bp::arg("val") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
PyHandle_exposer.def( bp::self == bp::other< bp::api::object >() );
PyHandle_exposer.def( bp::self == bp::self );
}
}
void register_TextureObjectBuffer_class(){
{ //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >
typedef bp::class_< osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > > TextureObjectBuffer_exposer_t;
TextureObjectBuffer_exposer_t TextureObjectBuffer_exposer = TextureObjectBuffer_exposer_t( "TextureObjectBuffer", bp::init< >() );
bp::scope TextureObjectBuffer_scope( TextureObjectBuffer_exposer );
TextureObjectBuffer_exposer.def( bp::init< unsigned int >(( bp::arg("size") )) );
bp::implicitly_convertible< unsigned int, osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > >();
{ //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::clear
typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
typedef void ( exported_class_t::*clear_function_type )( ) ;
TextureObjectBuffer_exposer.def(
"clear"
, clear_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::clear ) );
}
{ //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::empty
typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
typedef bool ( exported_class_t::*empty_function_type )( ) const;
TextureObjectBuffer_exposer.def(
"empty"
, empty_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::empty ) );
}
{ //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator=
typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
typedef ::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > & ( exported_class_t::*assign_function_type )( ::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > const & ) ;
TextureObjectBuffer_exposer.def(
"assign"
, assign_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator= )
, ( bp::arg("rhs") )
, bp::return_self< >() );
}
{ //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator[]
typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
typedef ::osg::ref_ptr< osg::Texture::TextureObject > & ( exported_class_t::*__getitem___function_type )( unsigned int ) ;
TextureObjectBuffer_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator[] )
, ( bp::arg("pos") )
, bp::return_internal_reference< >() );
}
{ //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator[]
typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
typedef ::osg::ref_ptr< osg::Texture::TextureObject > const & ( exported_class_t::*__getitem___function_type )( unsigned int ) const;
TextureObjectBuffer_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator[] )
, ( bp::arg("pos") )
, bp::return_internal_reference< >() );
}
{ //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::resize
typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
typedef void ( exported_class_t::*resize_function_type )( unsigned int ) ;
TextureObjectBuffer_exposer.def(
"resize"
, resize_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::resize )
, ( bp::arg("newSize") ) );
}
{ //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::setAllElementsTo
typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
typedef void ( exported_class_t::*setAllElementsTo_function_type )( ::osg::ref_ptr< osg::Texture::TextureObject > const & ) ;
TextureObjectBuffer_exposer.def(
"setAllElementsTo"
, setAllElementsTo_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::setAllElementsTo )
, ( bp::arg("t") ) );
}
{ //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::size
typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
typedef unsigned int ( exported_class_t::*size_function_type )( ) const;
TextureObjectBuffer_exposer.def(
"size"
, size_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::size ) );
}
}
}
void register_CBaseHandle_class(){
{ //::CBaseHandle
typedef bp::class_< CBaseHandle > CBaseHandle_exposer_t;
CBaseHandle_exposer_t CBaseHandle_exposer = CBaseHandle_exposer_t( "CBaseHandle", bp::init< >() );
bp::scope CBaseHandle_scope( CBaseHandle_exposer );
CBaseHandle_exposer.def( bp::init< CBaseHandle const & >(( bp::arg("other") )) );
CBaseHandle_exposer.def( bp::init< long unsigned int >(( bp::arg("value") )) );
bp::implicitly_convertible< long unsigned int, CBaseHandle >();
CBaseHandle_exposer.def( bp::init< int, int >(( bp::arg("iEntry"), bp::arg("iSerialNumber") )) );
{ //::CBaseHandle::GetEntryIndex
typedef int ( ::CBaseHandle::*GetEntryIndex_function_type )( ) const;
CBaseHandle_exposer.def(
"GetEntryIndex"
, GetEntryIndex_function_type( &::CBaseHandle::GetEntryIndex ) );
}
{ //::CBaseHandle::GetSerialNumber
typedef int ( ::CBaseHandle::*GetSerialNumber_function_type )( ) const;
CBaseHandle_exposer.def(
"GetSerialNumber"
, GetSerialNumber_function_type( &::CBaseHandle::GetSerialNumber ) );
}
{ //::CBaseHandle::IsValid
typedef bool ( ::CBaseHandle::*IsValid_function_type )( ) const;
CBaseHandle_exposer.def(
"IsValid"
, IsValid_function_type( &::CBaseHandle::IsValid ) );
}
{ //::CBaseHandle::ToInt
typedef int ( ::CBaseHandle::*ToInt_function_type )( ) const;
CBaseHandle_exposer.def(
"ToInt"
, ToInt_function_type( &::CBaseHandle::ToInt ) );
}
CBaseHandle_exposer.def( bp::self != bp::self );
CBaseHandle_exposer.def( bp::self != bp::other< IHandleEntity const * >() );
CBaseHandle_exposer.def( bp::self < bp::self );
CBaseHandle_exposer.def( bp::self < bp::other< IHandleEntity const * >() );
{ //::CBaseHandle::operator=
typedef ::CBaseHandle const & ( ::CBaseHandle::*assign_function_type )( ::IHandleEntity const * ) ;
CBaseHandle_exposer.def(
"assign"
, assign_function_type( &::CBaseHandle::operator= )
, ( bp::arg("pEntity") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
CBaseHandle_exposer.def( bp::self == bp::self );
CBaseHandle_exposer.def( bp::self == bp::other< IHandleEntity const * >() );
}
}
void register_Array_less__int__grate__class() {
{ //::CLAM::Array< int >
typedef bp::class_< CLAM::Array< int > > Array_less__int__grate__exposer_t;
Array_less__int__grate__exposer_t Array_less__int__grate__exposer = Array_less__int__grate__exposer_t( "Array_less__int__grate_", bp::init< bp::optional< CLAM::TSize, CLAM::TSize > >(( bp::arg("size")=(int)(0), bp::arg("step")=(int)(1) )) );
bp::scope Array_less__int__grate__scope( Array_less__int__grate__exposer );
{ //::CLAM::Array< int >::AddElem
typedef CLAM::Array< int > exported_class_t;
typedef void ( exported_class_t::*AddElem_function_type )( int const & ) ;
Array_less__int__grate__exposer.def(
"AddElem"
, AddElem_function_type( &::CLAM::Array< int >::AddElem )
, ( bp::arg("elem") ) );
}
{ //::CLAM::Array< int >::AllocatedSize
typedef CLAM::Array< int > exported_class_t;
typedef ::CLAM::TSize ( exported_class_t::*AllocatedSize_function_type )( ) const;
Array_less__int__grate__exposer.def(
"AllocatedSize"
, AllocatedSize_function_type( &::CLAM::Array< int >::AllocatedSize ) );
}
{ //::CLAM::Array< int >::AllocatedSizeInBytes
typedef CLAM::Array< int > exported_class_t;
typedef ::CLAM::TSize ( exported_class_t::*AllocatedSizeInBytes_function_type )( ) const;
Array_less__int__grate__exposer.def(
"AllocatedSizeInBytes"
, AllocatedSizeInBytes_function_type( &::CLAM::Array< int >::AllocatedSizeInBytes ) );
}
{ //::CLAM::Array< int >::CopyChunk
typedef CLAM::Array< int > exported_class_t;
typedef void ( exported_class_t::*CopyChunk_function_type )( int,int,::CLAM::Array< int > & ) const;
Array_less__int__grate__exposer.def(
"CopyChunk"
, CopyChunk_function_type( &::CLAM::Array< int >::CopyChunk )
, ( bp::arg("pos"), bp::arg("size"), bp::arg("a") ) );
}
{ //::CLAM::Array< int >::DeleteElem
typedef CLAM::Array< int > exported_class_t;
typedef void ( exported_class_t::*DeleteElem_function_type )( int ) ;
Array_less__int__grate__exposer.def(
"DeleteElem"
, DeleteElem_function_type( &::CLAM::Array< int >::DeleteElem )
, ( bp::arg("where") ) );
}
{ //::CLAM::Array< int >::Empty
typedef CLAM::Array< int > exported_class_t;
typedef bool ( exported_class_t::*Empty_function_type )( ) const;
Array_less__int__grate__exposer.def(
"Empty"
, Empty_function_type( &::CLAM::Array< int >::Empty ) );
}
{ //::CLAM::Array< int >::GetStep
typedef CLAM::Array< int > exported_class_t;
typedef ::CLAM::TSize ( exported_class_t::*GetStep_function_type )( ) const;
Array_less__int__grate__exposer.def(
"GetStep"
, GetStep_function_type( &::CLAM::Array< int >::GetStep ) );
}
{ //::CLAM::Array< int >::GiveChunk
typedef CLAM::Array< int > exported_class_t;
typedef void ( exported_class_t::*GiveChunk_function_type )( int,int,::CLAM::Array< int > & ) const;
Array_less__int__grate__exposer.def(
"GiveChunk"
, GiveChunk_function_type( &::CLAM::Array< int >::GiveChunk )
, ( bp::arg("pos"), bp::arg("size"), bp::arg("a") ) );
}
{ //::CLAM::Array< int >::Init
typedef CLAM::Array< int > exported_class_t;
typedef void ( exported_class_t::*Init_function_type )( ) ;
Array_less__int__grate__exposer.def(
"Init"
, Init_function_type( &::CLAM::Array< int >::Init ) );
}
{ //::CLAM::Array< int >::InsertElem
typedef CLAM::Array< int > exported_class_t;
typedef void ( exported_class_t::*InsertElem_function_type )( int,int const & ) ;
Array_less__int__grate__exposer.def(
"InsertElem"
, InsertElem_function_type( &::CLAM::Array< int >::InsertElem )
, ( bp::arg("where"), bp::arg("elem") ) );
}
{ //::CLAM::Array< int >::OwnsMemory
typedef CLAM::Array< int > exported_class_t;
typedef bool ( exported_class_t::*OwnsMemory_function_type )( ) const;
Array_less__int__grate__exposer.def(
"OwnsMemory"
, OwnsMemory_function_type( &::CLAM::Array< int >::OwnsMemory ) );
}
{ //::CLAM::Array< int >::Resize
typedef CLAM::Array< int > exported_class_t;
typedef void ( exported_class_t::*Resize_function_type )( ::CLAM::TSize ) ;
Array_less__int__grate__exposer.def(
"Resize"
, Resize_function_type( &::CLAM::Array< int >::Resize )
, ( bp::arg("newAllocSize") ) );
}
{ //::CLAM::Array< int >::SetPtr
typedef CLAM::Array< int > exported_class_t;
typedef void ( exported_class_t::*SetPtr_function_type )( int *,int ) ;
Array_less__int__grate__exposer.def(
"SetPtr"
, SetPtr_function_type( &::CLAM::Array< int >::SetPtr )
, ( bp::arg("ptr"), bp::arg("size")=(int)(0) ) );
}
{ //::CLAM::Array< int >::SetSize
typedef CLAM::Array< int > exported_class_t;
typedef void ( exported_class_t::*SetSize_function_type )( ::CLAM::TSize ) ;
Array_less__int__grate__exposer.def(
"SetSize"
, SetSize_function_type( &::CLAM::Array< int >::SetSize )
, ( bp::arg("size") ) );
}
{ //::CLAM::Array< int >::SetStep
typedef CLAM::Array< int > exported_class_t;
typedef void ( exported_class_t::*SetStep_function_type )( ::CLAM::TSize ) ;
Array_less__int__grate__exposer.def(
"SetStep"
, SetStep_function_type( &::CLAM::Array< int >::SetStep )
, ( bp::arg("step") ) );
}
{ //::CLAM::Array< int >::Size
typedef CLAM::Array< int > exported_class_t;
typedef ::CLAM::TSize ( exported_class_t::*Size_function_type )( ) const;
Array_less__int__grate__exposer.def(
"Size"
, Size_function_type( &::CLAM::Array< int >::Size ) );
}
{ //::CLAM::Array< int >::SizeInBytes
typedef CLAM::Array< int > exported_class_t;
typedef ::CLAM::TSize ( exported_class_t::*SizeInBytes_function_type )( ) const;
Array_less__int__grate__exposer.def(
"SizeInBytes"
, SizeInBytes_function_type( &::CLAM::Array< int >::SizeInBytes ) );
}
Array_less__int__grate__exposer.def( bp::self += bp::self );
{ //::CLAM::Array< int >::operator=
typedef CLAM::Array< int > exported_class_t;
typedef ::CLAM::Array< int > & ( exported_class_t::*assign_function_type )( ::CLAM::Array< int > const & ) ;
Array_less__int__grate__exposer.def(
"assign"
, assign_function_type( &::CLAM::Array< int >::operator= )
, ( bp::arg("src") )
, bp::return_self< >() );
}
{ //::CLAM::Array< int >::operator[]
typedef CLAM::Array< int > exported_class_t;
typedef int const & ( exported_class_t::*__getitem___function_type )( int const & ) const;
Array_less__int__grate__exposer.def(
"__getitem__"
, __getitem___function_type( &::CLAM::Array< int >::operator[] )
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::CLAM::Array< int >::operator[]
typedef CLAM::Array< int > exported_class_t;
typedef int & ( exported_class_t::*__getitem___function_type )( int const & ) ;
Array_less__int__grate__exposer.def(
"__getitem__"
, __getitem___function_type( &::CLAM::Array< int >::operator[] )
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
}
}
void register_Hit_class(){
{ //::osgUtil::Hit
typedef bp::class_< osgUtil::Hit > Hit_exposer_t;
Hit_exposer_t Hit_exposer = Hit_exposer_t( "Hit", bp::init< >() );
bp::scope Hit_scope( Hit_exposer );
Hit_exposer.def( bp::init< osgUtil::Hit const & >(( bp::arg("hit") )) );
{ //::osgUtil::Hit::getDrawable
typedef ::osg::Drawable * ( ::osgUtil::Hit::*getDrawable_function_type)( ) ;
Hit_exposer.def(
"getDrawable"
, getDrawable_function_type( &::osgUtil::Hit::getDrawable )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getDrawable
typedef ::osg::Drawable const * ( ::osgUtil::Hit::*getDrawable_function_type)( ) const;
Hit_exposer.def(
"getDrawable"
, getDrawable_function_type( &::osgUtil::Hit::getDrawable )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getGeode
typedef ::osg::Geode * ( ::osgUtil::Hit::*getGeode_function_type)( ) ;
Hit_exposer.def(
"getGeode"
, getGeode_function_type( &::osgUtil::Hit::getGeode )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getGeode
typedef ::osg::Geode const * ( ::osgUtil::Hit::*getGeode_function_type)( ) const;
Hit_exposer.def(
"getGeode"
, getGeode_function_type( &::osgUtil::Hit::getGeode )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getInverseMatrix
typedef ::osg::RefMatrix const * ( ::osgUtil::Hit::*getInverseMatrix_function_type)( ) const;
Hit_exposer.def(
"getInverseMatrix"
, getInverseMatrix_function_type( &::osgUtil::Hit::getInverseMatrix )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getLocalIntersectNormal
typedef ::osg::Vec3 const & ( ::osgUtil::Hit::*getLocalIntersectNormal_function_type)( ) const;
Hit_exposer.def(
"getLocalIntersectNormal"
, getLocalIntersectNormal_function_type( &::osgUtil::Hit::getLocalIntersectNormal )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getLocalIntersectPoint
typedef ::osg::Vec3 const & ( ::osgUtil::Hit::*getLocalIntersectPoint_function_type)( ) const;
Hit_exposer.def(
"getLocalIntersectPoint"
, getLocalIntersectPoint_function_type( &::osgUtil::Hit::getLocalIntersectPoint )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getLocalLineSegment
typedef ::osg::LineSegment const * ( ::osgUtil::Hit::*getLocalLineSegment_function_type)( ) const;
Hit_exposer.def(
"getLocalLineSegment"
, getLocalLineSegment_function_type( &::osgUtil::Hit::getLocalLineSegment )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getMatrix
typedef ::osg::RefMatrix const * ( ::osgUtil::Hit::*getMatrix_function_type)( ) const;
Hit_exposer.def(
"getMatrix"
, getMatrix_function_type( &::osgUtil::Hit::getMatrix )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getNodePath
typedef ::osg::NodePath & ( ::osgUtil::Hit::*getNodePath_function_type)( ) ;
Hit_exposer.def(
"getNodePath"
, getNodePath_function_type( &::osgUtil::Hit::getNodePath )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getNodePath
typedef ::osg::NodePath const & ( ::osgUtil::Hit::*getNodePath_function_type)( ) const;
Hit_exposer.def(
"getNodePath"
, getNodePath_function_type( &::osgUtil::Hit::getNodePath )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getOriginalLineSegment
typedef ::osg::LineSegment const * ( ::osgUtil::Hit::*getOriginalLineSegment_function_type)( ) const;
Hit_exposer.def(
"getOriginalLineSegment"
, getOriginalLineSegment_function_type( &::osgUtil::Hit::getOriginalLineSegment )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getPrimitiveIndex
typedef int ( ::osgUtil::Hit::*getPrimitiveIndex_function_type)( ) const;
Hit_exposer.def(
"getPrimitiveIndex"
, getPrimitiveIndex_function_type( &::osgUtil::Hit::getPrimitiveIndex ) );
}
{ //::osgUtil::Hit::getRatio
typedef float ( ::osgUtil::Hit::*getRatio_function_type)( ) const;
Hit_exposer.def(
"getRatio"
, getRatio_function_type( &::osgUtil::Hit::getRatio ) );
}
{ //::osgUtil::Hit::getVecIndexList
typedef ::std::vector< int > const & ( ::osgUtil::Hit::*getVecIndexList_function_type)( ) const;
Hit_exposer.def(
"getVecIndexList"
, getVecIndexList_function_type( &::osgUtil::Hit::getVecIndexList )
, bp::return_internal_reference< >() );
}
{ //::osgUtil::Hit::getWorldIntersectNormal
typedef ::osg::Vec3 const ( ::osgUtil::Hit::*getWorldIntersectNormal_function_type)( ) const;
Hit_exposer.def(
"getWorldIntersectNormal"
, getWorldIntersectNormal_function_type( &::osgUtil::Hit::getWorldIntersectNormal ) );
}
{ //::osgUtil::Hit::getWorldIntersectPoint
typedef ::osg::Vec3 const ( ::osgUtil::Hit::*getWorldIntersectPoint_function_type)( ) const;
Hit_exposer.def(
"getWorldIntersectPoint"
, getWorldIntersectPoint_function_type( &::osgUtil::Hit::getWorldIntersectPoint ) );
}
Hit_exposer.def( bp::self < bp::self );
{ //::osgUtil::Hit::operator=
typedef ::osgUtil::Hit & ( ::osgUtil::Hit::*assign_function_type)( ::osgUtil::Hit const & ) ;
Hit_exposer.def(
"assign"
, assign_function_type( &::osgUtil::Hit::operator= )
, ( bp::arg("hit") )
, bp::return_self< >() );
}
Hit_exposer.def_readwrite( "_drawable", &osgUtil::Hit::_drawable );
Hit_exposer.def_readwrite( "_geode", &osgUtil::Hit::_geode );
Hit_exposer.def_readwrite( "_intersectNormal", &osgUtil::Hit::_intersectNormal );
Hit_exposer.def_readwrite( "_intersectPoint", &osgUtil::Hit::_intersectPoint );
Hit_exposer.def_readwrite( "_inverse", &osgUtil::Hit::_inverse );
Hit_exposer.def_readwrite( "_localLineSegment", &osgUtil::Hit::_localLineSegment );
Hit_exposer.def_readwrite( "_matrix", &osgUtil::Hit::_matrix );
Hit_exposer.def_readwrite( "_nodePath", &osgUtil::Hit::_nodePath );
Hit_exposer.def_readwrite( "_originalLineSegment", &osgUtil::Hit::_originalLineSegment );
Hit_exposer.def_readwrite( "_primitiveIndex", &osgUtil::Hit::_primitiveIndex );
Hit_exposer.def_readwrite( "_ratio", &osgUtil::Hit::_ratio );
Hit_exposer.def_readwrite( "_vecIndexList", &osgUtil::Hit::_vecIndexList );
}
}
void register_buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__class(){
{ //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >
typedef bp::class_< osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > > buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer_t;
buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer_t buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer = buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer_t( "buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater_", "\n Implements a simple buffered value for values that need to be buffered on\n a per graphics context basis.\n", bp::init< >("\n Implements a simple buffered value for values that need to be buffered on\n a per graphics context basis.\n") );
bp::scope buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__scope( buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer );
buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def( bp::init< unsigned int >(( bp::arg("size") ), "\n Implements a simple buffered value for values that need to be buffered on\n a per graphics context basis.\n") );
bp::implicitly_convertible< unsigned int, osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > >();
{ //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::clear
typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
typedef void ( exported_class_t::*clear_function_type )( ) ;
buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def(
"clear"
, clear_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::clear ) );
}
{ //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::empty
typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
typedef bool ( exported_class_t::*empty_function_type )( ) const;
buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def(
"empty"
, empty_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::empty ) );
}
{ //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator=
typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
typedef ::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > & ( exported_class_t::*assign_function_type )( ::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > const & ) ;
buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def(
"assign"
, assign_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator= )
, ( bp::arg("rhs") )
, bp::return_self< >()
, "\n Implements a simple buffered value for values that need to be buffered on\n a per graphics context basis.\n" );
}
{ //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator[]
typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
typedef ::osg::ref_ptr< osg::Program::PerContextProgram > & ( exported_class_t::*__getitem___function_type )( unsigned int ) ;
buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator[] )
, ( bp::arg("pos") )
, bp::return_internal_reference< >() );
}
{ //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator[]
typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
typedef ::osg::ref_ptr< osg::Program::PerContextProgram > ( exported_class_t::*__getitem___function_type )( unsigned int ) const;
buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator[] )
, ( bp::arg("pos") ) );
}
{ //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::resize
typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
typedef void ( exported_class_t::*resize_function_type )( unsigned int ) ;
buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def(
"resize"
, resize_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::resize )
, ( bp::arg("newSize") ) );
}
{ //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::setAllElementsTo
typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
typedef void ( exported_class_t::*setAllElementsTo_function_type )( ::osg::ref_ptr< osg::Program::PerContextProgram > const & ) ;
buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def(
"setAllElementsTo"
, setAllElementsTo_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::setAllElementsTo )
, ( bp::arg("t") ) );
}
{ //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::size
typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
typedef unsigned int ( exported_class_t::*size_function_type )( ) const;
buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def(
"size"
, size_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::size ) );
}
}
}
void register_ObserverNodePath_class(){
{ //::osg::ObserverNodePath
typedef bp::class_< osg::ObserverNodePath > ObserverNodePath_exposer_t;
ObserverNodePath_exposer_t ObserverNodePath_exposer = ObserverNodePath_exposer_t( "ObserverNodePath", "\n ObserverNodePath is an observer class for tracking changes to a NodePath,\n that automatically invalidates it when nodes are deleted.\n", bp::init< >("\n ObserverNodePath is an observer class for tracking changes to a NodePath,\n that automatically invalidates it when nodes are deleted.\n") );
bp::scope ObserverNodePath_scope( ObserverNodePath_exposer );
ObserverNodePath_exposer.def( bp::init< osg::ObserverNodePath const & >(( bp::arg("rhs") )) );
ObserverNodePath_exposer.def( bp::init< osg::NodePath const & >(( bp::arg("nodePath") )) );
bp::implicitly_convertible< osg::NodePath const &, osg::ObserverNodePath >();
{ //::osg::ObserverNodePath::clearNodePath
typedef void ( ::osg::ObserverNodePath::*clearNodePath_function_type )( ) ;
ObserverNodePath_exposer.def(
"clearNodePath"
, clearNodePath_function_type( &::osg::ObserverNodePath::clearNodePath ) );
}
{ //::osg::ObserverNodePath::empty
typedef bool ( ::osg::ObserverNodePath::*empty_function_type )( ) const;
ObserverNodePath_exposer.def(
"empty"
, empty_function_type( &::osg::ObserverNodePath::empty ) );
}
{ //::osg::ObserverNodePath::getNodePath
typedef bool ( ::osg::ObserverNodePath::*getNodePath_function_type )( ::osg::NodePath & ) const;
ObserverNodePath_exposer.def(
"getNodePath"
, getNodePath_function_type( &::osg::ObserverNodePath::getNodePath )
, ( bp::arg("nodePath") )
, "\n Get a lightweight NodePath that isnt thread safe but\n may be safely used in single threaded applications, or when\n its known that the NodePath wont be invalidated during usage\n of the NodePath. return true if NodePath is valid.\n" );
}
{ //::osg::ObserverNodePath::getRefNodePath
typedef bool ( ::osg::ObserverNodePath::*getRefNodePath_function_type )( ::osg::RefNodePath & ) const;
ObserverNodePath_exposer.def(
"getRefNodePath"
, getRefNodePath_function_type( &::osg::ObserverNodePath::getRefNodePath )
, ( bp::arg("refNodePath") )
, "\n Get a thread safe RefNodePath, return true if NodePath is valid.\n" );
}
{ //::osg::ObserverNodePath::operator=
typedef ::osg::ObserverNodePath & ( ::osg::ObserverNodePath::*assign_function_type )( ::osg::ObserverNodePath const & ) ;
ObserverNodePath_exposer.def(
"assign"
, assign_function_type( &::osg::ObserverNodePath::operator= )
, ( bp::arg("rhs") )
, bp::return_self< >() );
}
{ //::osg::ObserverNodePath::setNodePath
typedef void ( ::osg::ObserverNodePath::*setNodePath_function_type )( ::osg::RefNodePath const & ) ;
ObserverNodePath_exposer.def(
"setNodePath"
, setNodePath_function_type( &::osg::ObserverNodePath::setNodePath )
, ( bp::arg("nodePath") ) );
}
{ //::osg::ObserverNodePath::setNodePath
typedef void ( ::osg::ObserverNodePath::*setNodePath_function_type )( ::osg::NodePath const & ) ;
ObserverNodePath_exposer.def(
"setNodePath"
, setNodePath_function_type( &::osg::ObserverNodePath::setNodePath )
, ( bp::arg("nodePath") ) );
}
{ //::osg::ObserverNodePath::setNodePathTo
typedef void ( ::osg::ObserverNodePath::*setNodePathTo_function_type )( ::osg::Node * ) ;
ObserverNodePath_exposer.def(
"setNodePathTo"
, setNodePathTo_function_type( &::osg::ObserverNodePath::setNodePathTo )
, ( bp::arg("node") )
, "\n get the NodePath from the first parental chain back to root, plus the specified node.\n" );
}
}
}
void register_Vec4_class(){
{ //::xfx::Vec4
typedef bp::class_< xfx::Vec4 > Vec4_exposer_t;
Vec4_exposer_t Vec4_exposer = Vec4_exposer_t( "Vec4", bp::init< >() );
bp::scope Vec4_scope( Vec4_exposer );
Vec4_exposer.def( bp::init< float >(( bp::arg("v") )) );
bp::implicitly_convertible< float, xfx::Vec4 >();
Vec4_exposer.def( bp::init< xfx::Vec4 const & >(( bp::arg("v") )) );
Vec4_exposer.def( bp::init< float, float, float, float >(( bp::arg("vx"), bp::arg("vy"), bp::arg("vz"), bp::arg("vw") )) );
{ //::xfx::Vec4::Clip
typedef void ( *clip_function_type )( ::xfx::Vec4 & );
Vec4_exposer.def(
"clip"
, clip_function_type( &::xfx::Vec4::Clip )
, ( bp::arg("v") ) );
}
{ //::xfx::Vec4::Dot
typedef float ( *dot_function_type )( ::xfx::Vec4 const &,::xfx::Vec4 const & );
Vec4_exposer.def(
"dot"
, dot_function_type( &::xfx::Vec4::Dot )
, ( bp::arg("u"), bp::arg("v") ) );
}
{ //::xfx::Vec4::Lerp
typedef ::xfx::Vec4 ( *lerp_function_type )( ::xfx::Vec4 const &,::xfx::Vec4 const &,float const & );
Vec4_exposer.def(
"lerp"
, lerp_function_type( &::xfx::Vec4::Lerp )
, ( bp::arg("u"), bp::arg("v"), bp::arg("t") ) );
}
{ //::xfx::Vec4::Normalize
typedef void ( ::xfx::Vec4::*normalize_function_type )( ) ;
Vec4_exposer.def(
"normalize"
, normalize_function_type( &::xfx::Vec4::Normalize ) );
}
{ //::xfx::Vec4::Rand
typedef ::xfx::Vec4 ( *rand_function_type )( );
Vec4_exposer.def(
"rand"
, rand_function_type( &::xfx::Vec4::Rand ) );
}
{ //::xfx::Vec4::ToString
typedef ::xfx::String ( ::xfx::Vec4::*__repr___function_type )( ) const;
Vec4_exposer.def(
"__repr__"
, __repr___function_type( &::xfx::Vec4::ToString ) );
}
Vec4_exposer.def( bp::self *= bp::other< float >() );
Vec4_exposer.def( bp::self *= bp::self );
Vec4_exposer.def( bp::self += bp::self );
Vec4_exposer.def( -bp::self );
Vec4_exposer.def( bp::self -= bp::self );
Vec4_exposer.def( bp::self /= bp::other< float >() );
{ //::xfx::Vec4::operator=
typedef ::xfx::Vec4 & ( ::xfx::Vec4::*assign_function_type )( ::xfx::Vec4 const & ) ;
Vec4_exposer.def(
"assign"
, assign_function_type( &::xfx::Vec4::operator= )
, ( bp::arg("v") )
, bp::return_self< >() );
}
{ //::xfx::Vec4::xyzw
typedef void ( ::xfx::Vec4::*xyzw_function_type )( float,float,float,float ) ;
Vec4_exposer.def(
"xyzw"
, xyzw_function_type( &::xfx::Vec4::xyzw )
, ( bp::arg("_x"), bp::arg("_y"), bp::arg("_z"), bp::arg("_w") ) );
}
Vec4_exposer.def_readwrite( "w", &xfx::Vec4::w );
Vec4_exposer.def_readwrite( "x", &xfx::Vec4::x );
Vec4_exposer.def_readwrite( "y", &xfx::Vec4::y );
Vec4_exposer.def_readwrite( "z", &xfx::Vec4::z );
Vec4_exposer.staticmethod( "clip" );
Vec4_exposer.staticmethod( "dot" );
Vec4_exposer.staticmethod( "lerp" );
Vec4_exposer.staticmethod( "rand" );
{ //property "normalized"[fget=::xfx::Vec4::GetNormalized]
typedef ::xfx::Vec4 ( ::xfx::Vec4::*fget )( ) const;
Vec4_exposer.add_property(
"normalized"
, fget( &::xfx::Vec4::GetNormalized )
, "get property, built on top of \"xfx::Vec4 xfx::Vec4::GetNormalized() const [member function]\"" );
}
{ //property "len_sq"[fget=::xfx::Vec4::LenSq]
typedef float ( ::xfx::Vec4::*fget )( ) const;
Vec4_exposer.add_property(
"len_sq"
, fget( &::xfx::Vec4::LenSq )
, "get property, built on top of \"float xfx::Vec4::LenSq() const [member function]\"" );
}
{ //property "len"[fget=::xfx::Vec4::Len]
typedef float ( ::xfx::Vec4::*fget )( ) const;
Vec4_exposer.add_property(
"len"
, fget( &::xfx::Vec4::Len )
, "get property, built on top of \"float xfx::Vec4::Len() const [member function]\"" );
}
Vec4_exposer.def( bp::self != bp::self );
Vec4_exposer.def( bp::self * bp::other< float >() );
Vec4_exposer.def( bp::other< float >() * bp::self );
Vec4_exposer.def( bp::self + bp::self );
Vec4_exposer.def( bp::self - bp::self );
Vec4_exposer.def( bp::self / bp::other< float >() );
Vec4_exposer.def( bp::self == bp::self );
bp::register_ptr_to_python< boost::shared_ptr< xfx::Vec4 const > >( );
bp::implicitly_convertible< boost::shared_ptr< xfx::Vec4 >, boost::shared_ptr< xfx::Vec4 const > >( );
}
}
void register_ArgumentParser_class(){
{ //::osg::ArgumentParser
typedef bp::class_< osg::ArgumentParser > ArgumentParser_exposer_t;
ArgumentParser_exposer_t ArgumentParser_exposer = ArgumentParser_exposer_t( "ArgumentParser", bp::no_init );
bp::scope ArgumentParser_scope( ArgumentParser_exposer );
bp::enum_< osg::ArgumentParser::ErrorSeverity>("ErrorSeverity")
.value("BENIGN", osg::ArgumentParser::BENIGN)
.value("CRITICAL", osg::ArgumentParser::CRITICAL)
.export_values()
;
{ //::osg::ArgumentParser::Parameter
typedef bp::class_< osg::ArgumentParser::Parameter > Parameter_exposer_t;
Parameter_exposer_t Parameter_exposer = Parameter_exposer_t( "Parameter", bp::init< bool & >(( bp::arg("value") )) );
bp::scope Parameter_scope( Parameter_exposer );
bp::enum_< osg::ArgumentParser::Parameter::ParameterType>("ParameterType")
.value("BOOL_PARAMETER", osg::ArgumentParser::Parameter::BOOL_PARAMETER)
.value("FLOAT_PARAMETER", osg::ArgumentParser::Parameter::FLOAT_PARAMETER)
.value("DOUBLE_PARAMETER", osg::ArgumentParser::Parameter::DOUBLE_PARAMETER)
.value("INT_PARAMETER", osg::ArgumentParser::Parameter::INT_PARAMETER)
.value("UNSIGNED_INT_PARAMETER", osg::ArgumentParser::Parameter::UNSIGNED_INT_PARAMETER)
.value("STRING_PARAMETER", osg::ArgumentParser::Parameter::STRING_PARAMETER)
.export_values()
;
bp::implicitly_convertible< bool &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< float & >(( bp::arg("value") )) );
bp::implicitly_convertible< float &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< double & >(( bp::arg("value") )) );
bp::implicitly_convertible< double &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< int & >(( bp::arg("value") )) );
bp::implicitly_convertible< int &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< unsigned int & >(( bp::arg("value") )) );
bp::implicitly_convertible< unsigned int &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< std::string & >(( bp::arg("value") )) );
bp::implicitly_convertible< std::string &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< osg::ArgumentParser::Parameter const & >(( bp::arg("param") )) );
{ //::osg::ArgumentParser::Parameter::assign
typedef bool ( ::osg::ArgumentParser::Parameter::*assign_function_type)( char const * ) ;
Parameter_exposer.def(
"assign"
, assign_function_type( &::osg::ArgumentParser::Parameter::assign )
, ( bp::arg("str") ) );
}
{ //::osg::ArgumentParser::Parameter::operator=
typedef ::osg::ArgumentParser::Parameter & ( ::osg::ArgumentParser::Parameter::*assign_function_type)( ::osg::ArgumentParser::Parameter const & ) ;
Parameter_exposer.def(
"assign"
, assign_function_type( &::osg::ArgumentParser::Parameter::operator= )
, ( bp::arg("param") )
, bp::return_self< >() );
}
{ //::osg::ArgumentParser::Parameter::valid
typedef bool ( ::osg::ArgumentParser::Parameter::*valid_function_type)( char const * ) const;
Parameter_exposer.def(
"valid"
, valid_function_type( &::osg::ArgumentParser::Parameter::valid )
, ( bp::arg("str") ) );
}
}
ArgumentParser_exposer.def( bp::init< int *, char * * >(( bp::arg("argc"), bp::arg("argv") )) );
{ //::osg::ArgumentParser::argc
typedef int & ( ::osg::ArgumentParser::*argc_function_type)( ) ;
ArgumentParser_exposer.def(
"argc"
, argc_function_type( &::osg::ArgumentParser::argc )
, bp::return_value_policy< bp::copy_non_const_reference >()
, "\n Return the argument count.\n" );
}
{ //::osg::ArgumentParser::containsOptions
typedef bool ( ::osg::ArgumentParser::*containsOptions_function_type)( ) const;
ArgumentParser_exposer.def(
"containsOptions"
, containsOptions_function_type( &::osg::ArgumentParser::containsOptions ) );
}
{ //::osg::ArgumentParser::errors
typedef bool ( ::osg::ArgumentParser::*errors_function_type)( ::osg::ArgumentParser::ErrorSeverity ) const;
ArgumentParser_exposer.def(
"errors"
, errors_function_type( &::osg::ArgumentParser::errors )
, ( bp::arg("severity")=::osg::ArgumentParser::BENIGN )
, "\n Return the error flag, true if an error has occurred when reading arguments.\n" );
}
{ //::osg::ArgumentParser::find
typedef int ( ::osg::ArgumentParser::*find_function_type)( ::std::string const & ) const;
ArgumentParser_exposer.def(
"find"
, find_function_type( &::osg::ArgumentParser::find )
, ( bp::arg("str") )
, "\n Return the position of an occurrence of a string in the argument list.\n Return -1 if no string is found.\n" );
}
{ //::osg::ArgumentParser::getApplicationName
typedef ::std::string ( ::osg::ArgumentParser::*getApplicationName_function_type)( ) const;
ArgumentParser_exposer.def(
"getApplicationName"
, getApplicationName_function_type( &::osg::ArgumentParser::getApplicationName )
, "\n Return the application name, as specified by argv[0]\n" );
}
{ //::osg::ArgumentParser::getApplicationUsage
typedef ::osg::ApplicationUsage * ( ::osg::ArgumentParser::*getApplicationUsage_function_type)( ) ;
ArgumentParser_exposer.def(
"getApplicationUsage"
, getApplicationUsage_function_type( &::osg::ArgumentParser::getApplicationUsage )
, bp::return_internal_reference< >() );
}
{ //::osg::ArgumentParser::getApplicationUsage
typedef ::osg::ApplicationUsage const * ( ::osg::ArgumentParser::*getApplicationUsage_function_type)( ) const;
ArgumentParser_exposer.def(
"getApplicationUsage"
, getApplicationUsage_function_type( &::osg::ArgumentParser::getApplicationUsage )
, bp::return_internal_reference< >() );
}
{ //::osg::ArgumentParser::getErrorMessageMap
typedef ::std::map< std::string, osg::ArgumentParser::ErrorSeverity > & ( ::osg::ArgumentParser::*getErrorMessageMap_function_type)( ) ;
ArgumentParser_exposer.def(
"getErrorMessageMap"
, getErrorMessageMap_function_type( &::osg::ArgumentParser::getErrorMessageMap )
, bp::return_internal_reference< >()
, "\n Return the error message, if any has occurred.\n" );
}
{ //::osg::ArgumentParser::getErrorMessageMap
typedef ::std::map< std::string, osg::ArgumentParser::ErrorSeverity > const & ( ::osg::ArgumentParser::*getErrorMessageMap_function_type)( ) const;
ArgumentParser_exposer.def(
"getErrorMessageMap"
, getErrorMessageMap_function_type( &::osg::ArgumentParser::getErrorMessageMap )
, bp::return_internal_reference< >()
, "\n Return the error message, if any has occurred.\n" );
}
{ //::osg::ArgumentParser::isBool
typedef bool ( *isBool_function_type )( char const * );
ArgumentParser_exposer.def(
"isBool"
, isBool_function_type( &::osg::ArgumentParser::isBool )
, ( bp::arg("str") )
, "\n Return true if specified parameter is a bool.\n" );
}
{ //::osg::ArgumentParser::isNumber
typedef bool ( *isNumber_function_type )( char const * );
ArgumentParser_exposer.def(
"isNumber"
, isNumber_function_type( &::osg::ArgumentParser::isNumber )
, ( bp::arg("str") )
, "\n Return true if specified parameter is a number.\n" );
}
{ //::osg::ArgumentParser::isNumber
typedef bool ( ::osg::ArgumentParser::*isNumber_function_type)( int ) const;
ArgumentParser_exposer.def(
"isNumber"
, isNumber_function_type( &::osg::ArgumentParser::isNumber )
, ( bp::arg("pos") )
, "\n Return true if the specified parameter is a number.\n" );
}
{ //::osg::ArgumentParser::isOption
typedef bool ( *isOptionStr_function_type )( char const * );
ArgumentParser_exposer.def(
"isOptionStr"
, isOptionStr_function_type( &::osg::ArgumentParser::isOption )
, ( bp::arg("str") )
, "\n Return true if the specified string is an option in the form\n -option or --option.\n" );
}
{ //::osg::ArgumentParser::isOption
typedef bool ( ::osg::ArgumentParser::*isOption_function_type)( int ) const;
ArgumentParser_exposer.def(
"isOption"
, isOption_function_type( &::osg::ArgumentParser::isOption )
, ( bp::arg("pos") )
, "\n Return true if the specified parameter is an option in the form of\n -option or --option.\n" );
}
{ //::osg::ArgumentParser::isString
typedef bool ( *isString_function_type )( char const * );
ArgumentParser_exposer.def(
"isString"
, isString_function_type( &::osg::ArgumentParser::isString )
, ( bp::arg("str") )
, "\n Return true if string is non-NULL and not an option in the form\n -option or --option.\n" );
}
{ //::osg::ArgumentParser::isString
typedef bool ( ::osg::ArgumentParser::*isString_function_type)( int ) const;
ArgumentParser_exposer.def(
"isString"
, isString_function_type( &::osg::ArgumentParser::isString )
, ( bp::arg("pos") )
, "\n Return true if the specified parameter is a string not in\n the form of an option.\n" );
}
{ //::osg::ArgumentParser::match
typedef bool ( ::osg::ArgumentParser::*match_function_type)( int,::std::string const & ) const;
ArgumentParser_exposer.def(
"match"
, match_function_type( &::osg::ArgumentParser::match )
, ( bp::arg("pos"), bp::arg("str") )
, "\n Return true if the specified argument matches the given string.\n" );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const & ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str") )
, "\n Search for an occurrence of a string in the argument list. If found,\n remove that occurrence and return true. Otherwise, return false.\n" );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6"), bp::arg("value7") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6"), bp::arg("value7"), bp::arg("value8") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const & ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str") )
, "\n If the argument value at the specified position matches the given string,\n and subsequent parameters are also matched, then set the parameter values,\n remove the arguments from the list, and return true. Otherwise, return false.\n" );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6"), bp::arg("value7") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6"), bp::arg("value7"), bp::arg("value8") ) );
}
{ //::osg::ArgumentParser::readHelpType
typedef ::osg::ApplicationUsage::Type ( ::osg::ArgumentParser::*readHelpType_function_type)( ) ;
ArgumentParser_exposer.def(
"readHelpType"
, readHelpType_function_type( &::osg::ArgumentParser::readHelpType )
, "\n This convenience method handles help requests on the command line.\n Return the type(s) of help requested. The return value of this\n function is suitable for passing into getApplicationUsage()->write().\n If ApplicationUsage::NO_HELP is returned then no help commandline option\n was found on the command line.\n" );
}
{ //::osg::ArgumentParser::remove
typedef void ( ::osg::ArgumentParser::*remove_function_type)( int,int ) ;
ArgumentParser_exposer.def(
"remove"
, remove_function_type( &::osg::ArgumentParser::remove )
, ( bp::arg("pos"), bp::arg("num")=(int)(1) )
, "\n Remove one or more arguments from the argv argument list,\n and decrement the argc respectively.\n" );
}
{ //::osg::ArgumentParser::reportError
typedef void ( ::osg::ArgumentParser::*reportError_function_type)( ::std::string const &,::osg::ArgumentParser::ErrorSeverity ) ;
ArgumentParser_exposer.def(
"reportError"
, reportError_function_type( &::osg::ArgumentParser::reportError )
, ( bp::arg("message"), bp::arg("severity")=::osg::ArgumentParser::CRITICAL )
, "\n Report an error message by adding to the ErrorMessageMap.\n" );
}
{ //::osg::ArgumentParser::reportRemainingOptionsAsUnrecognized
typedef void ( ::osg::ArgumentParser::*reportRemainingOptionsAsUnrecognized_function_type)( ::osg::ArgumentParser::ErrorSeverity ) ;
ArgumentParser_exposer.def(
"reportRemainingOptionsAsUnrecognized"
, reportRemainingOptionsAsUnrecognized_function_type( &::osg::ArgumentParser::reportRemainingOptionsAsUnrecognized )
, ( bp::arg("severity")=::osg::ArgumentParser::BENIGN )
, "\n For each remaining option, report it as unrecognized.\n" );
}
{ //::osg::ArgumentParser::setApplicationUsage
typedef void ( ::osg::ArgumentParser::*setApplicationUsage_function_type)( ::osg::ApplicationUsage * ) ;
ArgumentParser_exposer.def(
"setApplicationUsage"
, setApplicationUsage_function_type( &::osg::ArgumentParser::setApplicationUsage )
, ( bp::arg("usage") ) );
}
{ //::osg::ArgumentParser::writeErrorMessages
typedef void ( ::osg::ArgumentParser::*writeErrorMessages_function_type)( ::std::ostream &,::osg::ArgumentParser::ErrorSeverity ) ;
ArgumentParser_exposer.def(
"writeErrorMessages"
, writeErrorMessages_function_type( &::osg::ArgumentParser::writeErrorMessages )
, ( bp::arg("output"), bp::arg("sevrity")=::osg::ArgumentParser::BENIGN )
, "\n Write error messages to the given ostream, if at or above the given severity.\n" );
}
ArgumentParser_exposer.staticmethod( "isBool" );
ArgumentParser_exposer.staticmethod( "isNumber" );
ArgumentParser_exposer.staticmethod( "isOptionStr" );
ArgumentParser_exposer.staticmethod( "isString" );
ArgumentParser_exposer.def( "__init__", bp::make_constructor( &initArgumentParser ) );
ArgumentParser_exposer.def( "__init__", bp::make_constructor( &initArgumentParser2 ) );
ArgumentParser_exposer.def( "__getitem__", &getArgumentParserItem );
}
}
void register_IPAddress_class(){
{ //::osiris::IPAddress
typedef ::boost::python::class_< ::osiris::IPAddress > IPAddress_exposer_t;
IPAddress_exposer_t IPAddress_exposer = IPAddress_exposer_t( "IPAddress", ::boost::python::init< >() );
::boost::python::scope IPAddress_scope( IPAddress_exposer );
IPAddress_exposer.def( ::boost::python::init< ::osiris::uint8, ::osiris::uint8, ::osiris::uint8, ::osiris::uint8, ::osiris::uint32 >(( ::boost::python::arg("a"), ::boost::python::arg("b"), ::boost::python::arg("c"), ::boost::python::arg("d"), ::boost::python::arg("port") )) );
IPAddress_exposer.def( ::boost::python::init< ::osiris::uint32, ::osiris::uint32 >(( ::boost::python::arg("ip"), ::boost::python::arg("port") )) );
IPAddress_exposer.def( ::boost::python::init< ::osiris::IPAddress const & >(( ::boost::python::arg("second") )) );
{ //::osiris::IPAddress::getIP
typedef boost::python::object ( *getIP_function_type )( ::osiris::IPAddress const & );
IPAddress_exposer.def(
"getIP"
, getIP_function_type( &getIP_32999fbf07323c9f80e570a813bfa961 ) );
}
{ //::osiris::IPAddress::getPort
typedef boost::python::object ( *getPort_function_type )( ::osiris::IPAddress const & );
IPAddress_exposer.def(
"getPort"
, getPort_function_type( &getPort_738d5dca4426fcac34cf27d9bd6e9a63 ) );
}
{ //::osiris::IPAddress::isLocalAddress
typedef boost::python::object ( *isLocalAddress_function_type )( ::osiris::IPAddress const & );
IPAddress_exposer.def(
"isLocalAddress"
, isLocalAddress_function_type( &isLocalAddress_5a51fbafa82dc510d399c0257b31abcd ) );
}
{ //::osiris::IPAddress::isPrivateAddress
typedef boost::python::object ( *isPrivateAddress_function_type )( ::osiris::IPAddress const & );
IPAddress_exposer.def(
"isPrivateAddress"
, isPrivateAddress_function_type( &isPrivateAddress_6b01a27198c1ea530dc0bfea70e3dbf9 ) );
}
{ //::osiris::IPAddress::isAny
typedef boost::python::object ( *isAny_function_type )( ::osiris::IPAddress const & );
IPAddress_exposer.def(
"isAny"
, isAny_function_type( &isAny_edddd4d2bdbc030d3e3e09114121f4f2 ) );
}
{ //::osiris::IPAddress::setEndpoint
typedef boost::python::object ( *setEndpoint_function_type )( ::osiris::IPAddress &,::osiris::String const &,::osiris::uint32 );
IPAddress_exposer.def(
"setEndpoint"
, setEndpoint_function_type( &setEndpoint_149d86b9a54209e270da806866b57cfe )
, ( ::boost::python::arg("inst"), ::boost::python::arg("ip"), ::boost::python::arg("port") ) );
}
{ //::osiris::IPAddress::toNative
typedef boost::python::object ( *toNative_function_type )( ::osiris::IPAddress const & );
IPAddress_exposer.def(
"toNative"
, toNative_function_type( &toNative_fe8bacf449c67715a56d6388b5e77507 ) );
}
{ //::osiris::IPAddress::toString
typedef boost::python::object ( *toString_function_type )( ::osiris::IPAddress const & );
IPAddress_exposer.def(
"toString"
, toString_function_type( &toString_fc3c99ef8ddfbf8b4a2044728058c718 ) );
}
{ //::osiris::IPAddress::clear
typedef void ( *clear_function_type )( ::osiris::IPAddress & );
IPAddress_exposer.def(
"clear"
, clear_function_type( &clear_8c276be2894f2513b34096ff62055825 ) );
}
{ //::osiris::IPAddress::fromString
typedef boost::python::object ( *fromString_function_type )( ::osiris::IPAddress &,::osiris::String const & );
IPAddress_exposer.def(
"fromString"
, fromString_function_type( &fromString_ef6b03c612b005e64e31bcd0ea9e9d48 )
, ( ::boost::python::arg("inst"), ::boost::python::arg("ip") ) );
}
IPAddress_exposer.def( ::boost::python::self != ::boost::python::self );
IPAddress_exposer.def( ::boost::python::self < ::boost::python::self );
IPAddress_exposer.def( ::boost::python::self <= ::boost::python::self );
{ //::osiris::IPAddress::operator=
typedef ::osiris::IPAddress & ( ::osiris::IPAddress::*assign_function_type )( ::osiris::IPAddress const & ) ;
IPAddress_exposer.def(
"assign"
, assign_function_type( &::osiris::IPAddress::operator= )
, ( ::boost::python::arg("second") )
, bp::return_self< >() );
}
IPAddress_exposer.def( ::boost::python::self == ::boost::python::self );
{ //::osiris::IPAddress::setIP
typedef void ( *setIP_function_type )( ::osiris::IPAddress &,::osiris::uint32 );
IPAddress_exposer.def(
"setIP"
, setIP_function_type( &setIP_d0e55deba0e3c4a4e9bf44bd550fe8f8 )
, ( ::boost::python::arg("inst"), ::boost::python::arg("ip") ) );
}
{ //::osiris::IPAddress::setPort
typedef void ( *setPort_function_type )( ::osiris::IPAddress &,::osiris::uint32 );
IPAddress_exposer.def(
"setPort"
, setPort_function_type( &setPort_76a55649e9666c068a6373719b232825 )
, ( ::boost::python::arg("inst"), ::boost::python::arg("port") ) );
}
IPAddress_exposer.def_readonly( "ANY", ::osiris::IPAddress::ANY );
IPAddress_exposer.def_readonly( "any_addr", ::osiris::IPAddress::any_addr );
IPAddress_exposer.def_readonly( "any_port", ::osiris::IPAddress::any_port );
{ //property "ip"[fget=::osiris::IPAddress::getIP, fset=::osiris::IPAddress::setIP]
typedef ::osiris::uint32 ( ::osiris::IPAddress::*fget )( ) const;
typedef void ( ::osiris::IPAddress::*fset )( ::osiris::uint32 ) ;
IPAddress_exposer.add_property(
"ip"
, fget( &::osiris::IPAddress::getIP )
, fset( &::osiris::IPAddress::setIP )
, "get\\set property, built on top of \"osiris::uint32 osiris::IPAddress::getIP() const [member function]\" and \"void osiris::IPAddress::setIP(osiris::uint32 ip) [member function]\"" );
}
{ //property "port"[fget=::osiris::IPAddress::getPort, fset=::osiris::IPAddress::setPort]
typedef ::osiris::uint32 ( ::osiris::IPAddress::*fget )( ) const;
typedef void ( ::osiris::IPAddress::*fset )( ::osiris::uint32 ) ;
IPAddress_exposer.add_property(
"port"
, fget( &::osiris::IPAddress::getPort )
, fset( &::osiris::IPAddress::setPort )
, "get\\set property, built on top of \"osiris::uint32 osiris::IPAddress::getPort() const [member function]\" and \"void osiris::IPAddress::setPort(osiris::uint32 port) [member function]\"" );
}
::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::IPAddress > >();
::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IPAddress >, boost::shared_ptr< ::osiris::Object > >();
}
}
void register_RenderInfo_class(){
{ //::osg::RenderInfo
typedef bp::class_< osg::RenderInfo > RenderInfo_exposer_t;
RenderInfo_exposer_t RenderInfo_exposer = RenderInfo_exposer_t( "RenderInfo", bp::init< >() );
bp::scope RenderInfo_scope( RenderInfo_exposer );
RenderInfo_exposer.def( bp::init< osg::RenderInfo const & >(( bp::arg("rhs") )) );
RenderInfo_exposer.def( bp::init< osg::State *, osg::View * >(( bp::arg("state"), bp::arg("view") )) );
{ //::osg::RenderInfo::getContextID
typedef unsigned int ( ::osg::RenderInfo::*getContextID_function_type )( ) const;
RenderInfo_exposer.def(
"getContextID"
, getContextID_function_type( &::osg::RenderInfo::getContextID ) );
}
{ //::osg::RenderInfo::getCurrentCamera
typedef ::osg::Camera * ( ::osg::RenderInfo::*getCurrentCamera_function_type )( ) ;
RenderInfo_exposer.def(
"getCurrentCamera"
, getCurrentCamera_function_type( &::osg::RenderInfo::getCurrentCamera )
, bp::return_internal_reference< >() );
}
{ //::osg::RenderInfo::getState
typedef ::osg::State * ( ::osg::RenderInfo::*getState_function_type )( ) ;
RenderInfo_exposer.def(
"getState"
, getState_function_type( &::osg::RenderInfo::getState )
, bp::return_internal_reference< >() );
}
{ //::osg::RenderInfo::getState
typedef ::osg::State const * ( ::osg::RenderInfo::*getState_function_type )( ) const;
RenderInfo_exposer.def(
"getState"
, getState_function_type( &::osg::RenderInfo::getState )
, bp::return_internal_reference< >() );
}
{ //::osg::RenderInfo::getUserData
typedef ::osg::Referenced * ( ::osg::RenderInfo::*getUserData_function_type )( ) ;
RenderInfo_exposer.def(
"getUserData"
, getUserData_function_type( &::osg::RenderInfo::getUserData )
, bp::return_internal_reference< >() );
}
{ //::osg::RenderInfo::getUserData
typedef ::osg::Referenced const * ( ::osg::RenderInfo::*getUserData_function_type )( ) const;
RenderInfo_exposer.def(
"getUserData"
, getUserData_function_type( &::osg::RenderInfo::getUserData )
, bp::return_internal_reference< >() );
}
{ //::osg::RenderInfo::getView
typedef ::osg::View * ( ::osg::RenderInfo::*getView_function_type )( ) ;
RenderInfo_exposer.def(
"getView"
, getView_function_type( &::osg::RenderInfo::getView )
, bp::return_internal_reference< >() );
}
{ //::osg::RenderInfo::getView
typedef ::osg::View const * ( ::osg::RenderInfo::*getView_function_type )( ) const;
RenderInfo_exposer.def(
"getView"
, getView_function_type( &::osg::RenderInfo::getView )
, bp::return_internal_reference< >() );
}
{ //::osg::RenderInfo::operator=
typedef ::osg::RenderInfo & ( ::osg::RenderInfo::*assign_function_type )( ::osg::RenderInfo const & ) ;
RenderInfo_exposer.def(
"assign"
, assign_function_type( &::osg::RenderInfo::operator= )
, ( bp::arg("rhs") )
, bp::return_self< >() );
}
{ //::osg::RenderInfo::popCamera
typedef void ( ::osg::RenderInfo::*popCamera_function_type )( ) ;
RenderInfo_exposer.def(
"popCamera"
, popCamera_function_type( &::osg::RenderInfo::popCamera ) );
}
{ //::osg::RenderInfo::pushCamera
typedef void ( ::osg::RenderInfo::*pushCamera_function_type )( ::osg::Camera * ) ;
RenderInfo_exposer.def(
"pushCamera"
, pushCamera_function_type( &::osg::RenderInfo::pushCamera )
, ( bp::arg("camera") ) );
}
{ //::osg::RenderInfo::setState
typedef void ( ::osg::RenderInfo::*setState_function_type )( ::osg::State * ) ;
RenderInfo_exposer.def(
"setState"
, setState_function_type( &::osg::RenderInfo::setState )
, ( bp::arg("state") ) );
}
{ //::osg::RenderInfo::setUserData
typedef void ( ::osg::RenderInfo::*setUserData_function_type )( ::osg::Referenced * ) ;
RenderInfo_exposer.def(
"setUserData"
, setUserData_function_type( &::osg::RenderInfo::setUserData )
, ( bp::arg("userData") ) );
}
{ //::osg::RenderInfo::setView
typedef void ( ::osg::RenderInfo::*setView_function_type )( ::osg::View * ) ;
RenderInfo_exposer.def(
"setView"
, setView_function_type( &::osg::RenderInfo::setView )
, ( bp::arg("view") ) );
}
}
}
void register_ID_class(){
{ //::osiris::ID
typedef ::boost::python::class_< ID_wrapper > ID_exposer_t;
ID_exposer_t ID_exposer = ID_exposer_t( "ID", ::boost::python::init< >() );
::boost::python::scope ID_scope( ID_exposer );
::boost::python::enum_< ::osiris::ID::IDType>("IDType")
.value("idUnknown", ::osiris::ID::idUnknown)
.value("idPortal", ::osiris::ID::idPortal)
.value("idObject", ::osiris::ID::idObject)
.value("idModule", ::osiris::ID::idModule)
.value("idComponent", ::osiris::ID::idComponent)
.export_values()
;
{ //::osiris::ID::Header
typedef ::boost::python::class_< ::osiris::ID::Header > Header_exposer_t;
Header_exposer_t Header_exposer = Header_exposer_t( "Header", ::boost::python::init< ::osiris::ID::IDType >(( ::boost::python::arg("type") )) );
::boost::python::scope Header_scope( Header_exposer );
::boost::python::implicitly_convertible< ::osiris::ID::IDType, ::osiris::ID::Header >();
{ //::osiris::ID::Header::getType
typedef boost::python::object ( *getType_function_type )( ::osiris::ID::Header const & );
Header_exposer.def(
"getType"
, getType_function_type( &getType_3cb634128d1d758beea2b1b763818e39 ) );
}
{ //::osiris::ID::Header::getFirst
typedef boost::python::object ( *getFirst_function_type )( ::osiris::ID::Header const & );
Header_exposer.def(
"getFirst"
, getFirst_function_type( &getFirst_9d0ef18d4a2e202a12d0e12cbe6af64a ) );
}
{ //::osiris::ID::Header::getSecond
typedef boost::python::object ( *getSecond_function_type )( ::osiris::ID::Header const & );
Header_exposer.def(
"getSecond"
, getSecond_function_type( &getSecond_2071a2840a28fd7c9175dfe04b4cf2e6 ) );
}
{ //::osiris::ID::Header::getThird
typedef boost::python::object ( *getThird_function_type )( ::osiris::ID::Header const & );
Header_exposer.def(
"getThird"
, getThird_function_type( &getThird_67a38bca0bd4fe381fb58e179df97d83 ) );
}
{ //::osiris::ID::Header::getFourth
typedef boost::python::object ( *getFourth_function_type )( ::osiris::ID::Header const & );
Header_exposer.def(
"getFourth"
, getFourth_function_type( &getFourth_39e93cc6c71d52d1aef3f25ac8ca05db ) );
}
{ //::osiris::ID::Header::getValue
typedef boost::python::object ( *getValue_function_type )( ::osiris::ID::Header const & );
Header_exposer.def(
"getValue"
, getValue_function_type( &getValue_36b44b39697fa40ef12535dbb67a07b2 ) );
}
{ //::osiris::ID::Header::setFirst
typedef void ( *setFirst_function_type )( ::osiris::ID::Header &,::osiris::byte );
Header_exposer.def(
"setFirst"
, setFirst_function_type( &setFirst_d43fa481bf77d2567a4d94a4093af298 )
, ( ::boost::python::arg("inst"), ::boost::python::arg("value") ) );
}
{ //::osiris::ID::Header::setSecond
typedef void ( *setSecond_function_type )( ::osiris::ID::Header &,::osiris::byte );
Header_exposer.def(
"setSecond"
, setSecond_function_type( &setSecond_08fd38d1a62c013068407d5616d6af04 )
, ( ::boost::python::arg("inst"), ::boost::python::arg("value") ) );
}
{ //::osiris::ID::Header::setThird
typedef void ( *setThird_function_type )( ::osiris::ID::Header &,::osiris::byte );
Header_exposer.def(
"setThird"
, setThird_function_type( &setThird_753c6c5f8d0e91719d5100475d06dc07 )
, ( ::boost::python::arg("inst"), ::boost::python::arg("value") ) );
}
{ //property "first"[fget=::osiris::ID::Header::getFirst, fset=::osiris::ID::Header::setFirst]
typedef ::osiris::byte ( ::osiris::ID::Header::*fget )( ) const;
typedef void ( ::osiris::ID::Header::*fset )( ::osiris::byte ) ;
Header_exposer.add_property(
"first"
, fget( &::osiris::ID::Header::getFirst )
, fset( &::osiris::ID::Header::setFirst )
, "get\\set property, built on top of \"osiris::byte osiris::ID::Header::getFirst() const [member function]\" and \"void osiris::ID::Header::setFirst(osiris::byte value) [member function]\"" );
}
{ //property "second"[fget=::osiris::ID::Header::getSecond, fset=::osiris::ID::Header::setSecond]
typedef ::osiris::byte ( ::osiris::ID::Header::*fget )( ) const;
typedef void ( ::osiris::ID::Header::*fset )( ::osiris::byte ) ;
Header_exposer.add_property(
"second"
, fget( &::osiris::ID::Header::getSecond )
, fset( &::osiris::ID::Header::setSecond )
, "get\\set property, built on top of \"osiris::byte osiris::ID::Header::getSecond() const [member function]\" and \"void osiris::ID::Header::setSecond(osiris::byte value) [member function]\"" );
}
{ //property "third"[fget=::osiris::ID::Header::getThird, fset=::osiris::ID::Header::setThird]
typedef ::osiris::byte ( ::osiris::ID::Header::*fget )( ) const;
typedef void ( ::osiris::ID::Header::*fset )( ::osiris::byte ) ;
Header_exposer.add_property(
"third"
, fget( &::osiris::ID::Header::getThird )
, fset( &::osiris::ID::Header::setThird )
, "get\\set property, built on top of \"osiris::byte osiris::ID::Header::getThird() const [member function]\" and \"void osiris::ID::Header::setThird(osiris::byte value) [member function]\"" );
}
{ //property "type"[fget=::osiris::ID::Header::getType]
typedef ::osiris::ID::IDType ( ::osiris::ID::Header::*fget )( ) const;
Header_exposer.add_property(
"type"
, fget( &::osiris::ID::Header::getType )
, "get property, built on top of \"osiris::ID::IDType osiris::ID::Header::getType() const [member function]\"" );
}
{ //property "fourth"[fget=::osiris::ID::Header::getFourth]
typedef ::osiris::byte ( ::osiris::ID::Header::*fget )( ) const;
Header_exposer.add_property(
"fourth"
, fget( &::osiris::ID::Header::getFourth )
, "get property, built on top of \"osiris::byte osiris::ID::Header::getFourth() const [member function]\"" );
}
{ //property "value"[fget=::osiris::ID::Header::getValue]
typedef ::osiris::uint32 ( ::osiris::ID::Header::*fget )( ) const;
Header_exposer.add_property(
"value"
, fget( &::osiris::ID::Header::getValue )
, "get property, built on top of \"osiris::uint32 osiris::ID::Header::getValue() const [member function]\"" );
}
}
ID_exposer.def( ::boost::python::init< ::std::string const & >(( ::boost::python::arg("id") )) );
::boost::python::implicitly_convertible< ::std::string const &, ::osiris::ID >();
ID_exposer.def( ::boost::python::init< ::osiris::ID const & >(( ::boost::python::arg("second") )) );
{ //::osiris::ID::getHeader
typedef boost::python::object ( *getHeader_function_type )( ::osiris::ID const & );
ID_exposer.def(
"getHeader"
, getHeader_function_type( &ID_wrapper::getHeader ) );
}
{ //::osiris::ID::getString
typedef boost::python::object ( *getString_function_type )( ::osiris::ID const & );
ID_exposer.def(
"getString"
, getString_function_type( &ID_wrapper::getString ) );
}
{ //::osiris::ID::getType
typedef boost::python::object ( *getType_function_type )( ::osiris::ID const & );
ID_exposer.def(
"getType"
, getType_function_type( &ID_wrapper::getType ) );
}
{ //::osiris::ID::empty
typedef boost::python::object ( *empty_function_type )( ::osiris::ID const & );
ID_exposer.def(
"empty"
, empty_function_type( &ID_wrapper::empty ) );
}
{ //::osiris::ID::toWide
typedef boost::python::object ( *toWide_function_type )( ::osiris::ID const & );
ID_exposer.def(
"toWide"
, toWide_function_type( &ID_wrapper::toWide ) );
}
{ //::osiris::ID::toUTF16
typedef boost::python::object ( *toUTF16_function_type )( ::osiris::ID const & );
ID_exposer.def(
"toUTF16"
, toUTF16_function_type( &ID_wrapper::toUTF16 ) );
}
{ //::osiris::ID::getHash
typedef boost::python::object ( *getHash_function_type )( ::osiris::ID const & );
ID_exposer.def(
"getHash"
, getHash_function_type( &ID_wrapper::getHash ) );
}
{ //::osiris::ID::clear
typedef void ( *clear_function_type )( ::osiris::ID & );
ID_exposer.def(
"clear"
, clear_function_type( &ID_wrapper::clear ) );
}
{ //::osiris::ID::getValidationType
typedef ::osiris::ID::IDType ( ID_wrapper::*getValidationType_function_type )( ) const;
ID_exposer.def(
"getValidationType"
, getValidationType_function_type( &ID_wrapper::default_getValidationType ) );
}
{ //::osiris::ID::generateID
typedef ::std::string ( *generateID_function_type )( ::osiris::ID::Header const &,::std::string const & );
ID_exposer.def(
"generateID"
, generateID_function_type( &ID_wrapper::generateID )
, ( ::boost::python::arg("header"), ::boost::python::arg("hash") ) );
}
{ //::osiris::ID::assign
typedef boost::python::object ( *assign_function_type )( ::osiris::ID &,::std::string const & );
ID_exposer.def(
"assign"
, assign_function_type( &ID_wrapper::assign )
, ( ::boost::python::arg("inst"), ::boost::python::arg("id") ) );
}
{ //::osiris::ID::operator=
typedef ::osiris::ID & ( ::osiris::ID::*assign_function_type )( ::std::string const & ) ;
ID_exposer.def(
"assign"
, assign_function_type( &::osiris::ID::operator= )
, ( ::boost::python::arg("id") )
, bp::return_self< >() );
}
{ //::osiris::ID::standardiseID
typedef ::std::string ( *standardiseID_function_type )( ::std::string const & );
ID_exposer.def(
"standardiseID"
, standardiseID_function_type( &ID_wrapper::standardiseID )
, ( ::boost::python::arg("id") ) );
}
{ //::osiris::ID::validate
typedef bool ( ::osiris::ID::*validate_function_type )( bool ) const;
typedef bool ( ID_wrapper::*default_validate_function_type )( bool ) const;
ID_exposer.def(
"validate"
, validate_function_type(&::osiris::ID::validate)
, default_validate_function_type(&ID_wrapper::default_validate)
, ( ::boost::python::arg("allow_null") ) );
}
ID_exposer.def_readonly( "HASH_SIZE", ::osiris::ID::HASH_SIZE );
ID_exposer.def_readonly( "HEADER_SIZE", ::osiris::ID::HEADER_SIZE );
ID_exposer.def_readonly( "SIZE", ::osiris::ID::SIZE );
ID_exposer.staticmethod( "generateID" );
ID_exposer.staticmethod( "standardiseID" );
{ //property "header"[fget=::osiris::ID::getHeader]
typedef ::osiris::ID::Header const & ( ::osiris::ID::*fget )( ) const;
ID_exposer.add_property(
"header"
, ::boost::python::make_function(
fget( &::osiris::ID::getHeader )
, bp::return_value_policy< bp::copy_const_reference >() )
, "get property, built on top of \"osiris::ID::Header const & osiris::ID::getHeader() const [member function]\"" );
}
{ //property "string"[fget=::osiris::ID::getString]
typedef ::std::string const & ( ::osiris::ID::*fget )( ) const;
ID_exposer.add_property(
"string"
, ::boost::python::make_function(
fget( &::osiris::ID::getString )
, bp::return_value_policy< bp::copy_const_reference >() )
, "get property, built on top of \"std::string const & osiris::ID::getString() const [member function]\"" );
}
{ //property "type"[fget=::osiris::ID::getType]
typedef ::osiris::ID::IDType ( ::osiris::ID::*fget )( ) const;
ID_exposer.add_property(
"type"
, fget( &::osiris::ID::getType )
, "get property, built on top of \"osiris::ID::IDType osiris::ID::getType() const [member function]\"" );
}
{ //property "hash"[fget=::osiris::ID::getHash]
typedef ::std::string ( ::osiris::ID::*fget )( ) const;
ID_exposer.add_property(
"hash"
, fget( &::osiris::ID::getHash )
, "get property, built on top of \"std::string osiris::ID::getHash() const [member function]\"" );
}
}
}
void register_State_class(){
{ //::ompl::base::ScopedState< ompl::base::StateSpace >
typedef bp::class_< ompl::base::ScopedState< ompl::base::StateSpace > > State_exposer_t;
State_exposer_t State_exposer = State_exposer_t( "State", bp::init< boost::shared_ptr< ompl::base::SpaceInformation > const & >(( bp::arg("si") )) );
bp::scope State_scope( State_exposer );
bp::implicitly_convertible< boost::shared_ptr< ompl::base::SpaceInformation > const &, ompl::base::ScopedState< ompl::base::StateSpace > >();
State_exposer.def( bp::init< boost::shared_ptr< ompl::base::StateSpace > const & >(( bp::arg("space") )) );
bp::implicitly_convertible< boost::shared_ptr< ompl::base::StateSpace > const &, ompl::base::ScopedState< ompl::base::StateSpace > >();
State_exposer.def( bp::init< ompl::base::ScopedState< ompl::base::StateSpace > const & >(( bp::arg("other") )) );
State_exposer.def( bp::init< boost::shared_ptr< ompl::base::StateSpace > const &, ompl::base::State const * >(( bp::arg("space"), bp::arg("state") )) );
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::distance
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef double ( exported_class_t::*distance_function_type)( ::ompl::base::State const * ) const;
State_exposer.def(
"distance"
, distance_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::distance )
, ( bp::arg("state") ) );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::enforceBounds
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef void ( exported_class_t::*enforceBounds_function_type)( ) ;
State_exposer.def(
"enforceBounds"
, enforceBounds_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::enforceBounds ) );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::get
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef ::ompl::base::State * ( exported_class_t::*get_function_type)( ) ;
State_exposer.def(
"get"
, get_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::get )
, bp::return_value_policy< bp::reference_existing_object >() );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::get
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef ::ompl::base::State const * ( exported_class_t::*get_function_type)( ) const;
State_exposer.def(
"get"
, get_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::get )
, bp::return_value_policy< bp::reference_existing_object >() );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::getSpace
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef ::boost::shared_ptr< ompl::base::StateSpace > const & ( exported_class_t::*getSpace_function_type)( ) const;
State_exposer.def(
"getSpace"
, getSpace_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::getSpace )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::operator()
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef ::ompl::base::State * ( exported_class_t::*__call___function_type)( ) const;
State_exposer.def(
"__call__"
, __call___function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::operator() )
, bp::return_value_policy< bp::reference_existing_object >() );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::operator=
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef ::ompl::base::ScopedState< ompl::base::StateSpace > & ( exported_class_t::*assign_function_type)( ::ompl::base::ScopedState< ompl::base::StateSpace > const & ) ;
State_exposer.def(
"assign"
, assign_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::operator= )
, ( bp::arg("other") )
, bp::return_value_policy< bp::reference_existing_object >() );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::operator=
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef ::ompl::base::ScopedState< ompl::base::StateSpace > & ( exported_class_t::*assign_function_type)( ::ompl::base::State const * ) ;
State_exposer.def(
"assign"
, assign_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::operator= )
, ( bp::arg("other") )
, bp::return_value_policy< bp::reference_existing_object >() );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::operator=
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef ::ompl::base::ScopedState< ompl::base::StateSpace > & ( exported_class_t::*assign_function_type)( ::std::vector< double > const & ) ;
State_exposer.def(
"assign"
, assign_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::operator= )
, ( bp::arg("reals") )
, bp::return_value_policy< bp::reference_existing_object >() );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::operator=
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef ::ompl::base::ScopedState< ompl::base::StateSpace > & ( exported_class_t::*assign_function_type)( double const ) ;
State_exposer.def(
"assign"
, assign_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::operator= )
, ( bp::arg("value") )
, bp::return_value_policy< bp::reference_existing_object >() );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::random
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef void ( exported_class_t::*random_function_type)( ) ;
State_exposer.def(
"random"
, random_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::random ) );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::reals
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef ::std::vector< double > ( exported_class_t::*reals_function_type)( ) const;
State_exposer.def(
"reals"
, reals_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::reals ) );
}
{ //::ompl::base::ScopedState< ompl::base::StateSpace >::satisfiesBounds
typedef ompl::base::ScopedState< ompl::base::StateSpace > exported_class_t;
typedef bool ( exported_class_t::*satisfiesBounds_function_type)( ) const;
State_exposer.def(
"satisfiesBounds"
, satisfiesBounds_function_type( &::ompl::base::ScopedState< ompl::base::StateSpace >::satisfiesBounds ) );
}
State_exposer.def("__getitem__", &__getitem);
State_exposer.def("__setitem__", &__setitem);
State_exposer.def(bp::init<ompl::base::ScopedState<ompl::base::CompoundStateSpace> const &>(( bp::arg("other") )));
State_exposer.def(bp::init<ompl::base::ScopedState<ompl::base::RealVectorStateSpace> const &>(( bp::arg("other") )));
State_exposer.def(bp::init<ompl::base::ScopedState<ompl::base::SO2StateSpace> const &>(( bp::arg("other") )));
State_exposer.def(bp::init<ompl::base::ScopedState<ompl::base::SO3StateSpace> const &>(( bp::arg("other") )));
State_exposer.def(bp::init<ompl::base::ScopedState<ompl::base::SE2StateSpace> const &>(( bp::arg("other") )));
State_exposer.def(bp::init<ompl::base::ScopedState<ompl::base::SE3StateSpace> const &>(( bp::arg("other") )));
State_exposer.def(bp::init<ompl::base::ScopedState<ompl::base::DiscreteStateSpace> const &>(( bp::arg("other") )));
State_exposer.def(bp::init<ompl::base::ScopedState<ompl::base::TimeStateSpace> const &>(( bp::arg("other") )));
State_exposer.def(bp::init<ompl::base::ScopedState<ompl::base::DubinsStateSpace> const &>(( bp::arg("other") )));
State_exposer.def(bp::init<ompl::base::ScopedState<ompl::base::ReedsSheppStateSpace> const &>(( bp::arg("other") )));
State_exposer.def("__str__", &__str__);
}
}
void register_ShapeAttribute_class(){
{ //::osgSim::ShapeAttribute
typedef bp::class_< osgSim::ShapeAttribute > ShapeAttribute_exposer_t;
ShapeAttribute_exposer_t ShapeAttribute_exposer = ShapeAttribute_exposer_t( "ShapeAttribute", bp::init< >() );
bp::scope ShapeAttribute_scope( ShapeAttribute_exposer );
bp::enum_< osgSim::ShapeAttribute::Type>("Type")
.value("UNKNOWN", osgSim::ShapeAttribute::UNKNOWN)
.value("INTEGER", osgSim::ShapeAttribute::INTEGER)
.value("DOUBLE", osgSim::ShapeAttribute::DOUBLE)
.value("STRING", osgSim::ShapeAttribute::STRING)
.export_values()
;
ShapeAttribute_exposer.def( bp::init< char const * >(( bp::arg("name") )) );
bp::implicitly_convertible< char const *, osgSim::ShapeAttribute >();
ShapeAttribute_exposer.def( bp::init< char const *, int >(( bp::arg("name"), bp::arg("value") )) );
ShapeAttribute_exposer.def( bp::init< char const *, double >(( bp::arg("name"), bp::arg("value") )) );
ShapeAttribute_exposer.def( bp::init< char const *, char const * >(( bp::arg("name"), bp::arg("value") ), "\n Note, ShapeAttribute takes a copy of both name and value, the calling code should manage its own clean up of the original strings.\n") );
ShapeAttribute_exposer.def( bp::init< osgSim::ShapeAttribute const & >(( bp::arg("sa") )) );
{ //::osgSim::ShapeAttribute::compare
typedef int ( ::osgSim::ShapeAttribute::*compare_function_type)( ::osgSim::ShapeAttribute const & ) const;
ShapeAttribute_exposer.def(
"compare"
, compare_function_type( &::osgSim::ShapeAttribute::compare )
, ( bp::arg("sa") )
, "\n return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.\n" );
}
{ //::osgSim::ShapeAttribute::getDouble
typedef double ( ::osgSim::ShapeAttribute::*getDouble_function_type)( ) const;
ShapeAttribute_exposer.def(
"getDouble"
, getDouble_function_type( &::osgSim::ShapeAttribute::getDouble )
, "\n Get the attribute data as a double.\n" );
}
{ //::osgSim::ShapeAttribute::getInt
typedef int ( ::osgSim::ShapeAttribute::*getInt_function_type)( ) const;
ShapeAttribute_exposer.def(
"getInt"
, getInt_function_type( &::osgSim::ShapeAttribute::getInt )
, "\n Get the attribute data as an int.\n" );
}
{ //::osgSim::ShapeAttribute::getName
typedef ::std::string const & ( ::osgSim::ShapeAttribute::*getName_function_type)( ) const;
ShapeAttribute_exposer.def(
"getName"
, getName_function_type( &::osgSim::ShapeAttribute::getName )
, bp::return_value_policy< bp::copy_const_reference >()
, "\n Get the attribute name.\n" );
}
{ //::osgSim::ShapeAttribute::getString
typedef char const * ( ::osgSim::ShapeAttribute::*getString_function_type)( ) const;
ShapeAttribute_exposer.def(
"getString"
, getString_function_type( &::osgSim::ShapeAttribute::getString )
, "\n Get the attribute data as a string.\n" );
}
{ //::osgSim::ShapeAttribute::getType
typedef ::osgSim::ShapeAttribute::Type ( ::osgSim::ShapeAttribute::*getType_function_type)( ) const;
ShapeAttribute_exposer.def(
"getType"
, getType_function_type( &::osgSim::ShapeAttribute::getType )
, "\n Get the attribute data type.\n" );
}
ShapeAttribute_exposer.def( bp::self != bp::self );
ShapeAttribute_exposer.def( bp::self < bp::self );
{ //::osgSim::ShapeAttribute::operator=
typedef ::osgSim::ShapeAttribute & ( ::osgSim::ShapeAttribute::*assign_function_type)( ::osgSim::ShapeAttribute const & ) ;
ShapeAttribute_exposer.def(
"assign"
, assign_function_type( &::osgSim::ShapeAttribute::operator= )
, ( bp::arg("sa") )
, bp::return_self< >() );
}
ShapeAttribute_exposer.def( bp::self == bp::self );
{ //::osgSim::ShapeAttribute::setName
typedef void ( ::osgSim::ShapeAttribute::*setName_function_type)( ::std::string const & ) ;
ShapeAttribute_exposer.def(
"setName"
, setName_function_type( &::osgSim::ShapeAttribute::setName )
, ( bp::arg("name") )
, "\n Set the attribute name.\n" );
}
{ //::osgSim::ShapeAttribute::setValue
typedef void ( ::osgSim::ShapeAttribute::*setValue_function_type)( int ) ;
ShapeAttribute_exposer.def(
"setValue"
, setValue_function_type( &::osgSim::ShapeAttribute::setValue )
, ( bp::arg("value") )
, "\n Set an integer attribute data.\n" );
}
{ //::osgSim::ShapeAttribute::setValue
typedef void ( ::osgSim::ShapeAttribute::*setValue_function_type)( double ) ;
ShapeAttribute_exposer.def(
"setValue"
, setValue_function_type( &::osgSim::ShapeAttribute::setValue )
, ( bp::arg("value") )
, "\n Set a double attribute data.\n" );
}
{ //::osgSim::ShapeAttribute::setValue
typedef void ( ::osgSim::ShapeAttribute::*setValue_function_type)( char const * ) ;
ShapeAttribute_exposer.def(
"setValue"
, setValue_function_type( &::osgSim::ShapeAttribute::setValue )
, ( bp::arg("value") )
, "\n Set a string attribute data.\n" );
}
}
}
void register_FieldReaderIterator_class(){
{ //::osgDB::FieldReaderIterator
typedef bp::class_< FieldReaderIterator_wrapper > FieldReaderIterator_exposer_t;
FieldReaderIterator_exposer_t FieldReaderIterator_exposer = FieldReaderIterator_exposer_t( "FieldReaderIterator", bp::init< >() );
bp::scope FieldReaderIterator_scope( FieldReaderIterator_exposer );
bp::scope().attr("MINIMUM_FIELD_READER_QUEUE_SIZE") = (int)osgDB::FieldReaderIterator::MINIMUM_FIELD_READER_QUEUE_SIZE;
FieldReaderIterator_exposer.def( bp::init< osgDB::FieldReaderIterator const & >(( bp::arg("ic") )) );
{ //::osgDB::FieldReaderIterator::advanceOverCurrentFieldOrBlock
typedef void ( ::osgDB::FieldReaderIterator::*advanceOverCurrentFieldOrBlock_function_type)( ) ;
FieldReaderIterator_exposer.def(
"advanceOverCurrentFieldOrBlock"
, advanceOverCurrentFieldOrBlock_function_type( &::osgDB::FieldReaderIterator::advanceOverCurrentFieldOrBlock ) );
}
{ //::osgDB::FieldReaderIterator::advanceToEndOfBlock
typedef void ( ::osgDB::FieldReaderIterator::*advanceToEndOfBlock_function_type)( int ) ;
FieldReaderIterator_exposer.def(
"advanceToEndOfBlock"
, advanceToEndOfBlock_function_type( &::osgDB::FieldReaderIterator::advanceToEndOfBlock )
, ( bp::arg("noNestBrackets") ) );
}
{ //::osgDB::FieldReaderIterator::advanceToEndOfCurrentBlock
typedef void ( ::osgDB::FieldReaderIterator::*advanceToEndOfCurrentBlock_function_type)( ) ;
FieldReaderIterator_exposer.def(
"advanceToEndOfCurrentBlock"
, advanceToEndOfCurrentBlock_function_type( &::osgDB::FieldReaderIterator::advanceToEndOfCurrentBlock ) );
}
{ //::osgDB::FieldReaderIterator::attach
typedef void ( ::osgDB::FieldReaderIterator::*attach_function_type)( ::std::istream * ) ;
FieldReaderIterator_exposer.def(
"attach"
, attach_function_type( &::osgDB::FieldReaderIterator::attach )
, ( bp::arg("input") ) );
}
{ //::osgDB::FieldReaderIterator::detach
typedef void ( ::osgDB::FieldReaderIterator::*detach_function_type)( ) ;
FieldReaderIterator_exposer.def(
"detach"
, detach_function_type( &::osgDB::FieldReaderIterator::detach ) );
}
{ //::osgDB::FieldReaderIterator::eof
typedef bool ( ::osgDB::FieldReaderIterator::*eof_function_type)( ) const;
typedef bool ( FieldReaderIterator_wrapper::*default_eof_function_type)( ) const;
FieldReaderIterator_exposer.def(
"eof"
, eof_function_type(&::osgDB::FieldReaderIterator::eof)
, default_eof_function_type(&FieldReaderIterator_wrapper::default_eof) );
}
{ //::osgDB::FieldReaderIterator::field
typedef ::osgDB::Field & ( ::osgDB::FieldReaderIterator::*field_function_type)( int ) ;
FieldReaderIterator_exposer.def(
"field"
, field_function_type( &::osgDB::FieldReaderIterator::field )
, ( bp::arg("pos") )
, bp::return_internal_reference< >() );
}
{ //::osgDB::FieldReaderIterator::getFieldReader
typedef ::osgDB::FieldReader & ( ::osgDB::FieldReaderIterator::*getFieldReader_function_type)( ) ;
FieldReaderIterator_exposer.def(
"getFieldReader"
, getFieldReader_function_type( &::osgDB::FieldReaderIterator::getFieldReader )
, bp::return_internal_reference< >() );
}
{ //::osgDB::FieldReaderIterator::insert
typedef void ( ::osgDB::FieldReaderIterator::*insert_function_type)( int,::osgDB::Field * ) ;
FieldReaderIterator_exposer.def(
"insert"
, insert_function_type( &::osgDB::FieldReaderIterator::insert )
, ( bp::arg("pos"), bp::arg("field") ) );
}
{ //::osgDB::FieldReaderIterator::insert
typedef void ( ::osgDB::FieldReaderIterator::*insert_function_type)( int,char const * ) ;
FieldReaderIterator_exposer.def(
"insert"
, insert_function_type( &::osgDB::FieldReaderIterator::insert )
, ( bp::arg("pos"), bp::arg("str") ) );
}
{ //::osgDB::FieldReaderIterator::matchSequence
typedef bool ( ::osgDB::FieldReaderIterator::*matchSequence_function_type)( char const * ) ;
FieldReaderIterator_exposer.def(
"matchSequence"
, matchSequence_function_type( &::osgDB::FieldReaderIterator::matchSequence )
, ( bp::arg("str") ) );
}
FieldReaderIterator_exposer.def( bp::self += bp::other< int >() );
{ //::osgDB::FieldReaderIterator::operator=
typedef ::osgDB::FieldReaderIterator & ( ::osgDB::FieldReaderIterator::*assign_function_type)( ::osgDB::FieldReaderIterator const & ) ;
FieldReaderIterator_exposer.def(
"assign"
, assign_function_type( &::osgDB::FieldReaderIterator::operator= )
, ( bp::arg("ic") )
, bp::return_self< >() );
}
{ //::osgDB::FieldReaderIterator::operator[]
typedef ::osgDB::Field & ( ::osgDB::FieldReaderIterator::*__getitem___function_type)( int ) ;
FieldReaderIterator_exposer.def(
"__getitem__"
, __getitem___function_type( &::osgDB::FieldReaderIterator::operator[] )
, ( bp::arg("pos") )
, bp::return_internal_reference< >() );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( char const *,::std::string & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("keyword"), bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( char const *,unsigned int & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("keyword"), bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( char const *,int & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("keyword"), bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( char const *,float & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("keyword"), bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( char const *,::osg::Vec2f & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("keyword"), bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( char const *,::osg::Vec3f & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("keyword"), bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( char const *,::osg::Vec4f & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("keyword"), bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( char const *,::osg::Vec2d & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("keyword"), bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( char const *,::osg::Vec3d & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("keyword"), bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( char const *,::osg::Vec4d & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("keyword"), bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( ::std::string & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( unsigned int & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( int & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( float & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( ::osg::Vec2f & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( ::osg::Vec3f & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( ::osg::Vec4f & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( ::osg::Vec2d & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( ::osg::Vec3d & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("value") ) );
}
{ //::osgDB::FieldReaderIterator::readSequence
typedef bool ( ::osgDB::FieldReaderIterator::*readSequence_function_type)( ::osg::Vec4d & ) ;
FieldReaderIterator_exposer.def(
"readSequence"
, readSequence_function_type( &::osgDB::FieldReaderIterator::readSequence )
, ( bp::arg("value") ) );
}
}
}
void register_Plane_class(){
{ //::osg::Plane
typedef bp::class_< osg::Plane > Plane_exposer_t;
Plane_exposer_t Plane_exposer = Plane_exposer_t( "Plane", "\n A plane class. It can be used to represent an infinite plane.\n\n The infinite plane is described by an implicit plane equation a*x+b*y+c*z+d = 0. Though it is not mandatory that\n a^2+b^2+c^2 = 1 is fulfilled in general some methods require it (aee osg::Plane::distance).\n", bp::init< >("\n Default constructor\n The default constructor initializes all values to zero.\n Warning: Although the method osg::Plane::valid() will return true after the default constructors call the plane\n is mathematically invalid! Default data do not describe a valid plane.\n") );
bp::scope Plane_scope( Plane_exposer );
bp::scope().attr("num_components") = (int)osg::Plane::num_components;
Plane_exposer.def( bp::init< osg::Plane const & >(( bp::arg("pl") )) );
Plane_exposer.def( bp::init< double, double, double, double >(( bp::arg("a"), bp::arg("b"), bp::arg("c"), bp::arg("d") ), "\n Constructor\n The plane is described as a*x+b*y+c*z+d = 0.\n @remark You may call osg::Plane::MakeUnitLength afterwards if the passed values are not normalized.\n") );
Plane_exposer.def( bp::init< osg::Vec4f const & >(( bp::arg("vec") ), "\n Constructor\n The plane can also be described as vec*[x,y,z,1].\n @remark You may call osg::Plane::MakeUnitLength afterwards if the passed values are not normalized.\n") );
bp::implicitly_convertible< osg::Vec4f const &, osg::Plane >();
Plane_exposer.def( bp::init< osg::Vec4d const & >(( bp::arg("vec") ), "\n Constructor\n The plane can also be described as vec*[x,y,z,1].\n @remark You may call osg::Plane::MakeUnitLength afterwards if the passed values are not normalized.\n") );
bp::implicitly_convertible< osg::Vec4d const &, osg::Plane >();
Plane_exposer.def( bp::init< osg::Vec3d const &, double >(( bp::arg("norm"), bp::arg("d") ), "\n Constructor\n This constructor initializes the internal values directly without any checking or manipulation.\n @param norm: The normal of the plane.\n @param d: The negative distance from the point of origin to the plane.\n @remark You may call osg::Plane::MakeUnitLength afterwards if the passed normal was not normalized.\n") );
Plane_exposer.def( bp::init< osg::Vec3d const &, osg::Vec3d const &, osg::Vec3d const & >(( bp::arg("v1"), bp::arg("v2"), bp::arg("v3") ), "\n Constructor\n This constructor calculates from the three points describing an infinite plane the internal values.\n @param v1: Point in the plane.\n @param v2: Point in the plane.\n @param v3: Point in the plane.\n @remark After this constructor call the planes normal is normalized in case the three points described a mathematically\n valid plane.\n @remark The normal is determined by building the cross product of (v2-v1) ^ (v3-v2).\n") );
Plane_exposer.def( bp::init< osg::Vec3d const &, osg::Vec3d const & >(( bp::arg("norm"), bp::arg("point") ), "\n Constructor\n This constructor initializes the internal values directly without any checking or manipulation.\n @param norm: The normal of the plane.\n @param point: A point of the plane.\n @remark You may call osg::Plane::MakeUnitLength afterwards if the passed normal was not normalized.\n") );
{ //::osg::Plane::asVec4
typedef ::osg::Vec4d ( ::osg::Plane::*asVec4_function_type)( ) const;
Plane_exposer.def(
"asVec4"
, asVec4_function_type( &::osg::Plane::asVec4 ) );
}
{ //::osg::Plane::calculateUpperLowerBBCorners
typedef void ( ::osg::Plane::*calculateUpperLowerBBCorners_function_type)( ) ;
Plane_exposer.def(
"calculateUpperLowerBBCorners"
, calculateUpperLowerBBCorners_function_type( &::osg::Plane::calculateUpperLowerBBCorners )
, "\n calculate the upper and lower bounding box corners to be used\n in the intersect(BoundingBox&) method for speeding calculations.\n" );
}
{ //::osg::Plane::distance
typedef float ( ::osg::Plane::*distance_function_type)( ::osg::Vec3f const & ) const;
Plane_exposer.def(
"distance"
, distance_function_type( &::osg::Plane::distance )
, ( bp::arg("v") )
, "\n Calculate the distance between a point and the plane.\n @remark This method only leads to real distance values if the planes norm is 1.\n aa osg::Plane::makeUnitLength\n" );
}
{ //::osg::Plane::distance
typedef double ( ::osg::Plane::*distance_function_type)( ::osg::Vec3d const & ) const;
Plane_exposer.def(
"distance"
, distance_function_type( &::osg::Plane::distance )
, ( bp::arg("v") )
, "\n Calculate the distance between a point and the plane.\n @remark This method only leads to real distance values if the planes norm is 1.\n aa osg::Plane::makeUnitLength\n" );
}
{ //::osg::Plane::dotProductNormal
typedef float ( ::osg::Plane::*dotProductNormal_function_type)( ::osg::Vec3f const & ) const;
Plane_exposer.def(
"dotProductNormal"
, dotProductNormal_function_type( &::osg::Plane::dotProductNormal )
, ( bp::arg("v") )
, "\n calculate the dot product of the plane normal and a point.\n" );
}
{ //::osg::Plane::dotProductNormal
typedef double ( ::osg::Plane::*dotProductNormal_function_type)( ::osg::Vec3d const & ) const;
Plane_exposer.def(
"dotProductNormal"
, dotProductNormal_function_type( &::osg::Plane::dotProductNormal )
, ( bp::arg("v") )
, "\n calculate the dot product of the plane normal and a point.\n" );
}
{ //::osg::Plane::flip
typedef void ( ::osg::Plane::*flip_function_type)( ) ;
Plane_exposer.def(
"flip"
, flip_function_type( &::osg::Plane::flip )
, "\n flip/reverse the orientation of the plane.\n" );
}
{ //::osg::Plane::getNormal
typedef ::osg::Vec3d ( ::osg::Plane::*getNormal_function_type)( ) const;
Plane_exposer.def(
"getNormal"
, getNormal_function_type( &::osg::Plane::getNormal ) );
}
{ //::osg::Plane::intersect
typedef int ( ::osg::Plane::*intersect_function_type)( ::std::vector< osg::Vec3f > const & ) const;
Plane_exposer.def(
"intersect"
, intersect_function_type( &::osg::Plane::intersect )
, ( bp::arg("vertices") )
, "\n intersection test between plane and vertex list\n return 1 if the bs is completely above plane,\n return 0 if the bs intersects the plane,\n return -1 if the bs is completely below the plane.\n" );
}
{ //::osg::Plane::intersect
typedef int ( ::osg::Plane::*intersect_function_type)( ::std::vector< osg::Vec3d > const & ) const;
Plane_exposer.def(
"intersect"
, intersect_function_type( &::osg::Plane::intersect )
, ( bp::arg("vertices") )
, "\n intersection test between plane and vertex list\n return 1 if the bs is completely above plane,\n return 0 if the bs intersects the plane,\n return -1 if the bs is completely below the plane.\n" );
}
{ //::osg::Plane::intersect
typedef int ( ::osg::Plane::*intersect_function_type)( ::osg::BoundingSphere const & ) const;
Plane_exposer.def(
"intersect"
, intersect_function_type( &::osg::Plane::intersect )
, ( bp::arg("bs") )
, "\n intersection test between plane and bounding sphere.\n return 1 if the bs is completely above plane,\n return 0 if the bs intersects the plane,\n return -1 if the bs is completely below the plane.\n" );
}
{ //::osg::Plane::intersect
typedef int ( ::osg::Plane::*intersect_function_type)( ::osg::BoundingBox const & ) const;
Plane_exposer.def(
"intersect"
, intersect_function_type( &::osg::Plane::intersect )
, ( bp::arg("bb") )
, "\n intersection test between plane and bounding sphere.\n return 1 if the bs is completely above plane,\n return 0 if the bs intersects the plane,\n return -1 if the bs is completely below the plane.\n" );
}
{ //::osg::Plane::isNaN
typedef bool ( ::osg::Plane::*isNaN_function_type)( ) const;
Plane_exposer.def(
"isNaN"
, isNaN_function_type( &::osg::Plane::isNaN ) );
}
{ //::osg::Plane::makeUnitLength
typedef void ( ::osg::Plane::*makeUnitLength_function_type)( ) ;
Plane_exposer.def(
"makeUnitLength"
, makeUnitLength_function_type( &::osg::Plane::makeUnitLength )
, "\n This method multiplies the coefficients of the plane equation with a constant factor so that the\n equation a^2+b^2+c^2 = 1 holds.\n" );
}
Plane_exposer.def( bp::self != bp::self );
Plane_exposer.def( bp::self < bp::self );
{ //::osg::Plane::operator=
typedef ::osg::Plane & ( ::osg::Plane::*assign_function_type)( ::osg::Plane const & ) ;
Plane_exposer.def(
"assign"
, assign_function_type( &::osg::Plane::operator= )
, ( bp::arg("pl") )
, bp::return_self< >() );
}
Plane_exposer.def( bp::self == bp::self );
{ //::osg::Plane::operator[]
typedef double & ( ::osg::Plane::*__getitem___function_type)( unsigned int ) ;
Plane_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::Plane::operator[] )
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::osg::Plane::operator[]
typedef double ( ::osg::Plane::*__getitem___function_type)( unsigned int ) const;
Plane_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::Plane::operator[] )
, ( bp::arg("i") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Plane const & ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("pl") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( double,double,double,double ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("a"), bp::arg("b"), bp::arg("c"), bp::arg("d") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Vec4f const & ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("vec") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Vec4d const & ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("vec") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Vec3d const &,double ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("norm"), bp::arg("d") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Vec3d const &,::osg::Vec3d const &,::osg::Vec3d const & ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("v1"), bp::arg("v2"), bp::arg("v3") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Vec3d const &,::osg::Vec3d const & ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("norm"), bp::arg("point") ) );
}
{ //::osg::Plane::transform
typedef void ( ::osg::Plane::*transform_function_type)( ::osg::Matrix const & ) ;
Plane_exposer.def(
"transform"
, transform_function_type( &::osg::Plane::transform )
, ( bp::arg("matrix") )
, "\n Transform the plane by matrix. Note, this operation carries out\n the calculation of the inverse of the matrix since a plane\n must be multiplied by the inverse transposed to transform it. This\n make this operation expensive. If the inverse has been already\n calculated elsewhere then use transformProvidingInverse() instead.\n See http://www.worldserver.com/turk/computergraphics/NormalTransformations.pdf\n" );
}
{ //::osg::Plane::transformProvidingInverse
typedef void ( ::osg::Plane::*transformProvidingInverse_function_type)( ::osg::Matrix const & ) ;
Plane_exposer.def(
"transformProvidingInverse"
, transformProvidingInverse_function_type( &::osg::Plane::transformProvidingInverse )
, ( bp::arg("matrix") )
, "\n Transform the plane by providing a pre inverted matrix.\n see transform for details.\n" );
}
{ //::osg::Plane::valid
typedef bool ( ::osg::Plane::*valid_function_type)( ) const;
Plane_exposer.def(
"valid"
, valid_function_type( &::osg::Plane::valid )
, "\n Checks if all internal values describing the plane have valid numbers\n Warning: This method does not check if the plane is mathematically correctly described!\n @remark The only case where all elements have valid numbers and the plane description is invalid occurs if the planes normal\n is zero.\n" );
}
Plane_exposer.def( bp::self_ns::str( bp::self ) );
}
}
