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_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_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_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_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_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_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_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_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_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 ) );
}
}
