void register_ClampedLinearCostFunction1D_class(){ { //::osg::ClampedLinearCostFunction1D typedef bp::class_< osg::ClampedLinearCostFunction1D > ClampedLinearCostFunction1D_exposer_t; ClampedLinearCostFunction1D_exposer_t ClampedLinearCostFunction1D_exposer = ClampedLinearCostFunction1D_exposer_t( "ClampedLinearCostFunction1D", bp::init< bp::optional< double, double, unsigned int > >(( bp::arg("cost0")=0.0, bp::arg("dcost_di")=0.0, bp::arg("min_input")=(unsigned int)(0) )) ); bp::scope ClampedLinearCostFunction1D_scope( ClampedLinearCostFunction1D_exposer ); bp::implicitly_convertible< double, osg::ClampedLinearCostFunction1D >(); { //::osg::ClampedLinearCostFunction1D::operator() typedef double ( ::osg::ClampedLinearCostFunction1D::*__call___function_type)( unsigned int ) const; ClampedLinearCostFunction1D_exposer.def( "__call__" , __call___function_type( &::osg::ClampedLinearCostFunction1D::operator() ) , ( bp::arg("input") ) ); } { //::osg::ClampedLinearCostFunction1D::set typedef void ( ::osg::ClampedLinearCostFunction1D::*set_function_type)( double,double,unsigned int ) ; ClampedLinearCostFunction1D_exposer.def( "set" , set_function_type( &::osg::ClampedLinearCostFunction1D::set ) , ( bp::arg("cost0"), bp::arg("dcost_di"), bp::arg("min_input") ) ); } ClampedLinearCostFunction1D_exposer.def_readwrite( "_cost0", &osg::ClampedLinearCostFunction1D::_cost0 ); ClampedLinearCostFunction1D_exposer.def_readwrite( "_dcost_di", &osg::ClampedLinearCostFunction1D::_dcost_di ); ClampedLinearCostFunction1D_exposer.def_readwrite( "_min_input", &osg::ClampedLinearCostFunction1D::_min_input ); } }
void register_Vec3us_class(){ { //::osg::Vec3us typedef bp::class_< osg::Vec3us > Vec3us_exposer_t; Vec3us_exposer_t Vec3us_exposer = Vec3us_exposer_t( "Vec3us", bp::init< >("\n Constructor that sets all components of the vector to zero\n") ); bp::scope Vec3us_scope( Vec3us_exposer ); bp::scope().attr("num_components") = (int)osg::Vec3us::num_components; Vec3us_exposer.def( bp::init< short unsigned int, short unsigned int, short unsigned int >(( bp::arg("r"), bp::arg("g"), bp::arg("b") )) ); Vec3us_exposer.def( bp::self != bp::self ); Vec3us_exposer.def( bp::self * bp::other< short unsigned int >() ); Vec3us_exposer.def( bp::self * bp::self ); Vec3us_exposer.def( bp::self *= bp::other< short unsigned int >() ); Vec3us_exposer.def( bp::self + bp::self ); Vec3us_exposer.def( bp::self += bp::self ); Vec3us_exposer.def( bp::self - bp::self ); Vec3us_exposer.def( bp::self -= bp::self ); Vec3us_exposer.def( bp::self / bp::other< short unsigned int >() ); Vec3us_exposer.def( bp::self /= bp::other< short unsigned int >() ); Vec3us_exposer.def( bp::self < bp::self ); Vec3us_exposer.def( bp::self == bp::self ); { //::osg::Vec3us::operator[] typedef short unsigned int & ( ::osg::Vec3us::*__getitem___function_type )( unsigned int ) ; Vec3us_exposer.def( "__getitem__" , __getitem___function_type( &::osg::Vec3us::operator[] ) , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_non_const_reference >() ); } { //::osg::Vec3us::operator[] typedef short unsigned int ( ::osg::Vec3us::*__getitem___function_type )( unsigned int ) const; Vec3us_exposer.def( "__getitem__" , __getitem___function_type( &::osg::Vec3us::operator[] ) , ( bp::arg("i") ) ); } { //::osg::Vec3us::set typedef void ( ::osg::Vec3us::*set_function_type )( short unsigned int,short unsigned int,short unsigned int ) ; Vec3us_exposer.def( "set" , set_function_type( &::osg::Vec3us::set ) , ( bp::arg("r"), bp::arg("g"), bp::arg("b") ) ); } { //::osg::Vec3us::set typedef void ( ::osg::Vec3us::*set_function_type )( ::osg::Vec3us const & ) ; Vec3us_exposer.def( "set" , set_function_type( &::osg::Vec3us::set ) , ( bp::arg("rhs") ) ); } { //property "x"[fget=::osg::Vec3us::x] typedef short unsigned int & ( ::osg::Vec3us::*fget )( ) ; Vec3us_exposer.add_property( "x" , bp::make_function( fget( &::osg::Vec3us::x ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "x"[fget=::osg::Vec3us::x] typedef short unsigned int ( ::osg::Vec3us::*fget )( ) const; Vec3us_exposer.add_property( "x" , fget( &::osg::Vec3us::x ) ); } { //property "y"[fget=::osg::Vec3us::y] typedef short unsigned int & ( ::osg::Vec3us::*fget )( ) ; Vec3us_exposer.add_property( "y" , bp::make_function( fget( &::osg::Vec3us::y ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "y"[fget=::osg::Vec3us::y] typedef short unsigned int ( ::osg::Vec3us::*fget )( ) const; Vec3us_exposer.add_property( "y" , fget( &::osg::Vec3us::y ) ); } { //property "z"[fget=::osg::Vec3us::z] typedef short unsigned int & ( ::osg::Vec3us::*fget )( ) ; Vec3us_exposer.add_property( "z" , bp::make_function( fget( &::osg::Vec3us::z ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "z"[fget=::osg::Vec3us::z] typedef short unsigned int ( ::osg::Vec3us::*fget )( ) const; Vec3us_exposer.add_property( "z" , fget( &::osg::Vec3us::z ) ); } { //property "r"[fget=::osg::Vec3us::r] typedef short unsigned int & ( ::osg::Vec3us::*fget )( ) ; Vec3us_exposer.add_property( "r" , bp::make_function( fget( &::osg::Vec3us::r ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "r"[fget=::osg::Vec3us::r] typedef short unsigned int ( ::osg::Vec3us::*fget )( ) const; Vec3us_exposer.add_property( "r" , fget( &::osg::Vec3us::r ) ); } { //property "g"[fget=::osg::Vec3us::g] typedef short unsigned int & ( ::osg::Vec3us::*fget )( ) ; Vec3us_exposer.add_property( "g" , bp::make_function( fget( &::osg::Vec3us::g ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "g"[fget=::osg::Vec3us::g] typedef short unsigned int ( ::osg::Vec3us::*fget )( ) const; Vec3us_exposer.add_property( "g" , fget( &::osg::Vec3us::g ) ); } { //property "b"[fget=::osg::Vec3us::b] typedef short unsigned int & ( ::osg::Vec3us::*fget )( ) ; Vec3us_exposer.add_property( "b" , bp::make_function( fget( &::osg::Vec3us::b ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "b"[fget=::osg::Vec3us::b] typedef short unsigned int ( ::osg::Vec3us::*fget )( ) const; Vec3us_exposer.add_property( "b" , fget( &::osg::Vec3us::b ) ); } Vec3us_exposer.def(bp::indexing::container_suite< osg::Vec3us, bp::indexing::all_methods, OsgVec_algorithms<osg::Vec3us, osg::Vec3us::value_type, osg::Vec3us::num_components> >()); } }
void register_Vec2d_class(){ { //::osg::Vec2d typedef bp::class_< osg::Vec2d > Vec2d_exposer_t; Vec2d_exposer_t Vec2d_exposer = Vec2d_exposer_t( "Vec2d", "\n General purpose double pair, uses include representation of\n texture coordinates.\n No support yet added for double * Vec2d - is it necessary?\n Need to define a non-member non-friend operator* etc.\n BTW: Vec2d * double is okay\n", bp::init< >("\n Constructor that sets all components of the vector to zero\n") ); bp::scope Vec2d_scope( Vec2d_exposer ); bp::scope().attr("num_components") = (int)osg::Vec2d::num_components; Vec2d_exposer.def( bp::init< double, double >(( bp::arg("x"), bp::arg("y") )) ); Vec2d_exposer.def( bp::init< osg::Vec2f const & >(( bp::arg("vec") )) ); bp::implicitly_convertible< osg::Vec2f const &, osg::Vec2d >(); { //::osg::Vec2d::isNaN typedef bool ( ::osg::Vec2d::*isNaN_function_type )( ) const; Vec2d_exposer.def( "isNaN" , isNaN_function_type( &::osg::Vec2d::isNaN ) , "\n Returns true if at least one component has value NaN.\n" ); } { //::osg::Vec2d::length typedef double ( ::osg::Vec2d::*length_function_type )( ) const; Vec2d_exposer.def( "length" , length_function_type( &::osg::Vec2d::length ) , "\n Length of the vector = sqrt( vec . vec )\n" ); } { //::osg::Vec2d::length2 typedef double ( ::osg::Vec2d::*length2_function_type )( ) const; Vec2d_exposer.def( "length2" , length2_function_type( &::osg::Vec2d::length2 ) , "\n Length squared of the vector = vec . vec\n" ); } { //::osg::Vec2d::normalize typedef double ( ::osg::Vec2d::*normalize_function_type )( ) ; Vec2d_exposer.def( "normalize" , normalize_function_type( &::osg::Vec2d::normalize ) , "\n Normalize the vector so that it has length unity.\n Returns the previous length of the vector.\n" ); } Vec2d_exposer.def( "as__scope_osg_scope_Vec2f", &osg::Vec2d::operator ::osg::Vec2f ); Vec2d_exposer.def( bp::self != bp::self ); Vec2d_exposer.def( bp::self * bp::self ); Vec2d_exposer.def( bp::self * bp::other< double >() ); Vec2d_exposer.def( bp::self *= bp::other< double >() ); Vec2d_exposer.def( bp::self + bp::self ); Vec2d_exposer.def( bp::self += bp::self ); Vec2d_exposer.def( bp::self - bp::self ); Vec2d_exposer.def( -bp::self ); Vec2d_exposer.def( bp::self -= bp::self ); Vec2d_exposer.def( bp::self / bp::other< double >() ); Vec2d_exposer.def( bp::self /= bp::other< double >() ); Vec2d_exposer.def( bp::self < bp::self ); Vec2d_exposer.def( bp::self == bp::self ); { //::osg::Vec2d::operator[] typedef double & ( ::osg::Vec2d::*__getitem___function_type )( int ) ; Vec2d_exposer.def( "__getitem__" , __getitem___function_type( &::osg::Vec2d::operator[] ) , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_non_const_reference >() ); } { //::osg::Vec2d::operator[] typedef double ( ::osg::Vec2d::*__getitem___function_type )( int ) const; Vec2d_exposer.def( "__getitem__" , __getitem___function_type( &::osg::Vec2d::operator[] ) , ( bp::arg("i") ) ); } { //::osg::Vec2d::set typedef void ( ::osg::Vec2d::*set_function_type )( double,double ) ; Vec2d_exposer.def( "set" , set_function_type( &::osg::Vec2d::set ) , ( bp::arg("x"), bp::arg("y") ) ); } { //::osg::Vec2d::valid typedef bool ( ::osg::Vec2d::*valid_function_type )( ) const; Vec2d_exposer.def( "valid" , valid_function_type( &::osg::Vec2d::valid ) , "\n Returns true if all components have values that are not NaN.\n" ); } { //property "x"[fget=::osg::Vec2d::x] typedef double & ( ::osg::Vec2d::*fget )( ) ; Vec2d_exposer.add_property( "x" , bp::make_function( fget( &::osg::Vec2d::x ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "x"[fget=::osg::Vec2d::x] typedef double ( ::osg::Vec2d::*fget )( ) const; Vec2d_exposer.add_property( "x" , fget( &::osg::Vec2d::x ) ); } { //property "y"[fget=::osg::Vec2d::y] typedef double & ( ::osg::Vec2d::*fget )( ) ; Vec2d_exposer.add_property( "y" , bp::make_function( fget( &::osg::Vec2d::y ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "y"[fget=::osg::Vec2d::y] typedef double ( ::osg::Vec2d::*fget )( ) const; Vec2d_exposer.add_property( "y" , fget( &::osg::Vec2d::y ) ); } Vec2d_exposer.def( bp::self_ns::str( bp::self ) ); Vec2d_exposer.def( bp::self_ns::str(bp::self) ); Vec2d_exposer.def(bp::indexing::container_suite< osg::Vec2d, bp::indexing::all_methods, OsgVec_algorithms<osg::Vec2d, osg::Vec2d::value_type, osg::Vec2d::num_components> >()); } }
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_Vec4ui_class(){ { //::osg::Vec4ui typedef bp::class_< osg::Vec4ui > Vec4ui_exposer_t; Vec4ui_exposer_t Vec4ui_exposer = Vec4ui_exposer_t( "Vec4ui", "\n General purpose integer quad\n", bp::init< >() ); bp::scope Vec4ui_scope( Vec4ui_exposer ); bp::scope().attr("num_components") = (int)osg::Vec4ui::num_components; Vec4ui_exposer.def( bp::init< unsigned int, unsigned int, unsigned int, unsigned int >(( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("w") )) ); Vec4ui_exposer.def( bp::self != bp::self ); Vec4ui_exposer.def( bp::self * bp::other< unsigned int >() ); Vec4ui_exposer.def( bp::self * bp::self ); Vec4ui_exposer.def( bp::self + bp::other< unsigned int >() ); Vec4ui_exposer.def( bp::self + bp::self ); Vec4ui_exposer.def( bp::self - bp::other< unsigned int >() ); Vec4ui_exposer.def( bp::self - bp::self ); Vec4ui_exposer.def( bp::self / bp::other< unsigned int >() ); Vec4ui_exposer.def( bp::self < bp::self ); Vec4ui_exposer.def( bp::self == bp::self ); { //::osg::Vec4ui::operator[] typedef unsigned int & ( ::osg::Vec4ui::*__getitem___function_type )( unsigned int ) ; Vec4ui_exposer.def( "__getitem__" , __getitem___function_type( &::osg::Vec4ui::operator[] ) , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_non_const_reference >() ); } { //::osg::Vec4ui::operator[] typedef unsigned int ( ::osg::Vec4ui::*__getitem___function_type )( unsigned int ) const; Vec4ui_exposer.def( "__getitem__" , __getitem___function_type( &::osg::Vec4ui::operator[] ) , ( bp::arg("i") ) ); } { //::osg::Vec4ui::set typedef void ( ::osg::Vec4ui::*set_function_type )( unsigned int,unsigned int,unsigned int,unsigned int ) ; Vec4ui_exposer.def( "set" , set_function_type( &::osg::Vec4ui::set ) , ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("w") ) ); } { //property "x"[fget=::osg::Vec4ui::x] typedef unsigned int & ( ::osg::Vec4ui::*fget )( ) ; Vec4ui_exposer.add_property( "x" , bp::make_function( fget( &::osg::Vec4ui::x ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "x"[fget=::osg::Vec4ui::x] typedef unsigned int ( ::osg::Vec4ui::*fget )( ) const; Vec4ui_exposer.add_property( "x" , fget( &::osg::Vec4ui::x ) ); } { //property "y"[fget=::osg::Vec4ui::y] typedef unsigned int & ( ::osg::Vec4ui::*fget )( ) ; Vec4ui_exposer.add_property( "y" , bp::make_function( fget( &::osg::Vec4ui::y ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "y"[fget=::osg::Vec4ui::y] typedef unsigned int ( ::osg::Vec4ui::*fget )( ) const; Vec4ui_exposer.add_property( "y" , fget( &::osg::Vec4ui::y ) ); } { //property "z"[fget=::osg::Vec4ui::z] typedef unsigned int & ( ::osg::Vec4ui::*fget )( ) ; Vec4ui_exposer.add_property( "z" , bp::make_function( fget( &::osg::Vec4ui::z ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "z"[fget=::osg::Vec4ui::z] typedef unsigned int ( ::osg::Vec4ui::*fget )( ) const; Vec4ui_exposer.add_property( "z" , fget( &::osg::Vec4ui::z ) ); } { //property "w"[fget=::osg::Vec4ui::w] typedef unsigned int & ( ::osg::Vec4ui::*fget )( ) ; Vec4ui_exposer.add_property( "w" , bp::make_function( fget( &::osg::Vec4ui::w ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "w"[fget=::osg::Vec4ui::w] typedef unsigned int ( ::osg::Vec4ui::*fget )( ) const; Vec4ui_exposer.add_property( "w" , fget( &::osg::Vec4ui::w ) ); } { //property "r"[fget=::osg::Vec4ui::r] typedef unsigned int & ( ::osg::Vec4ui::*fget )( ) ; Vec4ui_exposer.add_property( "r" , bp::make_function( fget( &::osg::Vec4ui::r ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "r"[fget=::osg::Vec4ui::r] typedef unsigned int ( ::osg::Vec4ui::*fget )( ) const; Vec4ui_exposer.add_property( "r" , fget( &::osg::Vec4ui::r ) ); } { //property "g"[fget=::osg::Vec4ui::g] typedef unsigned int & ( ::osg::Vec4ui::*fget )( ) ; Vec4ui_exposer.add_property( "g" , bp::make_function( fget( &::osg::Vec4ui::g ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "g"[fget=::osg::Vec4ui::g] typedef unsigned int ( ::osg::Vec4ui::*fget )( ) const; Vec4ui_exposer.add_property( "g" , fget( &::osg::Vec4ui::g ) ); } { //property "b"[fget=::osg::Vec4ui::b] typedef unsigned int & ( ::osg::Vec4ui::*fget )( ) ; Vec4ui_exposer.add_property( "b" , bp::make_function( fget( &::osg::Vec4ui::b ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "b"[fget=::osg::Vec4ui::b] typedef unsigned int ( ::osg::Vec4ui::*fget )( ) const; Vec4ui_exposer.add_property( "b" , fget( &::osg::Vec4ui::b ) ); } { //property "a"[fget=::osg::Vec4ui::a] typedef unsigned int & ( ::osg::Vec4ui::*fget )( ) ; Vec4ui_exposer.add_property( "a" , bp::make_function( fget( &::osg::Vec4ui::a ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "a"[fget=::osg::Vec4ui::a] typedef unsigned int ( ::osg::Vec4ui::*fget )( ) const; Vec4ui_exposer.add_property( "a" , fget( &::osg::Vec4ui::a ) ); } Vec4ui_exposer.def(bp::indexing::container_suite< osg::Vec4ui, bp::indexing::all_methods, OsgVec_algorithms<osg::Vec4ui, osg::Vec4ui::value_type, osg::Vec4ui::num_components> >()); } }
void register_XMLAttributes_class(){ { //::osiris::XMLAttributes typedef ::boost::python::class_< ::osiris::XMLAttributes > XMLAttributes_exposer_t; XMLAttributes_exposer_t XMLAttributes_exposer = XMLAttributes_exposer_t( "XMLAttributes", ::boost::python::init< ::osiris::XMLNode & >(( ::boost::python::arg("node") )) ); ::boost::python::scope XMLAttributes_scope( XMLAttributes_exposer ); ::boost::python::implicitly_convertible< ::osiris::XMLNode &, ::osiris::XMLAttributes >(); { //::osiris::XMLAttributes::getNode typedef boost::python::object ( *getNode_function_type )( ::osiris::XMLAttributes & ); XMLAttributes_exposer.def( "getNode" , getNode_function_type( &getNode_4e57c0c8f9b0f179513dbc4a9f5d4c90 ) ); } { //::osiris::XMLAttributes::getNode typedef boost::python::object ( *getNode_function_type )( ::osiris::XMLAttributes const & ); XMLAttributes_exposer.def( "getNode" , getNode_function_type( &getNode_c7ca0ab9de3bad23f457972b89ccd4bc ) ); } { //::osiris::XMLAttributes::empty typedef boost::python::object ( *empty_function_type )( ::osiris::XMLAttributes const & ); XMLAttributes_exposer.def( "empty" , empty_function_type( &empty_b69603b713f1a8a59c2ffc4b6c71ff93 ) ); } { //::osiris::XMLAttributes::size typedef boost::python::object ( *size_function_type )( ::osiris::XMLAttributes const & ); XMLAttributes_exposer.def( "size" , size_function_type( &size_97d3881c48560de9a0f1e73dafa6a53e ) ); } { //::osiris::XMLAttributes::set typedef void ( *set_function_type )( ::osiris::XMLAttributes &,::osiris::String const &,::osiris::String const & ); XMLAttributes_exposer.def( "set" , set_function_type( &set_1e63dd0dc5475b37dd70f5a51470babd ) , ( ::boost::python::arg("inst"), ::boost::python::arg("name"), ::boost::python::arg("value") ) ); } { //::osiris::XMLAttributes::clear typedef void ( *clear_function_type )( ::osiris::XMLAttributes & ); XMLAttributes_exposer.def( "clear" , clear_function_type( &clear_bbd254cd8250d6049df9feeec423473d ) ); } { //::osiris::XMLAttributes::exists typedef boost::python::object ( *exists_function_type )( ::osiris::XMLAttributes const &,::osiris::String const & ); XMLAttributes_exposer.def( "exists" , exists_function_type( &exists_9b7ddaa903c86a33882aca33647d86d9 ) , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) ); } { //::osiris::XMLAttributes::find typedef boost::python::object ( *find_function_type )( ::osiris::XMLAttributes const &,::osiris::String const & ); XMLAttributes_exposer.def( "find" , find_function_type( &find_981dbb4e0c25761bece5c543ec955f9e ) , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) ); } { //::osiris::XMLAttributes::find typedef boost::python::object ( *find_function_type )( ::osiris::XMLAttributes const &,::size_t ); XMLAttributes_exposer.def( "find" , find_function_type( &find_f566384adab53722dbbf56f49e0e8597 ) , ( ::boost::python::arg("inst"), ::boost::python::arg("index") ) ); } { //::osiris::XMLAttributes::get typedef boost::python::object ( *get_function_type )( ::osiris::XMLAttributes const &,::osiris::String const & ); XMLAttributes_exposer.def( "get" , get_function_type( &get_8341dbbadae2779456a992562f1485db ) , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) ); } { //::osiris::XMLAttributes::remove typedef void ( *remove_function_type )( ::osiris::XMLAttributes &,::osiris::String const & ); XMLAttributes_exposer.def( "remove" , remove_function_type( &remove_13651ce1619d4c347a785c48f2131d08 ) , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) ); } ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::XMLAttributes > >(); ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::XMLAttributes >, boost::shared_ptr< ::osiris::Object > >(); } }
void register_Vec3f_class(){ { //::osg::Vec3f typedef bp::class_< osg::Vec3f > Vec3f_exposer_t; Vec3f_exposer_t Vec3f_exposer = Vec3f_exposer_t( "Vec3f", "\n General purpose float triple for use as vertices, vectors and normals.\n Provides general math operations from addition through to cross products.\n No support yet added for float * Vec3f - is it necessary?\n Need to define a non-member non-friend operator* etc.\n Vec3f * float is okay\n", bp::init< >("\n Constructor that sets all components of the vector to zero\n") ); bp::scope Vec3f_scope( Vec3f_exposer ); bp::scope().attr("num_components") = (int)osg::Vec3f::num_components; Vec3f_exposer.def( bp::init< float, float, float >(( bp::arg("x"), bp::arg("y"), bp::arg("z") )) ); Vec3f_exposer.def( bp::init< osg::Vec2f const &, float >(( bp::arg("v2"), bp::arg("zz") )) ); { //::osg::Vec3f::isNaN typedef bool ( ::osg::Vec3f::*isNaN_function_type)( ) const; Vec3f_exposer.def( "isNaN" , isNaN_function_type( &::osg::Vec3f::isNaN ) , "\n Returns true if at least one component has value NaN.\n" ); } { //::osg::Vec3f::length typedef float ( ::osg::Vec3f::*length_function_type)( ) const; Vec3f_exposer.def( "length" , length_function_type( &::osg::Vec3f::length ) , "\n Length of the vector = sqrt( vec . vec )\n" ); } { //::osg::Vec3f::length2 typedef float ( ::osg::Vec3f::*length2_function_type)( ) const; Vec3f_exposer.def( "length2" , length2_function_type( &::osg::Vec3f::length2 ) , "\n Length squared of the vector = vec . vec\n" ); } { //::osg::Vec3f::normalize typedef float ( ::osg::Vec3f::*normalize_function_type)( ) ; Vec3f_exposer.def( "normalize" , normalize_function_type( &::osg::Vec3f::normalize ) , "\n Normalize the vector so that it has length unity.\n Returns the previous length of the vector.\n" ); } Vec3f_exposer.def( bp::self != bp::self ); Vec3f_exposer.def( bp::self * bp::self ); Vec3f_exposer.def( bp::self * bp::other< float >() ); Vec3f_exposer.def( bp::self *= bp::other< float >() ); Vec3f_exposer.def( bp::self + bp::self ); Vec3f_exposer.def( bp::self += bp::self ); Vec3f_exposer.def( bp::self - bp::self ); Vec3f_exposer.def( -bp::self ); Vec3f_exposer.def( bp::self -= bp::self ); Vec3f_exposer.def( bp::self / bp::other< float >() ); Vec3f_exposer.def( bp::self /= bp::other< float >() ); Vec3f_exposer.def( bp::self < bp::self ); Vec3f_exposer.def( bp::self == bp::self ); { //::osg::Vec3f::operator[] typedef float & ( ::osg::Vec3f::*__getitem___function_type)( int ) ; Vec3f_exposer.def( "__getitem__" , __getitem___function_type( &::osg::Vec3f::operator[] ) , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_non_const_reference >() ); } { //::osg::Vec3f::operator[] typedef float ( ::osg::Vec3f::*__getitem___function_type)( int ) const; Vec3f_exposer.def( "__getitem__" , __getitem___function_type( &::osg::Vec3f::operator[] ) , ( bp::arg("i") ) ); } Vec3f_exposer.def( bp::self ^ bp::self ); { //::osg::Vec3f::set typedef void ( ::osg::Vec3f::*set_function_type)( float,float,float ) ; Vec3f_exposer.def( "set" , set_function_type( &::osg::Vec3f::set ) , ( bp::arg("x"), bp::arg("y"), bp::arg("z") ) ); } { //::osg::Vec3f::set typedef void ( ::osg::Vec3f::*set_function_type)( ::osg::Vec3f const & ) ; Vec3f_exposer.def( "set" , set_function_type( &::osg::Vec3f::set ) , ( bp::arg("rhs") ) ); } { //::osg::Vec3f::valid typedef bool ( ::osg::Vec3f::*valid_function_type)( ) const; Vec3f_exposer.def( "valid" , valid_function_type( &::osg::Vec3f::valid ) , "\n Returns true if all components have values that are not NaN.\n" ); } { //property "x"[fget=::osg::Vec3f::x] typedef float & ( ::osg::Vec3f::*fget)( ) ; Vec3f_exposer.add_property( "x" , bp::make_function( fget( &::osg::Vec3f::x ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "x"[fget=::osg::Vec3f::x] typedef float ( ::osg::Vec3f::*fget)( ) const; Vec3f_exposer.add_property( "x" , fget( &::osg::Vec3f::x ) ); } { //property "y"[fget=::osg::Vec3f::y] typedef float & ( ::osg::Vec3f::*fget)( ) ; Vec3f_exposer.add_property( "y" , bp::make_function( fget( &::osg::Vec3f::y ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "y"[fget=::osg::Vec3f::y] typedef float ( ::osg::Vec3f::*fget)( ) const; Vec3f_exposer.add_property( "y" , fget( &::osg::Vec3f::y ) ); } { //property "z"[fget=::osg::Vec3f::z] typedef float & ( ::osg::Vec3f::*fget)( ) ; Vec3f_exposer.add_property( "z" , bp::make_function( fget( &::osg::Vec3f::z ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "z"[fget=::osg::Vec3f::z] typedef float ( ::osg::Vec3f::*fget)( ) const; Vec3f_exposer.add_property( "z" , fget( &::osg::Vec3f::z ) ); } Vec3f_exposer.def( bp::self * bp::other< osg::Matrixf >() ); Vec3f_exposer.def( bp::self * bp::other< osg::Matrixd >() ); Vec3f_exposer.def( bp::self * bp::other< osg::Vec4d >() ); Vec3f_exposer.def( bp::self * bp::other< osg::Vec4f >() ); Vec3f_exposer.def( bp::self_ns::str( bp::self ) ); Vec3f_exposer.def( bp::self_ns::str(bp::self) ); Vec3f_exposer.def(bp::indexing::container_suite< osg::Vec3f, bp::indexing::all_methods, OsgVec_algorithms<osg::Vec3f, osg::Vec3f::value_type, osg::Vec3f::num_components> >()); } }
void register_Vec4us_class(){ { //::osg::Vec4us typedef bp::class_< osg::Vec4us > Vec4us_exposer_t; Vec4us_exposer_t Vec4us_exposer = Vec4us_exposer_t( "Vec4us", "\n General purpose float quad. Uses include representation\n of color coordinates.\n No support yet added for float * Vec4us - is it necessary?\n Need to define a non-member non-friend operator* etc.\n Vec4us * float is okay\n", bp::init< >("\n Constructor that sets all components of the vector to zero\n") ); bp::scope Vec4us_scope( Vec4us_exposer ); bp::scope().attr("num_components") = (int)osg::Vec4us::num_components; Vec4us_exposer.def( bp::init< short unsigned int, short unsigned int, short unsigned int, short unsigned int >(( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("w") )) ); Vec4us_exposer.def( bp::self != bp::self ); Vec4us_exposer.def( bp::self * bp::other< short unsigned int >() ); Vec4us_exposer.def( bp::self * bp::self ); Vec4us_exposer.def( bp::self *= bp::other< short unsigned int >() ); Vec4us_exposer.def( bp::self + bp::self ); Vec4us_exposer.def( bp::self += bp::self ); Vec4us_exposer.def( bp::self - bp::self ); Vec4us_exposer.def( bp::self -= bp::self ); Vec4us_exposer.def( bp::self / bp::other< short unsigned int >() ); Vec4us_exposer.def( bp::self /= bp::other< short unsigned int >() ); Vec4us_exposer.def( bp::self < bp::self ); Vec4us_exposer.def( bp::self == bp::self ); { //::osg::Vec4us::operator[] typedef short unsigned int & ( ::osg::Vec4us::*__getitem___function_type)( unsigned int ) ; Vec4us_exposer.def( "__getitem__" , __getitem___function_type( &::osg::Vec4us::operator[] ) , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_non_const_reference >() ); } { //::osg::Vec4us::operator[] typedef short unsigned int ( ::osg::Vec4us::*__getitem___function_type)( unsigned int ) const; Vec4us_exposer.def( "__getitem__" , __getitem___function_type( &::osg::Vec4us::operator[] ) , ( bp::arg("i") ) ); } { //::osg::Vec4us::set typedef void ( ::osg::Vec4us::*set_function_type)( short unsigned int,short unsigned int,short unsigned int,short unsigned int ) ; Vec4us_exposer.def( "set" , set_function_type( &::osg::Vec4us::set ) , ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("w") ) ); } { //property "x"[fget=::osg::Vec4us::x] typedef short unsigned int & ( ::osg::Vec4us::*fget)( ) ; Vec4us_exposer.add_property( "x" , bp::make_function( fget( &::osg::Vec4us::x ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "x"[fget=::osg::Vec4us::x] typedef short unsigned int ( ::osg::Vec4us::*fget)( ) const; Vec4us_exposer.add_property( "x" , fget( &::osg::Vec4us::x ) ); } { //property "y"[fget=::osg::Vec4us::y] typedef short unsigned int & ( ::osg::Vec4us::*fget)( ) ; Vec4us_exposer.add_property( "y" , bp::make_function( fget( &::osg::Vec4us::y ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "y"[fget=::osg::Vec4us::y] typedef short unsigned int ( ::osg::Vec4us::*fget)( ) const; Vec4us_exposer.add_property( "y" , fget( &::osg::Vec4us::y ) ); } { //property "z"[fget=::osg::Vec4us::z] typedef short unsigned int & ( ::osg::Vec4us::*fget)( ) ; Vec4us_exposer.add_property( "z" , bp::make_function( fget( &::osg::Vec4us::z ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "z"[fget=::osg::Vec4us::z] typedef short unsigned int ( ::osg::Vec4us::*fget)( ) const; Vec4us_exposer.add_property( "z" , fget( &::osg::Vec4us::z ) ); } { //property "w"[fget=::osg::Vec4us::w] typedef short unsigned int & ( ::osg::Vec4us::*fget)( ) ; Vec4us_exposer.add_property( "w" , bp::make_function( fget( &::osg::Vec4us::w ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "w"[fget=::osg::Vec4us::w] typedef short unsigned int ( ::osg::Vec4us::*fget)( ) const; Vec4us_exposer.add_property( "w" , fget( &::osg::Vec4us::w ) ); } { //property "r"[fget=::osg::Vec4us::r] typedef short unsigned int & ( ::osg::Vec4us::*fget)( ) ; Vec4us_exposer.add_property( "r" , bp::make_function( fget( &::osg::Vec4us::r ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "r"[fget=::osg::Vec4us::r] typedef short unsigned int ( ::osg::Vec4us::*fget)( ) const; Vec4us_exposer.add_property( "r" , fget( &::osg::Vec4us::r ) ); } { //property "g"[fget=::osg::Vec4us::g] typedef short unsigned int & ( ::osg::Vec4us::*fget)( ) ; Vec4us_exposer.add_property( "g" , bp::make_function( fget( &::osg::Vec4us::g ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "g"[fget=::osg::Vec4us::g] typedef short unsigned int ( ::osg::Vec4us::*fget)( ) const; Vec4us_exposer.add_property( "g" , fget( &::osg::Vec4us::g ) ); } { //property "b"[fget=::osg::Vec4us::b] typedef short unsigned int & ( ::osg::Vec4us::*fget)( ) ; Vec4us_exposer.add_property( "b" , bp::make_function( fget( &::osg::Vec4us::b ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "b"[fget=::osg::Vec4us::b] typedef short unsigned int ( ::osg::Vec4us::*fget)( ) const; Vec4us_exposer.add_property( "b" , fget( &::osg::Vec4us::b ) ); } { //property "a"[fget=::osg::Vec4us::a] typedef short unsigned int & ( ::osg::Vec4us::*fget)( ) ; Vec4us_exposer.add_property( "a" , bp::make_function( fget( &::osg::Vec4us::a ) , bp::return_value_policy< bp::copy_non_const_reference >() ) ); } { //property "a"[fget=::osg::Vec4us::a] typedef short unsigned int ( ::osg::Vec4us::*fget)( ) const; Vec4us_exposer.add_property( "a" , fget( &::osg::Vec4us::a ) ); } Vec4us_exposer.def(bp::indexing::container_suite< osg::Vec4us, bp::indexing::all_methods, OsgVec_algorithms<osg::Vec4us, osg::Vec4us::value_type, osg::Vec4us::num_components> >()); } }
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 ) ); } }