diff --git a/include/osg/Vec2d b/include/osg/Vec2d index 8d1d137de..c5eefa15d 100644 --- a/include/osg/Vec2d +++ b/include/osg/Vec2d @@ -166,14 +166,24 @@ class Vec2d return( norm ); } - friend inline std::ostream& operator << (std::ostream& output, const Vec2d& vec) - { - output << vec._v[0] << " " - << vec._v[1]; - return output; // to enable cascading - } - }; // end of class Vec2d + +// streaming operators + +inline std::ostream& operator << (std::ostream& output, const Vec2d& vec) +{ + output << vec._v[0] << " " + << vec._v[1]; + return output; // to enable cascading +} + +inline std::istream& operator >> (std::istream& input, Vec2d& vec) +{ + input >> vec._v[0] >> vec._v[1]; + return input; +} + + } // end of namespace osg #endif diff --git a/include/osg/Vec2f b/include/osg/Vec2f index c38532cbe..170fd69b3 100644 --- a/include/osg/Vec2f +++ b/include/osg/Vec2f @@ -15,6 +15,7 @@ #define OSG_VEC2F 1 #include +#include #include @@ -162,14 +163,25 @@ class Vec2f } return( norm ); } - - friend inline std::ostream& operator << (std::ostream& output, const Vec2f& vec) - { - output << vec._v[0] << " " << vec._v[1]; - return output; // to enable cascading - } - + }; // end of class Vec2f + +// streaming operators + +inline std::ostream& operator << (std::ostream& output, const Vec2f& vec) +{ + output << vec._v[0] << " " << vec._v[1]; + return output; // to enable cascading +} + +inline std::istream& operator >> (std::istream& input, Vec2f& vec) +{ + input >> vec._v[0] >> vec._v[1]; + return input; +} + + } // end of namespace osg #endif + diff --git a/include/osg/Vec3d b/include/osg/Vec3d index f806e906c..9d7e8135c 100644 --- a/include/osg/Vec3d +++ b/include/osg/Vec3d @@ -197,10 +197,11 @@ class Vec3d return( norm ); } - friend inline std::ostream& operator << (std::ostream& output, const Vec3d& vec); - }; // end of class Vec3d + +// streaming operators + inline std::ostream& operator << (std::ostream& output, const Vec3d& vec) { output << vec._v[0] << " " @@ -209,6 +210,13 @@ inline std::ostream& operator << (std::ostream& output, const Vec3d& vec) return output; // to enable cascading } +inline std::istream& operator >> (std::istream& input, Vec3d& vec) +{ + input >> vec._v[0] >> vec._v[1] >> vec._v[2]; + return input; +} + + } // end of namespace osg #endif diff --git a/include/osg/Vec3f b/include/osg/Vec3f index 44b7949d1..101d8dffb 100644 --- a/include/osg/Vec3f +++ b/include/osg/Vec3f @@ -15,6 +15,7 @@ #define OSG_VEC3F 1 #include +#include #include #include @@ -194,10 +195,10 @@ class Vec3f return( norm ); } - friend inline std::ostream& operator << (std::ostream& output, const Vec3f& vec); - }; // end of class Vec3f +// streaming operators + inline std::ostream& operator << (std::ostream& output, const Vec3f& vec) { output << vec._v[0] << " " @@ -206,6 +207,12 @@ inline std::ostream& operator << (std::ostream& output, const Vec3f& vec) return output; // to enable cascading } +inline std::istream& operator >> (std::istream& input, Vec3f& vec) +{ + input >> vec._v[0] >> vec._v[1] >> vec._v[2]; + return input; +} + const Vec3f X_AXIS(1.0,0.0,0.0); const Vec3f Y_AXIS(0.0,1.0,0.0); const Vec3f Z_AXIS(0.0,0.0,1.0); @@ -213,3 +220,4 @@ const Vec3f Z_AXIS(0.0,0.0,1.0); } // end of namespace osg #endif + diff --git a/include/osg/Vec4f b/include/osg/Vec4f index 02d7e80c8..66485e294 100644 --- a/include/osg/Vec4f +++ b/include/osg/Vec4f @@ -229,18 +229,27 @@ class Vec4f return( norm ); } - friend inline std::ostream& operator << (std::ostream& output, const Vec4f& vec) - { - output << vec._v[0] << " " - << vec._v[1] << " " - << vec._v[2] << " " - << vec._v[3]; - return output; // to enable cascading - } - }; // end of class Vec4f +// streaming operators + +inline std::ostream& operator << (std::ostream& output, const Vec4f& vec) +{ + output << vec._v[0] << " " + << vec._v[1] << " " + << vec._v[2] << " " + << vec._v[3]; + return output; // to enable cascading +} + +inline std::istream& operator >> (std::istream& input, Vec4f& vec) +{ + input >> vec._v[0] >> vec._v[1] >> vec._v[2] >> vec._v[3]; + return input; +} + + /** Compute the dot product of a (Vec3,1.0) and a Vec4f. */ inline Vec4f::value_type operator * (const Vec3f& lhs,const Vec4f& rhs) { @@ -256,3 +265,4 @@ inline Vec4f::value_type operator * (const Vec4f& lhs,const Vec3f& rhs) } // end of namespace osg #endif + diff --git a/include/osgIntrospection/Converter b/include/osgIntrospection/Converter new file mode 100644 index 000000000..68e655201 --- /dev/null +++ b/include/osgIntrospection/Converter @@ -0,0 +1,70 @@ +#ifndef OSGINTROSPECTION_CONVERTER_ +#define OSGINTROSPECTION_CONVERTER_ + +#include +#include + +namespace osgIntrospection +{ + + struct Converter + { + virtual Value convert(const Value &) const = 0; + virtual ~Converter() {} + }; + + typedef std::vector ConverterList; + + class CompositeConverter: public Converter + { + public: + CompositeConverter(const ConverterList &cvt): cvt_(cvt) {} + CompositeConverter(ConverterList &cvt) { cvt_.swap(cvt); } + virtual ~CompositeConverter() {} + + virtual Value convert(const Value &src) const + { + Value accum(src); + for (ConverterList::const_iterator i=cvt_.begin(); i!=cvt_.end(); ++i) + accum = (*i)->convert(accum); + return accum; + } + + private: + ConverterList cvt_; + }; + + template + struct StaticConverter: Converter + { + virtual ~StaticConverter() {} + virtual Value convert(const Value &src) const + { + return static_cast(variant_cast(src)); + } + }; + + template + struct DynamicConverter: Converter + { + virtual ~DynamicConverter() {} + virtual Value convert(const Value &src) const + { + return dynamic_cast(variant_cast(src)); + } + }; + + template + struct ReinterpretConverter: Converter + { + virtual ~ReinterpretConverter() {} + virtual Value convert(const Value &src) const + { + return reinterpret_cast(variant_cast(src)); + } + }; + +} + +#endif + diff --git a/include/osgIntrospection/ConverterProxy b/include/osgIntrospection/ConverterProxy new file mode 100644 index 000000000..e2dea9a5e --- /dev/null +++ b/include/osgIntrospection/ConverterProxy @@ -0,0 +1,22 @@ +#ifndef OSGINTROSPECTION_CONVERTERPROXY_ +#define OSGINTROSPECTION_CONVERTERPROXY_ + +#include + +namespace osgIntrospection +{ + + struct Converter; + + struct ConverterProxy + { + ConverterProxy(const Type &source, const Type &dest, const Converter *cvt) + { + Reflection::registerConverter(source, dest, cvt); + } + }; + +} + +#endif + diff --git a/include/osgIntrospection/ReaderWriter b/include/osgIntrospection/ReaderWriter index a59b0a5e0..99e84d3e3 100644 --- a/include/osgIntrospection/ReaderWriter +++ b/include/osgIntrospection/ReaderWriter @@ -13,50 +13,6 @@ #include -namespace osg -{ - - /// ---------------------------------------------------------------------- - /// TEMPORARY FIX - /// (currently osg::Vec? classes don't support input streaming) - /// (currently osg::ref_ptr<> class doesn't support I/O streaming) - inline std::istream& operator >> (std::istream& input, Vec2f& vec) - { - input >> vec._v[0] >> vec._v[1]; - return input; - } - - inline std::istream& operator >> (std::istream& input, Vec3f& vec) - { - input >> vec._v[0] >> vec._v[1] >> vec._v[2]; - return input; - } - - inline std::istream& operator >> (std::istream& input, Vec4& vec) - { - input >> vec._v[0] >> vec._v[1] >> vec._v[2] >> vec._v[3]; - return input; - } - - template - std::ostream &operator << (std::ostream &s, const osg::ref_ptr &r) - { - return s << r.get(); - } - - template - std::istream &operator >> (std::istream &s, osg::ref_ptr &r) - { - void *ptr; - s >> ptr; - r = (T *)ptr; - return s; - } - - /// - /// END OF TEMPORARY FIX - /// ---------------------------------------------------------------------- -} namespace osgIntrospection { diff --git a/include/osgIntrospection/Reflection b/include/osgIntrospection/Reflection index 5bde15b3d..2dc09dc21 100644 --- a/include/osgIntrospection/Reflection +++ b/include/osgIntrospection/Reflection @@ -5,6 +5,7 @@ #include #include +#include /// This macro emulates the behavior of the standard typeid operator, /// returning the Type object associated to the type of the given @@ -15,6 +16,9 @@ namespace osgIntrospection { class Type; + struct Converter; + + typedef std::vector ConverterList; /// This predicate compares two instances of std::type_info for equality. /// Note that we can't rely on default pointer comparison because it is @@ -58,22 +62,34 @@ namespace osgIntrospection /// This is a shortcut for typeof(void), which may be slow if /// the type map is large. static const Type &type_void(); + + static const Converter *getConverter(const Type &source, const Type &dest); + static bool getConversionPath(const Type &source, const Type &dest, ConverterList &conv); private: template friend class Reflector; template friend struct TypeNameAliasProxy; + friend struct ConverterProxy; struct StaticData { TypeMap typemap; const Type *type_void; + + typedef std::map ConverterMap; + typedef std::map ConverterMapMap; + ConverterMapMap convmap; + + ~StaticData(); }; static StaticData &getOrCreateStaticData(); static Type *registerType(const std::type_info &ti); static Type *getOrRegisterType(const std::type_info &ti, bool replace_if_defined = false); + static void registerConverter(const Type &source, const Type &dest, const Converter *cvt); private: + static bool accum_conv_path(const Type &source, const Type &dest, ConverterList &conv, std::vector &chain); static StaticData *staticdata__; }; diff --git a/include/osgIntrospection/ReflectionMacros b/include/osgIntrospection/ReflectionMacros index 3dd48bee7..0e9832930 100644 --- a/include/osgIntrospection/ReflectionMacros +++ b/include/osgIntrospection/ReflectionMacros @@ -1,8 +1,11 @@ #ifndef OSGINTROSPECTION_REFLECTIONMACROS_ #define OSGINTROSPECTION_REFLECTIONMACROS_ +#include #include #include +#include +#include // -------------------------------------------------------------------------- // "private" macros, not to be used outside this file @@ -20,6 +23,24 @@ #define TYPE_NAME_ALIAS(t, n) \ namespace { osgIntrospection::TypeNameAliasProxy OSG_RM_LINEID(tnalias) (#n); } + + +// -------------------------------------------------------------------------- +// TYPE CONVERTERS +// -------------------------------------------------------------------------- + +#define Converter(s, d, c) \ + namespace { osgIntrospection::ConverterProxy OSG_RM_LINEID(cvt) (s, d, new c); } + +#define StaticConverter(s, d) \ + Converter(s, d, osgIntrospection::StaticConverter); + +#define DynamicConverter(s, d) \ + Converter(s, d, osgIntrospection::DynamicConverter); + +#define ReinterpretConverter(s, d) \ + Converter(s, d, osgIntrospection::ReinterpretConverter); + // -------------------------------------------------------------------------- // ONE-LINE REFLECTORS @@ -110,7 +131,33 @@ #define ReaderWriter(x) setReaderWriter(new x); #define Comparator(x) setComparator(new x); -#define BaseType(x) addBaseType(typeof(x)); +#define BaseType(x) \ + { \ + addBaseType(typeof(x)); \ + const osgIntrospection::Type &st = typeof(reflected_type *); \ + const osgIntrospection::Type &cst = typeof(const reflected_type *); \ + const osgIntrospection::Type &dt = typeof(x *); \ + const osgIntrospection::Type &cdt = typeof(const x *); \ + osgIntrospection::ConverterProxy cp1(st, dt, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp2(cst, cdt, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp1c(st, cdt, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp3(dt, st, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp4(cdt, cst, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp3c(dt, cst, new osgIntrospection::StaticConverter); \ + } + +#define VirtualBaseType(x) \ + { \ + addBaseType(typeof(x)); \ + const osgIntrospection::Type &st = typeof(reflected_type *); \ + const osgIntrospection::Type &cst = typeof(const reflected_type *); \ + const osgIntrospection::Type &dt = typeof(x *); \ + const osgIntrospection::Type &cdt = typeof(const x *); \ + osgIntrospection::ConverterProxy cp1(st, dt, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp2(cst, cdt, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp1c(st, cdt, new osgIntrospection::StaticConverter); \ + } + #define EnumLabel(x) addEnumLabel(x, #x, true); diff --git a/src/osgIntrospection/Reflection.cpp b/src/osgIntrospection/Reflection.cpp index 8736059d7..7ad428339 100644 --- a/src/osgIntrospection/Reflection.cpp +++ b/src/osgIntrospection/Reflection.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include @@ -11,6 +12,20 @@ using namespace osgIntrospection; Reflection::StaticData *Reflection::staticdata__ = 0; +Reflection::StaticData::~StaticData() +{ + for (TypeMap::iterator i=typemap.begin(); i!=typemap.end(); ++i) + delete i->second; + + for (ConverterMapMap::iterator i=convmap.begin(); i!=convmap.end(); ++i) + { + for (ConverterMap::iterator j=i->second.begin(); j!=i->second.end(); ++j) + { + delete j->second; + } + } +} + const TypeMap &Reflection::getTypes() { return getOrCreateStaticData().typemap; @@ -48,13 +63,13 @@ const Type &Reflection::getType(const std::string &qname) const TypeMap &types = getTypes(); for (TypeMap::const_iterator i=types.begin(); i!=types.end(); ++i) - { + { if (i->second->isDefined() && i->second->getQualifiedName().compare(qname) == 0) return *i->second; - for (int j=0; jsecond->getNumAliases(); ++j) - if (i->second->getAlias(j).compare(qname) == 0) - return *i->second; - } + for (int j=0; jsecond->getNumAliases(); ++j) + if (i->second->getAlias(j).compare(qname) == 0) + return *i->second; + } throw TypeNotFoundException(qname); } @@ -77,22 +92,74 @@ Type *Reflection::getOrRegisterType(const std::type_info &ti, bool replace_if_de TypeMap::iterator i = tm.find(&ti); if (i != tm.end()) - { - if (replace_if_defined && i->second->isDefined()) - { - std::string old_name = i->second->getName(); - std::string old_namespace = i->second->getNamespace(); - std::vector old_aliases = i->second->aliases_; + { + if (replace_if_defined && i->second->isDefined()) + { + std::string old_name = i->second->getName(); + std::string old_namespace = i->second->getNamespace(); + std::vector old_aliases = i->second->aliases_; - Type *newtype = new (i->second) Type(ti); - newtype->name_ = old_name; - newtype->namespace_ = old_namespace; - newtype->aliases_.swap(old_aliases); + Type *newtype = new (i->second) Type(ti); + newtype->name_ = old_name; + newtype->namespace_ = old_namespace; + newtype->aliases_.swap(old_aliases); - return newtype; - } - return i->second; - } + return newtype; + } + return i->second; + } return registerType(ti); } + +void Reflection::registerConverter(const Type &source, const Type &dest, const Converter *cvt) +{ + getOrCreateStaticData().convmap[&source][&dest] = cvt; +} + +const Converter *Reflection::getConverter(const Type &source, const Type &dest) +{ + return getOrCreateStaticData().convmap[&source][&dest]; +} + +bool Reflection::getConversionPath(const Type &source, const Type &dest, ConverterList &conv) +{ + ConverterList temp; + std::vector chain; + if (accum_conv_path(source, dest, temp, chain)) + { + conv.swap(temp); + return true; + } + return false; +} + +bool Reflection::accum_conv_path(const Type &source, const Type &dest, ConverterList &conv, std::vector &chain) +{ + // break unwanted loops + if (std::find(chain.begin(), chain.end(), &source) != chain.end()) + return false; + + // store the type being processed to avoid loops + chain.push_back(&source); + + StaticData::ConverterMapMap::const_iterator i = getOrCreateStaticData().convmap.find(&source); + if (i == getOrCreateStaticData().convmap.end()) + return false; + + const StaticData::ConverterMap &cmap = i->second; + StaticData::ConverterMap::const_iterator j = cmap.find(&dest); + if (j != cmap.end()) + { + conv.push_back(j->second); + return true; + } + + for (j=cmap.begin(); j!=cmap.end(); ++j) + { + if (accum_conv_path(*j->first, dest, conv, chain)) + return true; + } + + return false; +} diff --git a/src/osgIntrospection/Value.cpp b/src/osgIntrospection/Value.cpp index 15365576d..1bf597673 100644 --- a/src/osgIntrospection/Value.cpp +++ b/src/osgIntrospection/Value.cpp @@ -3,6 +3,8 @@ #include #include #include +#include +#include #include #include @@ -27,6 +29,14 @@ Value Value::tryConvertTo(const Type &outtype) const if (type_->isConstPointer() && outtype.isNonConstPointer()) return Value(); + // search custom converters + ConverterList conv; + if (Reflection::getConversionPath(*type_, outtype, conv)) + { + std::auto_ptr cvt(new CompositeConverter(conv)); + return cvt->convert(*this); + } + std::auto_ptr wopt; if (type_->isEnum() && (outtype.getQualifiedName() == "int" || outtype.getQualifiedName() == "unsigned int")) @@ -41,12 +51,11 @@ Value Value::tryConvertTo(const Type &outtype) const const ReaderWriter *dst_rw = outtype.getReaderWriter(); if (dst_rw) { - std::ostringstream oss; - if (src_rw->writeTextValue(oss, *this, wopt.get())) + std::stringstream ss; + if (src_rw->writeTextValue(ss, *this, wopt.get())) { Value v; - std::istringstream iss(oss.str()); - if (dst_rw->readTextValue(iss, v)) + if (dst_rw->readTextValue(ss, v)) { return v; } @@ -80,107 +89,107 @@ void Value::check_empty() const void Value::swap(Value &v) { - std::swap(inbox_, v.inbox_); - std::swap(type_, v.type_); - std::swap(ptype_, v.ptype_); + std::swap(inbox_, v.inbox_); + std::swap(type_, v.type_); + std::swap(ptype_, v.ptype_); } bool Value::operator ==(const Value &other) const { - if (isEmpty() && other.isEmpty()) - return true; + if (isEmpty() && other.isEmpty()) + return true; - if (isEmpty() ^ other.isEmpty()) - return false; + if (isEmpty() ^ other.isEmpty()) + return false; - const Comparator *cmp1 = type_->getComparator(); - const Comparator *cmp2 = other.type_->getComparator(); - - const Comparator *cmp = cmp1? cmp1: cmp2; - - if (!cmp) - throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + const Comparator *cmp1 = type_->getComparator(); + const Comparator *cmp2 = other.type_->getComparator(); + + const Comparator *cmp = cmp1? cmp1: cmp2; + + if (!cmp) + throw ComparisonNotPermittedException(type_->getStdTypeInfo()); - if (cmp1 == cmp2) - return cmp->isEqualTo(*this, other); + if (cmp1 == cmp2) + return cmp->isEqualTo(*this, other); - if (cmp1) - return cmp1->isEqualTo(*this, other.convertTo(*type_)); + if (cmp1) + return cmp1->isEqualTo(*this, other.convertTo(*type_)); - return cmp2->isEqualTo(convertTo(*other.type_), other); + return cmp2->isEqualTo(convertTo(*other.type_), other); } bool Value::operator <=(const Value &other) const { - const Comparator *cmp1 = type_->getComparator(); - const Comparator *cmp2 = other.type_->getComparator(); - - const Comparator *cmp = cmp1? cmp1: cmp2; - - if (!cmp) - throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + const Comparator *cmp1 = type_->getComparator(); + const Comparator *cmp2 = other.type_->getComparator(); + + const Comparator *cmp = cmp1? cmp1: cmp2; + + if (!cmp) + throw ComparisonNotPermittedException(type_->getStdTypeInfo()); - if (cmp1 == cmp2) - return cmp->isLessThanOrEqualTo(*this, other); + if (cmp1 == cmp2) + return cmp->isLessThanOrEqualTo(*this, other); - if (cmp1) - return cmp1->isLessThanOrEqualTo(*this, other.convertTo(*type_)); + if (cmp1) + return cmp1->isLessThanOrEqualTo(*this, other.convertTo(*type_)); - return cmp2->isLessThanOrEqualTo(convertTo(*other.type_), other); + return cmp2->isLessThanOrEqualTo(convertTo(*other.type_), other); } bool Value::operator !=(const Value &other) const { - return !operator==(other); + return !operator==(other); } bool Value::operator >(const Value &other) const { - return !operator<=(other); + return !operator<=(other); } bool Value::operator <(const Value &other) const { - const Comparator *cmp1 = type_->getComparator(); - const Comparator *cmp2 = other.type_->getComparator(); - - const Comparator *cmp = cmp1? cmp1: cmp2; - - if (!cmp) - throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + const Comparator *cmp1 = type_->getComparator(); + const Comparator *cmp2 = other.type_->getComparator(); + + const Comparator *cmp = cmp1? cmp1: cmp2; + + if (!cmp) + throw ComparisonNotPermittedException(type_->getStdTypeInfo()); - if (cmp1 == cmp2) - return cmp->isLessThanOrEqualTo(*this, other) && !cmp->isEqualTo(*this, other); + if (cmp1 == cmp2) + return cmp->isLessThanOrEqualTo(*this, other) && !cmp->isEqualTo(*this, other); - if (cmp1) - { - Value temp(other.convertTo(*type_)); - return cmp1->isLessThanOrEqualTo(*this, temp) && !cmp1->isEqualTo(*this, temp); - } + if (cmp1) + { + Value temp(other.convertTo(*type_)); + return cmp1->isLessThanOrEqualTo(*this, temp) && !cmp1->isEqualTo(*this, temp); + } - Value temp(convertTo(*other.type_)); - return cmp2->isLessThanOrEqualTo(temp, other) && !cmp2->isEqualTo(temp, other); + Value temp(convertTo(*other.type_)); + return cmp2->isLessThanOrEqualTo(temp, other) && !cmp2->isEqualTo(temp, other); } bool Value::operator >=(const Value &other) const { - const Comparator *cmp1 = type_->getComparator(); - const Comparator *cmp2 = other.type_->getComparator(); - - const Comparator *cmp = cmp1? cmp1: cmp2; - - if (!cmp) - throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + const Comparator *cmp1 = type_->getComparator(); + const Comparator *cmp2 = other.type_->getComparator(); + + const Comparator *cmp = cmp1? cmp1: cmp2; + + if (!cmp) + throw ComparisonNotPermittedException(type_->getStdTypeInfo()); - if (cmp1 == cmp2) - return !cmp->isLessThanOrEqualTo(*this, other) || cmp->isEqualTo(*this, other); + if (cmp1 == cmp2) + return !cmp->isLessThanOrEqualTo(*this, other) || cmp->isEqualTo(*this, other); - if (cmp1) - { - Value temp(other.convertTo(*type_)); - return !cmp1->isLessThanOrEqualTo(*this, temp) || cmp1->isEqualTo(*this, temp); - } + if (cmp1) + { + Value temp(other.convertTo(*type_)); + return !cmp1->isLessThanOrEqualTo(*this, temp) || cmp1->isEqualTo(*this, temp); + } - Value temp(convertTo(*other.type_)); - return !cmp2->isLessThanOrEqualTo(temp, other) || cmp2->isEqualTo(temp, other); + Value temp(convertTo(*other.type_)); + return !cmp2->isLessThanOrEqualTo(temp, other) || cmp2->isEqualTo(temp, other); } diff --git a/src/osgPlugins/ive/DataInputStream.cpp b/src/osgPlugins/ive/DataInputStream.cpp index b7cc67c50..3d4101015 100644 --- a/src/osgPlugins/ive/DataInputStream.cpp +++ b/src/osgPlugins/ive/DataInputStream.cpp @@ -76,9 +76,22 @@ using namespace ive; using namespace std; +void DataInputStream::setOptions(const osgDB::ReaderWriter::Options* options) +{ + _options = options; + + if (_options.get()) + { + setLoadExternalReferenceFiles(_options->getOptionString().find("noLoadExternalReferenceFiles")==std::string::npos); + osg::notify(osg::DEBUG_INFO) << "ive::DataInputStream.setLoadExternalReferenceFiles()=" << getLoadExternalReferenceFiles() << std::endl; + } +} + DataInputStream::DataInputStream(std::istream* istream) { unsigned int endianType ; + + _loadExternalReferenceFiles = false; _verboseOutput = false; diff --git a/src/osgPlugins/ive/DataInputStream.h b/src/osgPlugins/ive/DataInputStream.h index 926389a13..f2aafd429 100644 --- a/src/osgPlugins/ive/DataInputStream.h +++ b/src/osgPlugins/ive/DataInputStream.h @@ -36,7 +36,7 @@ public: DataInputStream(std::istream* istream); ~DataInputStream(); - void setOptions(const osgDB::ReaderWriter::Options* options) { _options = options; } + void setOptions(const osgDB::ReaderWriter::Options* options); const osgDB::ReaderWriter::Options* getOptions() const { return _options.get(); } unsigned int getVersion(); @@ -83,6 +83,10 @@ public: osg::Shape* readShape(); osg::Node* readNode(); + // Set and get if must be generated external reference ive files + void setLoadExternalReferenceFiles(bool b) {_loadExternalReferenceFiles=b;}; + bool getLoadExternalReferenceFiles() {return _loadExternalReferenceFiles;}; + typedef std::map > ImageMap; typedef std::map > StateSetMap; typedef std::map > StateAttributeMap; @@ -104,6 +108,8 @@ private: DrawableMap _drawableMap; ShapeMap _shapeMap; NodeMap _nodeMap; + + bool _loadExternalReferenceFiles; osg::ref_ptr _options; diff --git a/src/osgPlugins/ive/ProxyNode.cpp b/src/osgPlugins/ive/ProxyNode.cpp index d4e08d8dd..579f01036 100644 --- a/src/osgPlugins/ive/ProxyNode.cpp +++ b/src/osgPlugins/ive/ProxyNode.cpp @@ -166,17 +166,21 @@ void ProxyNode::read(DataInputStream* in) fpl.pop_front(); } - for(i=0; igetLoadExternalReferenceFiles() ) { - if(i>=numChildren && !getFileName(i).empty()) + for(i=0; igetOptions())->getDatabasePathList(); - fpl.push_front( fpl.empty() ? osgDB::getFilePath(getFileName(i)) : fpl.front()+'/'+ osgDB::getFilePath(getFileName(i))); - osg::Node *node = osgDB::readNodeFile(getFileName(i), in->getOptions()); - fpl.pop_front(); - if(node) + if(i>=numChildren && !getFileName(i).empty()) { - insertChild(i, node); + osgDB::FilePathList& fpl = ((osgDB::ReaderWriter::Options*)in->getOptions())->getDatabasePathList(); + fpl.push_front( fpl.empty() ? osgDB::getFilePath(getFileName(i)) : fpl.front()+'/'+ osgDB::getFilePath(getFileName(i))); + osg::Node *node = osgDB::readNodeFile(getFileName(i), in->getOptions()); + fpl.pop_front(); + + if(node) + { + insertChild(i, node); + } } } } diff --git a/src/osgWrappers/osg/AlphaFunc.cpp b/src/osgWrappers/osg/AlphaFunc.cpp new file mode 100644 index 000000000..70fc1a547 --- /dev/null +++ b/src/osgWrappers/osg/AlphaFunc.cpp @@ -0,0 +1,52 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::AlphaFunc::ComparisonFunction) + EnumLabel(osg::AlphaFunc::NEVER); + EnumLabel(osg::AlphaFunc::LESS); + EnumLabel(osg::AlphaFunc::EQUAL); + EnumLabel(osg::AlphaFunc::LEQUAL); + EnumLabel(osg::AlphaFunc::GREATER); + EnumLabel(osg::AlphaFunc::NOTEQUAL); + EnumLabel(osg::AlphaFunc::GEQUAL); + EnumLabel(osg::AlphaFunc::ALWAYS); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::AlphaFunc) + BaseType(osg::StateAttribute); + Constructor0(); + Constructor2(IN, osg::AlphaFunc::ComparisonFunction, func, IN, float, ref); + ConstructorWithDefaults2(IN, const osg::AlphaFunc &, af, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method2(void, setFunction, IN, osg::AlphaFunc::ComparisonFunction, func, IN, float, ref); + Method1(void, setFunction, IN, osg::AlphaFunc::ComparisonFunction, func); + Method0(osg::AlphaFunc::ComparisonFunction, getFunction); + Method1(void, setReferenceValue, IN, float, value); + Method0(float, getReferenceValue); + Method1(void, apply, IN, osg::State &, state); + Property(osg::AlphaFunc::ComparisonFunction, Function); + Property(float, ReferenceValue); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/AnimationPath.cpp b/src/osgWrappers/osg/AnimationPath.cpp new file mode 100644 index 000000000..94e2853ff --- /dev/null +++ b/src/osgWrappers/osg/AnimationPath.cpp @@ -0,0 +1,120 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::map< double COMMA osg::AnimationPath::ControlPoint >, osg::AnimationPath::TimeControlPointMap); + +BEGIN_ENUM_REFLECTOR(osg::AnimationPath::LoopMode) + EnumLabel(osg::AnimationPath::SWING); + EnumLabel(osg::AnimationPath::LOOP); + EnumLabel(osg::AnimationPath::NO_LOOPING); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::AnimationPath) + VirtualBaseType(osg::Object); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::AnimationPath &, ap, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method2(bool, getMatrix, IN, double, time, IN, osg::Matrixf &, matrix); + Method2(bool, getMatrix, IN, double, time, IN, osg::Matrixd &, matrix); + Method2(bool, getInverse, IN, double, time, IN, osg::Matrixf &, matrix); + Method2(bool, getInverse, IN, double, time, IN, osg::Matrixd &, matrix); + Method2(bool, getInterpolatedControlPoint, IN, double, time, IN, osg::AnimationPath::ControlPoint &, controlPoint); + Method2(void, insert, IN, double, time, IN, const osg::AnimationPath::ControlPoint &, controlPoint); + Method0(double, getFirstTime); + Method0(double, getLastTime); + Method0(double, getPeriod); + Method1(void, setLoopMode, IN, osg::AnimationPath::LoopMode, lm); + Method0(osg::AnimationPath::LoopMode, getLoopMode); + Method1(void, setTimeControlPointMap, IN, osg::AnimationPath::TimeControlPointMap &, tcpm); + Method0(osg::AnimationPath::TimeControlPointMap &, getTimeControlPointMap); + Method0(const osg::AnimationPath::TimeControlPointMap &, getTimeControlPointMap); + Method0(bool, empty); + Method1(void, read, IN, std::istream &, in); + Method1(void, write, IN, std::ostream &, out); + ReadOnlyProperty(double, FirstTime); + ReadOnlyProperty(double, LastTime); + Property(osg::AnimationPath::LoopMode, LoopMode); + ReadOnlyProperty(double, Period); + Property(osg::AnimationPath::TimeControlPointMap &, TimeControlPointMap); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::AnimationPath::ControlPoint) + Constructor0(); + Constructor1(IN, const osg::Vec3d &, position); + Constructor2(IN, const osg::Vec3d &, position, IN, const osg::Quat &, rotation); + Constructor3(IN, const osg::Vec3d &, position, IN, const osg::Quat &, rotation, IN, const osg::Vec3d &, scale); + Method1(void, setPosition, IN, const osg::Vec3d &, position); + Method0(const osg::Vec3d &, getPosition); + Method1(void, setRotation, IN, const osg::Quat &, rotation); + Method0(const osg::Quat &, getRotation); + Method1(void, setScale, IN, const osg::Vec3d &, scale); + Method0(const osg::Vec3d &, getScale); + Method3(void, interpolate, IN, float, ratio, IN, const osg::AnimationPath::ControlPoint &, first, IN, const osg::AnimationPath::ControlPoint &, second); + Method1(void, getMatrix, IN, osg::Matrixf &, matrix); + Method1(void, getMatrix, IN, osg::Matrixd &, matrix); + Method1(void, getInverse, IN, osg::Matrixf &, matrix); + Method1(void, getInverse, IN, osg::Matrixd &, matrix); + Property(const osg::Vec3d &, Position); + Property(const osg::Quat &, Rotation); + Property(const osg::Vec3d &, Scale); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::AnimationPathCallback) + BaseType(osg::NodeCallback); + Constructor0(); + Constructor2(IN, const osg::AnimationPathCallback &, apc, IN, const osg::CopyOp &, copyop); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + ConstructorWithDefaults3(IN, osg::AnimationPath *, ap, , IN, double, timeOffset, 0.0, IN, double, timeMultiplier, 1.0); + Method1(void, setAnimationPath, IN, osg::AnimationPath *, path); + Method0(osg::AnimationPath *, getAnimationPath); + Method0(const osg::AnimationPath *, getAnimationPath); + Method1(void, setPivotPoint, IN, const osg::Vec3d &, pivot); + Method0(const osg::Vec3d &, getPivotPoint); + Method1(void, setUseInverseMatrix, IN, bool, useInverseMatrix); + Method0(bool, getUseInverseMatrix); + Method1(void, setTimeOffset, IN, double, offset); + Method0(double, getTimeOffset); + Method1(void, setTimeMultiplier, IN, double, multiplier); + Method0(double, getTimeMultiplier); + Method0(void, reset); + Method1(void, setPause, IN, bool, pause); + Method0(bool, getPause); + Method0(double, getAnimationTime); + Method1(void, update, IN, osg::Node &, node); + Property(osg::AnimationPath *, AnimationPath); + ReadOnlyProperty(double, AnimationTime); + Property(bool, Pause); + Property(const osg::Vec3d &, PivotPoint); + Property(double, TimeMultiplier); + Property(double, TimeOffset); + Property(bool, UseInverseMatrix); +END_REFLECTOR + +STD_MAP_REFLECTOR(std::map< double COMMA osg::AnimationPath::ControlPoint >); + diff --git a/src/osgWrappers/osg/ApplicationUsage.cpp b/src/osgWrappers/osg/ApplicationUsage.cpp new file mode 100644 index 000000000..205c76405 --- /dev/null +++ b/src/osgWrappers/osg/ApplicationUsage.cpp @@ -0,0 +1,63 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include + +TYPE_NAME_ALIAS(std::map< std::string COMMA std::string >, osg::ApplicationUsage::UsageMap); + +BEGIN_ENUM_REFLECTOR(osg::ApplicationUsage::Type) + EnumLabel(osg::ApplicationUsage::COMMAND_LINE_OPTION); + EnumLabel(osg::ApplicationUsage::ENVIRONMENTAL_VARIABLE); + EnumLabel(osg::ApplicationUsage::KEYBOARD_MOUSE_BINDING); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ApplicationUsage) + Constructor0(); + Constructor1(IN, const std::string &, commandLineUsage); + Method1(void, setApplicationName, IN, const std::string &, name); + Method0(const std::string &, getApplicationName); + Method1(void, setDescription, IN, const std::string &, desc); + Method0(const std::string &, getDescription); + Method3(void, addUsageExplanation, IN, osg::ApplicationUsage::Type, type, IN, const std::string &, option, IN, const std::string &, explanation); + Method1(void, setCommandLineUsage, IN, const std::string &, explanation); + Method0(const std::string &, getCommandLineUsage); + MethodWithDefaults3(void, addCommandLineOption, IN, const std::string &, option, , IN, const std::string &, explanation, , IN, const std::string &, defaultValue, ""); + Method1(void, setCommandLineOptions, IN, const osg::ApplicationUsage::UsageMap &, usageMap); + Method0(const osg::ApplicationUsage::UsageMap &, getCommandLineOptions); + Method1(void, setCommandLineOptionsDefaults, IN, const osg::ApplicationUsage::UsageMap &, usageMap); + Method0(const osg::ApplicationUsage::UsageMap &, getCommandLineOptionsDefaults); + MethodWithDefaults3(void, addEnvironmentalVariable, IN, const std::string &, option, , IN, const std::string &, explanation, , IN, const std::string &, defaultValue, ""); + Method1(void, setEnvironmentalVariables, IN, const osg::ApplicationUsage::UsageMap &, usageMap); + Method0(const osg::ApplicationUsage::UsageMap &, getEnvironmentalVariables); + Method1(void, setEnvironmentalVariablesDefaults, IN, const osg::ApplicationUsage::UsageMap &, usageMap); + Method0(const osg::ApplicationUsage::UsageMap &, getEnvironmentalVariablesDefaults); + Method2(void, addKeyboardMouseBinding, IN, const std::string &, option, IN, const std::string &, explanation); + Method1(void, setKeyboardMouseBindings, IN, const osg::ApplicationUsage::UsageMap &, usageMap); + Method0(const osg::ApplicationUsage::UsageMap &, getKeyboardMouseBindings); + MethodWithDefaults5(void, getFormattedString, IN, std::string &, str, , IN, const osg::ApplicationUsage::UsageMap &, um, , IN, unsigned int, widthOfOutput, 80, IN, bool, showDefaults, false, IN, const osg::ApplicationUsage::UsageMap &, ud, osg::ApplicationUsage::UsageMap()); + MethodWithDefaults5(void, write, IN, std::ostream &, output, , IN, const osg::ApplicationUsage::UsageMap &, um, , IN, unsigned int, widthOfOutput, 80, IN, bool, showDefaults, false, IN, const osg::ApplicationUsage::UsageMap &, ud, osg::ApplicationUsage::UsageMap()); + MethodWithDefaults4(void, write, IN, std::ostream &, output, , IN, unsigned int, type, osg::ApplicationUsage::COMMAND_LINE_OPTION, IN, unsigned int, widthOfOutput, 80, IN, bool, showDefaults, false); + Property(const std::string &, ApplicationName); + Property(const osg::ApplicationUsage::UsageMap &, CommandLineOptions); + Property(const osg::ApplicationUsage::UsageMap &, CommandLineOptionsDefaults); + Property(const std::string &, CommandLineUsage); + Property(const std::string &, Description); + Property(const osg::ApplicationUsage::UsageMap &, EnvironmentalVariables); + Property(const osg::ApplicationUsage::UsageMap &, EnvironmentalVariablesDefaults); + Property(const osg::ApplicationUsage::UsageMap &, KeyboardMouseBindings); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ApplicationUsageProxy) + Constructor3(IN, osg::ApplicationUsage::Type, type, IN, const std::string &, option, IN, const std::string &, explanation); +END_REFLECTOR + +STD_MAP_REFLECTOR(std::map< std::string COMMA std::string >); + diff --git a/src/osgWrappers/osg/ArgumentParser.cpp b/src/osgWrappers/osg/ArgumentParser.cpp new file mode 100644 index 000000000..e2945a74a --- /dev/null +++ b/src/osgWrappers/osg/ArgumentParser.cpp @@ -0,0 +1,86 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include + +TYPE_NAME_ALIAS(std::map< std::string COMMA osg::ArgumentParser::ErrorSeverity >, osg::ArgumentParser::ErrorMessageMap); + +BEGIN_ENUM_REFLECTOR(osg::ArgumentParser::ErrorSeverity) + EnumLabel(osg::ArgumentParser::BENIGN); + EnumLabel(osg::ArgumentParser::CRITICAL); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ArgumentParser) + Constructor2(IN, int *, argc, IN, char **, argv); + Method1(void, setApplicationUsage, IN, osg::ApplicationUsage *, usage); + Method0(osg::ApplicationUsage *, getApplicationUsage); + Method0(const osg::ApplicationUsage *, getApplicationUsage); + Method0(int &, argc); + Method0(char **, argv); + Method0(std::string, getApplicationName); + Method1(int, find, IN, const std::string &, str); + Method1(bool, isOption, IN, int, pos); + Method1(bool, isString, IN, int, pos); + Method1(bool, isNumber, IN, int, pos); + Method0(bool, containsOptions); + MethodWithDefaults2(void, remove, IN, int, pos, , IN, int, num, 1); + Method2(bool, match, IN, int, pos, IN, const std::string &, str); + Method1(bool, read, IN, const std::string &, str); + Method2(bool, read, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1); + Method3(bool, read, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2); + Method4(bool, read, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3); + Method5(bool, read, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3, IN, osg::ArgumentParser::Parameter, value4); + Method6(bool, read, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3, IN, osg::ArgumentParser::Parameter, value4, IN, osg::ArgumentParser::Parameter, value5); + Method7(bool, read, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3, IN, osg::ArgumentParser::Parameter, value4, IN, osg::ArgumentParser::Parameter, value5, IN, osg::ArgumentParser::Parameter, value6); + Method8(bool, read, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3, IN, osg::ArgumentParser::Parameter, value4, IN, osg::ArgumentParser::Parameter, value5, IN, osg::ArgumentParser::Parameter, value6, IN, osg::ArgumentParser::Parameter, value7); + Method9(bool, read, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3, IN, osg::ArgumentParser::Parameter, value4, IN, osg::ArgumentParser::Parameter, value5, IN, osg::ArgumentParser::Parameter, value6, IN, osg::ArgumentParser::Parameter, value7, IN, osg::ArgumentParser::Parameter, value8); + Method2(bool, read, IN, int, pos, IN, const std::string &, str); + Method3(bool, read, IN, int, pos, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1); + Method4(bool, read, IN, int, pos, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2); + Method5(bool, read, IN, int, pos, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3); + Method6(bool, read, IN, int, pos, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3, IN, osg::ArgumentParser::Parameter, value4); + Method7(bool, read, IN, int, pos, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3, IN, osg::ArgumentParser::Parameter, value4, IN, osg::ArgumentParser::Parameter, value5); + Method8(bool, read, IN, int, pos, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3, IN, osg::ArgumentParser::Parameter, value4, IN, osg::ArgumentParser::Parameter, value5, IN, osg::ArgumentParser::Parameter, value6); + Method9(bool, read, IN, int, pos, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3, IN, osg::ArgumentParser::Parameter, value4, IN, osg::ArgumentParser::Parameter, value5, IN, osg::ArgumentParser::Parameter, value6, IN, osg::ArgumentParser::Parameter, value7); + Method10(bool, read, IN, int, pos, IN, const std::string &, str, IN, osg::ArgumentParser::Parameter, value1, IN, osg::ArgumentParser::Parameter, value2, IN, osg::ArgumentParser::Parameter, value3, IN, osg::ArgumentParser::Parameter, value4, IN, osg::ArgumentParser::Parameter, value5, IN, osg::ArgumentParser::Parameter, value6, IN, osg::ArgumentParser::Parameter, value7, IN, osg::ArgumentParser::Parameter, value8); + MethodWithDefaults1(bool, errors, IN, osg::ArgumentParser::ErrorSeverity, severity, osg::ArgumentParser::BENIGN); + MethodWithDefaults2(void, reportError, IN, const std::string &, message, , IN, osg::ArgumentParser::ErrorSeverity, severity, osg::ArgumentParser::CRITICAL); + MethodWithDefaults1(void, reportRemainingOptionsAsUnrecognized, IN, osg::ArgumentParser::ErrorSeverity, severity, osg::ArgumentParser::BENIGN); + Method0(osg::ArgumentParser::ErrorMessageMap &, getErrorMessageMap); + Method0(const osg::ArgumentParser::ErrorMessageMap &, getErrorMessageMap); + MethodWithDefaults2(void, writeErrorMessages, IN, std::ostream &, output, , IN, osg::ArgumentParser::ErrorSeverity, sevrity, osg::ArgumentParser::BENIGN); + ReadOnlyProperty(std::string, ApplicationName); + Property(osg::ApplicationUsage *, ApplicationUsage); + ReadOnlyProperty(osg::ArgumentParser::ErrorMessageMap &, ErrorMessageMap); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::ArgumentParser::Parameter::ParameterType) + EnumLabel(osg::ArgumentParser::Parameter::FLOAT_PARAMETER); + EnumLabel(osg::ArgumentParser::Parameter::DOUBLE_PARAMETER); + EnumLabel(osg::ArgumentParser::Parameter::INT_PARAMETER); + EnumLabel(osg::ArgumentParser::Parameter::UNSIGNED_INT_PARAMETER); + EnumLabel(osg::ArgumentParser::Parameter::STRING_PARAMETER); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ArgumentParser::Parameter) + Constructor1(IN, float &, value); + Constructor1(IN, double &, value); + Constructor1(IN, int &, value); + Constructor1(IN, unsigned int &, value); + Constructor1(IN, std::string &, value); + Constructor1(IN, const osg::ArgumentParser::Parameter &, param); + Method1(bool, valid, IN, const char *, str); + Method1(bool, assign, IN, const char *, str); +END_REFLECTOR + +STD_MAP_REFLECTOR(std::map< std::string COMMA osg::ArgumentParser::ErrorSeverity >); + diff --git a/src/osgWrappers/osg/Array.cpp b/src/osgWrappers/osg/Array.cpp new file mode 100644 index 000000000..dba9d9020 --- /dev/null +++ b/src/osgWrappers/osg/Array.cpp @@ -0,0 +1,404 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::Array::Type) + EnumLabel(osg::Array::ArrayType); + EnumLabel(osg::Array::ByteArrayType); + EnumLabel(osg::Array::ShortArrayType); + EnumLabel(osg::Array::IntArrayType); + EnumLabel(osg::Array::UByteArrayType); + EnumLabel(osg::Array::UShortArrayType); + EnumLabel(osg::Array::UIntArrayType); + EnumLabel(osg::Array::UByte4ArrayType); + EnumLabel(osg::Array::FloatArrayType); + EnumLabel(osg::Array::Vec2ArrayType); + EnumLabel(osg::Array::Vec3ArrayType); + EnumLabel(osg::Array::Vec4ArrayType); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Array) + BaseType(osg::Object); + ConstructorWithDefaults3(IN, osg::Array::Type, arrayType, osg::Array::ArrayType, IN, GLint, dataSize, 0, IN, GLenum, dataType, 0); + ConstructorWithDefaults2(IN, const osg::Array &, array, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ArrayVisitor &, x); + Method1(void, accept, IN, osg::ConstArrayVisitor &, x); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, x); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, x); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(osg::Array::Type, getType); + Method0(GLint, getDataSize); + Method0(GLenum, getDataType); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + Method0(void, dirty); + Method1(void, setModifiedCount, IN, unsigned int, value); + Method0(unsigned int, getModifiedCount); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(GLint, DataSize); + ReadOnlyProperty(GLenum, DataType); + Property(unsigned int, ModifiedCount); + ReadOnlyProperty(unsigned int, TotalDataSize); + ReadOnlyProperty(osg::Array::Type, Type); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ArrayVisitor) + Constructor0(); + Method1(void, apply, IN, osg::Array &, x); + Method1(void, apply, IN, osg::ByteArray &, x); + Method1(void, apply, IN, osg::ShortArray &, x); + Method1(void, apply, IN, osg::IntArray &, x); + Method1(void, apply, IN, osg::UByteArray &, x); + Method1(void, apply, IN, osg::UShortArray &, x); + Method1(void, apply, IN, osg::UIntArray &, x); + Method1(void, apply, IN, osg::UByte4Array &, x); + Method1(void, apply, IN, osg::FloatArray &, x); + Method1(void, apply, IN, osg::Vec2Array &, x); + Method1(void, apply, IN, osg::Vec3Array &, x); + Method1(void, apply, IN, osg::Vec4Array &, x); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ConstArrayVisitor) + Constructor0(); + Method1(void, apply, IN, const osg::Array &, x); + Method1(void, apply, IN, const osg::ByteArray &, x); + Method1(void, apply, IN, const osg::ShortArray &, x); + Method1(void, apply, IN, const osg::IntArray &, x); + Method1(void, apply, IN, const osg::UByteArray &, x); + Method1(void, apply, IN, const osg::UShortArray &, x); + Method1(void, apply, IN, const osg::UIntArray &, x); + Method1(void, apply, IN, const osg::UByte4Array &, x); + Method1(void, apply, IN, const osg::FloatArray &, x); + Method1(void, apply, IN, const osg::Vec2Array &, x); + Method1(void, apply, IN, const osg::Vec3Array &, x); + Method1(void, apply, IN, const osg::Vec4Array &, x); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ConstValueVisitor) + Constructor0(); + Method1(void, apply, IN, const GLbyte &, x); + Method1(void, apply, IN, const GLshort &, x); + Method1(void, apply, IN, const GLint &, x); + Method1(void, apply, IN, const GLushort &, x); + Method1(void, apply, IN, const GLubyte &, x); + Method1(void, apply, IN, const GLuint &, x); + Method1(void, apply, IN, const GLfloat &, x); + Method1(void, apply, IN, const osg::UByte4 &, x); + Method1(void, apply, IN, const osg::Vec2 &, x); + Method1(void, apply, IN, const osg::Vec3 &, x); + Method1(void, apply, IN, const osg::Vec4 &, x); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::IndexArray) + BaseType(osg::Array); + ConstructorWithDefaults3(IN, osg::Array::Type, arrayType, osg::Array::ArrayType, IN, GLint, dataSize, 0, IN, GLenum, dataType, 0); + ConstructorWithDefaults2(IN, const osg::Array &, array, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method1(unsigned int, index, IN, unsigned int, pos); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ValueVisitor) + Constructor0(); + Method1(void, apply, IN, GLbyte &, x); + Method1(void, apply, IN, GLshort &, x); + Method1(void, apply, IN, GLint &, x); + Method1(void, apply, IN, GLushort &, x); + Method1(void, apply, IN, GLubyte &, x); + Method1(void, apply, IN, GLuint &, x); + Method1(void, apply, IN, GLfloat &, x); + Method1(void, apply, IN, osg::UByte4 &, x); + Method1(void, apply, IN, osg::Vec2 &, x); + Method1(void, apply, IN, osg::Vec3 &, x); + Method1(void, apply, IN, osg::Vec4 &, x); +END_REFLECTOR + +TYPE_NAME_ALIAS(osg::TemplateIndexArray< GLbyte COMMA osg::Array::ByteArrayType COMMA 1 COMMA GL_BYTE >, osg::ByteArray); + +TYPE_NAME_ALIAS(osg::TemplateIndexArray< GLshort COMMA osg::Array::ShortArrayType COMMA 1 COMMA GL_SHORT >, osg::ShortArray); + +TYPE_NAME_ALIAS(osg::TemplateIndexArray< GLint COMMA osg::Array::IntArrayType COMMA 1 COMMA GL_INT >, osg::IntArray); + +TYPE_NAME_ALIAS(osg::TemplateIndexArray< GLubyte COMMA osg::Array::UByteArrayType COMMA 1 COMMA GL_UNSIGNED_BYTE >, osg::UByteArray); + +TYPE_NAME_ALIAS(osg::TemplateIndexArray< GLushort COMMA osg::Array::UShortArrayType COMMA 1 COMMA GL_UNSIGNED_SHORT >, osg::UShortArray); + +TYPE_NAME_ALIAS(osg::TemplateIndexArray< GLuint COMMA osg::Array::UIntArrayType COMMA 1 COMMA GL_UNSIGNED_INT >, osg::UIntArray); + +TYPE_NAME_ALIAS(osg::TemplateArray< GLfloat COMMA osg::Array::FloatArrayType COMMA 1 COMMA GL_FLOAT >, osg::FloatArray); + +TYPE_NAME_ALIAS(osg::TemplateArray< osg::UByte4 COMMA osg::Array::UByte4ArrayType COMMA 4 COMMA GL_UNSIGNED_BYTE >, osg::UByte4Array); + +TYPE_NAME_ALIAS(osg::TemplateArray< osg::Vec2 COMMA osg::Array::Vec2ArrayType COMMA 2 COMMA GL_FLOAT >, osg::Vec2Array); + +TYPE_NAME_ALIAS(osg::TemplateArray< osg::Vec3 COMMA osg::Array::Vec3ArrayType COMMA 3 COMMA GL_FLOAT >, osg::Vec3Array); + +TYPE_NAME_ALIAS(osg::TemplateArray< osg::Vec4 COMMA osg::Array::Vec4ArrayType COMMA 4 COMMA GL_FLOAT >, osg::Vec4Array); + +BEGIN_OBJECT_REFLECTOR(osg::TemplateArray< GLfloat COMMA osg::Array::FloatArrayType COMMA 1 COMMA GL_FLOAT >) + BaseType(osg::Array); + BaseType(std::vector); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TemplateArray< GLfloat COMMA osg::Array::FloatArrayType COMMA 1 COMMA GL_FLOAT > &, ta, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, unsigned int, no); + Constructor2(IN, unsigned int, no, IN, GLfloat *, ptr); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(void, accept, IN, osg::ArrayVisitor &, av); + Method1(void, accept, IN, osg::ConstArrayVisitor &, av); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, vv); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, vv); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TemplateArray< osg::UByte4 COMMA osg::Array::UByte4ArrayType COMMA 4 COMMA GL_UNSIGNED_BYTE >) + BaseType(osg::Array); + BaseType(std::vector); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TemplateArray< osg::UByte4 COMMA osg::Array::UByte4ArrayType COMMA 4 COMMA GL_UNSIGNED_BYTE > &, ta, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, unsigned int, no); + Constructor2(IN, unsigned int, no, IN, osg::UByte4 *, ptr); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(void, accept, IN, osg::ArrayVisitor &, av); + Method1(void, accept, IN, osg::ConstArrayVisitor &, av); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, vv); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, vv); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TemplateArray< osg::Vec2 COMMA osg::Array::Vec2ArrayType COMMA 2 COMMA GL_FLOAT >) + BaseType(osg::Array); + BaseType(std::vector); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TemplateArray< osg::Vec2 COMMA osg::Array::Vec2ArrayType COMMA 2 COMMA GL_FLOAT > &, ta, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, unsigned int, no); + Constructor2(IN, unsigned int, no, IN, osg::Vec2 *, ptr); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(void, accept, IN, osg::ArrayVisitor &, av); + Method1(void, accept, IN, osg::ConstArrayVisitor &, av); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, vv); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, vv); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TemplateArray< osg::Vec3 COMMA osg::Array::Vec3ArrayType COMMA 3 COMMA GL_FLOAT >) + BaseType(osg::Array); + BaseType(std::vector); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TemplateArray< osg::Vec3 COMMA osg::Array::Vec3ArrayType COMMA 3 COMMA GL_FLOAT > &, ta, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, unsigned int, no); + Constructor2(IN, unsigned int, no, IN, osg::Vec3 *, ptr); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(void, accept, IN, osg::ArrayVisitor &, av); + Method1(void, accept, IN, osg::ConstArrayVisitor &, av); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, vv); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, vv); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TemplateArray< osg::Vec4 COMMA osg::Array::Vec4ArrayType COMMA 4 COMMA GL_FLOAT >) + BaseType(osg::Array); + BaseType(std::vector); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TemplateArray< osg::Vec4 COMMA osg::Array::Vec4ArrayType COMMA 4 COMMA GL_FLOAT > &, ta, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, unsigned int, no); + Constructor2(IN, unsigned int, no, IN, osg::Vec4 *, ptr); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(void, accept, IN, osg::ArrayVisitor &, av); + Method1(void, accept, IN, osg::ConstArrayVisitor &, av); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, vv); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, vv); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TemplateIndexArray< GLbyte COMMA osg::Array::ByteArrayType COMMA 1 COMMA GL_BYTE >) + BaseType(osg::IndexArray); + BaseType(std::vector); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TemplateIndexArray< GLbyte COMMA osg::Array::ByteArrayType COMMA 1 COMMA GL_BYTE > &, ta, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, unsigned int, no); + Constructor2(IN, unsigned int, no, IN, GLbyte *, ptr); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(void, accept, IN, osg::ArrayVisitor &, av); + Method1(void, accept, IN, osg::ConstArrayVisitor &, av); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, vv); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, vv); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + Method1(unsigned int, index, IN, unsigned int, pos); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TemplateIndexArray< GLint COMMA osg::Array::IntArrayType COMMA 1 COMMA GL_INT >) + BaseType(osg::IndexArray); + BaseType(std::vector); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TemplateIndexArray< GLint COMMA osg::Array::IntArrayType COMMA 1 COMMA GL_INT > &, ta, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, unsigned int, no); + Constructor2(IN, unsigned int, no, IN, GLint *, ptr); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(void, accept, IN, osg::ArrayVisitor &, av); + Method1(void, accept, IN, osg::ConstArrayVisitor &, av); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, vv); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, vv); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + Method1(unsigned int, index, IN, unsigned int, pos); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TemplateIndexArray< GLshort COMMA osg::Array::ShortArrayType COMMA 1 COMMA GL_SHORT >) + BaseType(osg::IndexArray); + BaseType(std::vector); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TemplateIndexArray< GLshort COMMA osg::Array::ShortArrayType COMMA 1 COMMA GL_SHORT > &, ta, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, unsigned int, no); + Constructor2(IN, unsigned int, no, IN, GLshort *, ptr); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(void, accept, IN, osg::ArrayVisitor &, av); + Method1(void, accept, IN, osg::ConstArrayVisitor &, av); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, vv); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, vv); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + Method1(unsigned int, index, IN, unsigned int, pos); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TemplateIndexArray< GLubyte COMMA osg::Array::UByteArrayType COMMA 1 COMMA GL_UNSIGNED_BYTE >) + BaseType(osg::IndexArray); + BaseType(std::vector); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TemplateIndexArray< GLubyte COMMA osg::Array::UByteArrayType COMMA 1 COMMA GL_UNSIGNED_BYTE > &, ta, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, unsigned int, no); + Constructor2(IN, unsigned int, no, IN, GLubyte *, ptr); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(void, accept, IN, osg::ArrayVisitor &, av); + Method1(void, accept, IN, osg::ConstArrayVisitor &, av); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, vv); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, vv); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + Method1(unsigned int, index, IN, unsigned int, pos); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TemplateIndexArray< GLuint COMMA osg::Array::UIntArrayType COMMA 1 COMMA GL_UNSIGNED_INT >) + BaseType(osg::IndexArray); + BaseType(std::vector); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TemplateIndexArray< GLuint COMMA osg::Array::UIntArrayType COMMA 1 COMMA GL_UNSIGNED_INT > &, ta, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, unsigned int, no); + Constructor2(IN, unsigned int, no, IN, GLuint *, ptr); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(void, accept, IN, osg::ArrayVisitor &, av); + Method1(void, accept, IN, osg::ConstArrayVisitor &, av); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, vv); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, vv); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + Method1(unsigned int, index, IN, unsigned int, pos); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TemplateIndexArray< GLushort COMMA osg::Array::UShortArrayType COMMA 1 COMMA GL_UNSIGNED_SHORT >) + BaseType(osg::IndexArray); + BaseType(std::vector); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TemplateIndexArray< GLushort COMMA osg::Array::UShortArrayType COMMA 1 COMMA GL_UNSIGNED_SHORT > &, ta, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, unsigned int, no); + Constructor2(IN, unsigned int, no, IN, GLushort *, ptr); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(void, accept, IN, osg::ArrayVisitor &, av); + Method1(void, accept, IN, osg::ConstArrayVisitor &, av); + Method2(void, accept, IN, unsigned int, index, IN, osg::ValueVisitor &, vv); + Method2(void, accept, IN, unsigned int, index, IN, osg::ConstValueVisitor &, vv); + Method2(int, compare, IN, unsigned int, lhs, IN, unsigned int, rhs); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(unsigned int, getNumElements); + Method1(unsigned int, index, IN, unsigned int, pos); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + + + STD_VECTOR_REFLECTOR(std::vector); + STD_VECTOR_REFLECTOR(std::vector); + STD_VECTOR_REFLECTOR(std::vector); + STD_VECTOR_REFLECTOR(std::vector); + STD_VECTOR_REFLECTOR(std::vector); + STD_VECTOR_REFLECTOR(std::vector); + STD_VECTOR_REFLECTOR(std::vector); + STD_VECTOR_REFLECTOR(std::vector); + STD_VECTOR_REFLECTOR(std::vector); + STD_VECTOR_REFLECTOR(std::vector); + diff --git a/src/osgWrappers/osg/AutoTransform.cpp b/src/osgWrappers/osg/AutoTransform.cpp new file mode 100644 index 000000000..8c19e58bf --- /dev/null +++ b/src/osgWrappers/osg/AutoTransform.cpp @@ -0,0 +1,63 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::AutoTransform::AutoRotateMode) + EnumLabel(osg::AutoTransform::NO_ROTATION); + EnumLabel(osg::AutoTransform::ROTATE_TO_SCREEN); + EnumLabel(osg::AutoTransform::ROTATE_TO_CAMERA); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::AutoTransform) + BaseType(osg::Transform); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::AutoTransform &, pat, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method0(osg::AutoTransform *, asAutoTransform); + Method0(const osg::AutoTransform *, asAutoTransform); + Method1(void, setPosition, IN, const osg::Vec3 &, pos); + Method0(const osg::Vec3 &, getPosition); + Method1(void, setRotation, IN, const osg::Quat &, quat); + Method0(const osg::Quat &, getRotation); + Method1(void, setScale, IN, float, scale); + Method1(void, setScale, IN, const osg::Vec3 &, scale); + Method0(const osg::Vec3 &, getScale); + Method1(void, setPivotPoint, IN, const osg::Vec3 &, pivot); + Method0(const osg::Vec3 &, getPivotPoint); + Method1(void, setAutoUpdateEyeMovementTolerance, IN, float, tolerance); + Method0(float, getAutoUpdateEyeMovementTolerance); + Method1(void, setAutoRotateMode, IN, osg::AutoTransform::AutoRotateMode, mode); + Method0(osg::AutoTransform::AutoRotateMode, getAutoRotateMode); + Method1(void, setAutoScaleToScreen, IN, bool, autoScaleToScreen); + Method0(bool, getAutoScaleToScreen); + Method2(bool, computeLocalToWorldMatrix, IN, osg::Matrix &, matrix, IN, osg::NodeVisitor *, nv); + Method2(bool, computeWorldToLocalMatrix, IN, osg::Matrix &, matrix, IN, osg::NodeVisitor *, nv); + Property(osg::AutoTransform::AutoRotateMode, AutoRotateMode); + Property(bool, AutoScaleToScreen); + Property(float, AutoUpdateEyeMovementTolerance); + Property(const osg::Vec3 &, PivotPoint); + Property(const osg::Vec3 &, Position); + Property(const osg::Quat &, Rotation); + Property(const osg::Vec3 &, Scale); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Billboard.cpp b/src/osgWrappers/osg/Billboard.cpp new file mode 100644 index 000000000..d0c8cc49c --- /dev/null +++ b/src/osgWrappers/osg/Billboard.cpp @@ -0,0 +1,61 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< osg::Vec3 >, osg::Billboard::PositionList); + +BEGIN_ENUM_REFLECTOR(osg::Billboard::Mode) + EnumLabel(osg::Billboard::POINT_ROT_EYE); + EnumLabel(osg::Billboard::POINT_ROT_WORLD); + EnumLabel(osg::Billboard::AXIAL_ROT); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Billboard) + BaseType(osg::Geode); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Billboard &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, setMode, IN, osg::Billboard::Mode, mode); + Method0(osg::Billboard::Mode, getMode); + Method1(void, setAxis, IN, const osg::Vec3 &, axis); + Method0(const osg::Vec3 &, getAxis); + Method1(void, setNormal, IN, const osg::Vec3 &, normal); + Method0(const osg::Vec3 &, getNormal); + Method2(void, setPosition, IN, unsigned int, i, IN, const osg::Vec3 &, pos); + Method1(const osg::Vec3 &, getPosition, IN, unsigned int, i); + Method1(void, setPositionList, IN, osg::Billboard::PositionList &, pl); + Method0(osg::Billboard::PositionList &, getPositionList); + Method0(const osg::Billboard::PositionList &, getPositionList); + Method1(bool, addDrawable, IN, osg::Drawable *, gset); + Method2(bool, addDrawable, IN, osg::Drawable *, gset, IN, const osg::Vec3 &, pos); + Method1(bool, removeDrawable, IN, osg::Drawable *, gset); + Method3(bool, computeMatrix, IN, osg::Matrix &, modelview, IN, const osg::Vec3 &, eye_local, IN, const osg::Vec3 &, pos_local); + Property(const osg::Vec3 &, Axis); + Property(osg::Billboard::Mode, Mode); + Property(const osg::Vec3 &, Normal); + IndexedProperty1(const osg::Vec3 &, Position, unsigned int, i); + Property(osg::Billboard::PositionList &, PositionList); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< osg::Vec3 >); + diff --git a/src/osgWrappers/osg/BlendColor.cpp b/src/osgWrappers/osg/BlendColor.cpp new file mode 100644 index 000000000..dcd29fa51 --- /dev/null +++ b/src/osgWrappers/osg/BlendColor.cpp @@ -0,0 +1,51 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::BlendColor) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::BlendColor &, trans, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setConstantColor, IN, const osg::Vec4 &, color); + Method0(osg::Vec4, getConstantColor); + Method1(void, apply, IN, osg::State &, state); + ReadOnlyProperty(osg::Vec4, ConstantColor); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::BlendColor::Extensions) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::BlendColor::Extensions &, rhs); + Method1(void, lowestCommonDenominator, IN, const osg::BlendColor::Extensions &, rhs); + Method0(void, setupGLExtenions); + Method1(void, setBlendColorSupported, IN, bool, flag); + Method0(bool, isBlendColorSupported); + Method1(void, setBlendColorProc, IN, void *, ptr); + Method4(void, glBlendColor, IN, GLclampf, red, IN, GLclampf, green, IN, GLclampf, blue, IN, GLclampf, alpha); + WriteOnlyProperty(void *, BlendColorProc); + WriteOnlyProperty(bool, BlendColorSupported); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/BlendEquation.cpp b/src/osgWrappers/osg/BlendEquation.cpp new file mode 100644 index 000000000..511f7f860 --- /dev/null +++ b/src/osgWrappers/osg/BlendEquation.cpp @@ -0,0 +1,62 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::BlendEquation::Equation) + EnumLabel(osg::BlendEquation::RGBA_MIN); + EnumLabel(osg::BlendEquation::RGBA_MAX); + EnumLabel(osg::BlendEquation::ALPHA_MIN); + EnumLabel(osg::BlendEquation::ALPHA_MAX); + EnumLabel(osg::BlendEquation::LOGIC_OP); + EnumLabel(osg::BlendEquation::FUNC_ADD); + EnumLabel(osg::BlendEquation::FUNC_SUBTRACT); + EnumLabel(osg::BlendEquation::FUNC_REVERSE_SUBTRACT); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::BlendEquation) + BaseType(osg::StateAttribute); + Constructor0(); + Constructor1(IN, osg::BlendEquation::Equation, equation); + ConstructorWithDefaults2(IN, const osg::BlendEquation &, trans, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setEquation, IN, osg::BlendEquation::Equation, equation); + Method0(osg::BlendEquation::Equation, getEquation); + Method1(void, apply, IN, osg::State &, state); + Property(osg::BlendEquation::Equation, Equation); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::BlendEquation::Extensions) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::BlendEquation::Extensions &, rhs); + Method1(void, lowestCommonDenominator, IN, const osg::BlendEquation::Extensions &, rhs); + Method0(void, setupGLExtenions); + Method1(void, setBlendEquationSupported, IN, bool, flag); + Method0(bool, isBlendEquationSupported); + Method1(void, setBlendEquationProc, IN, void *, ptr); + Method1(void, glBlendEquation, IN, GLenum, mode); + WriteOnlyProperty(void *, BlendEquationProc); + WriteOnlyProperty(bool, BlendEquationSupported); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/BlendFunc.cpp b/src/osgWrappers/osg/BlendFunc.cpp index 7f7b33c5f..461c97375 100644 --- a/src/osgWrappers/osg/BlendFunc.cpp +++ b/src/osgWrappers/osg/BlendFunc.cpp @@ -1,10 +1,19 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include #include - -using namespace osgIntrospection; +#include +#include +#include +#include BEGIN_ENUM_REFLECTOR(osg::BlendFunc::BlendFuncMode) EnumLabel(osg::BlendFunc::DST_ALPHA); @@ -25,13 +34,26 @@ BEGIN_ENUM_REFLECTOR(osg::BlendFunc::BlendFuncMode) END_REFLECTOR BEGIN_OBJECT_REFLECTOR(osg::BlendFunc) - BaseType(osg::StateAttribute) + BaseType(osg::StateAttribute); + Constructor0(); + Constructor2(IN, GLenum, source, IN, GLenum, destination); + ConstructorWithDefaults2(IN, const osg::BlendFunc &, trans, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); Method2(void, setFunction, IN, GLenum, source, IN, GLenum, destination); - - Property(GLenum, Source); - Attribute(PropertyTypeAttribute(typeof(osg::BlendFunc::BlendFuncMode))); - + Method1(void, setSource, IN, GLenum, source); + Method0(GLenum, getSource); + Method1(void, setDestination, IN, GLenum, destination); + Method0(GLenum, getDestination); + Method1(void, apply, IN, osg::State &, state); Property(GLenum, Destination); - Attribute(PropertyTypeAttribute(typeof(osg::BlendFunc::BlendFuncMode))); - + Property(GLenum, Source); + ReadOnlyProperty(osg::StateAttribute::Type, Type); END_REFLECTOR + diff --git a/src/osgWrappers/osg/BoundingBox.cpp b/src/osgWrappers/osg/BoundingBox.cpp new file mode 100644 index 000000000..d98c1d07b --- /dev/null +++ b/src/osgWrappers/osg/BoundingBox.cpp @@ -0,0 +1,48 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include + +BEGIN_VALUE_REFLECTOR(osg::BoundingBox) + Constructor0(); + Constructor6(IN, float, xmin, IN, float, ymin, IN, float, zmin, IN, float, xmax, IN, float, ymax, IN, float, zmax); + Constructor2(IN, const osg::Vec3 &, min, IN, const osg::Vec3 &, max); + Method0(void, init); + Method0(bool, valid); + Method6(void, set, IN, float, xmin, IN, float, ymin, IN, float, zmin, IN, float, xmax, IN, float, ymax, IN, float, zmax); + Method2(void, set, IN, const osg::Vec3 &, min, IN, const osg::Vec3 &, max); + Method0(float &, xMin); + Method0(float, xMin); + Method0(float &, yMin); + Method0(float, yMin); + Method0(float &, zMin); + Method0(float, zMin); + Method0(float &, xMax); + Method0(float, xMax); + Method0(float &, yMax); + Method0(float, yMax); + Method0(float &, zMax); + Method0(float, zMax); + Method0(const osg::Vec3, center); + Method0(float, radius); + Method0(float, radius2); + Method1(const osg::Vec3, corner, IN, unsigned int, pos); + Method1(void, expandBy, IN, const osg::Vec3 &, v); + Method3(void, expandBy, IN, float, x, IN, float, y, IN, float, z); + Method1(void, expandBy, IN, const osg::BoundingBox &, bb); + Method1(void, expandBy, IN, const osg::BoundingSphere &, sh); + Method1(osg::BoundingBox, intersect, IN, const osg::BoundingBox &, bb); + Method1(bool, intersects, IN, const osg::BoundingBox &, bb); + Method1(bool, contains, IN, const osg::Vec3 &, v); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/BoundingSphere.cpp b/src/osgWrappers/osg/BoundingSphere.cpp new file mode 100644 index 000000000..5ae80216f --- /dev/null +++ b/src/osgWrappers/osg/BoundingSphere.cpp @@ -0,0 +1,36 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include + +BEGIN_VALUE_REFLECTOR(osg::BoundingSphere) + Constructor0(); + Constructor2(IN, const osg::Vec3 &, center, IN, float, radius); + Method0(void, init); + Method0(bool, valid); + Method2(void, set, IN, const osg::Vec3 &, center, IN, float, radius); + Method0(osg::Vec3 &, center); + Method0(const osg::Vec3 &, center); + Method0(float &, radius); + Method0(float, radius); + Method0(float, radius2); + Method1(void, expandBy, IN, const osg::Vec3 &, v); + Method1(void, expandRadiusBy, IN, const osg::Vec3 &, v); + Method1(void, expandBy, IN, const osg::BoundingSphere &, sh); + Method1(void, expandRadiusBy, IN, const osg::BoundingSphere &, sh); + Method1(void, expandBy, IN, const osg::BoundingBox &, bb); + Method1(void, expandRadiusBy, IN, const osg::BoundingBox &, bb); + Method1(bool, contains, IN, const osg::Vec3 &, v); + Method1(bool, intersects, IN, const osg::BoundingSphere &, bs); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/BufferObject.cpp b/src/osgWrappers/osg/BufferObject.cpp new file mode 100644 index 000000000..f980e4e54 --- /dev/null +++ b/src/osgWrappers/osg/BufferObject.cpp @@ -0,0 +1,81 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::BufferObject) + BaseType(osg::Object); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::BufferObject &, bo, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(bool, isBufferObjectSupported, IN, unsigned int, contextID); + Method1(GLuint &, buffer, IN, unsigned int, contextID); + Method1(void, bindBuffer, IN, unsigned int, contextID); + Method1(void, unbindBuffer, IN, unsigned int, contextID); + Method1(bool, needsCompile, IN, unsigned int, contextID); + Method1(void, compileBuffer, IN, osg::State &, state); + Method1(void, releaseBuffer, IN, osg::State *, state); + Method3(void, flushDeletedBufferObjects, IN, unsigned int, contextID, IN, double, x, IN, double &, availableTime); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::BufferObject::BufferEntry) + Constructor0(); + Constructor1(IN, const osg::BufferObject::BufferEntry &, be); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::BufferObject::Extensions) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::BufferObject::Extensions &, rhs); + Method1(void, lowestCommonDenominator, IN, const osg::BufferObject::Extensions &, rhs); + Method0(void, setupGLExtenions); + Method0(bool, isBufferObjectSupported); + Method2(void, glGenBuffers, IN, GLsizei, n, IN, GLuint *, buffers); + Method2(void, glBindBuffer, IN, GLenum, target, IN, GLuint, buffer); + Method4(void, glBufferData, IN, GLenum, target, IN, GLsizeiptrARB, size, IN, const GLvoid *, data, IN, GLenum, usage); + Method4(void, glBufferSubData, IN, GLenum, target, IN, GLintptrARB, offset, IN, GLsizeiptrARB, size, IN, const GLvoid *, data); + Method2(void, glDeleteBuffers, IN, GLsizei, n, IN, const GLuint *, buffers); + Method1(GLboolean, glIsBuffer, IN, GLuint, buffer); + Method4(void, glGetBufferSubData, IN, GLenum, target, IN, GLintptrARB, offset, IN, GLsizeiptrARB, size, IN, GLvoid *, data); + Method2(GLvoid *, glMapBuffer, IN, GLenum, target, IN, GLenum, access); + Method1(GLboolean, glUnmapBuffer, IN, GLenum, target); + Method3(void, glGetBufferParameteriv, IN, GLenum, target, IN, GLenum, pname, IN, GLint *, params); + Method3(void, glGetBufferPointerv, IN, GLenum, target, IN, GLenum, pname, IN, GLvoid **, params); +END_REFLECTOR + +TYPE_NAME_ALIAS(std::pair< osg::BufferObject::BufferEntry COMMA osg::Image * >, osg::PixelBufferObject::BufferEntryImagePair); + +BEGIN_OBJECT_REFLECTOR(osg::PixelBufferObject) + BaseType(osg::BufferObject); + ConstructorWithDefaults1(IN, osg::Image *, image, 0); + ConstructorWithDefaults2(IN, const osg::PixelBufferObject &, pbo, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, setImage, IN, osg::Image *, image); + Method0(osg::Image *, getImage); + Method0(const osg::Image *, getImage); + Method0(unsigned int, offset); + Method1(bool, needsCompile, IN, unsigned int, contextID); + Method1(void, compileBuffer, IN, osg::State &, state); + Property(osg::Image *, Image); +END_REFLECTOR + +STD_PAIR_REFLECTOR(std::pair< osg::BufferObject::BufferEntry COMMA osg::Image * >); + diff --git a/src/osgWrappers/osg/ClearNode.cpp b/src/osgWrappers/osg/ClearNode.cpp new file mode 100644 index 000000000..ad4ecfa1f --- /dev/null +++ b/src/osgWrappers/osg/ClearNode.cpp @@ -0,0 +1,35 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::ClearNode) + BaseType(osg::Group); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::ClearNode &, es, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, setRequiresClear, IN, bool, requiresClear); + Method0(bool, getRequiresClear); + Method1(void, setClearColor, IN, const osg::Vec4 &, color); + Method0(const osg::Vec4 &, getClearColor); + Property(const osg::Vec4 &, ClearColor); + Property(bool, RequiresClear); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/ClipNode.cpp b/src/osgWrappers/osg/ClipNode.cpp new file mode 100644 index 000000000..f09dca274 --- /dev/null +++ b/src/osgWrappers/osg/ClipNode.cpp @@ -0,0 +1,63 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< osg::ref_ptr< osg::ClipPlane > >, osg::ClipNode::ClipPlaneList); + +BEGIN_OBJECT_REFLECTOR(osg::ClipNode) + BaseType(osg::Group); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::ClipNode &, es, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + MethodWithDefaults2(void, createClipBox, IN, const osg::BoundingBox &, bb, , IN, unsigned int, clipPlaneNumberBase, 0); + Method1(bool, addClipPlane, IN, osg::ClipPlane *, clipplane); + Method1(bool, removeClipPlane, IN, osg::ClipPlane *, clipplane); + Method1(bool, removeClipPlane, IN, unsigned int, pos); + Method0(unsigned int, getNumClipPlanes); + Method1(osg::ClipPlane *, getClipPlane, IN, unsigned int, pos); + Method1(const osg::ClipPlane *, getClipPlane, IN, unsigned int, pos); + Method1(void, getClipPlaneList, IN, const osg::ClipNode::ClipPlaneList &, cpl); + Method0(osg::ClipNode::ClipPlaneList &, getClipPlaneList); + Method0(const osg::ClipNode::ClipPlaneList &, getClipPlaneList); + Method2(void, setStateSetModes, IN, osg::StateSet &, x, IN, osg::StateAttribute::GLModeValue, x); + MethodWithDefaults1(void, setLocalStateSetModes, IN, osg::StateAttribute::GLModeValue, x, osg::StateAttribute::ON); + ArrayProperty_GA(osg::ClipPlane *, ClipPlane, ClipPlanes, unsigned int, bool); + ReadOnlyProperty(osg::ClipNode::ClipPlaneList &, ClipPlaneList); + WriteOnlyProperty(osg::StateAttribute::GLModeValue, LocalStateSetModes); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::ClipPlane >) + Constructor0(); + Constructor1(IN, osg::ClipPlane *, t); + Constructor1(IN, const osg::ref_ptr< osg::ClipPlane > &, rp); + Method0(bool, valid); + Method0(osg::ClipPlane *, get); + Method0(const osg::ClipPlane *, get); + Method0(osg::ClipPlane *, take); + Method0(osg::ClipPlane *, release); + ReadOnlyProperty(osg::ClipPlane *, ); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< osg::ref_ptr< osg::ClipPlane > >); + diff --git a/src/osgWrappers/osg/ClipPlane.cpp b/src/osgWrappers/osg/ClipPlane.cpp new file mode 100644 index 000000000..4a892c955 --- /dev/null +++ b/src/osgWrappers/osg/ClipPlane.cpp @@ -0,0 +1,48 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::ClipPlane) + BaseType(osg::StateAttribute); + Constructor0(); + Constructor2(IN, unsigned int, no, IN, const osg::Vec4d &, plane); + Constructor2(IN, unsigned int, no, IN, const osg::Plane &, plane); + Constructor5(IN, unsigned int, no, IN, double, a, IN, double, b, IN, double, c, IN, double, d); + ConstructorWithDefaults2(IN, const osg::ClipPlane &, cp, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method0(unsigned int, getMember); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setClipPlane, IN, const osg::Plane &, plane); + Method4(void, setClipPlane, IN, double, a, IN, double, b, IN, double, c, IN, double, d); + Method1(void, setClipPlane, IN, const osg::Vec4d &, plane); + Method0(const osg::Vec4d &, getClipPlane); + Method1(void, setClipPlaneNum, IN, unsigned int, num); + Method0(unsigned int, getClipPlaneNum); + Method1(void, apply, IN, osg::State &, state); + Property(const osg::Vec4d &, ClipPlane); + Property(unsigned int, ClipPlaneNum); + ReadOnlyProperty(unsigned int, Member); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/ClusterCullingCallback.cpp b/src/osgWrappers/osg/ClusterCullingCallback.cpp new file mode 100644 index 000000000..ca1224c48 --- /dev/null +++ b/src/osgWrappers/osg/ClusterCullingCallback.cpp @@ -0,0 +1,51 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::ClusterCullingCallback) + BaseType(osg::Drawable::CullCallback); + BaseType(osg::NodeCallback); + Constructor0(); + Constructor2(IN, const osg::ClusterCullingCallback &, ccc, IN, const osg::CopyOp &, copyop); + Constructor3(IN, const osg::Vec3 &, controlPoint, IN, const osg::Vec3 &, normal, IN, float, deviation); + Constructor1(IN, const osg::Drawable *, drawable); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, computeFrom, IN, const osg::Drawable *, drawable); + Method1(void, transform, IN, const osg::Matrixd &, matrix); + Method4(void, set, IN, const osg::Vec3 &, controlPoint, IN, const osg::Vec3 &, normal, IN, float, deviation, IN, float, radius); + Method1(void, setControlPoint, IN, const osg::Vec3 &, controlPoint); + Method0(const osg::Vec3 &, getControlPoint); + Method1(void, setNormal, IN, const osg::Vec3 &, normal); + Method0(const osg::Vec3 &, getNormal); + Method1(void, setRadius, IN, float, radius); + Method0(float, getRadius); + Method1(void, setDeviation, IN, float, deviation); + Method0(float, getDeviation); + Method3(bool, cull, IN, osg::NodeVisitor *, x, IN, osg::Drawable *, x, IN, osg::State *, x); + Property(const osg::Vec3 &, ControlPoint); + Property(float, Deviation); + Property(const osg::Vec3 &, Normal); + Property(float, Radius); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/CollectOccludersVisitor.cpp b/src/osgWrappers/osg/CollectOccludersVisitor.cpp new file mode 100644 index 000000000..6cd643c9e --- /dev/null +++ b/src/osgWrappers/osg/CollectOccludersVisitor.cpp @@ -0,0 +1,55 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::set< osg::ShadowVolumeOccluder >, osg::CollectOccludersVisitor::ShadowVolumeOccluderSet); + +BEGIN_VALUE_REFLECTOR(osg::CollectOccludersVisitor) + BaseType(osg::NodeVisitor); + BaseType(osg::CullStack); + Constructor0(); + Method0(osg::CollectOccludersVisitor *, cloneType); + Method0(void, reset); + Method2(float, getDistanceToEyePoint, IN, const osg::Vec3 &, pos, IN, bool, withLODScale); + Method2(float, getDistanceFromEyePoint, IN, const osg::Vec3 &, pos, IN, bool, withLODScale); + Method1(void, apply, IN, osg::Node &, x); + Method1(void, apply, IN, osg::Transform &, node); + Method1(void, apply, IN, osg::Projection &, node); + Method1(void, apply, IN, osg::Switch &, node); + Method1(void, apply, IN, osg::LOD &, node); + Method1(void, apply, IN, osg::OccluderNode &, node); + Method1(void, setMinimumShadowOccluderVolume, IN, float, vol); + Method0(float, getMinimumShadowOccluderVolume); + Method1(void, setMaximumNumberOfActiveOccluders, IN, unsigned int, num); + Method0(unsigned int, getMaximumNumberOfActiveOccluders); + Method1(void, setCreateDrawablesOnOccludeNodes, IN, bool, flag); + Method0(bool, getCreateDrawablesOnOccludeNodes); + Method1(void, setCollectedOcculderSet, IN, const osg::CollectOccludersVisitor::ShadowVolumeOccluderSet &, svol); + Method0(osg::CollectOccludersVisitor::ShadowVolumeOccluderSet &, getCollectedOccluderSet); + Method0(const osg::CollectOccludersVisitor::ShadowVolumeOccluderSet &, getCollectedOccluderSet); + Method0(void, removeOccludedOccluders); + ReadOnlyProperty(osg::CollectOccludersVisitor::ShadowVolumeOccluderSet &, CollectedOccluderSet); + WriteOnlyProperty(const osg::CollectOccludersVisitor::ShadowVolumeOccluderSet &, CollectedOcculderSet); + Property(bool, CreateDrawablesOnOccludeNodes); + Property(unsigned int, MaximumNumberOfActiveOccluders); + Property(float, MinimumShadowOccluderVolume); +END_REFLECTOR + +STD_SET_REFLECTOR(std::set< osg::ShadowVolumeOccluder >); + diff --git a/src/osgWrappers/osg/ColorMask.cpp b/src/osgWrappers/osg/ColorMask.cpp new file mode 100644 index 000000000..a3a11cfdb --- /dev/null +++ b/src/osgWrappers/osg/ColorMask.cpp @@ -0,0 +1,46 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::ColorMask) + BaseType(osg::StateAttribute); + Constructor0(); + Constructor4(IN, bool, red, IN, bool, green, IN, bool, blue, IN, bool, alpha); + ConstructorWithDefaults2(IN, const osg::ColorMask &, cm, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method4(void, setMask, IN, bool, red, IN, bool, green, IN, bool, blue, IN, bool, alpha); + Method1(void, getRedMask, IN, bool, mask); + Method0(bool, getRedMask); + Method1(void, setGreenMask, IN, bool, mask); + Method0(bool, getGreenMask); + Method1(void, setBlueMask, IN, bool, mask); + Method0(bool, getBlueMask); + Method1(void, setAlphaMask, IN, bool, mask); + Method0(bool, getAlphaMask); + Method1(void, apply, IN, osg::State &, state); + Property(bool, AlphaMask); + Property(bool, BlueMask); + Property(bool, GreenMask); + ReadOnlyProperty(bool, RedMask); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/ColorMatrix.cpp b/src/osgWrappers/osg/ColorMatrix.cpp new file mode 100644 index 000000000..44c46819c --- /dev/null +++ b/src/osgWrappers/osg/ColorMatrix.cpp @@ -0,0 +1,37 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::ColorMatrix) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::ColorMatrix &, cm, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(void, setMatrix, IN, const osg::Matrix &, matrix); + Method0(osg::Matrix &, getMatrix); + Method0(const osg::Matrix &, getMatrix); + Method1(void, apply, IN, osg::State &, state); + Property(const osg::Matrix &, Matrix); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/ConvexPlanarOccluder.cpp b/src/osgWrappers/osg/ConvexPlanarOccluder.cpp new file mode 100644 index 000000000..5cf3834a9 --- /dev/null +++ b/src/osgWrappers/osg/ConvexPlanarOccluder.cpp @@ -0,0 +1,40 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< osg::ConvexPlanarPolygon >, osg::ConvexPlanarOccluder::HoleList); + +BEGIN_OBJECT_REFLECTOR(osg::ConvexPlanarOccluder) + BaseType(osg::Object); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::ConvexPlanarOccluder &, cpo, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, setOccluder, IN, const osg::ConvexPlanarPolygon &, cpp); + Method0(osg::ConvexPlanarPolygon &, getOccluder); + Method0(const osg::ConvexPlanarPolygon &, getOccluder); + Method1(void, addHole, IN, const osg::ConvexPlanarPolygon &, cpp); + Method1(void, setHoleList, IN, const osg::ConvexPlanarOccluder::HoleList &, holeList); + Method0(osg::ConvexPlanarOccluder::HoleList &, getHoleList); + Method0(const osg::ConvexPlanarOccluder::HoleList &, getHoleList); + Property(const osg::ConvexPlanarOccluder::HoleList &, HoleList); + Property(const osg::ConvexPlanarPolygon &, Occluder); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< osg::ConvexPlanarPolygon >); + diff --git a/src/osgWrappers/osg/ConvexPlanarPolygon.cpp b/src/osgWrappers/osg/ConvexPlanarPolygon.cpp new file mode 100644 index 000000000..6d628c941 --- /dev/null +++ b/src/osgWrappers/osg/ConvexPlanarPolygon.cpp @@ -0,0 +1,25 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include + +TYPE_NAME_ALIAS(std::vector< osg::Vec3 >, osg::ConvexPlanarPolygon::VertexList); + +BEGIN_VALUE_REFLECTOR(osg::ConvexPlanarPolygon) + Constructor0(); + Method1(void, add, IN, const osg::Vec3 &, v); + Method1(void, setVertexList, IN, const osg::ConvexPlanarPolygon::VertexList &, vertexList); + Method0(osg::ConvexPlanarPolygon::VertexList &, getVertexList); + Method0(const osg::ConvexPlanarPolygon::VertexList &, getVertexList); + Property(const osg::ConvexPlanarPolygon::VertexList &, VertexList); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/CoordinateSystemNode.cpp b/src/osgWrappers/osg/CoordinateSystemNode.cpp new file mode 100644 index 000000000..71553e38e --- /dev/null +++ b/src/osgWrappers/osg/CoordinateSystemNode.cpp @@ -0,0 +1,69 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::CoordinateSystemNode) + BaseType(osg::Group); + Constructor0(); + Constructor2(IN, const std::string &, format, IN, const std::string &, cs); + ConstructorWithDefaults2(IN, const osg::CoordinateSystemNode &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, set, IN, const osg::CoordinateSystemNode &, csn); + Method1(void, setFormat, IN, const std::string &, format); + Method0(const std::string &, getFormat); + Method1(void, setCoordinateSystem, IN, const std::string &, cs); + Method0(const std::string &, getCoordinateSystem); + Method1(void, setEllipsoidModel, IN, osg::EllipsoidModel *, ellipsode); + Method0(osg::EllipsoidModel *, getEllipsoidModel); + Method0(const osg::EllipsoidModel *, getEllipsoidModel); + Method1(osg::CoordinateFrame, computeLocalCoordinateFrame, IN, const osg::Vec3d &, position); + Method1(osg::Vec3d, computeLocalUpVector, IN, const osg::Vec3d &, position); + WriteOnlyProperty(const osg::CoordinateSystemNode &, ); + Property(const std::string &, CoordinateSystem); + Property(osg::EllipsoidModel *, EllipsoidModel); + Property(const std::string &, Format); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::EllipsoidModel) + BaseType(osg::Object); + ConstructorWithDefaults2(IN, double, radiusEquator, osg::WGS_84_RADIUS_EQUATOR, IN, double, radiusPolar, osg::WGS_84_RADIUS_POLAR); + ConstructorWithDefaults2(IN, const osg::EllipsoidModel &, et, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, setRadiusEquator, IN, double, radius); + Method0(double, getRadiusEquator); + Method1(void, setRadiusPolar, IN, double, radius); + Method0(double, getRadiusPolar); + Method6(void, convertLatLongHeightToXYZ, IN, double, latitude, IN, double, longitude, IN, double, height, IN, double &, X, IN, double &, Y, IN, double &, Z); + Method6(void, convertXYZToLatLongHeight, IN, double, X, IN, double, Y, IN, double, Z, IN, double &, latitude, IN, double &, longitude, IN, double &, height); + Method4(void, computeLocalToWorldTransformFromLatLongHeight, IN, double, latitude, IN, double, longitude, IN, double, height, IN, osg::Matrixd &, localToWorld); + Method4(void, computeLocalToWorldTransformFromXYZ, IN, double, X, IN, double, Y, IN, double, Z, IN, osg::Matrixd &, localToWorld); + Method3(osg::Vec3d, computeLocalUpVector, IN, double, X, IN, double, Y, IN, double, Z); + Property(double, RadiusEquator); + Property(double, RadiusPolar); +END_REFLECTOR + +TYPE_NAME_ALIAS(osg::Matrixd, osg::CoordinateFrame); + diff --git a/src/osgWrappers/osg/CopyOp.cpp b/src/osgWrappers/osg/CopyOp.cpp new file mode 100644 index 000000000..98442ea8f --- /dev/null +++ b/src/osgWrappers/osg/CopyOp.cpp @@ -0,0 +1,45 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(unsigned int, osg::CopyOp::CopyFlags); + +BEGIN_ENUM_REFLECTOR(osg::CopyOp::Options) + EnumLabel(osg::CopyOp::SHALLOW_COPY); + EnumLabel(osg::CopyOp::DEEP_COPY_OBJECTS); + EnumLabel(osg::CopyOp::DEEP_COPY_NODES); + EnumLabel(osg::CopyOp::DEEP_COPY_DRAWABLES); + EnumLabel(osg::CopyOp::DEEP_COPY_STATESETS); + EnumLabel(osg::CopyOp::DEEP_COPY_STATEATTRIBUTES); + EnumLabel(osg::CopyOp::DEEP_COPY_TEXTURES); + EnumLabel(osg::CopyOp::DEEP_COPY_IMAGES); + EnumLabel(osg::CopyOp::DEEP_COPY_ARRAYS); + EnumLabel(osg::CopyOp::DEEP_COPY_PRIMITIVES); + EnumLabel(osg::CopyOp::DEEP_COPY_SHAPES); + EnumLabel(osg::CopyOp::DEEP_COPY_ALL); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::CopyOp) + ConstructorWithDefaults1(IN, osg::CopyOp::CopyFlags, flags, osg::CopyOp::SHALLOW_COPY); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/CullFace.cpp b/src/osgWrappers/osg/CullFace.cpp new file mode 100644 index 000000000..73772eb43 --- /dev/null +++ b/src/osgWrappers/osg/CullFace.cpp @@ -0,0 +1,42 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::CullFace::Mode) + EnumLabel(osg::CullFace::FRONT); + EnumLabel(osg::CullFace::BACK); + EnumLabel(osg::CullFace::FRONT_AND_BACK); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::CullFace) + BaseType(osg::StateAttribute); + ConstructorWithDefaults1(IN, osg::CullFace::Mode, mode, osg::CullFace::BACK); + ConstructorWithDefaults2(IN, const osg::CullFace &, cf, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setMode, IN, osg::CullFace::Mode, mode); + Method0(osg::CullFace::Mode, getMode); + Method1(void, apply, IN, osg::State &, state); + Property(osg::CullFace::Mode, Mode); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/CullSettings.cpp b/src/osgWrappers/osg/CullSettings.cpp new file mode 100644 index 000000000..a640e6e4a --- /dev/null +++ b/src/osgWrappers/osg/CullSettings.cpp @@ -0,0 +1,119 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(unsigned int, osg::CullSettings::CullingMode); + +BEGIN_ENUM_REFLECTOR(osg::CullSettings::VariablesMask) + EnumLabel(osg::CullSettings::COMPUTE_NEAR_FAR_MODE); + EnumLabel(osg::CullSettings::CULLING_MODE); + EnumLabel(osg::CullSettings::LOD_SCALE); + EnumLabel(osg::CullSettings::SMALL_FEATURE_CULLING_PIXEL_SIZE); + EnumLabel(osg::CullSettings::CLAMP_PROJECTION_MATRIX_CALLBACK); + EnumLabel(osg::CullSettings::NEAR_FAR_RATIO); + EnumLabel(osg::CullSettings::IMPOSTOR_ACTIVE); + EnumLabel(osg::CullSettings::DEPTH_SORT_IMPOSTOR_SPRITES); + EnumLabel(osg::CullSettings::IMPOSTOR_PIXEL_ERROR_THRESHOLD); + EnumLabel(osg::CullSettings::NUM_FRAMES_TO_KEEP_IMPOSTORS_SPRITES); + EnumLabel(osg::CullSettings::CULL_MASK); + EnumLabel(osg::CullSettings::CULL_MASK_LEFT); + EnumLabel(osg::CullSettings::CULL_MASK_RIGHT); + EnumLabel(osg::CullSettings::NO_VARIABLES); + EnumLabel(osg::CullSettings::ALL_VARIABLES); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::CullSettings::ComputeNearFarMode) + EnumLabel(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR); + EnumLabel(osg::CullSettings::COMPUTE_NEAR_FAR_USING_BOUNDING_VOLUMES); + EnumLabel(osg::CullSettings::COMPUTE_NEAR_FAR_USING_PRIMITIVES); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::CullSettings::CullingModeValues) + EnumLabel(osg::CullSettings::NO_CULLING); + EnumLabel(osg::CullSettings::VIEW_FRUSTUM_SIDES_CULLING); + EnumLabel(osg::CullSettings::NEAR_PLANE_CULLING); + EnumLabel(osg::CullSettings::FAR_PLANE_CULLING); + EnumLabel(osg::CullSettings::VIEW_FRUSTUM_CULLING); + EnumLabel(osg::CullSettings::SMALL_FEATURE_CULLING); + EnumLabel(osg::CullSettings::SHADOW_OCCLUSION_CULLING); + EnumLabel(osg::CullSettings::CLUSTER_CULLING); + EnumLabel(osg::CullSettings::DEFAULT_CULLING); + EnumLabel(osg::CullSettings::ENABLE_ALL_CULLING); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::CullSettings) + Constructor0(); + Constructor1(IN, osg::ArgumentParser &, arguments); + Constructor1(IN, const osg::CullSettings &, cs); + Method0(void, setDefaults); + Method1(void, setInheritanceMask, IN, unsigned int, mask); + Method0(unsigned int, getInheritanceMask); + Method1(void, setCullSettings, IN, const osg::CullSettings &, settings); + Method1(void, inheritCullSettings, IN, const osg::CullSettings &, settings); + Method2(void, inheritCullSettings, IN, const osg::CullSettings &, settings, IN, unsigned int, inheritanceMask); + Method0(void, readEnvironmentalVariables); + Method1(void, readCommandLine, IN, osg::ArgumentParser &, arguments); + Method1(void, setImpostorsActive, IN, bool, active); + Method0(bool, getImpostorsActive); + Method1(void, setImpostorPixelErrorThreshold, IN, float, numPixels); + Method0(float, getImpostorPixelErrorThreshold); + Method1(void, setDepthSortImpostorSprites, IN, bool, doDepthSort); + Method0(bool, getDepthSortImpostorSprites); + Method1(void, setNumberOfFrameToKeepImpostorSprites, IN, int, numFrames); + Method0(int, getNumberOfFrameToKeepImpostorSprites); + Method1(void, setComputeNearFarMode, IN, osg::CullSettings::ComputeNearFarMode, cnfm); + Method0(osg::CullSettings::ComputeNearFarMode, getComputeNearFarMode); + Method1(void, setNearFarRatio, IN, double, ratio); + Method0(double, getNearFarRatio); + Method1(void, setCullingMode, IN, osg::CullSettings::CullingMode, mode); + Method0(osg::CullSettings::CullingMode, getCullingMode); + Method1(void, setCullMask, IN, osg::Node::NodeMask, nm); + Method0(osg::Node::NodeMask, getCullMask); + Method1(void, setCullMaskLeft, IN, osg::Node::NodeMask, nm); + Method0(osg::Node::NodeMask, getCullMaskLeft); + Method1(void, setCullMaskRight, IN, osg::Node::NodeMask, nm); + Method0(osg::Node::NodeMask, getCullMaskRight); + Method1(void, setLODScale, IN, float, bias); + Method0(float, getLODScale); + Method1(void, setSmallFeatureCullingPixelSize, IN, float, value); + Method0(float, getSmallFeatureCullingPixelSize); + Method1(void, setClampProjectionMatrixCallback, IN, osg::CullSettings::ClampProjectionMatrixCallback *, cpmc); + Method0(osg::CullSettings::ClampProjectionMatrixCallback *, getClampProjectionMatrixCallback); + Method0(const osg::CullSettings::ClampProjectionMatrixCallback *, getClampProjectionMatrixCallback); + Property(osg::CullSettings::ClampProjectionMatrixCallback *, ClampProjectionMatrixCallback); + Property(osg::CullSettings::ComputeNearFarMode, ComputeNearFarMode); + Property(osg::Node::NodeMask, CullMask); + Property(osg::Node::NodeMask, CullMaskLeft); + Property(osg::Node::NodeMask, CullMaskRight); + WriteOnlyProperty(const osg::CullSettings &, CullSettings); + Property(osg::CullSettings::CullingMode, CullingMode); + Property(bool, DepthSortImpostorSprites); + Property(float, ImpostorPixelErrorThreshold); + Property(bool, ImpostorsActive); + Property(unsigned int, InheritanceMask); + Property(float, LODScale); + Property(double, NearFarRatio); + Property(int, NumberOfFrameToKeepImpostorSprites); + Property(float, SmallFeatureCullingPixelSize); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::CullSettings::ClampProjectionMatrixCallback) + BaseType(osg::Referenced); + Constructor0(); + Method3(bool, clampProjectionMatrixImplementation, IN, osg::Matrixf &, projection, IN, double &, znear, IN, double &, zfar); + Method3(bool, clampProjectionMatrixImplementation, IN, osg::Matrixd &, projection, IN, double &, znear, IN, double &, zfar); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/CullStack.cpp b/src/osgWrappers/osg/CullStack.cpp new file mode 100644 index 000000000..073c244d8 --- /dev/null +++ b/src/osgWrappers/osg/CullStack.cpp @@ -0,0 +1,29 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< osg::ShadowVolumeOccluder >, osg::CullStack::OccluderList); + +TYPE_NAME_ALIAS(std::vector< osg::CullingSet >, osg::CullStack::CullingStack); + +STD_VECTOR_REFLECTOR(std::vector< osg::CullingSet >); + +STD_VECTOR_REFLECTOR(std::vector< osg::ShadowVolumeOccluder >); + diff --git a/src/osgWrappers/osg/CullingSet.cpp b/src/osgWrappers/osg/CullingSet.cpp new file mode 100644 index 000000000..f49946c4b --- /dev/null +++ b/src/osgWrappers/osg/CullingSet.cpp @@ -0,0 +1,72 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< osg::ShadowVolumeOccluder >, osg::CullingSet::OccluderList); + +TYPE_NAME_ALIAS(unsigned int, osg::CullingSet::Mask); + +BEGIN_ENUM_REFLECTOR(osg::CullingSet::MaskValues) + EnumLabel(osg::CullingSet::NO_CULLING); + EnumLabel(osg::CullingSet::VIEW_FRUSTUM_SIDES_CULLING); + EnumLabel(osg::CullingSet::NEAR_PLANE_CULLING); + EnumLabel(osg::CullingSet::FAR_PLANE_CULLING); + EnumLabel(osg::CullingSet::VIEW_FRUSTUM_CULLING); + EnumLabel(osg::CullingSet::SMALL_FEATURE_CULLING); + EnumLabel(osg::CullingSet::SHADOW_OCCLUSION_CULLING); + EnumLabel(osg::CullingSet::DEFAULT_CULLING); + EnumLabel(osg::CullingSet::ENABLE_ALL_CULLING); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::CullingSet) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::CullingSet &, cs); + Constructor3(IN, const osg::CullingSet &, cs, IN, const osg::Matrix &, matrix, IN, const osg::Vec4 &, pixelSizeVector); + Method1(void, set, IN, const osg::CullingSet &, cs); + Method3(void, set, IN, const osg::CullingSet &, cs, IN, const osg::Matrix &, matrix, IN, const osg::Vec4 &, pixelSizeVector); + Method1(void, setCullingMask, IN, osg::CullingSet::Mask, mask); + Method0(osg::CullingSet::Mask, getCullingMask); + Method1(void, setFrustum, IN, osg::Polytope &, cv); + Method0(osg::Polytope &, getFrustum); + Method0(const osg::Polytope &, getFrustum); + Method1(void, addOccluder, IN, osg::ShadowVolumeOccluder &, cv); + Method1(void, setPixelSizeVector, IN, const osg::Vec4 &, v); + Method0(osg::Vec4 &, getPixelSizeVector); + Method0(const osg::Vec4 &, getPixelSizeVector); + Method1(void, setSmallFeatureCullingPixelSize, IN, float, value); + Method0(float &, getSmallFeatureCullingPixelSize); + Method0(float, getSmallFeatureCullingPixelSize); + Method2(float, pixelSize, IN, const osg::Vec3 &, v, IN, float, radius); + Method1(float, pixelSize, IN, const osg::BoundingSphere &, bs); + Method1(bool, isCulled, IN, const std::vector< osg::Vec3 > &, vertices); + Method1(bool, isCulled, IN, const osg::BoundingBox &, bb); + Method1(bool, isCulled, IN, const osg::BoundingSphere &, bs); + Method0(void, pushCurrentMask); + Method0(void, popCurrentMask); + Method1(void, disableAndPushOccludersCurrentMask, IN, osg::NodePath &, nodePath); + Method1(void, popOccludersCurrentMask, IN, osg::NodePath &, nodePath); + WriteOnlyProperty(const osg::CullingSet &, ); + Property(osg::CullingSet::Mask, CullingMask); + Property(osg::Polytope &, Frustum); + Property(const osg::Vec4 &, PixelSizeVector); + Property(float, SmallFeatureCullingPixelSize); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Depth.cpp b/src/osgWrappers/osg/Depth.cpp new file mode 100644 index 000000000..95f83cf8f --- /dev/null +++ b/src/osgWrappers/osg/Depth.cpp @@ -0,0 +1,57 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::Depth::Function) + EnumLabel(osg::Depth::NEVER); + EnumLabel(osg::Depth::LESS); + EnumLabel(osg::Depth::EQUAL); + EnumLabel(osg::Depth::LEQUAL); + EnumLabel(osg::Depth::GREATER); + EnumLabel(osg::Depth::NOTEQUAL); + EnumLabel(osg::Depth::GEQUAL); + EnumLabel(osg::Depth::ALWAYS); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Depth) + BaseType(osg::StateAttribute); + ConstructorWithDefaults4(IN, osg::Depth::Function, func, osg::Depth::LESS, IN, double, zNear, 0.0, IN, double, zFar, 1.0, IN, bool, writeMask, true); + ConstructorWithDefaults2(IN, const osg::Depth &, dp, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setFunction, IN, osg::Depth::Function, func); + Method0(osg::Depth::Function, getFunction); + Method2(void, setRange, IN, double, zNear, IN, double, zFar); + Method1(void, setZNear, IN, double, zNear); + Method0(double, getZNear); + Method1(void, setZFar, IN, double, zFar); + Method0(double, getZFar); + Method1(void, setWriteMask, IN, bool, mask); + Method0(bool, getWriteMask); + Method1(void, apply, IN, osg::State &, state); + Property(osg::Depth::Function, Function); + ReadOnlyProperty(osg::StateAttribute::Type, Type); + Property(bool, WriteMask); + Property(double, ZFar); + Property(double, ZNear); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/DisplaySettings.cpp b/src/osgWrappers/osg/DisplaySettings.cpp new file mode 100644 index 000000000..aed92f7f4 --- /dev/null +++ b/src/osgWrappers/osg/DisplaySettings.cpp @@ -0,0 +1,111 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::DisplaySettings::DisplayType) + EnumLabel(osg::DisplaySettings::MONITOR); + EnumLabel(osg::DisplaySettings::POWERWALL); + EnumLabel(osg::DisplaySettings::REALITY_CENTER); + EnumLabel(osg::DisplaySettings::HEAD_MOUNTED_DISPLAY); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::DisplaySettings::StereoMode) + EnumLabel(osg::DisplaySettings::QUAD_BUFFER); + EnumLabel(osg::DisplaySettings::ANAGLYPHIC); + EnumLabel(osg::DisplaySettings::HORIZONTAL_SPLIT); + EnumLabel(osg::DisplaySettings::VERTICAL_SPLIT); + EnumLabel(osg::DisplaySettings::LEFT_EYE); + EnumLabel(osg::DisplaySettings::RIGHT_EYE); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::DisplaySettings::SplitStereoHorizontalEyeMapping) + EnumLabel(osg::DisplaySettings::LEFT_EYE_LEFT_VIEWPORT); + EnumLabel(osg::DisplaySettings::LEFT_EYE_RIGHT_VIEWPORT); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::DisplaySettings::SplitStereoVerticalEyeMapping) + EnumLabel(osg::DisplaySettings::LEFT_EYE_TOP_VIEWPORT); + EnumLabel(osg::DisplaySettings::LEFT_EYE_BOTTOM_VIEWPORT); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::DisplaySettings) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, osg::ArgumentParser &, arguments); + Constructor1(IN, const osg::DisplaySettings &, vs); + Method1(void, setDisplaySettings, IN, const osg::DisplaySettings &, vs); + Method1(void, merge, IN, const osg::DisplaySettings &, vs); + Method0(void, setDefaults); + Method0(void, readEnvironmentalVariables); + Method1(void, readCommandLine, IN, osg::ArgumentParser &, arguments); + Method1(void, setDisplayType, IN, osg::DisplaySettings::DisplayType, type); + Method0(osg::DisplaySettings::DisplayType, getDisplayType); + Method1(void, setStereo, IN, bool, on); + Method0(bool, getStereo); + Method1(void, setStereoMode, IN, osg::DisplaySettings::StereoMode, mode); + Method0(osg::DisplaySettings::StereoMode, getStereoMode); + Method1(void, setEyeSeparation, IN, float, eyeSeparation); + Method0(float, getEyeSeparation); + Method1(void, setSplitStereoHorizontalEyeMapping, IN, osg::DisplaySettings::SplitStereoHorizontalEyeMapping, m); + Method0(osg::DisplaySettings::SplitStereoHorizontalEyeMapping, getSplitStereoHorizontalEyeMapping); + Method1(void, setSplitStereoHorizontalSeparation, IN, int, s); + Method0(int, getSplitStereoHorizontalSeparation); + Method1(void, setSplitStereoVerticalEyeMapping, IN, osg::DisplaySettings::SplitStereoVerticalEyeMapping, m); + Method0(osg::DisplaySettings::SplitStereoVerticalEyeMapping, getSplitStereoVerticalEyeMapping); + Method1(void, setSplitStereoVerticalSeparation, IN, int, s); + Method0(int, getSplitStereoVerticalSeparation); + Method1(void, setSplitStereoAutoAjustAspectRatio, IN, bool, flag); + Method0(bool, getSplitStereoAutoAjustAspectRatio); + Method1(void, setScreenWidth, IN, float, width); + Method0(float, getScreenWidth); + Method1(void, setScreenHeight, IN, float, height); + Method0(float, getScreenHeight); + Method1(void, setScreenDistance, IN, float, distance); + Method0(float, getScreenDistance); + Method1(void, setDoubleBuffer, IN, bool, flag); + Method0(bool, getDoubleBuffer); + Method1(void, setRGB, IN, bool, flag); + Method0(bool, getRGB); + Method1(void, setDepthBuffer, IN, bool, flag); + Method0(bool, getDepthBuffer); + Method1(void, setMinimumNumAlphaBits, IN, unsigned int, bits); + Method0(unsigned int, getMinimumNumAlphaBits); + Method0(bool, getAlphaBuffer); + Method1(void, setMinimumNumStencilBits, IN, unsigned int, bits); + Method0(unsigned int, getMinimumNumStencilBits); + Method0(bool, getStencilBuffer); + Method1(void, setMaxNumberOfGraphicsContexts, IN, unsigned int, num); + Method0(unsigned int, getMaxNumberOfGraphicsContexts); + ReadOnlyProperty(bool, AlphaBuffer); + Property(bool, DepthBuffer); + WriteOnlyProperty(const osg::DisplaySettings &, DisplaySettings); + Property(osg::DisplaySettings::DisplayType, DisplayType); + Property(bool, DoubleBuffer); + Property(float, EyeSeparation); + Property(unsigned int, MaxNumberOfGraphicsContexts); + Property(unsigned int, MinimumNumAlphaBits); + Property(unsigned int, MinimumNumStencilBits); + Property(bool, RGB); + Property(float, ScreenDistance); + Property(float, ScreenHeight); + Property(float, ScreenWidth); + Property(bool, SplitStereoAutoAjustAspectRatio); + Property(osg::DisplaySettings::SplitStereoHorizontalEyeMapping, SplitStereoHorizontalEyeMapping); + Property(int, SplitStereoHorizontalSeparation); + Property(osg::DisplaySettings::SplitStereoVerticalEyeMapping, SplitStereoVerticalEyeMapping); + Property(int, SplitStereoVerticalSeparation); + ReadOnlyProperty(bool, StencilBuffer); + Property(bool, Stereo); + Property(osg::DisplaySettings::StereoMode, StereoMode); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/DrawPixels.cpp b/src/osgWrappers/osg/DrawPixels.cpp new file mode 100644 index 000000000..aceda69f2 --- /dev/null +++ b/src/osgWrappers/osg/DrawPixels.cpp @@ -0,0 +1,43 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::DrawPixels) + BaseType(osg::Drawable); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::DrawPixels &, drawimage, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, setPosition, IN, const osg::Vec3 &, position); + Method0(osg::Vec3 &, getPosition); + Method0(const osg::Vec3 &, getPosition); + Method1(void, setImage, IN, osg::Image *, image); + Method0(osg::Image *, getImage); + Method0(const osg::Image *, getImage); + Method1(void, setUseSubImage, IN, bool, useSubImage); + Method0(bool, getUseSubImage); + Method4(void, setSubImageDimensions, IN, unsigned int, offsetX, IN, unsigned int, offsetY, IN, unsigned int, width, IN, unsigned int, height); + Method4(void, getSubImageDimensions, IN, unsigned int &, offsetX, IN, unsigned int &, offsetY, IN, unsigned int &, width, IN, unsigned int &, height); + Method1(void, drawImplementation, IN, osg::State &, state); + Property(osg::Image *, Image); + Property(const osg::Vec3 &, Position); + Property(bool, UseSubImage); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Drawable.cpp b/src/osgWrappers/osg/Drawable.cpp index 52a2a0c69..633589da2 100644 --- a/src/osgWrappers/osg/Drawable.cpp +++ b/src/osgWrappers/osg/Drawable.cpp @@ -1,13 +1,266 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include +#include +#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< osg::Node * >, osg::Drawable::ParentList); + +TYPE_NAME_ALIAS(unsigned int, osg::Drawable::AttributeType); + +BEGIN_ENUM_REFLECTOR(osg::Drawable::AttributeTypes) + EnumLabel(osg::Drawable::VERTICES); + EnumLabel(osg::Drawable::WEIGHTS); + EnumLabel(osg::Drawable::NORMALS); + EnumLabel(osg::Drawable::COLORS); + EnumLabel(osg::Drawable::SECONDARY_COLORS); + EnumLabel(osg::Drawable::FOG_COORDS); + EnumLabel(osg::Drawable::ATTIBUTE_6); + EnumLabel(osg::Drawable::ATTIBUTE_7); + EnumLabel(osg::Drawable::TEXTURE_COORDS); + EnumLabel(osg::Drawable::TEXTURE_COORDS_0); + EnumLabel(osg::Drawable::TEXTURE_COORDS_1); + EnumLabel(osg::Drawable::TEXTURE_COORDS_2); + EnumLabel(osg::Drawable::TEXTURE_COORDS_3); + EnumLabel(osg::Drawable::TEXTURE_COORDS_4); + EnumLabel(osg::Drawable::TEXTURE_COORDS_5); + EnumLabel(osg::Drawable::TEXTURE_COORDS_6); + EnumLabel(osg::Drawable::TEXTURE_COORDS_7); +END_REFLECTOR BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Drawable) BaseType(osg::Object); - Property(osg::StateSet *, StateSet); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Drawable &, drawable, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::Geometry *, asGeometry); + Method0(const osg::Geometry *, asGeometry); + Method0(const osg::Drawable::ParentList &, getParents); + Method0(osg::Drawable::ParentList, getParents); + Method1(osg::Node *, getParent, IN, unsigned int, i); + Method1(const osg::Node *, getParent, IN, unsigned int, i); + Method0(unsigned int, getNumParents); + Method1(void, setStateSet, IN, osg::StateSet *, state); + Method0(osg::StateSet *, getStateSet); + Method0(const osg::StateSet *, getStateSet); + Method0(osg::StateSet *, getOrCreateStateSet); + Method0(void, dirtyBound); + Method0(const osg::BoundingBox &, getBound); + Method1(void, setShape, IN, osg::Shape *, shape); + Method0(osg::Shape *, getShape); + Method0(const osg::Shape *, getShape); + Method1(void, setSupportsDisplayList, IN, bool, flag); + Method0(bool, getSupportsDisplayList); + Method1(void, setUseDisplayList, IN, bool, flag); + Method0(bool, getUseDisplayList); + Method1(void, setUseVertexBufferObjects, IN, bool, flag); + Method0(bool, getUseVertexBufferObjects); + Method0(void, dirtyDisplayList); + Method0(unsigned int, getGLObjectSizeHint); + Method1(void, draw, IN, osg::State &, state); + Method1(void, compileGLObjects, IN, osg::State &, state); + MethodWithDefaults1(void, releaseGLObjects, IN, osg::State *, state, 0); + Method1(void, setUpdateCallback, IN, osg::Drawable::UpdateCallback *, ac); + Method0(osg::Drawable::UpdateCallback *, getUpdateCallback); + Method0(const osg::Drawable::UpdateCallback *, getUpdateCallback); + Method1(void, setEventCallback, IN, osg::Drawable::EventCallback *, ac); + Method0(osg::Drawable::EventCallback *, getEventCallback); + Method0(const osg::Drawable::EventCallback *, getEventCallback); + Method1(void, setCullCallback, IN, osg::Drawable::CullCallback *, cc); + Method0(osg::Drawable::CullCallback *, getCullCallback); + Method0(const osg::Drawable::CullCallback *, getCullCallback); + Method1(void, setDrawCallback, IN, osg::Drawable::DrawCallback *, dc); + Method0(osg::Drawable::DrawCallback *, getDrawCallback); + Method0(const osg::Drawable::DrawCallback *, getDrawCallback); + Method1(void, drawImplementation, IN, osg::State &, state); + Method1(bool, supports, IN, const osg::Drawable::AttributeFunctor &, x); + Method1(void, accept, IN, osg::Drawable::AttributeFunctor &, x); + Method1(bool, supports, IN, const osg::Drawable::ConstAttributeFunctor &, x); + Method1(void, accept, IN, osg::Drawable::ConstAttributeFunctor &, x); + Method1(bool, supports, IN, const osg::PrimitiveFunctor &, x); + Method1(void, accept, IN, osg::PrimitiveFunctor &, x); + Method1(bool, supports, IN, const osg::PrimitiveIndexFunctor &, x); + Method1(void, accept, IN, osg::PrimitiveIndexFunctor &, x); + ReadOnlyProperty(const osg::BoundingBox &, Bound); + Property(osg::Drawable::CullCallback *, CullCallback); + Property(osg::Drawable::DrawCallback *, DrawCallback); + Property(osg::Drawable::EventCallback *, EventCallback); + ReadOnlyProperty(unsigned int, GLObjectSizeHint); + ArrayProperty_G(osg::Node *, Parent, Parents, unsigned int, void); ReadOnlyProperty(osg::Drawable::ParentList, Parents); + Property(osg::Shape *, Shape); + Property(osg::StateSet *, StateSet); + Property(bool, SupportsDisplayList); + Property(osg::Drawable::UpdateCallback *, UpdateCallback); + Property(bool, UseDisplayList); + Property(bool, UseVertexBufferObjects); END_REFLECTOR -STD_CONTAINER_REFLECTOR(osg::Drawable::ParentList); +BEGIN_VALUE_REFLECTOR(osg::Drawable::AttributeFunctor) + Constructor0(); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, unsigned, int, IN, GLbyte *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, unsigned, int, IN, GLshort *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, unsigned, int, IN, GLint *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, unsigned, int, IN, GLubyte *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, unsigned, int, IN, GLushort *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, unsigned, int, IN, GLuint *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, unsigned, int, IN, float *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, unsigned, int, IN, osg::Vec2 *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, unsigned, int, IN, osg::Vec3 *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, unsigned, int, IN, osg::Vec4 *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, unsigned, int, IN, osg::UByte4 *, x); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::Drawable::ConstAttributeFunctor) + Constructor0(); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, const unsigned, int, IN, const GLbyte *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, const unsigned, int, IN, const GLshort *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, const unsigned, int, IN, const GLint *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, const unsigned, int, IN, const GLubyte *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, const unsigned, int, IN, const GLushort *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, const unsigned, int, IN, const GLuint *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, const unsigned, int, IN, const float *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, const unsigned, int, IN, const osg::Vec2 *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, const unsigned, int, IN, const osg::Vec3 *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, const unsigned, int, IN, const osg::Vec4 *, x); + Method3(void, apply, IN, osg::Drawable::AttributeType, x, IN, const unsigned, int, IN, const osg::UByte4 *, x); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::Drawable::CullCallback) + VirtualBaseType(osg::Object); + Constructor0(); + Constructor2(IN, const osg::Drawable::CullCallback &, x, IN, const osg::CopyOp &, x); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method3(bool, cull, IN, osg::NodeVisitor *, x, IN, osg::Drawable *, x, IN, osg::State *, x); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::Drawable::DrawCallback) + VirtualBaseType(osg::Object); + Constructor0(); + Constructor2(IN, const osg::Drawable::DrawCallback &, x, IN, const osg::CopyOp &, x); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method2(void, drawImplementation, IN, osg::State &, x, IN, const osg::Drawable *, x); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::Drawable::EventCallback) + VirtualBaseType(osg::Object); + Constructor0(); + Constructor2(IN, const osg::Drawable::EventCallback &, x, IN, const osg::CopyOp &, x); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method2(void, event, IN, osg::NodeVisitor *, x, IN, osg::Drawable *, x); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Drawable::Extensions) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::Drawable::Extensions &, rhs); + Method1(void, lowestCommonDenominator, IN, const osg::Drawable::Extensions &, rhs); + Method0(void, setupGLExtenions); + Method1(void, setVertexProgramSupported, IN, bool, flag); + Method0(bool, isVertexProgramSupported); + Method1(void, setSecondaryColorSupported, IN, bool, flag); + Method0(bool, isSecondaryColorSupported); + Method1(void, setFogCoordSupported, IN, bool, flag); + Method0(bool, isFogCoordSupported); + Method1(void, setMultiTexSupported, IN, bool, flag); + Method0(bool, isMultiTexSupported); + Method1(void, setOcclusionQuerySupported, IN, bool, flag); + Method0(bool, isOcclusionQuerySupported); + Method1(void, setARBOcclusionQuerySupported, IN, bool, flag); + Method0(bool, isARBOcclusionQuerySupported); + Method1(void, glSecondaryColor3ubv, IN, const GLubyte *, coord); + Method1(void, glSecondaryColor3fv, IN, const GLfloat *, coord); + Method1(void, glFogCoordfv, IN, const GLfloat *, coord); + Method2(void, glMultiTexCoord1f, IN, GLenum, target, IN, GLfloat, coord); + Method2(void, glMultiTexCoord2fv, IN, GLenum, target, IN, const GLfloat *, coord); + Method2(void, glMultiTexCoord3fv, IN, GLenum, target, IN, const GLfloat *, coord); + Method2(void, glMultiTexCoord4fv, IN, GLenum, target, IN, const GLfloat *, coord); + Method2(void, glVertexAttrib1s, IN, unsigned int, index, IN, GLshort, s); + Method2(void, glVertexAttrib1f, IN, unsigned int, index, IN, GLfloat, f); + Method2(void, glVertexAttrib2fv, IN, unsigned int, index, IN, const GLfloat *, v); + Method2(void, glVertexAttrib3fv, IN, unsigned int, index, IN, const GLfloat *, v); + Method2(void, glVertexAttrib4fv, IN, unsigned int, index, IN, const GLfloat *, v); + Method2(void, glVertexAttrib4ubv, IN, unsigned int, index, IN, const GLubyte *, v); + Method2(void, glVertexAttrib4Nubv, IN, unsigned int, index, IN, const GLubyte *, v); + Method2(void, glGenBuffers, IN, GLsizei, n, IN, GLuint *, buffers); + Method2(void, glBindBuffer, IN, GLenum, target, IN, GLuint, buffer); + Method4(void, glBufferData, IN, GLenum, target, IN, GLsizeiptrARB, size, IN, const GLvoid *, data, IN, GLenum, usage); + Method4(void, glBufferSubData, IN, GLenum, target, IN, GLintptrARB, offset, IN, GLsizeiptrARB, size, IN, const GLvoid *, data); + Method2(void, glDeleteBuffers, IN, GLsizei, n, IN, const GLuint *, buffers); + Method1(GLboolean, glIsBuffer, IN, GLuint, buffer); + Method4(void, glGetBufferSubData, IN, GLenum, target, IN, GLintptrARB, offset, IN, GLsizeiptrARB, size, IN, GLvoid *, data); + Method2(GLvoid *, glMapBuffer, IN, GLenum, target, IN, GLenum, access); + Method1(GLboolean, glUnmapBuffer, IN, GLenum, target); + Method3(void, glGetBufferParameteriv, IN, GLenum, target, IN, GLenum, pname, IN, GLint *, params); + Method3(void, glGetBufferPointerv, IN, GLenum, target, IN, GLenum, pname, IN, GLvoid **, params); + Method2(void, glGenOcclusionQueries, IN, GLsizei, n, IN, GLuint *, ids); + Method2(void, glDeleteOcclusionQueries, IN, GLsizei, n, IN, const GLuint *, ids); + Method1(GLboolean, glIsOcclusionQuery, IN, GLuint, id); + Method1(void, glBeginOcclusionQuery, IN, GLuint, id); + Method0(void, glEndOcclusionQuery); + Method3(void, glGetOcclusionQueryiv, IN, GLuint, id, IN, GLenum, pname, IN, GLint *, params); + Method3(void, glGetOcclusionQueryuiv, IN, GLuint, id, IN, GLenum, pname, IN, GLuint *, params); + Method3(void, glGetQueryiv, IN, GLenum, target, IN, GLenum, pname, IN, GLint *, params); + Method2(void, glGenQueries, IN, GLsizei, n, IN, GLuint *, ids); + Method2(void, glBeginQuery, IN, GLenum, target, IN, GLuint, id); + Method1(void, glEndQuery, IN, GLenum, target); + Method1(GLboolean, glIsQuery, IN, GLuint, id); + Method3(void, glGetQueryObjectiv, IN, GLuint, id, IN, GLenum, pname, IN, GLint *, params); + Method3(void, glGetQueryObjectuiv, IN, GLuint, id, IN, GLenum, pname, IN, GLuint *, params); + WriteOnlyProperty(bool, ARBOcclusionQuerySupported); + WriteOnlyProperty(bool, FogCoordSupported); + WriteOnlyProperty(bool, MultiTexSupported); + WriteOnlyProperty(bool, OcclusionQuerySupported); + WriteOnlyProperty(bool, SecondaryColorSupported); + WriteOnlyProperty(bool, VertexProgramSupported); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::Drawable::UpdateCallback) + VirtualBaseType(osg::Object); + Constructor0(); + Constructor2(IN, const osg::Drawable::UpdateCallback &, x, IN, const osg::CopyOp &, x); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method2(void, update, IN, osg::NodeVisitor *, x, IN, osg::Drawable *, x); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< osg::Node * >); + diff --git a/src/osgWrappers/osg/Fog.cpp b/src/osgWrappers/osg/Fog.cpp new file mode 100644 index 000000000..f9ff36ad7 --- /dev/null +++ b/src/osgWrappers/osg/Fog.cpp @@ -0,0 +1,63 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::Fog::Mode) + EnumLabel(osg::Fog::LINEAR); + EnumLabel(osg::Fog::EXP); + EnumLabel(osg::Fog::EXP2); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::Fog::FogCoordinateSource) + EnumLabel(osg::Fog::FOG_COORDINATE); + EnumLabel(osg::Fog::FRAGMENT_DEPTH); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Fog) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Fog &, fog, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setMode, IN, osg::Fog::Mode, mode); + Method0(osg::Fog::Mode, getMode); + Method1(void, setDensity, IN, float, density); + Method0(float, getDensity); + Method1(void, setStart, IN, float, start); + Method0(float, getStart); + Method1(void, setEnd, IN, float, end); + Method0(float, getEnd); + Method1(void, setColor, IN, const osg::Vec4 &, color); + Method0(const osg::Vec4 &, getColor); + Method1(void, setFogCoordinateSource, IN, GLint, source); + Method0(GLint, getFogCoordinateSource); + Method1(void, apply, IN, osg::State &, state); + Property(const osg::Vec4 &, Color); + Property(float, Density); + Property(float, End); + Property(GLint, FogCoordinateSource); + Property(osg::Fog::Mode, Mode); + Property(float, Start); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/FragmentProgram.cpp b/src/osgWrappers/osg/FragmentProgram.cpp new file mode 100644 index 000000000..ca913ad1c --- /dev/null +++ b/src/osgWrappers/osg/FragmentProgram.cpp @@ -0,0 +1,77 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::map< GLuint COMMA osg::Vec4 >, osg::FragmentProgram::LocalParamList); + +TYPE_NAME_ALIAS(std::map< GLenum COMMA osg::Matrix >, osg::FragmentProgram::MatrixList); + +BEGIN_OBJECT_REFLECTOR(osg::FragmentProgram) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::FragmentProgram &, vp, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(GLuint &, getFragmentProgramID, IN, unsigned int, contextID); + Method1(void, setFragmentProgram, IN, const char *, program); + Method1(void, setFragmentProgram, IN, const std::string &, program); + Method0(const std::string &, getFragmentProgram); + Method2(void, setProgramLocalParameter, IN, const GLuint, index, IN, const osg::Vec4 &, p); + Method1(void, setLocalParameters, IN, const osg::FragmentProgram::LocalParamList &, lpl); + Method0(osg::FragmentProgram::LocalParamList &, getLocalParameters); + Method0(const osg::FragmentProgram::LocalParamList &, getLocalParameters); + Method2(void, setMatrix, IN, const GLenum, mode, IN, const osg::Matrix &, matrix); + Method1(void, setMatrices, IN, const osg::FragmentProgram::MatrixList &, matrices); + Method0(osg::FragmentProgram::MatrixList &, getMatrices); + Method0(const osg::FragmentProgram::MatrixList &, getMatrices); + Method0(void, dirtyFragmentProgramObject); + Method1(void, apply, IN, osg::State &, state); + Method1(void, compileGLObjects, IN, osg::State &, state); + MethodWithDefaults1(void, releaseGLObjects, IN, osg::State *, state, 0); + Property(const std::string &, FragmentProgram); + Property(const osg::FragmentProgram::LocalParamList &, LocalParameters); + Property(const osg::FragmentProgram::MatrixList &, Matrices); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::FragmentProgram::Extensions) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::FragmentProgram::Extensions &, rhs); + Method1(void, lowestCommonDenominator, IN, const osg::FragmentProgram::Extensions &, rhs); + Method0(void, setupGLExtenions); + Method1(void, setFragmentProgramSupported, IN, bool, flag); + Method0(bool, isFragmentProgramSupported); + Method2(void, glBindProgram, IN, GLenum, target, IN, GLuint, id); + Method2(void, glGenPrograms, IN, GLsizei, n, IN, GLuint *, programs); + Method2(void, glDeletePrograms, IN, GLsizei, n, IN, GLuint *, programs); + Method4(void, glProgramString, IN, GLenum, target, IN, GLenum, format, IN, GLsizei, len, IN, const void *, string); + Method3(void, glProgramLocalParameter4fv, IN, GLenum, target, IN, GLuint, index, IN, const GLfloat *, params); + WriteOnlyProperty(bool, FragmentProgramSupported); +END_REFLECTOR + +STD_MAP_REFLECTOR(std::map< GLenum COMMA osg::Matrix >); + +STD_MAP_REFLECTOR(std::map< GLuint COMMA osg::Vec4 >); + diff --git a/src/osgWrappers/osg/FrameStamp.cpp b/src/osgWrappers/osg/FrameStamp.cpp new file mode 100644 index 000000000..e5ba04bf4 --- /dev/null +++ b/src/osgWrappers/osg/FrameStamp.cpp @@ -0,0 +1,28 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include + +BEGIN_VALUE_REFLECTOR(osg::FrameStamp) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::FrameStamp &, fs); + Method1(void, setFrameNumber, IN, int, fnum); + Method0(int, getFrameNumber); + Method1(void, setReferenceTime, IN, double, refTime); + Method0(double, getReferenceTime); + Method1(void, setCalendarTime, IN, const tm &, calendarTime); + Method1(void, getCalendarTime, IN, tm &, calendarTime); + WriteOnlyProperty(const tm &, CalendarTime); + Property(int, FrameNumber); + Property(double, ReferenceTime); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/FrontFace.cpp b/src/osgWrappers/osg/FrontFace.cpp new file mode 100644 index 000000000..74cea3f22 --- /dev/null +++ b/src/osgWrappers/osg/FrontFace.cpp @@ -0,0 +1,40 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::FrontFace::Mode) + EnumLabel(osg::FrontFace::CLOCKWISE); + EnumLabel(osg::FrontFace::COUNTER_CLOCKWISE); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::FrontFace) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::FrontFace &, ff, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(void, setMode, IN, osg::FrontFace::Mode, mode); + Method0(osg::FrontFace::Mode, getMode); + Method1(void, apply, IN, osg::State &, state); + Property(osg::FrontFace::Mode, Mode); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/GNUmakefile b/src/osgWrappers/osg/GNUmakefile index b9c8c2bda..6ae9eabe9 100644 --- a/src/osgWrappers/osg/GNUmakefile +++ b/src/osgWrappers/osg/GNUmakefile @@ -2,20 +2,122 @@ TOPDIR = ../../.. include $(TOPDIR)/Make/makedefs CXXFILES =\ + AlphaFunc.cpp\ + AnimationPath.cpp\ + ApplicationUsage.cpp\ + ArgumentParser.cpp\ + Array.cpp\ + AutoTransform.cpp\ + Billboard.cpp\ + BlendColor.cpp\ + BlendEquation.cpp\ BlendFunc.cpp\ + BoundingBox.cpp\ + BoundingSphere.cpp\ + BufferObject.cpp\ + ClearNode.cpp\ + ClipNode.cpp\ + ClipPlane.cpp\ + ClusterCullingCallback.cpp\ + CollectOccludersVisitor.cpp\ + ColorMask.cpp\ + ColorMatrix.cpp\ + ConvexPlanarOccluder.cpp\ + ConvexPlanarPolygon.cpp\ + CoordinateSystemNode.cpp\ + CopyOp.cpp\ + CullFace.cpp\ + CullingSet.cpp\ + CullSettings.cpp\ + CullStack.cpp\ + Depth.cpp\ + DisplaySettings.cpp\ Drawable.cpp\ + DrawPixels.cpp\ + Fog.cpp\ + FragmentProgram.cpp\ + FrameStamp.cpp\ + FrontFace.cpp\ Geode.cpp\ Geometry.cpp\ Group.cpp\ + Image.cpp\ + ImageStream.cpp\ + Impostor.cpp\ + ImpostorSprite.cpp\ + Light.cpp\ + LightModel.cpp\ + LightSource.cpp\ + LineSegment.cpp\ + LineStipple.cpp\ + LineWidth.cpp\ + LOD.cpp\ + LogicOp.cpp\ Material.cpp\ + Matrix.cpp\ + Matrixd.cpp\ + Matrixf.cpp\ + MatrixTransform.cpp\ + Multisample.cpp\ + NodeCallback.cpp\ Node.cpp\ + NodeVisitor.cpp\ Object.cpp\ + OccluderNode.cpp\ + PagedLOD.cpp\ + Plane.cpp\ + Point.cpp\ + PointSprite.cpp\ + PolygonMode.cpp\ + PolygonOffset.cpp\ + PolygonStipple.cpp\ + Polytope.cpp\ + PositionAttitudeTransform.cpp\ + PrimitiveSet.cpp\ + Program.cpp\ + Projection.cpp\ + ProxyNode.cpp\ + Quat.cpp\ + Referenced.cpp\ + RefNodePath.cpp\ + Sequence.cpp\ + ShadeModel.cpp\ + Shader.cpp\ + ShadowVolumeOccluder.cpp\ + Shape.cpp\ + ShapeDrawable.cpp\ StateAttribute.cpp\ + State.cpp\ StateSet.cpp\ + Stencil.cpp\ + Switch.cpp\ + TexEnvCombine.cpp\ + TexEnv.cpp\ + TexEnvFilter.cpp\ + TexGen.cpp\ + TexGenNode.cpp\ + TexMat.cpp\ + Texture1D.cpp\ + Texture2D.cpp\ + Texture3D.cpp\ + Texture.cpp\ + TextureCubeMap.cpp\ + TextureRectangle.cpp\ + Timer.cpp\ + Transform.cpp\ + UByte4.cpp\ + Uniform.cpp\ Vec2.cpp\ + Vec2d.cpp\ + Vec2f.cpp\ Vec3.cpp\ + Vec3d.cpp\ + Vec3f.cpp\ Vec4.cpp\ - + Vec4d.cpp\ + Vec4f.cpp\ + VertexProgram.cpp\ + Viewport.cpp\ LIBS += -losg -losgIntrospection $(OTHER_LIBS) diff --git a/src/osgWrappers/osg/Geode.cpp b/src/osgWrappers/osg/Geode.cpp index 7258773dd..24cd56d8f 100644 --- a/src/osgWrappers/osg/Geode.cpp +++ b/src/osgWrappers/osg/Geode.cpp @@ -1,12 +1,61 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include +#include +#include +#include #include +#include +#include +#include -using namespace osgIntrospection; +TYPE_NAME_ALIAS(std::vector< osg::ref_ptr< osg::Drawable > >, osg::Geode::DrawableList); BEGIN_OBJECT_REFLECTOR(osg::Geode) BaseType(osg::Node); - ArrayPropertyWithReturnType(osg::Drawable *, Drawable, Drawables, bool); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Geode &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(bool, addDrawable, IN, osg::Drawable *, drawable); + Method1(bool, removeDrawable, IN, osg::Drawable *, drawable); + MethodWithDefaults2(bool, removeDrawable, IN, unsigned int, i, , IN, unsigned int, numDrawablesToRemove, 1); + Method2(bool, replaceDrawable, IN, osg::Drawable *, origDraw, IN, osg::Drawable *, newDraw); + Method2(bool, setDrawable, IN, unsigned int, i, IN, osg::Drawable *, drawable); + Method0(unsigned int, getNumDrawables); + Method1(osg::Drawable *, getDrawable, IN, unsigned int, i); + Method1(const osg::Drawable *, getDrawable, IN, unsigned int, i); + Method1(bool, containsDrawable, IN, const osg::Drawable *, gset); + Method1(unsigned int, getDrawableIndex, IN, const osg::Drawable *, drawable); + Method1(void, compileDrawables, IN, osg::State &, state); + Method0(const osg::BoundingBox &, getBoundingBox); + ReadOnlyProperty(const osg::BoundingBox &, BoundingBox); + ArrayProperty_GSA(osg::Drawable *, Drawable, Drawables, unsigned int, bool); END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::Drawable >) + Constructor0(); + Constructor1(IN, osg::Drawable *, t); + Constructor1(IN, const osg::ref_ptr< osg::Drawable > &, rp); + Method0(bool, valid); + Method0(osg::Drawable *, get); + Method0(const osg::Drawable *, get); + Method0(osg::Drawable *, take); + Method0(osg::Drawable *, release); + ReadOnlyProperty(osg::Drawable *, ); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< osg::ref_ptr< osg::Drawable > >); + diff --git a/src/osgWrappers/osg/Geometry.cpp b/src/osgWrappers/osg/Geometry.cpp index 4bf36bac2..db732fba6 100644 --- a/src/osgWrappers/osg/Geometry.cpp +++ b/src/osgWrappers/osg/Geometry.cpp @@ -1,16 +1,226 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include +#include +#include #include #include +#include +#include +#include -BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Drawable) - BaseType(osg::Object); - Property(osg::StateSet *, StateSet); - ReadOnlyProperty(osg::Drawable::ParentList, Parents); +TYPE_NAME_ALIAS(std::vector< osg::Geometry::ArrayData >, osg::Geometry::ArrayList); + +TYPE_NAME_ALIAS(std::vector< osg::ref_ptr< osg::PrimitiveSet > >, osg::Geometry::PrimitiveSetList); + +BEGIN_ENUM_REFLECTOR(osg::Geometry::AttributeBinding) + EnumLabel(osg::Geometry::BIND_OFF); + EnumLabel(osg::Geometry::BIND_OVERALL); + EnumLabel(osg::Geometry::BIND_PER_PRIMITIVE_SET); + EnumLabel(osg::Geometry::BIND_PER_PRIMITIVE); + EnumLabel(osg::Geometry::BIND_PER_VERTEX); END_REFLECTOR BEGIN_OBJECT_REFLECTOR(osg::Geometry) BaseType(osg::Drawable); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Geometry &, geometry, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::Geometry *, asGeometry); + Method0(const osg::Geometry *, asGeometry); + Method0(bool, empty); + Method1(void, setVertexArray, IN, osg::Array *, array); + Method0(osg::Array *, getVertexArray); + Method0(const osg::Array *, getVertexArray); + Method1(void, setVertexIndices, IN, osg::IndexArray *, array); + Method0(osg::IndexArray *, getVertexIndices); + Method0(const osg::IndexArray *, getVertexIndices); + Method1(void, setVertexData, IN, const osg::Geometry::ArrayData &, arrayData); + Method0(osg::Geometry::ArrayData &, getVertexData); + Method0(const osg::Geometry::ArrayData &, getVertexData); + Method1(void, setNormalBinding, IN, osg::Geometry::AttributeBinding, ab); + Method0(osg::Geometry::AttributeBinding, getNormalBinding); + Method1(void, setNormalArray, IN, osg::Vec3Array *, array); + Method0(osg::Vec3Array *, getNormalArray); + Method0(const osg::Vec3Array *, getNormalArray); + Method1(void, setNormalIndices, IN, osg::IndexArray *, array); + Method0(osg::IndexArray *, getNormalIndices); + Method0(const osg::IndexArray *, getNormalIndices); + Method1(void, setNormalData, IN, const osg::Geometry::Vec3ArrayData &, arrayData); + Method0(osg::Geometry::Vec3ArrayData &, getNormalData); + Method0(const osg::Geometry::Vec3ArrayData &, getNormalData); + Method1(void, setColorBinding, IN, osg::Geometry::AttributeBinding, ab); + Method0(osg::Geometry::AttributeBinding, getColorBinding); + Method1(void, setColorArray, IN, osg::Array *, array); + Method0(osg::Array *, getColorArray); + Method0(const osg::Array *, getColorArray); + Method1(void, setColorIndices, IN, osg::IndexArray *, array); + Method0(osg::IndexArray *, getColorIndices); + Method0(const osg::IndexArray *, getColorIndices); + Method1(void, setColorData, IN, const osg::Geometry::ArrayData &, arrayData); + Method0(osg::Geometry::ArrayData &, getColorData); + Method0(const osg::Geometry::ArrayData &, getColorData); + Method1(void, setSecondaryColorBinding, IN, osg::Geometry::AttributeBinding, ab); + Method0(osg::Geometry::AttributeBinding, getSecondaryColorBinding); + Method1(void, setSecondaryColorArray, IN, osg::Array *, array); + Method0(osg::Array *, getSecondaryColorArray); + Method0(const osg::Array *, getSecondaryColorArray); + Method1(void, setSecondaryColorIndices, IN, osg::IndexArray *, array); + Method0(osg::IndexArray *, getSecondaryColorIndices); + Method0(const osg::IndexArray *, getSecondaryColorIndices); + Method1(void, setSecondaryColorData, IN, const osg::Geometry::ArrayData &, arrayData); + Method0(osg::Geometry::ArrayData &, getSecondaryColorData); + Method0(const osg::Geometry::ArrayData &, getSecondaryColorData); + Method1(void, setFogCoordBinding, IN, osg::Geometry::AttributeBinding, ab); + Method0(osg::Geometry::AttributeBinding, getFogCoordBinding); + Method1(void, setFogCoordArray, IN, osg::Array *, array); + Method0(osg::Array *, getFogCoordArray); + Method0(const osg::Array *, getFogCoordArray); + Method1(void, setFogCoordIndices, IN, osg::IndexArray *, array); + Method0(osg::IndexArray *, getFogCoordIndices); + Method0(const osg::IndexArray *, getFogCoordIndices); + Method1(void, setFogCoordData, IN, const osg::Geometry::ArrayData &, arrayData); + Method0(osg::Geometry::ArrayData &, getFogCoordData); + Method0(const osg::Geometry::ArrayData &, getFogCoordData); + Method2(void, setTexCoordArray, IN, unsigned int, unit, IN, osg::Array *, x); + Method1(osg::Array *, getTexCoordArray, IN, unsigned int, unit); + Method1(const osg::Array *, getTexCoordArray, IN, unsigned int, unit); + Method2(void, setTexCoordIndices, IN, unsigned int, unit, IN, osg::IndexArray *, x); + Method1(osg::IndexArray *, getTexCoordIndices, IN, unsigned int, unit); + Method1(const osg::IndexArray *, getTexCoordIndices, IN, unsigned int, unit); + Method2(void, setTexCoordData, IN, unsigned int, index, IN, const osg::Geometry::ArrayData &, arrayData); + Method1(osg::Geometry::ArrayData &, getTexCoordData, IN, unsigned int, index); + Method1(const osg::Geometry::ArrayData &, getTexCoordData, IN, unsigned int, index); + Method0(unsigned int, getNumTexCoordArrays); + Method0(osg::Geometry::ArrayList &, getTexCoordArrayList); + Method0(const osg::Geometry::ArrayList &, getTexCoordArrayList); + Method2(void, setVertexAttribArray, IN, unsigned int, index, IN, osg::Array *, array); + Method1(osg::Array *, getVertexAttribArray, IN, unsigned int, index); + Method1(const osg::Array *, getVertexAttribArray, IN, unsigned int, index); + Method2(void, setVertexAttribIndices, IN, unsigned int, index, IN, osg::IndexArray *, array); + Method1(osg::IndexArray *, getVertexAttribIndices, IN, unsigned int, index); + Method1(const osg::IndexArray *, getVertexAttribIndices, IN, unsigned int, index); + Method2(void, setVertexAttribBinding, IN, unsigned int, index, IN, osg::Geometry::AttributeBinding, ab); + Method1(osg::Geometry::AttributeBinding, getVertexAttribBinding, IN, unsigned int, index); + Method2(void, setVertexAttribNormalize, IN, unsigned int, index, IN, GLboolean, norm); + Method1(GLboolean, getVertexAttribNormalize, IN, unsigned int, index); + Method2(void, setVertexAttribData, IN, unsigned int, index, IN, const osg::Geometry::ArrayData &, arrayData); + Method1(osg::Geometry::ArrayData &, getVertexAttribData, IN, unsigned int, index); + Method1(const osg::Geometry::ArrayData &, getVertexAttribData, IN, unsigned int, index); + Method0(unsigned int, getNumVertexAttribArrays); + Method0(osg::Geometry::ArrayList &, getVertexAttribArrayList); + Method0(const osg::Geometry::ArrayList &, getVertexAttribArrayList); + Method1(void, setPrimitiveSetList, IN, const osg::Geometry::PrimitiveSetList &, primitives); + Method0(osg::Geometry::PrimitiveSetList &, getPrimitiveSetList); + Method0(const osg::Geometry::PrimitiveSetList &, getPrimitiveSetList); + Method0(unsigned int, getNumPrimitiveSets); + Method1(osg::PrimitiveSet *, getPrimitiveSet, IN, unsigned int, pos); + Method1(const osg::PrimitiveSet *, getPrimitiveSet, IN, unsigned int, pos); + Method1(bool, addPrimitiveSet, IN, osg::PrimitiveSet *, primitiveset); + Method2(bool, setPrimitiveSet, IN, unsigned int, i, IN, osg::PrimitiveSet *, primitiveset); + Method2(bool, insertPrimitiveSet, IN, unsigned int, i, IN, osg::PrimitiveSet *, primitiveset); + MethodWithDefaults2(bool, removePrimitiveSet, IN, unsigned int, i, , IN, unsigned int, numElementsToRemove, 1); + Method1(unsigned int, getPrimitiveSetIndex, IN, const osg::PrimitiveSet *, primitiveset); + Method1(void, setFastPathHint, IN, bool, on); + Method0(bool, getFastPathHint); + Method0(bool, areFastPathsUsed); + Method0(bool, computeFastPathsUsed); + Method0(bool, verifyBindings); + Method0(void, computeCorrectBindingsAndArraySizes); + Method0(bool, suitableForOptimization); + Method1(void, copyToAndOptimize, IN, osg::Geometry &, target); + Method0(void, computeInternalOptimizedGeometry); + Method0(void, removeInternalOptimizedGeometry); + Method1(void, setInternalOptimizedGeometry, IN, osg::Geometry *, geometry); + Method0(osg::Geometry *, getInternalOptimizedGeometry); + Method0(const osg::Geometry *, getInternalOptimizedGeometry); + Method0(unsigned int, getGLObjectSizeHint); + Method1(void, drawImplementation, IN, osg::State &, state); + Method1(bool, supports, IN, const osg::Drawable::AttributeFunctor &, x); + Method1(void, accept, IN, osg::Drawable::AttributeFunctor &, af); + Method1(bool, supports, IN, const osg::Drawable::ConstAttributeFunctor &, x); + Method1(void, accept, IN, osg::Drawable::ConstAttributeFunctor &, af); + Method1(bool, supports, IN, const osg::PrimitiveFunctor &, x); + Method1(void, accept, IN, osg::PrimitiveFunctor &, pf); + Method1(bool, supports, IN, const osg::PrimitiveIndexFunctor &, x); + Method1(void, accept, IN, osg::PrimitiveIndexFunctor &, pf); + Property(osg::Array *, ColorArray); + Property(osg::Geometry::AttributeBinding, ColorBinding); + Property(const osg::Geometry::ArrayData &, ColorData); + Property(osg::IndexArray *, ColorIndices); + Property(bool, FastPathHint); + Property(osg::Array *, FogCoordArray); + Property(osg::Geometry::AttributeBinding, FogCoordBinding); + Property(const osg::Geometry::ArrayData &, FogCoordData); + Property(osg::IndexArray *, FogCoordIndices); + ReadOnlyProperty(unsigned int, GLObjectSizeHint); + Property(osg::Geometry *, InternalOptimizedGeometry); + Property(osg::Vec3Array *, NormalArray); + Property(osg::Geometry::AttributeBinding, NormalBinding); + Property(const osg::Geometry::Vec3ArrayData &, NormalData); + Property(osg::IndexArray *, NormalIndices); + ArrayProperty_GSA(osg::PrimitiveSet *, PrimitiveSet, PrimitiveSets, unsigned int, bool); + Property(const osg::Geometry::PrimitiveSetList &, PrimitiveSetList); + Property(osg::Array *, SecondaryColorArray); + Property(osg::Geometry::AttributeBinding, SecondaryColorBinding); + Property(const osg::Geometry::ArrayData &, SecondaryColorData); + Property(osg::IndexArray *, SecondaryColorIndices); + ArrayProperty_G(osg::Array *, TexCoordArray, TexCoordArrays, unsigned int, void); + ReadOnlyProperty(osg::Geometry::ArrayList &, TexCoordArrayList); + IndexedProperty1(const osg::Geometry::ArrayData &, TexCoordData, unsigned int, index); + IndexedProperty1(osg::IndexArray *, TexCoordIndices, unsigned int, unit); + Property(osg::Array *, VertexArray); + ArrayProperty_G(osg::Array *, VertexAttribArray, VertexAttribArrays, unsigned int, void); + ReadOnlyProperty(osg::Geometry::ArrayList &, VertexAttribArrayList); + IndexedProperty1(osg::Geometry::AttributeBinding, VertexAttribBinding, unsigned int, index); + IndexedProperty1(const osg::Geometry::ArrayData &, VertexAttribData, unsigned int, index); + IndexedProperty1(osg::IndexArray *, VertexAttribIndices, unsigned int, index); + IndexedProperty1(GLboolean, VertexAttribNormalize, unsigned int, index); + Property(const osg::Geometry::ArrayData &, VertexData); + Property(osg::IndexArray *, VertexIndices); END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::Geometry::ArrayData) + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Geometry::ArrayData &, data, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + ConstructorWithDefaults3(IN, osg::Array *, a, , IN, osg::Geometry::AttributeBinding, b, , IN, GLboolean, n, GL_FALSE); + ConstructorWithDefaults4(IN, osg::Array *, a, , IN, osg::IndexArray *, i, , IN, osg::Geometry::AttributeBinding, b, , IN, GLboolean, n, GL_FALSE); + Method0(bool, empty); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::Geometry::Vec3ArrayData) + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Geometry::Vec3ArrayData &, data, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + ConstructorWithDefaults3(IN, osg::Vec3Array *, a, , IN, osg::Geometry::AttributeBinding, b, , IN, GLboolean, n, GL_FALSE); + ConstructorWithDefaults4(IN, osg::Vec3Array *, a, , IN, osg::IndexArray *, i, , IN, osg::Geometry::AttributeBinding, b, , IN, GLboolean, n, GL_FALSE); + Method0(bool, empty); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::PrimitiveSet >) + Constructor0(); + Constructor1(IN, osg::PrimitiveSet *, t); + Constructor1(IN, const osg::ref_ptr< osg::PrimitiveSet > &, rp); + Method0(bool, valid); + Method0(osg::PrimitiveSet *, get); + Method0(const osg::PrimitiveSet *, get); + Method0(osg::PrimitiveSet *, take); + Method0(osg::PrimitiveSet *, release); + ReadOnlyProperty(osg::PrimitiveSet *, ); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< osg::Geometry::ArrayData >); + +STD_VECTOR_REFLECTOR(std::vector< osg::ref_ptr< osg::PrimitiveSet > >); + diff --git a/src/osgWrappers/osg/Group.cpp b/src/osgWrappers/osg/Group.cpp index c700c1ed4..df47749f6 100644 --- a/src/osgWrappers/osg/Group.cpp +++ b/src/osgWrappers/osg/Group.cpp @@ -1,12 +1,60 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include +#include #include - -using namespace osgIntrospection; +#include +#include +#include BEGIN_OBJECT_REFLECTOR(osg::Group) BaseType(osg::Node); - ArrayPropertyWithReturnType(osg::Node *, Child, Children, bool); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Group &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method0(osg::Group *, asGroup); + Method0(const osg::Group *, asGroup); + Method1(void, traverse, IN, osg::NodeVisitor &, nv); + Method1(bool, addChild, IN, osg::Node *, child); + Method2(bool, insertChild, IN, unsigned int, index, IN, osg::Node *, child); + Method1(bool, removeChild, IN, osg::Node *, child); + MethodWithDefaults2(bool, removeChild, IN, unsigned int, pos, , IN, unsigned int, numChildrenToRemove, 1); + Method2(bool, replaceChild, IN, osg::Node *, origChild, IN, osg::Node *, newChild); + Method0(unsigned int, getNumChildren); + Method2(bool, setChild, IN, unsigned int, i, IN, osg::Node *, node); + Method1(osg::Node *, getChild, IN, unsigned int, i); + Method1(const osg::Node *, getChild, IN, unsigned int, i); + Method1(bool, containsNode, IN, const osg::Node *, node); + Method1(unsigned int, getChildIndex, IN, const osg::Node *, node); + ArrayProperty_GSA(osg::Node *, Child, Children, unsigned int, bool); END_REFLECTOR + +TYPE_NAME_ALIAS(std::vector< osg::ref_ptr< osg::Node > >, osg::NodeList); + +BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::Node >) + Constructor0(); + Constructor1(IN, osg::Node *, t); + Constructor1(IN, const osg::ref_ptr< osg::Node > &, rp); + Method0(bool, valid); + Method0(osg::Node *, get); + Method0(const osg::Node *, get); + Method0(osg::Node *, take); + Method0(osg::Node *, release); + ReadOnlyProperty(osg::Node *, ); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< osg::ref_ptr< osg::Node > >); + diff --git a/src/osgWrappers/osg/Image.cpp b/src/osgWrappers/osg/Image.cpp new file mode 100644 index 000000000..08d88db6e --- /dev/null +++ b/src/osgWrappers/osg/Image.cpp @@ -0,0 +1,98 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< unsigned int >, osg::Image::MipmapDataType); + +BEGIN_ENUM_REFLECTOR(osg::Image::AllocationMode) + EnumLabel(osg::Image::NO_DELETE); + EnumLabel(osg::Image::USE_NEW_DELETE); + EnumLabel(osg::Image::USE_MALLOC_FREE); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Image) + BaseType(osg::Object); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Image &, image, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(int, compare, IN, const osg::Image &, rhs); + Method1(void, setFileName, IN, const std::string &, fileName); + Method0(const std::string &, getFileName); + Method1(void, setAllocationMode, IN, osg::Image::AllocationMode, mode); + Method0(osg::Image::AllocationMode, getAllocationMode); + MethodWithDefaults6(void, allocateImage, IN, int, s, , IN, int, t, , IN, int, r, , IN, GLenum, pixelFormat, , IN, GLenum, type, , IN, int, packing, 1); + MethodWithDefaults9(void, setImage, IN, int, s, , IN, int, t, , IN, int, r, , IN, GLint, internalTextureformat, , IN, GLenum, pixelFormat, , IN, GLenum, type, , IN, unsigned char *, data, , IN, osg::Image::AllocationMode, mode, , IN, int, packing, 1); + Method6(void, readPixels, IN, int, x, IN, int, y, IN, int, width, IN, int, height, IN, GLenum, pixelFormat, IN, GLenum, type); + Method2(void, readImageFromCurrentTexture, IN, unsigned int, contextID, IN, bool, copyMipMapsIfAvailable); + Method3(void, scaleImage, IN, int, s, IN, int, t, IN, int, r); + Method4(void, scaleImage, IN, int, s, IN, int, t, IN, int, r, IN, GLenum, newDataType); + Method4(void, copySubImage, IN, int, s_offset, IN, int, t_offset, IN, int, r_offset, IN, osg::Image *, source); + Method0(int, s); + Method0(int, t); + Method0(int, r); + Method1(void, setInternalTextureFormat, IN, GLint, internalFormat); + Method0(GLint, getInternalTextureFormat); + Method1(void, setPixelFormat, IN, GLenum, pixelFormat); + Method0(GLenum, getPixelFormat); + Method0(GLenum, getDataType); + Method0(unsigned int, getPacking); + Method0(unsigned int, getPixelSizeInBits); + Method0(unsigned int, getRowSizeInBytes); + Method0(unsigned int, getImageSizeInBytes); + Method0(unsigned int, getTotalSizeInBytes); + Method0(unsigned int, getTotalSizeInBytesIncludingMipmaps); + Method0(unsigned char *, data); + Method0(const unsigned char *, data); + MethodWithDefaults3(unsigned char *, data, IN, int, column, , IN, int, row, 0, IN, int, image, 0); + MethodWithDefaults3(const unsigned char *, data, IN, int, column, , IN, int, row, 0, IN, int, image, 0); + Method0(void, flipHorizontal); + Method0(void, flipVertical); + Method1(void, ensureValidSizeForTexturing, IN, GLint, maxTextureSize); + Method0(void, dirty); + Method1(void, setModifiedCount, IN, unsigned int, value); + Method0(unsigned int, getModifiedCount); + Method0(bool, isMipmap); + Method0(unsigned int, getNumMipmapLevels); + Method1(void, setMipmapLevels, IN, const osg::Image::MipmapDataType &, mipmapDataVector); + Method0(const osg::Image::MipmapDataType &, getMipmapLevels); + Method1(unsigned int, getMipmapOffset, IN, unsigned int, mipmapLevel); + Method1(unsigned char *, getMipmapData, IN, unsigned int, mipmapLevel); + Method1(const unsigned char *, getMipmapData, IN, unsigned int, mipmapLevel); + Method0(bool, isImageTranslucent); + Method1(void, setPixelBufferObject, IN, osg::PixelBufferObject *, buffer); + Method0(osg::PixelBufferObject *, getPixelBufferObject); + Method0(const osg::PixelBufferObject *, getPixelBufferObject); + Property(osg::Image::AllocationMode, AllocationMode); + ReadOnlyProperty(GLenum, DataType); + Property(const std::string &, FileName); + ReadOnlyProperty(unsigned int, ImageSizeInBytes); + Property(GLint, InternalTextureFormat); + Property(const osg::Image::MipmapDataType &, MipmapLevels); + Property(unsigned int, ModifiedCount); + ReadOnlyProperty(unsigned int, Packing); + Property(osg::PixelBufferObject *, PixelBufferObject); + Property(GLenum, PixelFormat); + ReadOnlyProperty(unsigned int, PixelSizeInBits); + ReadOnlyProperty(unsigned int, RowSizeInBytes); + ReadOnlyProperty(unsigned int, TotalSizeInBytes); + ReadOnlyProperty(unsigned int, TotalSizeInBytesIncludingMipmaps); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< unsigned int >); + diff --git a/src/osgWrappers/osg/ImageStream.cpp b/src/osgWrappers/osg/ImageStream.cpp new file mode 100644 index 000000000..61b978fde --- /dev/null +++ b/src/osgWrappers/osg/ImageStream.cpp @@ -0,0 +1,56 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::ImageStream::StreamStatus) + EnumLabel(osg::ImageStream::INVALID); + EnumLabel(osg::ImageStream::PLAYING); + EnumLabel(osg::ImageStream::PAUSED); + EnumLabel(osg::ImageStream::REWINDING); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::ImageStream::LoopingMode) + EnumLabel(osg::ImageStream::NO_LOOPING); + EnumLabel(osg::ImageStream::LOOPING); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::ImageStream) + BaseType(osg::Image); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::ImageStream &, image, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(int, compare, IN, const osg::Image &, rhs); + Method0(void, play); + Method0(void, pause); + Method0(void, rewind); + MethodWithDefaults1(void, quit, IN, bool, x, true); + Method0(osg::ImageStream::StreamStatus, getStatus); + Method1(void, setLoopingMode, IN, osg::ImageStream::LoopingMode, mode); + Method0(osg::ImageStream::LoopingMode, getLoopingMode); + Method1(void, setReferenceTime, IN, double, x); + Method0(double, getReferenceTime); + Method1(void, setTimeMultiplier, IN, double, x); + Method0(double, getTimeMultiplier); + Method0(void, update); + Property(osg::ImageStream::LoopingMode, LoopingMode); + Property(double, ReferenceTime); + ReadOnlyProperty(osg::ImageStream::StreamStatus, Status); + Property(double, TimeMultiplier); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Impostor.cpp b/src/osgWrappers/osg/Impostor.cpp new file mode 100644 index 000000000..fb0e6ed02 --- /dev/null +++ b/src/osgWrappers/osg/Impostor.cpp @@ -0,0 +1,55 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< osg::ref_ptr< osg::ImpostorSprite > >, osg::Impostor::ImpostorSpriteList); + +BEGIN_OBJECT_REFLECTOR(osg::Impostor) + BaseType(osg::LOD); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Impostor &, es, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, setImpostorThreshold, IN, float, distance); + Method0(float, getImpostorThreshold); + MethodWithDefaults1(void, setImpostorThresholdToBound, IN, float, ratio, 1.0f); + Method2(osg::ImpostorSprite *, findBestImpostorSprite, IN, unsigned int, contextID, IN, const osg::Vec3 &, currLocalEyePoint); + Method2(void, addImpostorSprite, IN, unsigned int, contextID, IN, osg::ImpostorSprite *, is); + Method1(osg::Impostor::ImpostorSpriteList &, getImpostorSpriteList, IN, unsigned int, contexID); + Method1(const osg::Impostor::ImpostorSpriteList &, getImpostorSpriteList, IN, unsigned int, contexID); + Property(float, ImpostorThreshold); + WriteOnlyProperty(float, ImpostorThresholdToBound); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::ImpostorSprite >) + Constructor0(); + Constructor1(IN, osg::ImpostorSprite *, t); + Constructor1(IN, const osg::ref_ptr< osg::ImpostorSprite > &, rp); + Method0(bool, valid); + Method0(osg::ImpostorSprite *, get); + Method0(const osg::ImpostorSprite *, get); + Method0(osg::ImpostorSprite *, take); + Method0(osg::ImpostorSprite *, release); + ReadOnlyProperty(osg::ImpostorSprite *, ); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< osg::ref_ptr< osg::ImpostorSprite > >); + diff --git a/src/osgWrappers/osg/ImpostorSprite.cpp b/src/osgWrappers/osg/ImpostorSprite.cpp new file mode 100644 index 000000000..863bf3af5 --- /dev/null +++ b/src/osgWrappers/osg/ImpostorSprite.cpp @@ -0,0 +1,80 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::ImpostorSprite) + BaseType(osg::Drawable); + Constructor0(); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, x); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, setParent, IN, osg::Impostor *, parent); + Method0(osg::Impostor *, getParent); + Method0(const osg::Impostor *, getParent); + Method1(void, setStoredLocalEyePoint, IN, const osg::Vec3 &, v); + Method0(const osg::Vec3 &, getStoredLocalEyePoint); + Method1(void, setLastFrameUsed, IN, int, frameNumber); + Method0(int, getLastFrameUsed); + Method0(osg::Vec3 *, getCoords); + Method0(const osg::Vec3 *, getCoords); + Method0(osg::Vec2 *, getTexCoords); + Method0(const osg::Vec2 *, getTexCoords); + Method0(osg::Vec3 *, getControlCoords); + Method0(const osg::Vec3 *, getControlCoords); + Method1(float, calcPixelError, IN, const osg::Matrix &, MVPW); + Method3(void, setTexture, IN, osg::Texture2D *, tex, IN, int, s, IN, int, t); + Method0(osg::Texture2D *, getTexture); + Method0(const osg::Texture2D *, getTexture); + Method0(int, s); + Method0(int, t); + Method1(void, drawImplementation, IN, osg::State &, state); + Method1(bool, supports, IN, const osg::Drawable::AttributeFunctor &, x); + Method1(void, accept, IN, osg::Drawable::AttributeFunctor &, af); + Method1(bool, supports, IN, const osg::Drawable::ConstAttributeFunctor &, x); + Method1(void, accept, IN, osg::Drawable::ConstAttributeFunctor &, af); + Method1(bool, supports, IN, const osg::PrimitiveFunctor &, x); + Method1(void, accept, IN, osg::PrimitiveFunctor &, pf); + ReadOnlyProperty(osg::Vec3 *, ControlCoords); + ReadOnlyProperty(osg::Vec3 *, Coords); + Property(int, LastFrameUsed); + Property(osg::Impostor *, Parent); + Property(const osg::Vec3 &, StoredLocalEyePoint); + ReadOnlyProperty(osg::Vec2 *, TexCoords); + ReadOnlyProperty(osg::Texture2D *, Texture); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::ImpostorSpriteManager) + BaseType(osg::Referenced); + Constructor0(); + Method0(bool, empty); + Method0(osg::ImpostorSprite *, first); + Method0(osg::ImpostorSprite *, last); + Method1(void, push_back, IN, osg::ImpostorSprite *, is); + Method1(void, remove, IN, osg::ImpostorSprite *, is); + Method3(osg::ImpostorSprite *, createOrReuseImpostorSprite, IN, int, s, IN, int, t, IN, int, frameNumber); + Method0(osg::StateSet *, createOrReuseStateSet); + Method0(void, reset); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/LOD.cpp b/src/osgWrappers/osg/LOD.cpp new file mode 100644 index 000000000..a0b3eedf5 --- /dev/null +++ b/src/osgWrappers/osg/LOD.cpp @@ -0,0 +1,71 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::pair< float COMMA float >, osg::LOD::MinMaxPair); + +TYPE_NAME_ALIAS(std::vector< osg::LOD::MinMaxPair >, osg::LOD::RangeList); + +BEGIN_ENUM_REFLECTOR(osg::LOD::CenterMode) + EnumLabel(osg::LOD::USE_BOUNDING_SPHERE_CENTER); + EnumLabel(osg::LOD::USER_DEFINED_CENTER); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::LOD::RangeMode) + EnumLabel(osg::LOD::DISTANCE_FROM_EYE_POINT); + EnumLabel(osg::LOD::PIXEL_SIZE_ON_SCREEN); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::LOD) + BaseType(osg::Group); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::LOD &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, traverse, IN, osg::NodeVisitor &, nv); + Method1(bool, addChild, IN, osg::Node *, child); + Method3(bool, addChild, IN, osg::Node *, child, IN, float, min, IN, float, max); + Method1(bool, removeChild, IN, osg::Node *, child); + Method1(void, setCenterMode, IN, osg::LOD::CenterMode, mode); + Method0(osg::LOD::CenterMode, getCenterMode); + Method1(void, setCenter, IN, const osg::Vec3 &, center); + Method0(const osg::Vec3 &, getCenter); + Method1(void, setRadius, IN, float, radius); + Method0(float, getRadius); + Method1(void, setRangeMode, IN, osg::LOD::RangeMode, mode); + Method0(osg::LOD::RangeMode, getRangeMode); + Method3(void, setRange, IN, unsigned int, childNo, IN, float, min, IN, float, max); + Method1(float, getMinRange, IN, unsigned int, childNo); + Method1(float, getMaxRange, IN, unsigned int, childNo); + Method0(unsigned int, getNumRanges); + Method1(void, setRangeList, IN, const osg::LOD::RangeList &, rangeList); + Method0(const osg::LOD::RangeList &, getRangeList); + Property(const osg::Vec3 &, Center); + Property(osg::LOD::CenterMode, CenterMode); + Property(float, Radius); + Property(const osg::LOD::RangeList &, RangeList); + Property(osg::LOD::RangeMode, RangeMode); +END_REFLECTOR + +STD_PAIR_REFLECTOR(std::pair< float COMMA float >); + +STD_VECTOR_REFLECTOR(std::vector< osg::LOD::MinMaxPair >); + diff --git a/src/osgWrappers/osg/Light.cpp b/src/osgWrappers/osg/Light.cpp new file mode 100644 index 000000000..c8d6bccdf --- /dev/null +++ b/src/osgWrappers/osg/Light.cpp @@ -0,0 +1,71 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::Light) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Light &, light, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method0(unsigned int, getMember); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setLightNum, IN, int, num); + Method0(int, getLightNum); + Method1(void, setAmbient, IN, const osg::Vec4 &, ambient); + Method0(const osg::Vec4 &, getAmbient); + Method1(void, setDiffuse, IN, const osg::Vec4 &, diffuse); + Method0(const osg::Vec4 &, getDiffuse); + Method1(void, setSpecular, IN, const osg::Vec4 &, specular); + Method0(const osg::Vec4 &, getSpecular); + Method1(void, setPosition, IN, const osg::Vec4 &, position); + Method0(const osg::Vec4 &, getPosition); + Method1(void, setDirection, IN, const osg::Vec3 &, direction); + Method0(const osg::Vec3 &, getDirection); + Method1(void, setConstantAttenuation, IN, float, constant_attenuation); + Method0(float, getConstantAttenuation); + Method1(void, setLinearAttenuation, IN, float, linear_attenuation); + Method0(float, getLinearAttenuation); + Method1(void, setQuadraticAttenuation, IN, float, quadratic_attenuation); + Method0(float, getQuadraticAttenuation); + Method1(void, setSpotExponent, IN, float, spot_exponent); + Method0(float, getSpotExponent); + Method1(void, setSpotCutoff, IN, float, spot_cutoff); + Method0(float, getSpotCutoff); + Method0(void, captureLightState); + Method1(void, apply, IN, osg::State &, state); + Property(const osg::Vec4 &, Ambient); + Property(float, ConstantAttenuation); + Property(const osg::Vec4 &, Diffuse); + Property(const osg::Vec3 &, Direction); + Property(int, LightNum); + Property(float, LinearAttenuation); + ReadOnlyProperty(unsigned int, Member); + Property(const osg::Vec4 &, Position); + Property(float, QuadraticAttenuation); + Property(const osg::Vec4 &, Specular); + Property(float, SpotCutoff); + Property(float, SpotExponent); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/LightModel.cpp b/src/osgWrappers/osg/LightModel.cpp new file mode 100644 index 000000000..9cd8e3639 --- /dev/null +++ b/src/osgWrappers/osg/LightModel.cpp @@ -0,0 +1,50 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::LightModel::ColorControl) + EnumLabel(osg::LightModel::SEPARATE_SPECULAR_COLOR); + EnumLabel(osg::LightModel::SINGLE_COLOR); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::LightModel) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::LightModel &, lw, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(void, setAmbientIntensity, IN, const osg::Vec4 &, ambient); + Method0(const osg::Vec4 &, getAmbientIntensity); + Method1(void, setColorControl, IN, osg::LightModel::ColorControl, cc); + Method0(osg::LightModel::ColorControl, getColorControl); + Method1(void, setLocalViewer, IN, bool, localViewer); + Method0(bool, getLocalViewer); + Method1(void, setTwoSided, IN, bool, twoSided); + Method0(bool, getTwoSided); + Method1(void, apply, IN, osg::State &, state); + Property(const osg::Vec4 &, AmbientIntensity); + Property(osg::LightModel::ColorControl, ColorControl); + Property(bool, LocalViewer); + Property(bool, TwoSided); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/LightSource.cpp b/src/osgWrappers/osg/LightSource.cpp new file mode 100644 index 000000000..db149c222 --- /dev/null +++ b/src/osgWrappers/osg/LightSource.cpp @@ -0,0 +1,46 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::LightSource::ReferenceFrame) + EnumLabel(osg::LightSource::RELATIVE_RF); + EnumLabel(osg::LightSource::ABSOLUTE_RF); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::LightSource) + BaseType(osg::Group); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::LightSource &, ls, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, setReferenceFrame, IN, osg::LightSource::ReferenceFrame, rf); + Method0(osg::LightSource::ReferenceFrame, getReferenceFrame); + Method1(void, setLight, IN, osg::Light *, light); + Method0(osg::Light *, getLight); + Method0(const osg::Light *, getLight); + Method2(void, setStateSetModes, IN, osg::StateSet &, x, IN, osg::StateAttribute::GLModeValue, x); + MethodWithDefaults1(void, setLocalStateSetModes, IN, osg::StateAttribute::GLModeValue, value, osg::StateAttribute::ON); + Property(osg::Light *, Light); + WriteOnlyProperty(osg::StateAttribute::GLModeValue, LocalStateSetModes); + Property(osg::LightSource::ReferenceFrame, ReferenceFrame); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/LineSegment.cpp b/src/osgWrappers/osg/LineSegment.cpp new file mode 100644 index 000000000..8c34e512f --- /dev/null +++ b/src/osgWrappers/osg/LineSegment.cpp @@ -0,0 +1,37 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::LineSegment) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::LineSegment &, seg); + Constructor2(IN, const osg::Vec3 &, s, IN, const osg::Vec3 &, e); + Method2(void, set, IN, const osg::Vec3 &, s, IN, const osg::Vec3 &, e); + Method0(osg::Vec3 &, start); + Method0(const osg::Vec3 &, start); + Method0(osg::Vec3 &, end); + Method0(const osg::Vec3 &, end); + Method0(bool, valid); + Method1(bool, intersect, IN, const osg::BoundingBox &, bb); + Method3(bool, intersect, IN, const osg::BoundingBox &, bb, IN, float &, r1, IN, float &, r2); + Method1(bool, intersect, IN, const osg::BoundingSphere &, bs); + Method3(bool, intersect, IN, const osg::BoundingSphere &, bs, IN, float &, r1, IN, float &, r2); + Method4(bool, intersect, IN, const osg::Vec3 &, v1, IN, const osg::Vec3 &, v2, IN, const osg::Vec3 &, v3, IN, float &, r); + Method2(void, mult, IN, const osg::LineSegment &, seg, IN, const osg::Matrix &, m); + Method2(void, mult, IN, const osg::Matrix &, m, IN, const osg::LineSegment &, seg); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/LineStipple.cpp b/src/osgWrappers/osg/LineStipple.cpp new file mode 100644 index 000000000..c4b57e58a --- /dev/null +++ b/src/osgWrappers/osg/LineStipple.cpp @@ -0,0 +1,39 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::LineStipple) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::LineStipple &, lw, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setFactor, IN, GLint, factor); + Method0(GLint, getFactor); + Method1(void, setPattern, IN, GLushort, pattern); + Method0(GLushort, getPattern); + Method1(void, apply, IN, osg::State &, state); + Property(GLint, Factor); + Property(GLushort, Pattern); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/LineWidth.cpp b/src/osgWrappers/osg/LineWidth.cpp new file mode 100644 index 000000000..cbe32b612 --- /dev/null +++ b/src/osgWrappers/osg/LineWidth.cpp @@ -0,0 +1,35 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::LineWidth) + BaseType(osg::StateAttribute); + ConstructorWithDefaults1(IN, float, width, 1.0f); + ConstructorWithDefaults2(IN, const osg::LineWidth &, lw, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(void, setWidth, IN, float, width); + Method0(float, getWidth); + Method1(void, apply, IN, osg::State &, state); + ReadOnlyProperty(osg::StateAttribute::Type, Type); + Property(float, Width); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/LogicOp.cpp b/src/osgWrappers/osg/LogicOp.cpp new file mode 100644 index 000000000..586273bf1 --- /dev/null +++ b/src/osgWrappers/osg/LogicOp.cpp @@ -0,0 +1,56 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::LogicOp::Opcode) + EnumLabel(osg::LogicOp::CLEAR); + EnumLabel(osg::LogicOp::SET); + EnumLabel(osg::LogicOp::COPY); + EnumLabel(osg::LogicOp::COPY_INVERTED); + EnumLabel(osg::LogicOp::NOOP); + EnumLabel(osg::LogicOp::INVERT); + EnumLabel(osg::LogicOp::AND); + EnumLabel(osg::LogicOp::NAND); + EnumLabel(osg::LogicOp::OR); + EnumLabel(osg::LogicOp::NOR); + EnumLabel(osg::LogicOp::XOR); + EnumLabel(osg::LogicOp::EQUIV); + EnumLabel(osg::LogicOp::AND_REVERSE); + EnumLabel(osg::LogicOp::AND_INVERTED); + EnumLabel(osg::LogicOp::OR_REVERSE); + EnumLabel(osg::LogicOp::OR_INVERTED); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::LogicOp) + BaseType(osg::StateAttribute); + Constructor0(); + Constructor1(IN, osg::LogicOp::Opcode, opcode); + ConstructorWithDefaults2(IN, const osg::LogicOp &, trans, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setOpcode, IN, osg::LogicOp::Opcode, opcode); + Method0(osg::LogicOp::Opcode, getOpcode); + Method1(void, apply, IN, osg::State &, state); + Property(osg::LogicOp::Opcode, Opcode); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Material.cpp b/src/osgWrappers/osg/Material.cpp index b7d5acc53..0d6a91c32 100644 --- a/src/osgWrappers/osg/Material.cpp +++ b/src/osgWrappers/osg/Material.cpp @@ -1,10 +1,20 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include +#include #include - -using namespace osgIntrospection; +#include +#include +#include +#include BEGIN_ENUM_REFLECTOR(osg::Material::Face) EnumLabel(osg::Material::FRONT); @@ -14,8 +24,8 @@ END_REFLECTOR BEGIN_ENUM_REFLECTOR(osg::Material::ColorMode) EnumLabel(osg::Material::AMBIENT); - EnumLabel(osg::Material::SPECULAR); EnumLabel(osg::Material::DIFFUSE); + EnumLabel(osg::Material::SPECULAR); EnumLabel(osg::Material::EMISSION); EnumLabel(osg::Material::AMBIENT_AND_DIFFUSE); EnumLabel(osg::Material::OFF); @@ -23,9 +33,47 @@ END_REFLECTOR BEGIN_OBJECT_REFLECTOR(osg::Material) BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Material &, mat, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, apply, IN, osg::State &, state); + Method1(void, setColorMode, IN, osg::Material::ColorMode, mode); + Method0(osg::Material::ColorMode, getColorMode); + Method2(void, setAmbient, IN, osg::Material::Face, face, IN, const osg::Vec4 &, ambient); + Method1(const osg::Vec4 &, getAmbient, IN, osg::Material::Face, face); + Method0(bool, getAmbientFrontAndBack); + Method2(void, setDiffuse, IN, osg::Material::Face, face, IN, const osg::Vec4 &, diffuse); + Method1(const osg::Vec4 &, getDiffuse, IN, osg::Material::Face, face); + Method0(bool, getDiffuseFrontAndBack); + Method2(void, setSpecular, IN, osg::Material::Face, face, IN, const osg::Vec4 &, specular); + Method1(const osg::Vec4 &, getSpecular, IN, osg::Material::Face, face); + Method0(bool, getSpecularFrontAndBack); + Method2(void, setEmission, IN, osg::Material::Face, face, IN, const osg::Vec4 &, emission); + Method1(const osg::Vec4 &, getEmission, IN, osg::Material::Face, face); + Method0(bool, getEmissionFrontAndBack); + Method2(void, setShininess, IN, osg::Material::Face, face, IN, float, shininess); + Method1(float, getShininess, IN, osg::Material::Face, face); + Method0(bool, getShininessFrontAndBack); + Method2(void, setTransparency, IN, osg::Material::Face, face, IN, float, trans); + Method2(void, setAlpha, IN, osg::Material::Face, face, IN, float, alpha); + IndexedProperty1(const osg::Vec4 &, Ambient, osg::Material::Face, face); + ReadOnlyProperty(bool, AmbientFrontAndBack); Property(osg::Material::ColorMode, ColorMode); - IndexedProperty(const osg::Vec4 &, Ambient, osg::Material::Face, face); - IndexedProperty(const osg::Vec4 &, Diffuse, osg::Material::Face, face); - IndexedProperty(const osg::Vec4 &, Specular, osg::Material::Face, face); + IndexedProperty1(const osg::Vec4 &, Diffuse, osg::Material::Face, face); + ReadOnlyProperty(bool, DiffuseFrontAndBack); + IndexedProperty1(const osg::Vec4 &, Emission, osg::Material::Face, face); + ReadOnlyProperty(bool, EmissionFrontAndBack); + IndexedProperty1(float, Shininess, osg::Material::Face, face); + ReadOnlyProperty(bool, ShininessFrontAndBack); + IndexedProperty1(const osg::Vec4 &, Specular, osg::Material::Face, face); + ReadOnlyProperty(bool, SpecularFrontAndBack); + ReadOnlyProperty(osg::StateAttribute::Type, Type); END_REFLECTOR diff --git a/src/osgWrappers/osg/Matrix.cpp b/src/osgWrappers/osg/Matrix.cpp new file mode 100644 index 000000000..13d013609 --- /dev/null +++ b/src/osgWrappers/osg/Matrix.cpp @@ -0,0 +1,17 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include + +TYPE_NAME_ALIAS(osg::Matrixd, osg::Matrix); + +TYPE_NAME_ALIAS(osg::RefMatrixd, osg::RefMatrix); + diff --git a/src/osgWrappers/osg/MatrixTransform.cpp b/src/osgWrappers/osg/MatrixTransform.cpp new file mode 100644 index 000000000..54ab2a62e --- /dev/null +++ b/src/osgWrappers/osg/MatrixTransform.cpp @@ -0,0 +1,41 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::MatrixTransform) + BaseType(osg::Transform); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::MatrixTransform &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, const osg::Matrix &, matix); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method0(osg::MatrixTransform *, asMatrixTransform); + Method0(const osg::MatrixTransform *, asMatrixTransform); + Method1(void, setMatrix, IN, const osg::Matrix &, mat); + Method0(const osg::Matrix &, getMatrix); + Method1(void, preMult, IN, const osg::Matrix &, mat); + Method1(void, postMult, IN, const osg::Matrix &, mat); + Method0(const osg::Matrix &, getInverseMatrix); + Method2(bool, computeLocalToWorldMatrix, IN, osg::Matrix &, matrix, IN, osg::NodeVisitor *, x); + Method2(bool, computeWorldToLocalMatrix, IN, osg::Matrix &, matrix, IN, osg::NodeVisitor *, x); + ReadOnlyProperty(const osg::Matrix &, InverseMatrix); + Property(const osg::Matrix &, Matrix); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Matrixd.cpp b/src/osgWrappers/osg/Matrixd.cpp new file mode 100644 index 000000000..b02113e41 --- /dev/null +++ b/src/osgWrappers/osg/Matrixd.cpp @@ -0,0 +1,108 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(double, osg::Matrixd::value_type); + +BEGIN_VALUE_REFLECTOR(osg::Matrixd) + Constructor0(); + Constructor1(IN, const osg::Matrixd &, mat); + Constructor1(IN, const osg::Matrixf &, mat); + Constructor1(IN, float const *const, ptr); + Constructor1(IN, double const *const, ptr); + Constructor1(IN, const osg::Quat &, quat); + Constructor16(IN, osg::Matrixd::value_type, a00, IN, osg::Matrixd::value_type, a01, IN, osg::Matrixd::value_type, a02, IN, osg::Matrixd::value_type, a03, IN, osg::Matrixd::value_type, a10, IN, osg::Matrixd::value_type, a11, IN, osg::Matrixd::value_type, a12, IN, osg::Matrixd::value_type, a13, IN, osg::Matrixd::value_type, a20, IN, osg::Matrixd::value_type, a21, IN, osg::Matrixd::value_type, a22, IN, osg::Matrixd::value_type, a23, IN, osg::Matrixd::value_type, a30, IN, osg::Matrixd::value_type, a31, IN, osg::Matrixd::value_type, a32, IN, osg::Matrixd::value_type, a33); + Method1(int, compare, IN, const osg::Matrixd &, m); + Method0(bool, valid); + Method0(bool, isNaN); + Method1(void, set, IN, const osg::Matrixd &, rhs); + Method1(void, set, IN, const osg::Matrixf &, rhs); + Method1(void, set, IN, float const *const, ptr); + Method1(void, set, IN, double const *const, ptr); + Method16(void, set, IN, osg::Matrixd::value_type, a00, IN, osg::Matrixd::value_type, a01, IN, osg::Matrixd::value_type, a02, IN, osg::Matrixd::value_type, a03, IN, osg::Matrixd::value_type, a10, IN, osg::Matrixd::value_type, a11, IN, osg::Matrixd::value_type, a12, IN, osg::Matrixd::value_type, a13, IN, osg::Matrixd::value_type, a20, IN, osg::Matrixd::value_type, a21, IN, osg::Matrixd::value_type, a22, IN, osg::Matrixd::value_type, a23, IN, osg::Matrixd::value_type, a30, IN, osg::Matrixd::value_type, a31, IN, osg::Matrixd::value_type, a32, IN, osg::Matrixd::value_type, a33); + Method1(void, set, IN, const osg::Quat &, q); + Method1(void, get, IN, osg::Quat &, q); + Method0(osg::Matrixd::value_type *, ptr); + Method0(const osg::Matrixd::value_type *, ptr); + Method0(void, makeIdentity); + Method1(void, makeScale, IN, const osg::Vec3f &, x); + Method1(void, makeScale, IN, const osg::Vec3d &, x); + Method3(void, makeScale, IN, osg::Matrixd::value_type, x, IN, osg::Matrixd::value_type, x, IN, osg::Matrixd::value_type, x); + Method1(void, makeTranslate, IN, const osg::Vec3f &, x); + Method1(void, makeTranslate, IN, const osg::Vec3d &, x); + Method3(void, makeTranslate, IN, osg::Matrixd::value_type, x, IN, osg::Matrixd::value_type, x, IN, osg::Matrixd::value_type, x); + Method2(void, makeRotate, IN, const osg::Vec3f &, from, IN, const osg::Vec3f &, to); + Method2(void, makeRotate, IN, const osg::Vec3d &, from, IN, const osg::Vec3d &, to); + Method2(void, makeRotate, IN, osg::Matrixd::value_type, angle, IN, const osg::Vec3f &, axis); + Method2(void, makeRotate, IN, osg::Matrixd::value_type, angle, IN, const osg::Vec3d &, axis); + Method4(void, makeRotate, IN, osg::Matrixd::value_type, angle, IN, osg::Matrixd::value_type, x, IN, osg::Matrixd::value_type, y, IN, osg::Matrixd::value_type, z); + Method1(void, makeRotate, IN, const osg::Quat &, x); + Method6(void, makeRotate, IN, osg::Matrixd::value_type, angle1, IN, const osg::Vec3f &, axis1, IN, osg::Matrixd::value_type, angle2, IN, const osg::Vec3f &, axis2, IN, osg::Matrixd::value_type, angle3, IN, const osg::Vec3f &, axis3); + Method6(void, makeRotate, IN, osg::Matrixd::value_type, angle1, IN, const osg::Vec3d &, axis1, IN, osg::Matrixd::value_type, angle2, IN, const osg::Vec3d &, axis2, IN, osg::Matrixd::value_type, angle3, IN, const osg::Vec3d &, axis3); + Method6(void, makeOrtho, IN, double, left, IN, double, right, IN, double, bottom, IN, double, top, IN, double, zNear, IN, double, zFar); + Method6(bool, getOrtho, IN, double &, left, IN, double &, right, IN, double &, bottom, IN, double &, top, IN, double &, zNear, IN, double &, zFar); + Method4(void, makeOrtho2D, IN, double, left, IN, double, right, IN, double, bottom, IN, double, top); + Method6(void, makeFrustum, IN, double, left, IN, double, right, IN, double, bottom, IN, double, top, IN, double, zNear, IN, double, zFar); + Method6(bool, getFrustum, IN, double &, left, IN, double &, right, IN, double &, bottom, IN, double &, top, IN, double &, zNear, IN, double &, zFar); + Method4(void, makePerspective, IN, double, fovy, IN, double, aspectRatio, IN, double, zNear, IN, double, zFar); + Method4(bool, getPerspective, IN, double &, fovy, IN, double &, aspectRatio, IN, double &, zNear, IN, double &, zFar); + Method3(void, makeLookAt, IN, const osg::Vec3d &, eye, IN, const osg::Vec3d &, center, IN, const osg::Vec3d &, up); + MethodWithDefaults4(void, getLookAt, IN, osg::Vec3f &, eye, , IN, osg::Vec3f &, center, , IN, osg::Vec3f &, up, , IN, osg::Matrixd::value_type, lookDistance, 1.0f); + MethodWithDefaults4(void, getLookAt, IN, osg::Vec3d &, eye, , IN, osg::Vec3d &, center, , IN, osg::Vec3d &, up, , IN, osg::Matrixd::value_type, lookDistance, 1.0f); + Method1(bool, invert, IN, const osg::Matrixd &, rhs); + Method1(bool, invert_4x4_orig, IN, const osg::Matrixd &, x); + Method1(bool, invert_4x4_new, IN, const osg::Matrixd &, x); + Method1(osg::Vec3f, preMult, IN, const osg::Vec3f &, v); + Method1(osg::Vec3d, preMult, IN, const osg::Vec3d &, v); + Method1(osg::Vec3f, postMult, IN, const osg::Vec3f &, v); + Method1(osg::Vec3d, postMult, IN, const osg::Vec3d &, v); + Method1(osg::Vec4f, preMult, IN, const osg::Vec4f &, v); + Method1(osg::Vec4d, preMult, IN, const osg::Vec4d &, v); + Method1(osg::Vec4f, postMult, IN, const osg::Vec4f &, v); + Method1(osg::Vec4d, postMult, IN, const osg::Vec4d &, v); + Method3(void, setTrans, IN, osg::Matrixd::value_type, tx, IN, osg::Matrixd::value_type, ty, IN, osg::Matrixd::value_type, tz); + Method1(void, setTrans, IN, const osg::Vec3f &, v); + Method1(void, setTrans, IN, const osg::Vec3d &, v); + Method0(osg::Vec3d, getTrans); + Method0(osg::Vec3d, getScale); + Method2(void, mult, IN, const osg::Matrixd &, x, IN, const osg::Matrixd &, x); + Method1(void, preMult, IN, const osg::Matrixd &, x); + Method1(void, postMult, IN, const osg::Matrixd &, x); + WriteOnlyProperty(float const *const, ); + ReadOnlyProperty(osg::Vec3d, Scale); + ReadOnlyProperty(osg::Vec3d, Trans); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::RefMatrixd) + BaseType(osg::Object); + BaseType(osg::Matrixd); + Constructor0(); + Constructor1(IN, const osg::Matrixd &, other); + Constructor1(IN, const osg::Matrixf &, other); + Constructor1(IN, const osg::RefMatrixd &, other); + Constructor1(IN, osg::Matrixd::value_type const *const, def); + Constructor16(IN, osg::Matrixd::value_type, a00, IN, osg::Matrixd::value_type, a01, IN, osg::Matrixd::value_type, a02, IN, osg::Matrixd::value_type, a03, IN, osg::Matrixd::value_type, a10, IN, osg::Matrixd::value_type, a11, IN, osg::Matrixd::value_type, a12, IN, osg::Matrixd::value_type, a13, IN, osg::Matrixd::value_type, a20, IN, osg::Matrixd::value_type, a21, IN, osg::Matrixd::value_type, a22, IN, osg::Matrixd::value_type, a23, IN, osg::Matrixd::value_type, a30, IN, osg::Matrixd::value_type, a31, IN, osg::Matrixd::value_type, a32, IN, osg::Matrixd::value_type, a33); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, x); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Matrixf.cpp b/src/osgWrappers/osg/Matrixf.cpp new file mode 100644 index 000000000..214cab6d7 --- /dev/null +++ b/src/osgWrappers/osg/Matrixf.cpp @@ -0,0 +1,108 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(float, osg::Matrixf::value_type); + +BEGIN_VALUE_REFLECTOR(osg::Matrixf) + Constructor0(); + Constructor1(IN, const osg::Matrixf &, mat); + Constructor1(IN, const osg::Matrixd &, mat); + Constructor1(IN, float const *const, ptr); + Constructor1(IN, double const *const, ptr); + Constructor1(IN, const osg::Quat &, quat); + Constructor16(IN, osg::Matrixf::value_type, a00, IN, osg::Matrixf::value_type, a01, IN, osg::Matrixf::value_type, a02, IN, osg::Matrixf::value_type, a03, IN, osg::Matrixf::value_type, a10, IN, osg::Matrixf::value_type, a11, IN, osg::Matrixf::value_type, a12, IN, osg::Matrixf::value_type, a13, IN, osg::Matrixf::value_type, a20, IN, osg::Matrixf::value_type, a21, IN, osg::Matrixf::value_type, a22, IN, osg::Matrixf::value_type, a23, IN, osg::Matrixf::value_type, a30, IN, osg::Matrixf::value_type, a31, IN, osg::Matrixf::value_type, a32, IN, osg::Matrixf::value_type, a33); + Method1(int, compare, IN, const osg::Matrixf &, m); + Method0(bool, valid); + Method0(bool, isNaN); + Method1(void, set, IN, const osg::Matrixf &, rhs); + Method1(void, set, IN, const osg::Matrixd &, rhs); + Method1(void, set, IN, float const *const, ptr); + Method1(void, set, IN, double const *const, ptr); + Method16(void, set, IN, osg::Matrixf::value_type, a00, IN, osg::Matrixf::value_type, a01, IN, osg::Matrixf::value_type, a02, IN, osg::Matrixf::value_type, a03, IN, osg::Matrixf::value_type, a10, IN, osg::Matrixf::value_type, a11, IN, osg::Matrixf::value_type, a12, IN, osg::Matrixf::value_type, a13, IN, osg::Matrixf::value_type, a20, IN, osg::Matrixf::value_type, a21, IN, osg::Matrixf::value_type, a22, IN, osg::Matrixf::value_type, a23, IN, osg::Matrixf::value_type, a30, IN, osg::Matrixf::value_type, a31, IN, osg::Matrixf::value_type, a32, IN, osg::Matrixf::value_type, a33); + Method1(void, set, IN, const osg::Quat &, q); + Method1(void, get, IN, osg::Quat &, q); + Method0(osg::Matrixf::value_type *, ptr); + Method0(const osg::Matrixf::value_type *, ptr); + Method0(void, makeIdentity); + Method1(void, makeScale, IN, const osg::Vec3f &, x); + Method1(void, makeScale, IN, const osg::Vec3d &, x); + Method3(void, makeScale, IN, osg::Matrixf::value_type, x, IN, osg::Matrixf::value_type, x, IN, osg::Matrixf::value_type, x); + Method1(void, makeTranslate, IN, const osg::Vec3f &, x); + Method1(void, makeTranslate, IN, const osg::Vec3d &, x); + Method3(void, makeTranslate, IN, osg::Matrixf::value_type, x, IN, osg::Matrixf::value_type, x, IN, osg::Matrixf::value_type, x); + Method2(void, makeRotate, IN, const osg::Vec3f &, from, IN, const osg::Vec3f &, to); + Method2(void, makeRotate, IN, const osg::Vec3d &, from, IN, const osg::Vec3d &, to); + Method2(void, makeRotate, IN, osg::Matrixf::value_type, angle, IN, const osg::Vec3f &, axis); + Method2(void, makeRotate, IN, osg::Matrixf::value_type, angle, IN, const osg::Vec3d &, axis); + Method4(void, makeRotate, IN, osg::Matrixf::value_type, angle, IN, osg::Matrixf::value_type, x, IN, osg::Matrixf::value_type, y, IN, osg::Matrixf::value_type, z); + Method1(void, makeRotate, IN, const osg::Quat &, x); + Method6(void, makeRotate, IN, osg::Matrixf::value_type, angle1, IN, const osg::Vec3f &, axis1, IN, osg::Matrixf::value_type, angle2, IN, const osg::Vec3f &, axis2, IN, osg::Matrixf::value_type, angle3, IN, const osg::Vec3f &, axis3); + Method6(void, makeRotate, IN, osg::Matrixf::value_type, angle1, IN, const osg::Vec3d &, axis1, IN, osg::Matrixf::value_type, angle2, IN, const osg::Vec3d &, axis2, IN, osg::Matrixf::value_type, angle3, IN, const osg::Vec3d &, axis3); + Method6(void, makeOrtho, IN, double, left, IN, double, right, IN, double, bottom, IN, double, top, IN, double, zNear, IN, double, zFar); + Method6(bool, getOrtho, IN, double &, left, IN, double &, right, IN, double &, bottom, IN, double &, top, IN, double &, zNear, IN, double &, zFar); + Method4(void, makeOrtho2D, IN, double, left, IN, double, right, IN, double, bottom, IN, double, top); + Method6(void, makeFrustum, IN, double, left, IN, double, right, IN, double, bottom, IN, double, top, IN, double, zNear, IN, double, zFar); + Method6(bool, getFrustum, IN, double &, left, IN, double &, right, IN, double &, bottom, IN, double &, top, IN, double &, zNear, IN, double &, zFar); + Method4(void, makePerspective, IN, double, fovy, IN, double, aspectRatio, IN, double, zNear, IN, double, zFar); + Method4(bool, getPerspective, IN, double &, fovy, IN, double &, aspectRatio, IN, double &, zNear, IN, double &, zFar); + Method3(void, makeLookAt, IN, const osg::Vec3d &, eye, IN, const osg::Vec3d &, center, IN, const osg::Vec3d &, up); + MethodWithDefaults4(void, getLookAt, IN, osg::Vec3f &, eye, , IN, osg::Vec3f &, center, , IN, osg::Vec3f &, up, , IN, osg::Matrixf::value_type, lookDistance, 1.0f); + MethodWithDefaults4(void, getLookAt, IN, osg::Vec3d &, eye, , IN, osg::Vec3d &, center, , IN, osg::Vec3d &, up, , IN, osg::Matrixf::value_type, lookDistance, 1.0f); + Method1(bool, invert, IN, const osg::Matrixf &, rhs); + Method1(bool, invert_4x4_orig, IN, const osg::Matrixf &, x); + Method1(bool, invert_4x4_new, IN, const osg::Matrixf &, x); + Method1(osg::Vec3f, preMult, IN, const osg::Vec3f &, v); + Method1(osg::Vec3d, preMult, IN, const osg::Vec3d &, v); + Method1(osg::Vec3f, postMult, IN, const osg::Vec3f &, v); + Method1(osg::Vec3d, postMult, IN, const osg::Vec3d &, v); + Method1(osg::Vec4f, preMult, IN, const osg::Vec4f &, v); + Method1(osg::Vec4d, preMult, IN, const osg::Vec4d &, v); + Method1(osg::Vec4f, postMult, IN, const osg::Vec4f &, v); + Method1(osg::Vec4d, postMult, IN, const osg::Vec4d &, v); + Method3(void, setTrans, IN, osg::Matrixf::value_type, tx, IN, osg::Matrixf::value_type, ty, IN, osg::Matrixf::value_type, tz); + Method1(void, setTrans, IN, const osg::Vec3f &, v); + Method1(void, setTrans, IN, const osg::Vec3d &, v); + Method0(osg::Vec3d, getTrans); + Method0(osg::Vec3d, getScale); + Method2(void, mult, IN, const osg::Matrixf &, x, IN, const osg::Matrixf &, x); + Method1(void, preMult, IN, const osg::Matrixf &, x); + Method1(void, postMult, IN, const osg::Matrixf &, x); + WriteOnlyProperty(float const *const, ); + ReadOnlyProperty(osg::Vec3d, Scale); + ReadOnlyProperty(osg::Vec3d, Trans); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::RefMatrixf) + BaseType(osg::Object); + BaseType(osg::Matrixf); + Constructor0(); + Constructor1(IN, const osg::Matrixf &, other); + Constructor1(IN, const osg::Matrixd &, other); + Constructor1(IN, const osg::RefMatrixf &, other); + Constructor1(IN, osg::Matrixf::value_type const *const, def); + Constructor16(IN, osg::Matrixf::value_type, a00, IN, osg::Matrixf::value_type, a01, IN, osg::Matrixf::value_type, a02, IN, osg::Matrixf::value_type, a03, IN, osg::Matrixf::value_type, a10, IN, osg::Matrixf::value_type, a11, IN, osg::Matrixf::value_type, a12, IN, osg::Matrixf::value_type, a13, IN, osg::Matrixf::value_type, a20, IN, osg::Matrixf::value_type, a21, IN, osg::Matrixf::value_type, a22, IN, osg::Matrixf::value_type, a23, IN, osg::Matrixf::value_type, a30, IN, osg::Matrixf::value_type, a31, IN, osg::Matrixf::value_type, a32, IN, osg::Matrixf::value_type, a33); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, x); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Multisample.cpp b/src/osgWrappers/osg/Multisample.cpp new file mode 100644 index 000000000..609a23823 --- /dev/null +++ b/src/osgWrappers/osg/Multisample.cpp @@ -0,0 +1,65 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::Multisample::Mode) + EnumLabel(osg::Multisample::FASTEST); + EnumLabel(osg::Multisample::NICEST); + EnumLabel(osg::Multisample::DONT_CARE); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Multisample) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Multisample &, trans, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method2(void, setSampleCoverage, IN, float, coverage, IN, bool, invert); + Method1(void, setCoverage, IN, float, coverage); + Method0(float, getCoverage); + Method1(void, setInvert, IN, bool, invert); + Method0(bool, getInvert); + Method1(void, setHint, IN, osg::Multisample::Mode, mode); + Method0(osg::Multisample::Mode, getHint); + Method1(void, apply, IN, osg::State &, state); + Property(float, Coverage); + Property(osg::Multisample::Mode, Hint); + Property(bool, Invert); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Multisample::Extensions) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::Multisample::Extensions &, rhs); + Method1(void, lowestCommonDenominator, IN, const osg::Multisample::Extensions &, rhs); + Method0(void, setupGLExtenions); + Method1(void, setMultisampleSupported, IN, bool, flag); + Method1(void, setMultisampleFilterHintSupported, IN, bool, flag); + Method0(bool, isMultisampleSupported); + Method0(bool, isMultisampleFilterHintSupported); + Method1(void, setSampleCoverageProc, IN, void *, ptr); + Method2(void, glSampleCoverage, IN, GLclampf, value, IN, GLboolean, invert); + WriteOnlyProperty(bool, MultisampleFilterHintSupported); + WriteOnlyProperty(bool, MultisampleSupported); + WriteOnlyProperty(void *, SampleCoverageProc); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Node.cpp b/src/osgWrappers/osg/Node.cpp index 7bef6414e..421a7575e 100644 --- a/src/osgWrappers/osg/Node.cpp +++ b/src/osgWrappers/osg/Node.cpp @@ -1,23 +1,103 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include -#include +#include +#include #include +#include +#include +#include +#include +#include +#include -using namespace osgIntrospection; +TYPE_NAME_ALIAS(std::vector< osg::Group * >, osg::Node::ParentList); -BEGIN_OBJECT_REFLECTOR(osg::NodeCallback) - BaseType(osg::Object); - Property(osg::NodeCallback *, NestedCallback); -END_REFLECTOR - -BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Node) +TYPE_NAME_ALIAS(unsigned int, osg::Node::NodeMask); + +TYPE_NAME_ALIAS(std::vector< std::string >, osg::Node::DescriptionList); + +BEGIN_OBJECT_REFLECTOR(osg::Node) BaseType(osg::Object); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Node &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::Group *, asGroup); + Method0(const osg::Group *, asGroup); + Method0(osg::Transform *, asTransform); + Method0(const osg::Transform *, asTransform); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, ascend, IN, osg::NodeVisitor &, nv); + Method1(void, traverse, IN, osg::NodeVisitor &, x); + Method1(void, setName, IN, const std::string &, name); + Method1(void, setName, IN, const char *, name); + Method0(const std::string &, getName); + Method0(const osg::Node::ParentList &, getParents); + Method0(osg::Node::ParentList, getParents); + Method1(osg::Group *, getParent, IN, unsigned int, i); + Method1(const osg::Group *, getParent, IN, unsigned int, i); + Method0(unsigned int, getNumParents); + Method1(void, setUpdateCallback, IN, osg::NodeCallback *, nc); + Method0(osg::NodeCallback *, getUpdateCallback); + Method0(const osg::NodeCallback *, getUpdateCallback); + Method0(unsigned int, getNumChildrenRequiringUpdateTraversal); + Method1(void, setEventCallback, IN, osg::NodeCallback *, nc); + Method0(osg::NodeCallback *, getEventCallback); + Method0(const osg::NodeCallback *, getEventCallback); + Method0(unsigned int, getNumChildrenRequiringEventTraversal); + Method1(void, setCullCallback, IN, osg::NodeCallback *, nc); + Method0(osg::NodeCallback *, getCullCallback); + Method0(const osg::NodeCallback *, getCullCallback); + Method1(void, setCullingActive, IN, bool, active); + Method0(bool, getCullingActive); + Method0(unsigned int, getNumChildrenWithCullingDisabled); + Method0(bool, isCullingActive); + Method0(unsigned int, getNumChildrenWithOccluderNodes); + Method0(bool, containsOccluderNodes); + Method1(void, setNodeMask, IN, osg::Node::NodeMask, nm); + Method0(osg::Node::NodeMask, getNodeMask); + Method1(void, setDescriptions, IN, const osg::Node::DescriptionList &, descriptions); + Method0(osg::Node::DescriptionList &, getDescriptions); + Method0(const osg::Node::DescriptionList &, getDescriptions); + Method1(const std::string &, getDescription, IN, unsigned int, i); + Method1(std::string &, getDescription, IN, unsigned int, i); + Method0(unsigned int, getNumDescriptions); + Method1(void, addDescription, IN, const std::string &, desc); + Method1(void, setStateSet, IN, osg::StateSet *, dstate); + Method0(osg::StateSet *, getOrCreateStateSet); + Method0(osg::StateSet *, getStateSet); + Method0(const osg::StateSet *, getStateSet); + Method0(const osg::BoundingSphere &, getBound); + Method0(void, dirtyBound); + ReadOnlyProperty(const osg::BoundingSphere &, Bound); + Property(osg::NodeCallback *, CullCallback); + Property(bool, CullingActive); + ArrayProperty_GA(const std::string &, Description, Descriptions, unsigned int, void); + Property(const osg::Node::DescriptionList &, Descriptions); + Property(osg::NodeCallback *, EventCallback); Property(const std::string &, Name); - Property(osg::NodeCallback *, UpdateCallback); - Property(osg::StateSet *, StateSet); + Property(osg::Node::NodeMask, NodeMask); + ArrayProperty_G(osg::Group *, Parent, Parents, unsigned int, void); ReadOnlyProperty(osg::Node::ParentList, Parents); + Property(osg::StateSet *, StateSet); + Property(osg::NodeCallback *, UpdateCallback); END_REFLECTOR -STD_CONTAINER_REFLECTOR(osg::Node::ParentList); +TYPE_NAME_ALIAS(std::vector< osg::Node * >, osg::NodePath); + +STD_VECTOR_REFLECTOR(std::vector< osg::Group * >); + +STD_VECTOR_REFLECTOR(std::vector< std::string >); + diff --git a/src/osgWrappers/osg/NodeCallback.cpp b/src/osgWrappers/osg/NodeCallback.cpp new file mode 100644 index 000000000..2332a9e09 --- /dev/null +++ b/src/osgWrappers/osg/NodeCallback.cpp @@ -0,0 +1,35 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::NodeCallback) + VirtualBaseType(osg::Object); + Constructor0(); + Constructor2(IN, const osg::NodeCallback &, nc, IN, const osg::CopyOp &, x); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method2(void, traverse, IN, osg::Node *, node, IN, osg::NodeVisitor *, nv); + Method1(void, setNestedCallback, IN, osg::NodeCallback *, nc); + Method0(osg::NodeCallback *, getNestedCallback); + Method0(const osg::NodeCallback *, getNestedCallback); + Method1(void, addNestedCallback, IN, osg::NodeCallback *, nc); + Method1(void, removeNestedCallback, IN, osg::NodeCallback *, nc); + Property(osg::NodeCallback *, NestedCallback); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/NodeVisitor.cpp b/src/osgWrappers/osg/NodeVisitor.cpp new file mode 100644 index 000000000..b137405f4 --- /dev/null +++ b/src/osgWrappers/osg/NodeVisitor.cpp @@ -0,0 +1,123 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +BEGIN_VALUE_REFLECTOR(osg::NodeAcceptOp) + Constructor1(IN, osg::NodeVisitor &, nv); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::NodeVisitor::TraversalMode) + EnumLabel(osg::NodeVisitor::TRAVERSE_NONE); + EnumLabel(osg::NodeVisitor::TRAVERSE_PARENTS); + EnumLabel(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN); + EnumLabel(osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::NodeVisitor::VisitorType) + EnumLabel(osg::NodeVisitor::NODE_VISITOR); + EnumLabel(osg::NodeVisitor::UPDATE_VISITOR); + EnumLabel(osg::NodeVisitor::EVENT_VISITOR); + EnumLabel(osg::NodeVisitor::COLLECT_OCCLUDER_VISITOR); + EnumLabel(osg::NodeVisitor::CULL_VISITOR); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::NodeVisitor) + VirtualBaseType(osg::Referenced); + ConstructorWithDefaults1(IN, osg::NodeVisitor::TraversalMode, tm, osg::NodeVisitor::TRAVERSE_NONE); + ConstructorWithDefaults2(IN, osg::NodeVisitor::VisitorType, type, , IN, osg::NodeVisitor::TraversalMode, tm, osg::NodeVisitor::TRAVERSE_NONE); + Method0(void, reset); + Method1(void, setVisitorType, IN, osg::NodeVisitor::VisitorType, type); + Method0(osg::NodeVisitor::VisitorType, getVisitorType); + Method1(void, setTraversalNumber, IN, int, fn); + Method0(int, getTraversalNumber); + Method1(void, setFrameStamp, IN, osg::FrameStamp *, fs); + Method0(const osg::FrameStamp *, getFrameStamp); + Method1(void, setTraversalMask, IN, osg::Node::NodeMask, mask); + Method0(osg::Node::NodeMask, getTraversalMask); + Method1(void, setNodeMaskOverride, IN, osg::Node::NodeMask, mask); + Method0(osg::Node::NodeMask, getNodeMaskOverride); + Method1(bool, validNodeMask, IN, const osg::Node &, node); + Method1(void, setTraversalMode, IN, osg::NodeVisitor::TraversalMode, mode); + Method0(osg::NodeVisitor::TraversalMode, getTraversalMode); + Method1(void, setUserData, IN, osg::Referenced *, obj); + Method0(osg::Referenced *, getUserData); + Method0(const osg::Referenced *, getUserData); + Method1(void, traverse, IN, osg::Node &, node); + Method1(void, pushOntoNodePath, IN, osg::Node *, node); + Method0(void, popFromNodePath); + Method0(osg::NodePath &, getNodePath); + Method0(const osg::NodePath &, getNodePath); + Method0(osg::Vec3, getEyePoint); + Method2(float, getDistanceToEyePoint, IN, const osg::Vec3 &, x, IN, bool, x); + Method2(float, getDistanceFromEyePoint, IN, const osg::Vec3 &, x, IN, bool, x); + Method1(void, apply, IN, osg::Node &, node); + Method1(void, apply, IN, osg::Geode &, node); + Method1(void, apply, IN, osg::Billboard &, node); + Method1(void, apply, IN, osg::Group &, node); + Method1(void, apply, IN, osg::Projection &, node); + Method1(void, apply, IN, osg::CoordinateSystemNode &, node); + Method1(void, apply, IN, osg::ClipNode &, node); + Method1(void, apply, IN, osg::TexGenNode &, node); + Method1(void, apply, IN, osg::LightSource &, node); + Method1(void, apply, IN, osg::Transform &, node); + Method1(void, apply, IN, osg::MatrixTransform &, node); + Method1(void, apply, IN, osg::PositionAttitudeTransform &, node); + Method1(void, apply, IN, osg::Switch &, node); + Method1(void, apply, IN, osg::Sequence &, node); + Method1(void, apply, IN, osg::LOD &, node); + Method1(void, apply, IN, osg::PagedLOD &, node); + Method1(void, apply, IN, osg::Impostor &, node); + Method1(void, apply, IN, osg::ClearNode &, node); + Method1(void, apply, IN, osg::OccluderNode &, node); + Method1(void, setDatabaseRequestHandler, IN, osg::NodeVisitor::DatabaseRequestHandler *, handler); + Method0(osg::NodeVisitor::DatabaseRequestHandler *, getDatabaseRequestHandler); + Method0(const osg::NodeVisitor::DatabaseRequestHandler *, getDatabaseRequestHandler); + Property(osg::NodeVisitor::DatabaseRequestHandler *, DatabaseRequestHandler); + ReadOnlyProperty(osg::Vec3, EyePoint); + WriteOnlyProperty(osg::FrameStamp *, FrameStamp); + Property(osg::Node::NodeMask, NodeMaskOverride); + ReadOnlyProperty(osg::NodePath &, NodePath); + Property(osg::Node::NodeMask, TraversalMask); + Property(osg::NodeVisitor::TraversalMode, TraversalMode); + Property(int, TraversalNumber); + Property(osg::Referenced *, UserData); + Property(osg::NodeVisitor::VisitorType, VisitorType); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::NodeVisitor::DatabaseRequestHandler) + BaseType(osg::Referenced); + Constructor0(); + Method4(void, requestNodeFile, IN, const std::string &, fileName, IN, osg::Group *, group, IN, float, priority, IN, const osg::FrameStamp *, framestamp); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Object.cpp b/src/osgWrappers/osg/Object.cpp index e0c58987a..89d427c93 100644 --- a/src/osgWrappers/osg/Object.cpp +++ b/src/osgWrappers/osg/Object.cpp @@ -1,23 +1,38 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include +#include #include - -using namespace osgIntrospection; - -// simple reflectors for types that are considered 'atomic' -ABSTRACT_OBJECT_REFLECTOR(osg::Referenced) +#include BEGIN_ENUM_REFLECTOR(osg::Object::DataVariance) - EnumLabel(osg::Object::STATIC); EnumLabel(osg::Object::DYNAMIC); + EnumLabel(osg::Object::STATIC); END_REFLECTOR BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Object) BaseType(osg::Referenced); - Property(osg::Object::DataVariance, DataVariance); - + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Object &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, x); + Method1(bool, isSameKindAs, IN, const osg::Object *, x); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, setDataVariance, IN, osg::Object::DataVariance, dv); + Method0(osg::Object::DataVariance, getDataVariance); + Method1(void, setUserData, IN, osg::Referenced *, obj); + Method0(osg::Referenced *, getUserData); + Method0(const osg::Referenced *, getUserData); + Property(osg::Object::DataVariance, DataVariance); Property(osg::Referenced *, UserData); - Attribute(DefaultValueAttribute(0)); END_REFLECTOR + diff --git a/src/osgWrappers/osg/OccluderNode.cpp b/src/osgWrappers/osg/OccluderNode.cpp new file mode 100644 index 000000000..4316e7d8f --- /dev/null +++ b/src/osgWrappers/osg/OccluderNode.cpp @@ -0,0 +1,33 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::OccluderNode) + BaseType(osg::Group); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::OccluderNode &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, setOccluder, IN, osg::ConvexPlanarOccluder *, occluder); + Method0(osg::ConvexPlanarOccluder *, getOccluder); + Method0(const osg::ConvexPlanarOccluder *, getOccluder); + Property(osg::ConvexPlanarOccluder *, Occluder); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/PagedLOD.cpp b/src/osgWrappers/osg/PagedLOD.cpp new file mode 100644 index 000000000..70c685618 --- /dev/null +++ b/src/osgWrappers/osg/PagedLOD.cpp @@ -0,0 +1,70 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< osg::PagedLOD::PerRangeData >, osg::PagedLOD::PerRangeDataList); + +BEGIN_OBJECT_REFLECTOR(osg::PagedLOD) + BaseType(osg::LOD); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::PagedLOD &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, traverse, IN, osg::NodeVisitor &, nv); + Method1(bool, addChild, IN, osg::Node *, child); + Method3(bool, addChild, IN, osg::Node *, child, IN, float, min, IN, float, max); + MethodWithDefaults6(bool, addChild, IN, osg::Node *, child, , IN, float, min, , IN, float, max, , IN, const std::string &, filename, , IN, float, priorityOffset, 0.0f, IN, float, priorityScale, 1.0f); + Method1(bool, removeChild, IN, osg::Node *, child); + Method1(void, setDatabasePath, IN, const std::string &, path); + Method0(const std::string &, getDatabasePath); + Method2(void, setFileName, IN, unsigned int, childNo, IN, const std::string &, filename); + Method1(const std::string &, getFileName, IN, unsigned int, childNo); + Method0(unsigned int, getNumFileNames); + Method2(void, setPriorityOffset, IN, unsigned int, childNo, IN, float, priorityOffset); + Method1(float, getPriorityOffset, IN, unsigned int, childNo); + Method0(unsigned int, getNumPriorityOffsets); + Method2(void, setPriorityScale, IN, unsigned int, childNo, IN, float, priorityScale); + Method1(float, getPriorityScale, IN, unsigned int, childNo); + Method0(unsigned int, getNumPriorityScales); + Method2(void, setTimeStamp, IN, unsigned int, childNo, IN, double, timeStamp); + Method1(double, getTimeStamp, IN, unsigned int, childNo); + Method0(unsigned int, getNumTimeStamps); + Method1(void, setFrameNumberOfLastTraversal, IN, int, frameNumber); + Method0(int, getFrameNumberOfLastTraversal); + Method1(void, setNumChildrenThatCannotBeExpired, IN, unsigned int, num); + Method0(unsigned int, getNumChildrenThatCannotBeExpired); + Method2(bool, removeExpiredChildren, IN, double, expiryTime, IN, osg::NodeList &, removedChildren); + Property(const std::string &, DatabasePath); + ArrayProperty_G(const std::string &, FileName, FileNames, unsigned int, void); + Property(int, FrameNumberOfLastTraversal); + WriteOnlyProperty(unsigned int, NumChildrenThatCannotBeExpired); + ArrayProperty_G(float, PriorityOffset, PriorityOffsets, unsigned int, void); + ArrayProperty_G(float, PriorityScale, PriorityScales, unsigned int, void); + ArrayProperty_G(double, TimeStamp, TimeStamps, unsigned int, void); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::PagedLOD::PerRangeData) + Constructor0(); + Constructor1(IN, const osg::PagedLOD::PerRangeData &, prd); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< osg::PagedLOD::PerRangeData >); + diff --git a/src/osgWrappers/osg/Plane.cpp b/src/osgWrappers/osg/Plane.cpp new file mode 100644 index 000000000..e570b1563 --- /dev/null +++ b/src/osgWrappers/osg/Plane.cpp @@ -0,0 +1,50 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_VALUE_REFLECTOR(osg::Plane) + Constructor0(); + Constructor1(IN, const osg::Plane &, pl); + Constructor4(IN, float, a, IN, float, b, IN, float, c, IN, float, d); + Constructor1(IN, const osg::Vec4 &, vec); + Constructor2(IN, const osg::Vec3 &, norm, IN, float, d); + Constructor3(IN, const osg::Vec3 &, v1, IN, const osg::Vec3 &, v2, IN, const osg::Vec3 &, v3); + Method1(void, set, IN, const osg::Plane &, pl); + Method4(void, set, IN, float, a, IN, float, b, IN, float, c, IN, float, d); + Method1(void, set, IN, const osg::Vec4 &, vec); + Method2(void, set, IN, const osg::Vec3 &, norm, IN, float, d); + Method3(void, set, IN, const osg::Vec3 &, v1, IN, const osg::Vec3 &, v2, IN, const osg::Vec3 &, v3); + Method2(void, set, IN, const osg::Vec3 &, norm, IN, const osg::Vec3 &, point); + Method0(void, flip); + Method0(void, makeUnitLength); + Method0(void, calculateUpperLowerBBCorners); + Method0(bool, valid); + Method0(float *, ptr); + Method0(const float *, ptr); + Method0(osg::Vec4 &, asVec4); + Method0(const osg::Vec4 &, asVec4); + Method0(osg::Vec3, getNormal); + Method1(float, distance, IN, const osg::Vec3 &, v); + Method1(int, intersect, IN, const std::vector< osg::Vec3 > &, vertices); + Method1(int, intersect, IN, const osg::BoundingSphere &, bs); + Method1(int, intersect, IN, const osg::BoundingBox &, bb); + Method1(void, transform, IN, const osg::Matrix &, matrix); + Method1(void, transformProvidingInverse, IN, const osg::Matrix &, matrix); + WriteOnlyProperty(const osg::Vec4 &, ); + ReadOnlyProperty(osg::Vec3, Normal); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Point.cpp b/src/osgWrappers/osg/Point.cpp new file mode 100644 index 000000000..15b2efe7b --- /dev/null +++ b/src/osgWrappers/osg/Point.cpp @@ -0,0 +1,49 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::Point) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Point &, point, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setSize, IN, float, size); + Method0(float, getSize); + Method1(void, setFadeThresholdSize, IN, float, fadeThresholdSize); + Method0(float, getFadeThresholdSize); + Method1(void, setDistanceAttenuation, IN, const osg::Vec3 &, distanceAttenuation); + Method0(const osg::Vec3 &, getDistanceAttenuation); + Method1(void, setMinSize, IN, float, minSize); + Method0(float, getMinSize); + Method1(void, setMaxSize, IN, float, maxSize); + Method0(float, getMaxSize); + Method1(void, apply, IN, osg::State &, state); + Property(const osg::Vec3 &, DistanceAttenuation); + Property(float, FadeThresholdSize); + Property(float, MaxSize); + Property(float, MinSize); + Property(float, Size); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/PointSprite.cpp b/src/osgWrappers/osg/PointSprite.cpp new file mode 100644 index 000000000..8da25a82f --- /dev/null +++ b/src/osgWrappers/osg/PointSprite.cpp @@ -0,0 +1,34 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::PointSprite) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::PointSprite &, texenv, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method0(bool, isTextureAttribute); + Method1(void, apply, IN, osg::State &, state); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/PolygonMode.cpp b/src/osgWrappers/osg/PolygonMode.cpp new file mode 100644 index 000000000..44a58dcb4 --- /dev/null +++ b/src/osgWrappers/osg/PolygonMode.cpp @@ -0,0 +1,49 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::PolygonMode::Mode) + EnumLabel(osg::PolygonMode::POINT); + EnumLabel(osg::PolygonMode::LINE); + EnumLabel(osg::PolygonMode::FILL); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::PolygonMode::Face) + EnumLabel(osg::PolygonMode::FRONT_AND_BACK); + EnumLabel(osg::PolygonMode::FRONT); + EnumLabel(osg::PolygonMode::BACK); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::PolygonMode) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::PolygonMode &, pm, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method2(void, setMode, IN, osg::PolygonMode::Face, face, IN, osg::PolygonMode::Mode, mode); + Method1(osg::PolygonMode::Mode, getMode, IN, osg::PolygonMode::Face, face); + Method0(bool, getFrontAndBack); + Method1(void, apply, IN, osg::State &, state); + ReadOnlyProperty(bool, FrontAndBack); + IndexedProperty1(osg::PolygonMode::Mode, Mode, osg::PolygonMode::Face, face); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/PolygonOffset.cpp b/src/osgWrappers/osg/PolygonOffset.cpp new file mode 100644 index 000000000..3ea8d6513 --- /dev/null +++ b/src/osgWrappers/osg/PolygonOffset.cpp @@ -0,0 +1,40 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::PolygonOffset) + BaseType(osg::StateAttribute); + Constructor0(); + Constructor2(IN, float, factor, IN, float, units); + ConstructorWithDefaults2(IN, const osg::PolygonOffset &, po, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setFactor, IN, float, factor); + Method0(float, getFactor); + Method1(void, setUnits, IN, float, units); + Method0(float, getUnits); + Method1(void, apply, IN, osg::State &, state); + Property(float, Factor); + ReadOnlyProperty(osg::StateAttribute::Type, Type); + Property(float, Units); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/PolygonStipple.cpp b/src/osgWrappers/osg/PolygonStipple.cpp new file mode 100644 index 000000000..a06602a65 --- /dev/null +++ b/src/osgWrappers/osg/PolygonStipple.cpp @@ -0,0 +1,36 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::PolygonStipple) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::PolygonStipple &, lw, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setMask, IN, const GLubyte *, mask); + Method0(const GLubyte *, getMask); + Method1(void, apply, IN, osg::State &, state); + Property(const GLubyte *, Mask); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Polytope.cpp b/src/osgWrappers/osg/Polytope.cpp new file mode 100644 index 000000000..06500b3e3 --- /dev/null +++ b/src/osgWrappers/osg/Polytope.cpp @@ -0,0 +1,83 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(unsigned int, osg::Polytope::ClippingMask); + +TYPE_NAME_ALIAS(std::vector< osg::Plane >, osg::Polytope::PlaneList); + +TYPE_NAME_ALIAS(std::vector< osg::Vec3 >, osg::Polytope::VertexList); + +TYPE_NAME_ALIAS(osg::fast_back_stack< osg::Polytope::ClippingMask >, osg::Polytope::MaskStack); + +BEGIN_VALUE_REFLECTOR(osg::Polytope) + Constructor0(); + Constructor1(IN, const osg::Polytope &, cv); + Constructor1(IN, const osg::Polytope::PlaneList &, pl); + Method0(void, clear); + MethodWithDefaults2(void, setToUnitFrustum, IN, bool, withNear, true, IN, bool, withFar, true); + Method2(void, setAndTransformProvidingInverse, IN, const osg::Polytope &, pt, IN, const osg::Matrix &, matrix); + Method1(void, set, IN, const osg::Polytope::PlaneList &, pl); + Method1(void, add, IN, const osg::Plane &, pl); + Method0(void, flip); + Method0(osg::Polytope::PlaneList &, getPlaneList); + Method0(const osg::Polytope::PlaneList &, getPlaneList); + Method1(void, setReferenceVertexList, IN, osg::Polytope::VertexList &, vertices); + Method0(osg::Polytope::VertexList &, getReferenceVertexList); + Method0(const osg::Polytope::VertexList &, getReferenceVertexList); + Method0(void, setupMask); + Method0(osg::Polytope::ClippingMask &, getCurrentMask); + Method0(osg::Polytope::ClippingMask, getCurrentMask); + Method1(void, setResultMask, IN, osg::Polytope::ClippingMask, mask); + Method0(osg::Polytope::ClippingMask, getResultMask); + Method0(osg::Polytope::MaskStack &, getMaskStack); + Method0(const osg::Polytope::MaskStack &, getMaskStack); + Method0(void, pushCurrentMask); + Method0(void, popCurrentMask); + Method1(bool, contains, IN, const osg::Vec3 &, v); + Method1(bool, contains, IN, const std::vector< osg::Vec3 > &, vertices); + Method1(bool, contains, IN, const osg::BoundingSphere &, bs); + Method1(bool, contains, IN, const osg::BoundingBox &, bb); + Method1(bool, containsAllOf, IN, const std::vector< osg::Vec3 > &, vertices); + Method1(bool, containsAllOf, IN, const osg::BoundingSphere &, bs); + Method1(bool, containsAllOf, IN, const osg::BoundingBox &, bb); + Method1(void, transform, IN, const osg::Matrix &, matrix); + Method1(void, transformProvidingInverse, IN, const osg::Matrix &, matrix); + WriteOnlyProperty(const osg::Polytope::PlaneList &, ); + ReadOnlyProperty(osg::Polytope::ClippingMask, CurrentMask); + ReadOnlyProperty(osg::Polytope::MaskStack &, MaskStack); + ReadOnlyProperty(osg::Polytope::PlaneList &, PlaneList); + Property(osg::Polytope::VertexList &, ReferenceVertexList); + Property(osg::Polytope::ClippingMask, ResultMask); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::fast_back_stack< osg::Polytope::ClippingMask >) + Constructor0(); + Constructor1(IN, const osg::fast_back_stack< osg::Polytope::ClippingMask > &, fbs); + Constructor1(IN, const osg::Polytope::ClippingMask &, value); + Method0(void, clear); + Method0(bool, empty); + Method0(unsigned int, size); + Method0(osg::Polytope::ClippingMask &, back); + Method0(const osg::Polytope::ClippingMask &, back); + Method0(void, push_back); + Method1(void, push_back, IN, const osg::Polytope::ClippingMask &, value); + Method0(void, pop_back); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< osg::Plane >); + diff --git a/src/osgWrappers/osg/PositionAttitudeTransform.cpp b/src/osgWrappers/osg/PositionAttitudeTransform.cpp new file mode 100644 index 000000000..2fb63f58d --- /dev/null +++ b/src/osgWrappers/osg/PositionAttitudeTransform.cpp @@ -0,0 +1,47 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::PositionAttitudeTransform) + BaseType(osg::Transform); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::PositionAttitudeTransform &, pat, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method0(osg::PositionAttitudeTransform *, asPositionAttitudeTransform); + Method0(const osg::PositionAttitudeTransform *, asPositionAttitudeTransform); + Method1(void, setPosition, IN, const osg::Vec3d &, pos); + Method0(const osg::Vec3d &, getPosition); + Method1(void, setAttitude, IN, const osg::Quat &, quat); + Method0(const osg::Quat &, getAttitude); + Method1(void, setScale, IN, const osg::Vec3d &, scale); + Method0(const osg::Vec3d &, getScale); + Method1(void, setPivotPoint, IN, const osg::Vec3d &, pivot); + Method0(const osg::Vec3d &, getPivotPoint); + Method2(bool, computeLocalToWorldMatrix, IN, osg::Matrix &, matrix, IN, osg::NodeVisitor *, nv); + Method2(bool, computeWorldToLocalMatrix, IN, osg::Matrix &, matrix, IN, osg::NodeVisitor *, nv); + Property(const osg::Quat &, Attitude); + Property(const osg::Vec3d &, PivotPoint); + Property(const osg::Vec3d &, Position); + Property(const osg::Vec3d &, Scale); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/PrimitiveSet.cpp b/src/osgWrappers/osg/PrimitiveSet.cpp new file mode 100644 index 000000000..a9e0820fe --- /dev/null +++ b/src/osgWrappers/osg/PrimitiveSet.cpp @@ -0,0 +1,241 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::DrawArrayLengths) + BaseType(osg::PrimitiveSet); + ConstructorWithDefaults1(IN, GLenum, mode, 0); + ConstructorWithDefaults2(IN, const osg::DrawArrayLengths &, dal, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor4(IN, GLenum, mode, IN, GLint, first, IN, unsigned int, no, IN, GLsizei *, ptr); + Constructor3(IN, GLenum, mode, IN, GLint, first, IN, unsigned int, no); + Constructor2(IN, GLenum, mode, IN, GLint, first); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, setFirst, IN, GLint, first); + Method0(GLint, getFirst); + Method2(void, draw, IN, osg::State &, state, IN, bool, useVertexBufferObjects); + Method1(void, accept, IN, osg::PrimitiveFunctor &, functor); + Method1(void, accept, IN, osg::PrimitiveIndexFunctor &, functor); + Method0(unsigned int, getNumIndices); + Method1(unsigned int, index, IN, unsigned int, pos); + Method1(void, offsetIndices, IN, int, offset); + Method0(unsigned int, getNumPrimitives); + Property(GLint, First); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::DrawArrays) + BaseType(osg::PrimitiveSet); + ConstructorWithDefaults1(IN, GLenum, mode, 0); + Constructor3(IN, GLenum, mode, IN, GLint, first, IN, GLsizei, count); + ConstructorWithDefaults2(IN, const osg::DrawArrays &, da, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method3(void, set, IN, GLenum, mode, IN, GLint, first, IN, GLsizei, count); + Method1(void, setFirst, IN, GLint, first); + Method0(GLint, getFirst); + Method1(void, setCount, IN, GLsizei, count); + Method0(GLsizei, getCount); + Method2(void, draw, IN, osg::State &, state, IN, bool, useVertexBufferObjects); + Method1(void, accept, IN, osg::PrimitiveFunctor &, functor); + Method1(void, accept, IN, osg::PrimitiveIndexFunctor &, functor); + Method0(unsigned int, getNumIndices); + Method1(unsigned int, index, IN, unsigned int, pos); + Method1(void, offsetIndices, IN, int, offset); + Property(GLsizei, Count); + Property(GLint, First); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::DrawElementsUByte) + BaseType(osg::PrimitiveSet); + ConstructorWithDefaults1(IN, GLenum, mode, 0); + ConstructorWithDefaults2(IN, const osg::DrawElementsUByte &, array, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor3(IN, GLenum, mode, IN, unsigned int, no, IN, GLubyte *, ptr); + Constructor2(IN, GLenum, mode, IN, unsigned int, no); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(bool, supportsBufferObject); + Method2(void, draw, IN, osg::State &, state, IN, bool, useVertexBufferObjects); + Method1(void, accept, IN, osg::PrimitiveFunctor &, functor); + Method1(void, accept, IN, osg::PrimitiveIndexFunctor &, functor); + Method0(unsigned int, getNumIndices); + Method1(unsigned int, index, IN, unsigned int, pos); + Method1(void, offsetIndices, IN, int, offset); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::DrawElementsUInt) + BaseType(osg::PrimitiveSet); + ConstructorWithDefaults1(IN, GLenum, mode, 0); + ConstructorWithDefaults2(IN, const osg::DrawElementsUInt &, array, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor3(IN, GLenum, mode, IN, unsigned int, no, IN, GLuint *, ptr); + Constructor2(IN, GLenum, mode, IN, unsigned int, no); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(bool, supportsBufferObject); + Method2(void, draw, IN, osg::State &, state, IN, bool, useVertexBufferObjects); + Method1(void, accept, IN, osg::PrimitiveFunctor &, functor); + Method1(void, accept, IN, osg::PrimitiveIndexFunctor &, functor); + Method0(unsigned int, getNumIndices); + Method1(unsigned int, index, IN, unsigned int, pos); + Method1(void, offsetIndices, IN, int, offset); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::DrawElementsUShort) + BaseType(osg::PrimitiveSet); + ConstructorWithDefaults1(IN, GLenum, mode, 0); + ConstructorWithDefaults2(IN, const osg::DrawElementsUShort &, array, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor3(IN, GLenum, mode, IN, unsigned int, no, IN, GLushort *, ptr); + Constructor2(IN, GLenum, mode, IN, unsigned int, no); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(bool, supportsBufferObject); + Method2(void, draw, IN, osg::State &, state, IN, bool, useVertexBufferObjects); + Method1(void, accept, IN, osg::PrimitiveFunctor &, functor); + Method1(void, accept, IN, osg::PrimitiveIndexFunctor &, functor); + Method0(unsigned int, getNumIndices); + Method1(unsigned int, index, IN, unsigned int, pos); + Method1(void, offsetIndices, IN, int, offset); + ReadOnlyProperty(const GLvoid *, DataPointer); + ReadOnlyProperty(unsigned int, TotalDataSize); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::PrimitiveFunctor) + Constructor0(); + Method2(void, setVertexArray, IN, unsigned int, count, IN, const osg::Vec2 *, vertices); + Method2(void, setVertexArray, IN, unsigned int, count, IN, const osg::Vec3 *, vertices); + Method2(void, setVertexArray, IN, unsigned int, count, IN, const osg::Vec4 *, vertices); + Method3(void, drawArrays, IN, GLenum, mode, IN, GLint, first, IN, GLsizei, count); + Method3(void, drawElements, IN, GLenum, mode, IN, GLsizei, count, IN, const GLubyte *, indices); + Method3(void, drawElements, IN, GLenum, mode, IN, GLsizei, count, IN, const GLushort *, indices); + Method3(void, drawElements, IN, GLenum, mode, IN, GLsizei, count, IN, const GLuint *, indices); + Method1(void, begin, IN, GLenum, mode); + Method1(void, vertex, IN, const osg::Vec2 &, vert); + Method1(void, vertex, IN, const osg::Vec3 &, vert); + Method1(void, vertex, IN, const osg::Vec4 &, vert); + Method2(void, vertex, IN, float, x, IN, float, y); + Method3(void, vertex, IN, float, x, IN, float, y, IN, float, z); + Method4(void, vertex, IN, float, x, IN, float, y, IN, float, z, IN, float, w); + Method0(void, end); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::PrimitiveIndexFunctor) + Constructor0(); + Method2(void, setVertexArray, IN, unsigned int, count, IN, const osg::Vec2 *, vertices); + Method2(void, setVertexArray, IN, unsigned int, count, IN, const osg::Vec3 *, vertices); + Method2(void, setVertexArray, IN, unsigned int, count, IN, const osg::Vec4 *, vertices); + Method3(void, drawArrays, IN, GLenum, mode, IN, GLint, first, IN, GLsizei, count); + Method3(void, drawElements, IN, GLenum, mode, IN, GLsizei, count, IN, const GLubyte *, indices); + Method3(void, drawElements, IN, GLenum, mode, IN, GLsizei, count, IN, const GLushort *, indices); + Method3(void, drawElements, IN, GLenum, mode, IN, GLsizei, count, IN, const GLuint *, indices); + Method1(void, begin, IN, GLenum, mode); + Method1(void, vertex, IN, unsigned int, pos); + Method0(void, end); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::PrimitiveSet::Type) + EnumLabel(osg::PrimitiveSet::PrimitiveType); + EnumLabel(osg::PrimitiveSet::DrawArraysPrimitiveType); + EnumLabel(osg::PrimitiveSet::DrawArrayLengthsPrimitiveType); + EnumLabel(osg::PrimitiveSet::DrawElementsUBytePrimitiveType); + EnumLabel(osg::PrimitiveSet::DrawElementsUShortPrimitiveType); + EnumLabel(osg::PrimitiveSet::DrawElementsUIntPrimitiveType); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::PrimitiveSet::Mode) + EnumLabel(osg::PrimitiveSet::POINTS); + EnumLabel(osg::PrimitiveSet::LINES); + EnumLabel(osg::PrimitiveSet::LINE_STRIP); + EnumLabel(osg::PrimitiveSet::LINE_LOOP); + EnumLabel(osg::PrimitiveSet::TRIANGLES); + EnumLabel(osg::PrimitiveSet::TRIANGLE_STRIP); + EnumLabel(osg::PrimitiveSet::TRIANGLE_FAN); + EnumLabel(osg::PrimitiveSet::QUADS); + EnumLabel(osg::PrimitiveSet::QUAD_STRIP); + EnumLabel(osg::PrimitiveSet::POLYGON); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::PrimitiveSet) + BaseType(osg::Object); + ConstructorWithDefaults2(IN, osg::PrimitiveSet::Type, primType, osg::PrimitiveSet::PrimitiveType, IN, GLenum, mode, 0); + ConstructorWithDefaults2(IN, const osg::PrimitiveSet &, prim, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::PrimitiveSet::Type, getType); + Method0(const GLvoid *, getDataPointer); + Method0(unsigned int, getTotalDataSize); + Method0(bool, supportsBufferObject); + Method1(void, setMode, IN, GLenum, mode); + Method0(GLenum, getMode); + Method2(void, draw, IN, osg::State &, state, IN, bool, useVertexBufferObjects); + Method1(void, accept, IN, osg::PrimitiveFunctor &, functor); + Method1(void, accept, IN, osg::PrimitiveIndexFunctor &, functor); + Method1(unsigned int, index, IN, unsigned int, pos); + Method0(unsigned int, getNumIndices); + Method1(void, offsetIndices, IN, int, offset); + Method0(unsigned int, getNumPrimitives); + Method0(void, dirty); + Method1(void, setModifiedCount, IN, unsigned int, value); + Method0(unsigned int, getModifiedCount); + ReadOnlyProperty(const GLvoid *, DataPointer); + Property(GLenum, Mode); + Property(unsigned int, ModifiedCount); + ReadOnlyProperty(unsigned int, TotalDataSize); + ReadOnlyProperty(osg::PrimitiveSet::Type, Type); +END_REFLECTOR + +TYPE_NAME_ALIAS(std::vector< GLsizei >, osg::VectorSizei); + +TYPE_NAME_ALIAS(std::vector< GLubyte >, osg::VectorUByte); + +TYPE_NAME_ALIAS(std::vector< GLushort >, osg::VectorUShort); + +TYPE_NAME_ALIAS(std::vector< GLuint >, osg::VectorUInt); + +STD_VECTOR_REFLECTOR(std::vector< GLsizei >); + +STD_VECTOR_REFLECTOR(std::vector< GLubyte >); + +STD_VECTOR_REFLECTOR(std::vector< GLuint >); + +STD_VECTOR_REFLECTOR(std::vector< GLushort >); + diff --git a/src/osgWrappers/osg/Program.cpp b/src/osgWrappers/osg/Program.cpp new file mode 100644 index 000000000..3a3a63995 --- /dev/null +++ b/src/osgWrappers/osg/Program.cpp @@ -0,0 +1,174 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::GL2Extensions) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::GL2Extensions &, rhs); + Method1(void, lowestCommonDenominator, IN, const osg::GL2Extensions &, rhs); + Method0(void, setupGL2Extensions); + Method0(bool, isGlslSupported); + Method0(float, getGlVersion); + Method0(float, getLanguageVersion); + Method1(void, setShaderObjectsSupported, IN, bool, flag); + Method0(bool, isShaderObjectsSupported); + Method1(void, setVertexShaderSupported, IN, bool, flag); + Method0(bool, isVertexShaderSupported); + Method1(void, setFragmentShaderSupported, IN, bool, flag); + Method0(bool, isFragmentShaderSupported); + Method1(void, setLanguage100Supported, IN, bool, flag); + Method0(bool, isLanguage100Supported); + Method2(void, glBlendEquationSeparate, IN, GLenum, modeRGB, IN, GLenum, modeAlpha); + Method2(void, glDrawBuffers, IN, GLsizei, n, IN, const GLenum *, bufs); + Method4(void, glStencilOpSeparate, IN, GLenum, face, IN, GLenum, sfail, IN, GLenum, dpfail, IN, GLenum, dppass); + Method4(void, glStencilFuncSeparate, IN, GLenum, frontfunc, IN, GLenum, backfunc, IN, GLint, ref, IN, GLuint, mask); + Method2(void, glStencilMaskSeparate, IN, GLenum, face, IN, GLuint, mask); + Method2(void, glAttachShader, IN, GLuint, program, IN, GLuint, shader); + Method3(void, glBindAttribLocation, IN, GLuint, program, IN, GLuint, index, IN, const GLchar *, name); + Method1(void, glCompileShader, IN, GLuint, shader); + Method0(GLuint, glCreateProgram); + Method1(GLuint, glCreateShader, IN, GLenum, type); + Method1(void, glDeleteProgram, IN, GLuint, program); + Method1(void, glDeleteShader, IN, GLuint, shader); + Method2(void, glDetachShader, IN, GLuint, program, IN, GLuint, shader); + Method1(void, glDisableVertexAttribArray, IN, GLuint, index); + Method1(void, glEnableVertexAttribArray, IN, GLuint, index); + Method7(void, glGetActiveAttrib, IN, GLuint, program, IN, GLuint, index, IN, GLsizei, bufSize, IN, GLsizei *, length, IN, GLint *, size, IN, GLenum *, type, IN, GLchar *, name); + Method7(void, glGetActiveUniform, IN, GLuint, program, IN, GLuint, index, IN, GLsizei, bufSize, IN, GLsizei *, length, IN, GLint *, size, IN, GLenum *, type, IN, GLchar *, name); + Method4(void, glGetAttachedShaders, IN, GLuint, program, IN, GLsizei, maxCount, IN, GLsizei *, count, IN, GLuint *, obj); + Method2(GLint, glGetAttribLocation, IN, GLuint, program, IN, const GLchar *, name); + Method3(void, glGetProgramiv, IN, GLuint, program, IN, GLenum, pname, IN, GLint *, params); + Method4(void, glGetProgramInfoLog, IN, GLuint, program, IN, GLsizei, bufSize, IN, GLsizei *, length, IN, GLchar *, infoLog); + Method3(void, glGetShaderiv, IN, GLuint, shader, IN, GLenum, pname, IN, GLint *, params); + Method4(void, glGetShaderInfoLog, IN, GLuint, shader, IN, GLsizei, bufSize, IN, GLsizei *, length, IN, GLchar *, infoLog); + Method4(void, glGetShaderSource, IN, GLuint, shader, IN, GLsizei, bufSize, IN, GLsizei *, length, IN, GLchar *, source); + Method2(GLint, glGetUniformLocation, IN, GLuint, program, IN, const GLchar *, name); + Method3(void, glGetUniformfv, IN, GLuint, program, IN, GLint, location, IN, GLfloat *, params); + Method3(void, glGetUniformiv, IN, GLuint, program, IN, GLint, location, IN, GLint *, params); + Method3(void, glGetVertexAttribdv, IN, GLuint, index, IN, GLenum, pname, IN, GLdouble *, params); + Method3(void, glGetVertexAttribfv, IN, GLuint, index, IN, GLenum, pname, IN, GLfloat *, params); + Method3(void, glGetVertexAttribiv, IN, GLuint, index, IN, GLenum, pname, IN, GLint *, params); + Method3(void, glGetVertexAttribPointerv, IN, GLuint, index, IN, GLenum, pname, IN, GLvoid **, pointer); + Method1(GLboolean, glIsProgram, IN, GLuint, program); + Method1(GLboolean, glIsShader, IN, GLuint, shader); + Method1(void, glLinkProgram, IN, GLuint, program); + Method4(void, glShaderSource, IN, GLuint, shader, IN, GLsizei, count, IN, const GLchar **, string, IN, const GLint *, length); + Method1(void, glUseProgram, IN, GLuint, program); + Method2(void, glUniform1f, IN, GLint, location, IN, GLfloat, v0); + Method3(void, glUniform2f, IN, GLint, location, IN, GLfloat, v0, IN, GLfloat, v1); + Method4(void, glUniform3f, IN, GLint, location, IN, GLfloat, v0, IN, GLfloat, v1, IN, GLfloat, v2); + Method5(void, glUniform4f, IN, GLint, location, IN, GLfloat, v0, IN, GLfloat, v1, IN, GLfloat, v2, IN, GLfloat, v3); + Method2(void, glUniform1i, IN, GLint, location, IN, GLint, v0); + Method3(void, glUniform2i, IN, GLint, location, IN, GLint, v0, IN, GLint, v1); + Method4(void, glUniform3i, IN, GLint, location, IN, GLint, v0, IN, GLint, v1, IN, GLint, v2); + Method5(void, glUniform4i, IN, GLint, location, IN, GLint, v0, IN, GLint, v1, IN, GLint, v2, IN, GLint, v3); + Method3(void, glUniform1fv, IN, GLint, location, IN, GLsizei, count, IN, const GLfloat *, value); + Method3(void, glUniform2fv, IN, GLint, location, IN, GLsizei, count, IN, const GLfloat *, value); + Method3(void, glUniform3fv, IN, GLint, location, IN, GLsizei, count, IN, const GLfloat *, value); + Method3(void, glUniform4fv, IN, GLint, location, IN, GLsizei, count, IN, const GLfloat *, value); + Method3(void, glUniform1iv, IN, GLint, location, IN, GLsizei, count, IN, const GLint *, value); + Method3(void, glUniform2iv, IN, GLint, location, IN, GLsizei, count, IN, const GLint *, value); + Method3(void, glUniform3iv, IN, GLint, location, IN, GLsizei, count, IN, const GLint *, value); + Method3(void, glUniform4iv, IN, GLint, location, IN, GLsizei, count, IN, const GLint *, value); + Method4(void, glUniformMatrix2fv, IN, GLint, location, IN, GLsizei, count, IN, GLboolean, transpose, IN, const GLfloat *, value); + Method4(void, glUniformMatrix3fv, IN, GLint, location, IN, GLsizei, count, IN, GLboolean, transpose, IN, const GLfloat *, value); + Method4(void, glUniformMatrix4fv, IN, GLint, location, IN, GLsizei, count, IN, GLboolean, transpose, IN, const GLfloat *, value); + Method1(void, glValidateProgram, IN, GLuint, program); + Method2(void, glVertexAttrib1d, IN, GLuint, index, IN, GLdouble, x); + Method2(void, glVertexAttrib1dv, IN, GLuint, index, IN, const GLdouble *, v); + Method2(void, glVertexAttrib1f, IN, GLuint, index, IN, GLfloat, x); + Method2(void, glVertexAttrib1fv, IN, GLuint, index, IN, const GLfloat *, v); + Method2(void, glVertexAttrib1s, IN, GLuint, index, IN, GLshort, x); + Method2(void, glVertexAttrib1sv, IN, GLuint, index, IN, const GLshort *, v); + Method3(void, glVertexAttrib2d, IN, GLuint, index, IN, GLdouble, x, IN, GLdouble, y); + Method2(void, glVertexAttrib2dv, IN, GLuint, index, IN, const GLdouble *, v); + Method3(void, glVertexAttrib2f, IN, GLuint, index, IN, GLfloat, x, IN, GLfloat, y); + Method2(void, glVertexAttrib2fv, IN, GLuint, index, IN, const GLfloat *, v); + Method3(void, glVertexAttrib2s, IN, GLuint, index, IN, GLshort, x, IN, GLshort, y); + Method2(void, glVertexAttrib2sv, IN, GLuint, index, IN, const GLshort *, v); + Method4(void, glVertexAttrib3d, IN, GLuint, index, IN, GLdouble, x, IN, GLdouble, y, IN, GLdouble, z); + Method2(void, glVertexAttrib3dv, IN, GLuint, index, IN, const GLdouble *, v); + Method4(void, glVertexAttrib3f, IN, GLuint, index, IN, GLfloat, x, IN, GLfloat, y, IN, GLfloat, z); + Method2(void, glVertexAttrib3fv, IN, GLuint, index, IN, const GLfloat *, v); + Method4(void, glVertexAttrib3s, IN, GLuint, index, IN, GLshort, x, IN, GLshort, y, IN, GLshort, z); + Method2(void, glVertexAttrib3sv, IN, GLuint, index, IN, const GLshort *, v); + Method2(void, glVertexAttrib4Nbv, IN, GLuint, index, IN, const GLbyte *, v); + Method2(void, glVertexAttrib4Niv, IN, GLuint, index, IN, const GLint *, v); + Method2(void, glVertexAttrib4Nsv, IN, GLuint, index, IN, const GLshort *, v); + Method5(void, glVertexAttrib4Nub, IN, GLuint, index, IN, GLubyte, x, IN, GLubyte, y, IN, GLubyte, z, IN, GLubyte, w); + Method2(void, glVertexAttrib4Nubv, IN, GLuint, index, IN, const GLubyte *, v); + Method2(void, glVertexAttrib4Nuiv, IN, GLuint, index, IN, const GLuint *, v); + Method2(void, glVertexAttrib4Nusv, IN, GLuint, index, IN, const GLushort *, v); + Method2(void, glVertexAttrib4bv, IN, GLuint, index, IN, const GLbyte *, v); + Method5(void, glVertexAttrib4d, IN, GLuint, index, IN, GLdouble, x, IN, GLdouble, y, IN, GLdouble, z, IN, GLdouble, w); + Method2(void, glVertexAttrib4dv, IN, GLuint, index, IN, const GLdouble *, v); + Method5(void, glVertexAttrib4f, IN, GLuint, index, IN, GLfloat, x, IN, GLfloat, y, IN, GLfloat, z, IN, GLfloat, w); + Method2(void, glVertexAttrib4fv, IN, GLuint, index, IN, const GLfloat *, v); + Method2(void, glVertexAttrib4iv, IN, GLuint, index, IN, const GLint *, v); + Method5(void, glVertexAttrib4s, IN, GLuint, index, IN, GLshort, x, IN, GLshort, y, IN, GLshort, z, IN, GLshort, w); + Method2(void, glVertexAttrib4sv, IN, GLuint, index, IN, const GLshort *, v); + Method2(void, glVertexAttrib4ubv, IN, GLuint, index, IN, const GLubyte *, v); + Method2(void, glVertexAttrib4uiv, IN, GLuint, index, IN, const GLuint *, v); + Method2(void, glVertexAttrib4usv, IN, GLuint, index, IN, const GLushort *, v); + Method6(void, glVertexAttribPointer, IN, GLuint, index, IN, GLint, size, IN, GLenum, type, IN, GLboolean, normalized, IN, GLsizei, stride, IN, const GLvoid *, pointer); + Method0(GLuint, getCurrentProgram); + Method2(bool, getProgramInfoLog, IN, GLuint, program, IN, std::string &, result); + Method2(bool, getShaderInfoLog, IN, GLuint, shader, IN, std::string &, result); + Method2(bool, getAttribLocation, IN, const char *, attribName, IN, GLuint &, slot); + ReadOnlyProperty(GLuint, CurrentProgram); + WriteOnlyProperty(bool, FragmentShaderSupported); + ReadOnlyProperty(float, GlVersion); + WriteOnlyProperty(bool, Language100Supported); + ReadOnlyProperty(float, LanguageVersion); + WriteOnlyProperty(bool, ShaderObjectsSupported); + WriteOnlyProperty(bool, VertexShaderSupported); +END_REFLECTOR + +TYPE_NAME_ALIAS(std::map< std::string COMMA GLuint >, osg::Program::AttribBindingList); + +BEGIN_OBJECT_REFLECTOR(osg::Program) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Program &, rhs, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(void, apply, IN, osg::State &, state); + Method1(void, compileGLObjects, IN, osg::State &, state); + MethodWithDefaults1(void, releaseGLObjects, IN, osg::State *, state, 0); + Method0(void, dirtyProgram); + Method1(bool, addShader, IN, osg::Shader *, shader); + Method1(bool, removeShader, IN, osg::Shader *, shader); + Method2(void, bindAttribLocation, IN, GLuint, index, IN, const char *, name); + Method0(const osg::Program::AttribBindingList &, getAttribBindingList); + Method0(bool, isFixedFunction); + Method2(void, getGlProgramInfoLog, IN, unsigned int, contextID, IN, std::string &, log); + Method1(void, setName, IN, const std::string &, name); + Method1(void, setName, IN, const char *, name); + Method0(const std::string &, getName); + ReadOnlyProperty(const osg::Program::AttribBindingList &, AttribBindingList); + Property(const std::string &, Name); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + +STD_MAP_REFLECTOR(std::map< std::string COMMA GLuint >); + diff --git a/src/osgWrappers/osg/Projection.cpp b/src/osgWrappers/osg/Projection.cpp new file mode 100644 index 000000000..4dc7f4501 --- /dev/null +++ b/src/osgWrappers/osg/Projection.cpp @@ -0,0 +1,35 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::Projection) + BaseType(osg::Group); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Projection &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Constructor1(IN, const osg::Matrix &, matix); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, setMatrix, IN, const osg::Matrix &, mat); + Method0(const osg::Matrix &, getMatrix); + Method1(void, preMult, IN, const osg::Matrix &, mat); + Method1(void, postMult, IN, const osg::Matrix &, mat); + Property(const osg::Matrix &, Matrix); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/ProxyNode.cpp b/src/osgWrappers/osg/ProxyNode.cpp new file mode 100644 index 000000000..d301c52ab --- /dev/null +++ b/src/osgWrappers/osg/ProxyNode.cpp @@ -0,0 +1,57 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< std::string >, osg::ProxyNode::FileNameList); + +BEGIN_ENUM_REFLECTOR(osg::ProxyNode::CenterMode) + EnumLabel(osg::ProxyNode::USE_BOUNDING_SPHERE_CENTER); + EnumLabel(osg::ProxyNode::USER_DEFINED_CENTER); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::ProxyNode) + BaseType(osg::Group); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::ProxyNode &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, traverse, IN, osg::NodeVisitor &, nv); + Method1(bool, addChild, IN, osg::Node *, child); + Method2(bool, addChild, IN, osg::Node *, child, IN, const std::string &, filename); + Method1(bool, removeChild, IN, osg::Node *, child); + Method1(void, setDatabasePath, IN, const std::string &, path); + Method0(const std::string &, getDatabasePath); + Method2(void, setFileName, IN, unsigned int, childNo, IN, const std::string &, filename); + Method1(const std::string &, getFileName, IN, unsigned int, childNo); + Method0(unsigned int, getNumFileNames); + Method1(void, setCenterMode, IN, osg::ProxyNode::CenterMode, mode); + Method0(osg::ProxyNode::CenterMode, getCenterMode); + Method1(void, setCenter, IN, const osg::Vec3 &, center); + Method0(const osg::Vec3 &, getCenter); + Method1(void, setRadius, IN, float, radius); + Method0(float, getRadius); + Property(const osg::Vec3 &, Center); + Property(osg::ProxyNode::CenterMode, CenterMode); + Property(const std::string &, DatabasePath); + ArrayProperty_G(const std::string &, FileName, FileNames, unsigned int, void); + Property(float, Radius); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Quat.cpp b/src/osgWrappers/osg/Quat.cpp new file mode 100644 index 000000000..22b762537 --- /dev/null +++ b/src/osgWrappers/osg/Quat.cpp @@ -0,0 +1,67 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(double, osg::Quat::value_type); + +BEGIN_VALUE_REFLECTOR(osg::Quat) + Constructor0(); + Constructor4(IN, osg::Quat::value_type, x, IN, osg::Quat::value_type, y, IN, osg::Quat::value_type, z, IN, osg::Quat::value_type, w); + Constructor1(IN, const osg::Vec4f &, v); + Constructor1(IN, const osg::Vec4d &, v); + Constructor2(IN, osg::Quat::value_type, angle, IN, const osg::Vec3f &, axis); + Constructor2(IN, osg::Quat::value_type, angle, IN, const osg::Vec3d &, axis); + Constructor6(IN, osg::Quat::value_type, angle1, IN, const osg::Vec3f &, axis1, IN, osg::Quat::value_type, angle2, IN, const osg::Vec3f &, axis2, IN, osg::Quat::value_type, angle3, IN, const osg::Vec3f &, axis3); + Constructor6(IN, osg::Quat::value_type, angle1, IN, const osg::Vec3d &, axis1, IN, osg::Quat::value_type, angle2, IN, const osg::Vec3d &, axis2, IN, osg::Quat::value_type, angle3, IN, const osg::Vec3d &, axis3); + Method0(osg::Vec4d, asVec4); + Method0(osg::Vec3d, asVec3); + Method4(void, set, IN, osg::Quat::value_type, x, IN, osg::Quat::value_type, y, IN, osg::Quat::value_type, z, IN, osg::Quat::value_type, w); + Method1(void, set, IN, const osg::Vec4f &, v); + Method1(void, set, IN, const osg::Vec4d &, v); + Method1(void, set, IN, const osg::Matrixf &, matrix); + Method1(void, set, IN, const osg::Matrixd &, matrix); + Method1(void, get, IN, osg::Matrixf &, matrix); + Method1(void, get, IN, osg::Matrixd &, matrix); + Method0(osg::Quat::value_type &, x); + Method0(osg::Quat::value_type &, y); + Method0(osg::Quat::value_type &, z); + Method0(osg::Quat::value_type &, w); + Method0(osg::Quat::value_type, x); + Method0(osg::Quat::value_type, y); + Method0(osg::Quat::value_type, z); + Method0(osg::Quat::value_type, w); + Method0(bool, zeroRotation); + Method0(osg::Quat::value_type, length); + Method0(osg::Quat::value_type, length2); + Method0(osg::Quat, conj); + Method0(const osg::Quat, inverse); + Method4(void, makeRotate, IN, osg::Quat::value_type, angle, IN, osg::Quat::value_type, x, IN, osg::Quat::value_type, y, IN, osg::Quat::value_type, z); + Method2(void, makeRotate, IN, osg::Quat::value_type, angle, IN, const osg::Vec3f &, vec); + Method2(void, makeRotate, IN, osg::Quat::value_type, angle, IN, const osg::Vec3d &, vec); + Method6(void, makeRotate, IN, osg::Quat::value_type, angle1, IN, const osg::Vec3f &, axis1, IN, osg::Quat::value_type, angle2, IN, const osg::Vec3f &, axis2, IN, osg::Quat::value_type, angle3, IN, const osg::Vec3f &, axis3); + Method6(void, makeRotate, IN, osg::Quat::value_type, angle1, IN, const osg::Vec3d &, axis1, IN, osg::Quat::value_type, angle2, IN, const osg::Vec3d &, axis2, IN, osg::Quat::value_type, angle3, IN, const osg::Vec3d &, axis3); + Method2(void, makeRotate, IN, const osg::Vec3f &, vec1, IN, const osg::Vec3f &, vec2); + Method2(void, makeRotate, IN, const osg::Vec3d &, vec1, IN, const osg::Vec3d &, vec2); + Method2(void, makeRotate_original, IN, const osg::Vec3d &, vec1, IN, const osg::Vec3d &, vec2); + Method4(void, getRotate, IN, osg::Quat::value_type &, angle, IN, osg::Quat::value_type &, x, IN, osg::Quat::value_type &, y, IN, osg::Quat::value_type &, z); + Method2(void, getRotate, IN, osg::Quat::value_type &, angle, IN, osg::Vec3f &, vec); + Method2(void, getRotate, IN, osg::Quat::value_type &, angle, IN, osg::Vec3d &, vec); + Method3(void, slerp, IN, osg::Quat::value_type, t, IN, const osg::Quat &, from, IN, const osg::Quat &, to); + WriteOnlyProperty(const osg::Vec4f &, ); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/RefNodePath.cpp b/src/osgWrappers/osg/RefNodePath.cpp new file mode 100644 index 000000000..585279d3f --- /dev/null +++ b/src/osgWrappers/osg/RefNodePath.cpp @@ -0,0 +1,21 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include + +BEGIN_VALUE_REFLECTOR(osg::RefNodePath) + Constructor0(); + Constructor1(IN, const osg::RefNodePath &, refNodePath); + Constructor1(IN, const osg::NodePath &, nodePath); + Method0(bool, valid); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Referenced.cpp b/src/osgWrappers/osg/Referenced.cpp new file mode 100644 index 000000000..1912b862b --- /dev/null +++ b/src/osgWrappers/osg/Referenced.cpp @@ -0,0 +1,32 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include + +BEGIN_VALUE_REFLECTOR(osg::DeleteHandler) + Constructor0(); + Method0(void, flush); + Method1(void, doDelete, IN, const osg::Referenced *, object); + Method1(void, requestDelete, IN, const osg::Referenced *, object); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Referenced) + Constructor0(); + Constructor1(IN, const osg::Referenced &, x); + Method1(void, setThreadSafeRefUnref, IN, bool, threadSafe); + Method0(bool, getThreadSafeRefUnref); + Method0(void, ref); + Method0(void, unref); + Method0(void, unref_nodelete); + Method0(int, referenceCount); + Property(bool, ThreadSafeRefUnref); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Sequence.cpp b/src/osgWrappers/osg/Sequence.cpp new file mode 100644 index 000000000..07bf2279d --- /dev/null +++ b/src/osgWrappers/osg/Sequence.cpp @@ -0,0 +1,54 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::Sequence::LoopMode) + EnumLabel(osg::Sequence::LOOP); + EnumLabel(osg::Sequence::SWING); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::Sequence::SequenceMode) + EnumLabel(osg::Sequence::START); + EnumLabel(osg::Sequence::STOP); + EnumLabel(osg::Sequence::PAUSE); + EnumLabel(osg::Sequence::RESUME); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Sequence) + BaseType(osg::Group); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Sequence &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, traverse, IN, osg::NodeVisitor &, nv); + Method1(void, setValue, IN, int, value); + Method0(int, getValue); + Method2(void, setTime, IN, int, frame, IN, float, t); + Method1(float, getTime, IN, int, frame); + Method3(void, setInterval, IN, osg::Sequence::LoopMode, mode, IN, int, begin, IN, int, end); + Method3(void, getInterval, IN, osg::Sequence::LoopMode &, mode, IN, int &, begin, IN, int &, end); + MethodWithDefaults2(void, setDuration, IN, float, speed, , IN, int, nreps, -1); + Method2(void, getDuration, IN, float &, speed, IN, int &, nreps); + Method1(void, setMode, IN, osg::Sequence::SequenceMode, mode); + Method0(osg::Sequence::SequenceMode, getMode); + Property(osg::Sequence::SequenceMode, Mode); + IndexedProperty1(float, Time, int, frame); + Property(int, Value); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/ShadeModel.cpp b/src/osgWrappers/osg/ShadeModel.cpp new file mode 100644 index 000000000..a326d8bf1 --- /dev/null +++ b/src/osgWrappers/osg/ShadeModel.cpp @@ -0,0 +1,40 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::ShadeModel::Mode) + EnumLabel(osg::ShadeModel::FLAT); + EnumLabel(osg::ShadeModel::SMOOTH); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::ShadeModel) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::ShadeModel &, sm, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(void, setMode, IN, osg::ShadeModel::Mode, mode); + Method0(osg::ShadeModel::Mode, getMode); + Method1(void, apply, IN, osg::State &, state); + Property(osg::ShadeModel::Mode, Mode); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Shader.cpp b/src/osgWrappers/osg/Shader.cpp new file mode 100644 index 000000000..06e269815 --- /dev/null +++ b/src/osgWrappers/osg/Shader.cpp @@ -0,0 +1,48 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::Shader::Type) + EnumLabel(osg::Shader::VERTEX); + EnumLabel(osg::Shader::FRAGMENT); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Shader) + BaseType(osg::Object); + ConstructorWithDefaults2(IN, osg::Shader::Type, type, , IN, const char *, sourceText, 0); + ConstructorWithDefaults2(IN, const osg::Shader &, rhs, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(int, compare, IN, const osg::Shader &, rhs); + Method1(void, setShaderSource, IN, const char *, sourceText); + Method1(bool, loadShaderSourceFromFile, IN, const char *, fileName); + Method0(const std::string &, getShaderSource); + Method0(osg::Shader::Type, getType); + Method0(const char *, getTypename); + Method0(void, dirtyShader); + Method1(void, compileShader, IN, unsigned int, contextID); + Method2(void, attachShader, IN, unsigned int, contextID, IN, GLuint, program); + Method2(void, getGlShaderInfoLog, IN, unsigned int, contextID, IN, std::string &, log); + Method1(void, setName, IN, const std::string &, name); + Method1(void, setName, IN, const char *, name); + Method0(const std::string &, getName); + Property(const std::string &, Name); + ReadOnlyProperty(const std::string &, ShaderSource); + ReadOnlyProperty(osg::Shader::Type, Type); + ReadOnlyProperty(const char *, Typename); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/ShadowVolumeOccluder.cpp b/src/osgWrappers/osg/ShadowVolumeOccluder.cpp new file mode 100644 index 000000000..45310bedf --- /dev/null +++ b/src/osgWrappers/osg/ShadowVolumeOccluder.cpp @@ -0,0 +1,53 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< osg::Polytope >, osg::ShadowVolumeOccluder::HoleList); + +BEGIN_VALUE_REFLECTOR(osg::ShadowVolumeOccluder) + Constructor1(IN, const osg::ShadowVolumeOccluder &, svo); + Constructor0(); + MethodWithDefaults4(bool, computeOccluder, IN, const osg::NodePath &, nodePath, , IN, const osg::ConvexPlanarOccluder &, occluder, , IN, osg::CullStack &, cullStack, , IN, bool, createDrawables, false); + Method0(void, disableResultMasks); + Method0(void, pushCurrentMask); + Method0(void, popCurrentMask); + Method1(bool, matchProjectionMatrix, IN, const osg::Matrix &, matrix); + Method1(void, setNodePath, IN, osg::NodePath &, nodePath); + Method0(osg::NodePath &, getNodePath); + Method0(const osg::NodePath &, getNodePath); + Method0(float, getVolume); + Method0(osg::Polytope &, getOccluder); + Method0(const osg::Polytope &, getOccluder); + Method0(osg::ShadowVolumeOccluder::HoleList &, getHoleList); + Method0(const osg::ShadowVolumeOccluder::HoleList &, getHoleList); + Method1(bool, contains, IN, const std::vector< osg::Vec3 > &, vertices); + Method1(bool, contains, IN, const osg::BoundingSphere &, bound); + Method1(bool, contains, IN, const osg::BoundingBox &, bound); + Method1(void, transformProvidingInverse, IN, const osg::Matrix &, matrix); + ReadOnlyProperty(osg::ShadowVolumeOccluder::HoleList &, HoleList); + Property(osg::NodePath &, NodePath); + ReadOnlyProperty(osg::Polytope &, Occluder); + ReadOnlyProperty(float, Volume); +END_REFLECTOR + +TYPE_NAME_ALIAS(std::vector< osg::ShadowVolumeOccluder >, osg::ShadowVolumeOccluderList); + +STD_VECTOR_REFLECTOR(std::vector< osg::Polytope >); + diff --git a/src/osgWrappers/osg/Shape.cpp b/src/osgWrappers/osg/Shape.cpp new file mode 100644 index 000000000..dd0c001a1 --- /dev/null +++ b/src/osgWrappers/osg/Shape.cpp @@ -0,0 +1,344 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::Box) + BaseType(osg::Shape); + Constructor0(); + Constructor2(IN, const osg::Vec3 &, center, IN, float, width); + Constructor4(IN, const osg::Vec3 &, center, IN, float, lengthX, IN, float, lengthY, IN, float, lengthZ); + ConstructorWithDefaults2(IN, const osg::Box &, box, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ShapeVisitor &, sv); + Method1(void, accept, IN, osg::ConstShapeVisitor &, csv); + Method0(bool, valid); + Method2(void, set, IN, const osg::Vec3 &, center, IN, const osg::Vec3 &, halfLengths); + Method1(void, setCenter, IN, const osg::Vec3 &, center); + Method0(const osg::Vec3 &, getCenter); + Method1(void, setHalfLengths, IN, const osg::Vec3 &, halfLengths); + Method0(const osg::Vec3 &, getHalfLengths); + Method1(void, setRotation, IN, const osg::Quat &, quat); + Method0(const osg::Quat &, getRotation); + Method0(osg::Matrix, computeRotationMatrix); + Method0(bool, zeroRotation); + Property(const osg::Vec3 &, Center); + Property(const osg::Vec3 &, HalfLengths); + Property(const osg::Quat &, Rotation); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Capsule) + BaseType(osg::Shape); + Constructor0(); + Constructor3(IN, const osg::Vec3 &, center, IN, float, radius, IN, float, height); + ConstructorWithDefaults2(IN, const osg::Capsule &, capsule, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ShapeVisitor &, sv); + Method1(void, accept, IN, osg::ConstShapeVisitor &, csv); + Method0(bool, valid); + Method3(void, set, IN, const osg::Vec3 &, center, IN, float, radius, IN, float, height); + Method1(void, setCenter, IN, const osg::Vec3 &, center); + Method0(const osg::Vec3 &, getCenter); + Method1(void, setRadius, IN, float, radius); + Method0(float, getRadius); + Method1(void, setHeight, IN, float, height); + Method0(float, getHeight); + Method1(void, setRotation, IN, const osg::Quat &, quat); + Method0(const osg::Quat &, getRotation); + Method0(osg::Matrix, computeRotationMatrix); + Method0(bool, zeroRotation); + Property(const osg::Vec3 &, Center); + Property(float, Height); + Property(float, Radius); + Property(const osg::Quat &, Rotation); +END_REFLECTOR + +TYPE_NAME_ALIAS(std::vector< osg::ref_ptr< osg::Shape > >, osg::CompositeShape::ChildList); + +BEGIN_OBJECT_REFLECTOR(osg::CompositeShape) + BaseType(osg::Shape); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::CompositeShape &, cs, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ShapeVisitor &, sv); + Method1(void, accept, IN, osg::ConstShapeVisitor &, csv); + Method1(void, setShape, IN, osg::Shape *, shape); + Method0(osg::Shape *, getShape); + Method0(const osg::Shape *, getShape); + Method0(unsigned int, getNumChildren); + Method1(osg::Shape *, getChild, IN, unsigned int, i); + Method1(const osg::Shape *, getChild, IN, unsigned int, i); + Method1(void, addChild, IN, osg::Shape *, shape); + Method1(void, removeChild, IN, unsigned int, i); + Method1(unsigned int, findChildNo, IN, osg::Shape *, shape); + ArrayProperty_GA(osg::Shape *, Child, Children, unsigned int, void); + Property(osg::Shape *, Shape); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Cone) + BaseType(osg::Shape); + Constructor0(); + Constructor3(IN, const osg::Vec3 &, center, IN, float, radius, IN, float, height); + ConstructorWithDefaults2(IN, const osg::Cone &, cone, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ShapeVisitor &, sv); + Method1(void, accept, IN, osg::ConstShapeVisitor &, csv); + Method0(bool, valid); + Method3(void, set, IN, const osg::Vec3 &, center, IN, float, radius, IN, float, height); + Method1(void, setCenter, IN, const osg::Vec3 &, center); + Method0(const osg::Vec3 &, getCenter); + Method1(void, setRadius, IN, float, radius); + Method0(float, getRadius); + Method1(void, setHeight, IN, float, height); + Method0(float, getHeight); + Method1(void, setRotation, IN, const osg::Quat &, quat); + Method0(const osg::Quat &, getRotation); + Method0(osg::Matrix, computeRotationMatrix); + Method0(bool, zeroRotation); + Method0(float, getBaseOffsetFactor); + Method0(float, getBaseOffset); + ReadOnlyProperty(float, BaseOffset); + ReadOnlyProperty(float, BaseOffsetFactor); + Property(const osg::Vec3 &, Center); + Property(float, Height); + Property(float, Radius); + Property(const osg::Quat &, Rotation); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ConstShapeVisitor) + Constructor0(); + Method1(void, apply, IN, const osg::Sphere &, x); + Method1(void, apply, IN, const osg::Box &, x); + Method1(void, apply, IN, const osg::Cone &, x); + Method1(void, apply, IN, const osg::Cylinder &, x); + Method1(void, apply, IN, const osg::Capsule &, x); + Method1(void, apply, IN, const osg::InfinitePlane &, x); + Method1(void, apply, IN, const osg::TriangleMesh &, x); + Method1(void, apply, IN, const osg::ConvexHull &, x); + Method1(void, apply, IN, const osg::HeightField &, x); + Method1(void, apply, IN, const osg::CompositeShape &, x); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::ConvexHull) + BaseType(osg::TriangleMesh); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::ConvexHull &, hull, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ShapeVisitor &, sv); + Method1(void, accept, IN, osg::ConstShapeVisitor &, csv); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Cylinder) + BaseType(osg::Shape); + Constructor0(); + Constructor3(IN, const osg::Vec3 &, center, IN, float, radius, IN, float, height); + ConstructorWithDefaults2(IN, const osg::Cylinder &, cylinder, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ShapeVisitor &, sv); + Method1(void, accept, IN, osg::ConstShapeVisitor &, csv); + Method0(bool, valid); + Method3(void, set, IN, const osg::Vec3 &, center, IN, float, radius, IN, float, height); + Method1(void, setCenter, IN, const osg::Vec3 &, center); + Method0(const osg::Vec3 &, getCenter); + Method1(void, setRadius, IN, float, radius); + Method0(float, getRadius); + Method1(void, setHeight, IN, float, height); + Method0(float, getHeight); + Method1(void, setRotation, IN, const osg::Quat &, quat); + Method0(const osg::Quat &, getRotation); + Method0(osg::Matrix, computeRotationMatrix); + Method0(bool, zeroRotation); + Property(const osg::Vec3 &, Center); + Property(float, Height); + Property(float, Radius); + Property(const osg::Quat &, Rotation); +END_REFLECTOR + +TYPE_NAME_ALIAS(std::vector< float >, osg::HeightField::HeightList); + +BEGIN_OBJECT_REFLECTOR(osg::HeightField) + BaseType(osg::Shape); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::HeightField &, mesh, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ShapeVisitor &, sv); + Method1(void, accept, IN, osg::ConstShapeVisitor &, csv); + Method2(void, allocate, IN, unsigned int, numColumns, IN, unsigned int, numRows); + Method2(void, allocateGrid, IN, unsigned int, numColumns, IN, unsigned int, numRows); + Method0(unsigned int, getNumColumns); + Method0(unsigned int, getNumRows); + Method1(void, setOrigin, IN, const osg::Vec3 &, origin); + Method0(const osg::Vec3 &, getOrigin); + Method1(void, setXInterval, IN, float, dx); + Method0(float, getXInterval); + Method1(void, setYInterval, IN, float, dy); + Method0(float, getYInterval); + Method1(void, setSkirtHeight, IN, float, skirtHeight); + Method0(float, getSkirtHeight); + Method1(void, setBorderWidth, IN, unsigned int, borderWidth); + Method0(unsigned int, getBorderWidth); + Method1(void, setRotation, IN, const osg::Quat &, quat); + Method0(const osg::Quat &, getRotation); + Method0(osg::Matrix, computeRotationMatrix); + Method0(bool, zeroRotation); + Method3(void, setHeight, IN, unsigned int, c, IN, unsigned int, r, IN, float, value); + Method2(float &, getHeight, IN, unsigned int, c, IN, unsigned int, r); + Method2(float, getHeight, IN, unsigned int, c, IN, unsigned int, r); + Method0(osg::HeightField::HeightList &, getHeightList); + Method0(const osg::HeightField::HeightList &, getHeightList); + Method2(osg::Vec3, getVertex, IN, unsigned int, c, IN, unsigned int, r); + Method2(osg::Vec3, getNormal, IN, unsigned int, c, IN, unsigned int, r); + Property(unsigned int, BorderWidth); + IndexedProperty2(float, Height, unsigned int, c, unsigned int, r); + ReadOnlyProperty(osg::HeightField::HeightList &, HeightList); + Property(const osg::Vec3 &, Origin); + Property(const osg::Quat &, Rotation); + Property(float, SkirtHeight); + Property(float, XInterval); + Property(float, YInterval); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::InfinitePlane) + BaseType(osg::Shape); + BaseType(osg::Plane); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::InfinitePlane &, plane, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ShapeVisitor &, sv); + Method1(void, accept, IN, osg::ConstShapeVisitor &, csv); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Shape) + BaseType(osg::Object); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Shape &, sa, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, x); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ShapeVisitor &, x); + Method1(void, accept, IN, osg::ConstShapeVisitor &, x); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ShapeVisitor) + Constructor0(); + Method1(void, apply, IN, osg::Sphere &, x); + Method1(void, apply, IN, osg::Box &, x); + Method1(void, apply, IN, osg::Cone &, x); + Method1(void, apply, IN, osg::Cylinder &, x); + Method1(void, apply, IN, osg::Capsule &, x); + Method1(void, apply, IN, osg::InfinitePlane &, x); + Method1(void, apply, IN, osg::TriangleMesh &, x); + Method1(void, apply, IN, osg::ConvexHull &, x); + Method1(void, apply, IN, osg::HeightField &, x); + Method1(void, apply, IN, osg::CompositeShape &, x); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Sphere) + BaseType(osg::Shape); + Constructor0(); + Constructor2(IN, const osg::Vec3 &, center, IN, float, radius); + ConstructorWithDefaults2(IN, const osg::Sphere &, sphere, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ShapeVisitor &, sv); + Method1(void, accept, IN, osg::ConstShapeVisitor &, csv); + Method0(bool, valid); + Method2(void, set, IN, const osg::Vec3 &, center, IN, float, radius); + Method1(void, setCenter, IN, const osg::Vec3 &, center); + Method0(const osg::Vec3 &, getCenter); + Method1(void, setRadius, IN, float, radius); + Method0(float, getRadius); + Property(const osg::Vec3 &, Center); + Property(float, Radius); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TriangleMesh) + BaseType(osg::Shape); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TriangleMesh &, mesh, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, accept, IN, osg::ShapeVisitor &, sv); + Method1(void, accept, IN, osg::ConstShapeVisitor &, csv); + Method1(void, setVertices, IN, osg::Vec3Array *, vertices); + Method0(osg::Vec3Array *, getVertices); + Method0(const osg::Vec3Array *, getVertices); + Method1(void, setIndices, IN, osg::IndexArray *, indices); + Method0(osg::IndexArray *, getIndices); + Method0(const osg::IndexArray *, getIndices); + Property(osg::IndexArray *, Indices); + Property(osg::Vec3Array *, Vertices); +END_REFLECTOR + +TYPE_NAME_ALIAS(osg::HeightField, osg::Grid); + +BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::Shape >) + Constructor0(); + Constructor1(IN, osg::Shape *, t); + Constructor1(IN, const osg::ref_ptr< osg::Shape > &, rp); + Method0(bool, valid); + Method0(osg::Shape *, get); + Method0(const osg::Shape *, get); + Method0(osg::Shape *, take); + Method0(osg::Shape *, release); + ReadOnlyProperty(osg::Shape *, ); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< float >); + +STD_VECTOR_REFLECTOR(std::vector< osg::ref_ptr< osg::Shape > >); + diff --git a/src/osgWrappers/osg/ShapeDrawable.cpp b/src/osgWrappers/osg/ShapeDrawable.cpp new file mode 100644 index 000000000..d6615a1eb --- /dev/null +++ b/src/osgWrappers/osg/ShapeDrawable.cpp @@ -0,0 +1,91 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::ShapeDrawable) + BaseType(osg::Drawable); + Constructor0(); + ConstructorWithDefaults2(IN, osg::Shape *, shape, , IN, osg::TessellationHints *, hints, 0); + ConstructorWithDefaults2(IN, const osg::ShapeDrawable &, pg, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, setColor, IN, const osg::Vec4 &, color); + Method0(const osg::Vec4 &, getColor); + Method1(void, setTessellationHints, IN, osg::TessellationHints *, hints); + Method0(osg::TessellationHints *, getTessellationHints); + Method0(const osg::TessellationHints *, getTessellationHints); + Method1(void, drawImplementation, IN, osg::State &, state); + Method1(bool, supports, IN, osg::Drawable::AttributeFunctor &, x); + Method1(bool, supports, IN, osg::Drawable::ConstAttributeFunctor &, x); + Method1(void, accept, IN, osg::Drawable::ConstAttributeFunctor &, af); + Method1(bool, supports, IN, osg::PrimitiveFunctor &, x); + Method1(void, accept, IN, osg::PrimitiveFunctor &, pf); + Property(const osg::Vec4 &, Color); + Property(osg::TessellationHints *, TessellationHints); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::TessellationHints::TessellationMode) + EnumLabel(osg::TessellationHints::USE_SHAPE_DEFAULTS); + EnumLabel(osg::TessellationHints::USE_TARGET_NUM_FACES); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TessellationHints) + BaseType(osg::Object); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TessellationHints &, tess, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method1(void, setTessellationMode, IN, osg::TessellationHints::TessellationMode, mode); + Method0(osg::TessellationHints::TessellationMode, getTessellationMode); + Method1(void, setDetailRatio, IN, float, ratio); + Method0(float, getDetailRatio); + Method1(void, setTargetNumFaces, IN, unsigned int, target); + Method0(unsigned int, getTargetNumFaces); + Method1(void, setCreateFrontFace, IN, bool, on); + Method0(bool, getCreateFrontFace); + Method1(void, setCreateBackFace, IN, bool, on); + Method0(bool, getCreateBackFace); + Method1(void, setCreateNormals, IN, bool, on); + Method0(bool, getCreateNormals); + Method1(void, setCreateTextureCoords, IN, bool, on); + Method0(bool, getCreateTextureCoords); + Method1(void, setCreateTop, IN, bool, on); + Method0(bool, getCreateTop); + Method1(void, setCreateBody, IN, bool, on); + Method0(bool, getCreateBody); + Method1(void, setCreateBottom, IN, bool, on); + Method0(bool, getCreateBottom); + Property(bool, CreateBackFace); + Property(bool, CreateBody); + Property(bool, CreateBottom); + Property(bool, CreateFrontFace); + Property(bool, CreateNormals); + Property(bool, CreateTextureCoords); + Property(bool, CreateTop); + Property(float, DetailRatio); + Property(unsigned int, TargetNumFaces); + Property(osg::TessellationHints::TessellationMode, TessellationMode); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/State.cpp b/src/osgWrappers/osg/State.cpp new file mode 100644 index 000000000..d1e3280aa --- /dev/null +++ b/src/osgWrappers/osg/State.cpp @@ -0,0 +1,164 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::pair< const osg::StateAttribute * COMMA osg::StateAttribute::OverrideValue >, osg::State::AttributePair); + +TYPE_NAME_ALIAS(std::vector< osg::State::AttributePair >, osg::State::AttributeVec); + +TYPE_NAME_ALIAS(std::vector< osg::StateAttribute::GLModeValue >, osg::State::ValueVec); + +TYPE_NAME_ALIAS(std::map< std::string COMMA osg::ref_ptr< osg::Uniform > >, osg::State::UniformMap); + +BEGIN_OBJECT_REFLECTOR(osg::State) + BaseType(osg::Referenced); + Constructor0(); + Method1(void, pushStateSet, IN, const osg::StateSet *, dstate); + Method0(void, popStateSet); + Method0(void, popAllStateSets); + Method1(void, captureCurrentState, IN, osg::StateSet &, stateset); + Method0(void, reset); + Method0(const osg::Viewport *, getCurrentViewport); + Method1(void, setInitialViewMatrix, IN, const osg::RefMatrix *, matrix); + Method0(const osg::Matrix &, getInitialViewMatrix); + Method0(const osg::Matrix &, getInitialInverseViewMatrix); + Method1(void, applyProjectionMatrix, IN, const osg::RefMatrix *, matrix); + Method0(const osg::Matrix &, getProjectionMatrix); + Method1(void, applyModelViewMatrix, IN, const osg::RefMatrix *, matrix); + Method0(const osg::Matrix &, getModelViewMatrix); + Method0(osg::Polytope, getViewFrustum); + Method1(void, apply, IN, const osg::StateSet *, dstate); + Method0(void, apply); + Method2(void, setGlobalDefaultModeValue, IN, osg::StateAttribute::GLMode, mode, IN, bool, enabled); + Method1(bool, getGlobalDefaultModeValue, IN, osg::StateAttribute::GLMode, mode); + Method2(bool, applyMode, IN, osg::StateAttribute::GLMode, mode, IN, bool, enabled); + Method3(void, setGlobalDefaultTextureModeValue, IN, unsigned int, unit, IN, osg::StateAttribute::GLMode, mode, IN, bool, enabled); + Method2(bool, getGlobalDefaultTextureModeValue, IN, unsigned int, unit, IN, osg::StateAttribute::GLMode, mode); + Method3(bool, applyTextureMode, IN, unsigned int, unit, IN, osg::StateAttribute::GLMode, mode, IN, bool, enabled); + Method1(void, setGlobalDefaultAttribute, IN, const osg::StateAttribute *, attribute); + MethodWithDefaults2(const osg::StateAttribute *, getGlobalDefaultAttribute, IN, osg::StateAttribute::Type, type, , IN, unsigned int, member, 0); + Method1(bool, applyAttribute, IN, const osg::StateAttribute *, attribute); + Method2(void, setGlobalDefaultTextureAttribute, IN, unsigned int, unit, IN, const osg::StateAttribute *, attribute); + MethodWithDefaults3(const osg::StateAttribute *, getGlobalDefaultTextureAttribute, IN, unsigned int, unit, , IN, osg::StateAttribute::Type, type, , IN, unsigned int, member, 0); + Method2(bool, applyTextureAttribute, IN, unsigned int, unit, IN, const osg::StateAttribute *, attribute); + Method2(void, haveAppliedMode, IN, osg::StateAttribute::GLMode, mode, IN, osg::StateAttribute::GLModeValue, value); + Method1(void, haveAppliedMode, IN, osg::StateAttribute::GLMode, mode); + Method1(void, haveAppliedAttribute, IN, const osg::StateAttribute *, attribute); + MethodWithDefaults2(void, haveAppliedAttribute, IN, osg::StateAttribute::Type, type, , IN, unsigned int, member, 0); + Method1(bool, getLastAppliedMode, IN, osg::StateAttribute::GLMode, mode); + MethodWithDefaults2(const osg::StateAttribute *, getLastAppliedAttribute, IN, osg::StateAttribute::Type, type, , IN, unsigned int, member, 0); + Method3(void, haveAppliedTextureMode, IN, unsigned int, unit, IN, osg::StateAttribute::GLMode, mode, IN, osg::StateAttribute::GLModeValue, value); + Method2(void, haveAppliedTextureMode, IN, unsigned int, unit, IN, osg::StateAttribute::GLMode, mode); + Method2(void, haveAppliedTextureAttribute, IN, unsigned int, unit, IN, const osg::StateAttribute *, attribute); + MethodWithDefaults3(void, haveAppliedTextureAttribute, IN, unsigned int, unit, , IN, osg::StateAttribute::Type, type, , IN, unsigned int, member, 0); + Method2(bool, getLastAppliedTextureMode, IN, unsigned int, unit, IN, osg::StateAttribute::GLMode, mode); + MethodWithDefaults3(const osg::StateAttribute *, getLastAppliedTextureAttribute, IN, unsigned int, unit, , IN, osg::StateAttribute::Type, type, , IN, unsigned int, member, 0); + Method0(void, dirtyAllModes); + Method0(void, dirtyAllAttributes); + Method0(void, disableAllVertexArrays); + Method0(void, dirtyAllVertexArrays); + Method3(void, setInterleavedArrays, IN, GLenum, format, IN, GLsizei, stride, IN, const GLvoid *, pointer); + Method4(void, setVertexPointer, IN, GLint, size, IN, GLenum, type, IN, GLsizei, stride, IN, const GLvoid *, ptr); + Method0(void, disableVertexPointer); + Method0(void, dirtyVertexPointer); + Method3(void, setNormalPointer, IN, GLenum, type, IN, GLsizei, stride, IN, const GLvoid *, ptr); + Method0(void, disableNormalPointer); + Method0(void, dirtyNormalPointer); + Method4(void, setColorPointer, IN, GLint, size, IN, GLenum, type, IN, GLsizei, stride, IN, const GLvoid *, ptr); + Method0(void, disableColorPointer); + Method0(void, dirtyColorPointer); + Method0(bool, isSecondaryColorSupported); + Method4(void, setSecondaryColorPointer, IN, GLint, size, IN, GLenum, type, IN, GLsizei, stride, IN, const GLvoid *, ptr); + Method0(void, disableSecondaryColorPointer); + Method0(void, dirtySecondaryColorPointer); + Method3(void, setIndexPointer, IN, GLenum, type, IN, GLsizei, stride, IN, const GLvoid *, ptr); + Method0(void, disableIndexPointer); + Method0(void, dirtyIndexPointer); + Method0(bool, isFogCoordSupported); + Method3(void, setFogCoordPointer, IN, GLenum, type, IN, GLsizei, stride, IN, const GLvoid *, ptr); + Method0(void, disableFogCoordPointer); + Method0(void, dirtyFogCoordPointer); + Method5(void, setTexCoordPointer, IN, unsigned int, unit, IN, GLint, size, IN, GLenum, type, IN, GLsizei, stride, IN, const GLvoid *, ptr); + Method1(void, disableTexCoordPointer, IN, unsigned int, unit); + Method1(void, dirtyTexCoordPointer, IN, unsigned int, unit); + Method1(void, disableTexCoordPointersAboveAndIncluding, IN, unsigned int, unit); + Method1(void, dirtyTexCoordPointersAboveAndIncluding, IN, unsigned int, unit); + Method1(bool, setActiveTextureUnit, IN, unsigned int, unit); + Method0(unsigned int, getActiveTextureUnit); + Method1(bool, setClientActiveTextureUnit, IN, unsigned int, unit); + Method0(unsigned int, getClientActiveTextureUnit); + Method6(void, setVertexAttribPointer, IN, unsigned int, index, IN, GLint, size, IN, GLenum, type, IN, GLboolean, normalized, IN, GLsizei, stride, IN, const GLvoid *, ptr); + Method1(void, disableVertexAttribPointer, IN, unsigned int, index); + Method1(void, disableVertexAttribPointersAboveAndIncluding, IN, unsigned int, index); + Method1(void, dirtyVertexAttribPointersAboveAndIncluding, IN, unsigned int, index); + Method0(bool, isVertexBufferObjectSupported); + Method1(void, setContextID, IN, unsigned int, contextID); + Method0(unsigned int, getContextID); + Method1(void, setFrameStamp, IN, osg::FrameStamp *, fs); + Method0(const osg::FrameStamp *, getFrameStamp); + Method1(void, setDisplaySettings, IN, osg::DisplaySettings *, vs); + Method0(const osg::DisplaySettings *, getDisplaySettings); + Method1(void, setAbortRenderingPtr, IN, bool *, abortPtr); + Method0(bool, getAbortRendering); + Method1(void, setReportGLErrors, IN, bool, flag); + Method0(bool, getReportGLErrors); + Method1(bool, checkGLErrors, IN, const char *, str); + Method1(bool, checkGLErrors, IN, osg::StateAttribute::GLMode, mode); + Method1(bool, checkGLErrors, IN, const osg::StateAttribute *, attribute); + Method1(const osg::Uniform *, findUniform, IN, const std::string &, name); + ReadOnlyProperty(bool, AbortRendering); + WriteOnlyProperty(bool *, AbortRenderingPtr); + PropertyWithReturnType(unsigned int, ActiveTextureUnit, bool); + PropertyWithReturnType(unsigned int, ClientActiveTextureUnit, bool); + Property(unsigned int, ContextID); + ReadOnlyProperty(const osg::Viewport *, CurrentViewport); + WriteOnlyProperty(osg::DisplaySettings *, DisplaySettings); + WriteOnlyProperty(osg::FrameStamp *, FrameStamp); + WriteOnlyProperty(const osg::StateAttribute *, GlobalDefaultAttribute); + IndexedProperty1(bool, GlobalDefaultModeValue, osg::StateAttribute::GLMode, mode); + IndexedProperty2(bool, GlobalDefaultTextureModeValue, unsigned int, unit, osg::StateAttribute::GLMode, mode); + ReadOnlyProperty(const osg::Matrix &, InitialInverseViewMatrix); + WriteOnlyProperty(const osg::RefMatrix *, InitialViewMatrix); + ReadOnlyProperty(const osg::Matrix &, ModelViewMatrix); + ReadOnlyProperty(const osg::Matrix &, ProjectionMatrix); + Property(bool, ReportGLErrors); + ReadOnlyProperty(osg::Polytope, ViewFrustum); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::Uniform >) + Constructor0(); + Constructor1(IN, osg::Uniform *, t); + Constructor1(IN, const osg::ref_ptr< osg::Uniform > &, rp); + Method0(bool, valid); + Method0(osg::Uniform *, get); + Method0(const osg::Uniform *, get); + Method0(osg::Uniform *, take); + Method0(osg::Uniform *, release); + ReadOnlyProperty(osg::Uniform *, ); +END_REFLECTOR + +STD_MAP_REFLECTOR(std::map< std::string COMMA osg::ref_ptr< osg::Uniform > >); + +STD_PAIR_REFLECTOR(std::pair< const osg::StateAttribute * COMMA osg::StateAttribute::OverrideValue >); + +STD_VECTOR_REFLECTOR(std::vector< osg::State::AttributePair >); + +STD_VECTOR_REFLECTOR(std::vector< osg::StateAttribute::GLModeValue >); + diff --git a/src/osgWrappers/osg/StateAttribute.cpp b/src/osgWrappers/osg/StateAttribute.cpp index 3cd66ce8b..b7c7de8d9 100644 --- a/src/osgWrappers/osg/StateAttribute.cpp +++ b/src/osgWrappers/osg/StateAttribute.cpp @@ -1,14 +1,26 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include +#include +#include +#include #include -using namespace osgIntrospection; +TYPE_NAME_ALIAS(GLenum, osg::StateAttribute::GLMode); -BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::StateAttribute) - BaseType(osg::Object); -END_REFLECTOR +TYPE_NAME_ALIAS(unsigned int, osg::StateAttribute::GLModeValue); + +TYPE_NAME_ALIAS(unsigned int, osg::StateAttribute::OverrideValue); + +TYPE_NAME_ALIAS(std::pair< osg::StateAttribute::Type COMMA unsigned int >, osg::StateAttribute::TypeMemberPair); BEGIN_ENUM_REFLECTOR(osg::StateAttribute::Values) EnumLabel(osg::StateAttribute::OFF); @@ -18,51 +30,83 @@ BEGIN_ENUM_REFLECTOR(osg::StateAttribute::Values) EnumLabel(osg::StateAttribute::INHERIT); END_REFLECTOR - BEGIN_ENUM_REFLECTOR(osg::StateAttribute::Type) - EnumLabel(osg::StateAttribute::TEXTURE); - EnumLabel(osg::StateAttribute::POLYGONMODE); - EnumLabel(osg::StateAttribute::POLYGONOFFSET); - EnumLabel(osg::StateAttribute::MATERIAL); - EnumLabel(osg::StateAttribute::ALPHAFUNC); - EnumLabel(osg::StateAttribute::ANTIALIAS); - EnumLabel(osg::StateAttribute::COLORTABLE); - EnumLabel(osg::StateAttribute::CULLFACE); - EnumLabel(osg::StateAttribute::FOG); - EnumLabel(osg::StateAttribute::FRONTFACE); - EnumLabel(osg::StateAttribute::LIGHT); - EnumLabel(osg::StateAttribute::POINT); - EnumLabel(osg::StateAttribute::LINEWIDTH); - EnumLabel(osg::StateAttribute::LINESTIPPLE); - EnumLabel(osg::StateAttribute::POLYGONSTIPPLE); - EnumLabel(osg::StateAttribute::SHADEMODEL); - EnumLabel(osg::StateAttribute::TEXENV); - EnumLabel(osg::StateAttribute::TEXENVFILTER); - EnumLabel(osg::StateAttribute::TEXGEN); - EnumLabel(osg::StateAttribute::TEXMAT); - EnumLabel(osg::StateAttribute::LIGHTMODEL); - EnumLabel(osg::StateAttribute::BLENDFUNC); - EnumLabel(osg::StateAttribute::STENCIL); - EnumLabel(osg::StateAttribute::COLORMASK); - EnumLabel(osg::StateAttribute::DEPTH); - EnumLabel(osg::StateAttribute::VIEWPORT); - EnumLabel(osg::StateAttribute::BLENDCOLOR); - EnumLabel(osg::StateAttribute::MULTISAMPLE); - EnumLabel(osg::StateAttribute::CLIPPLANE); - EnumLabel(osg::StateAttribute::COLORMATRIX); - EnumLabel(osg::StateAttribute::VERTEXPROGRAM); - EnumLabel(osg::StateAttribute::FRAGMENTPROGRAM); - EnumLabel(osg::StateAttribute::POINTSPRITE); - EnumLabel(osg::StateAttribute::PROGRAMOBJECT); - EnumLabel(osg::StateAttribute::VALIDATOR); - EnumLabel(osg::StateAttribute::VIEWMATRIXEXTRACTOR); - - EnumLabel(osg::StateAttribute::OSGNV_PARAMETER_BLOCK); - EnumLabel(osg::StateAttribute::OSGNVEXT_TEXTURE_SHADER); - EnumLabel(osg::StateAttribute::OSGNVEXT_VERTEX_PROGRAM); - EnumLabel(osg::StateAttribute::OSGNVEXT_REGISTER_COMBINERS); - EnumLabel(osg::StateAttribute::OSGNVCG_PROGRAM); - EnumLabel(osg::StateAttribute::OSGNVSLANG_PROGRAM); - EnumLabel(osg::StateAttribute::OSGNVPARSE_PROGRAM_PARSER); - + EnumLabel(osg::StateAttribute::TEXTURE); + EnumLabel(osg::StateAttribute::POLYGONMODE); + EnumLabel(osg::StateAttribute::POLYGONOFFSET); + EnumLabel(osg::StateAttribute::MATERIAL); + EnumLabel(osg::StateAttribute::ALPHAFUNC); + EnumLabel(osg::StateAttribute::ANTIALIAS); + EnumLabel(osg::StateAttribute::COLORTABLE); + EnumLabel(osg::StateAttribute::CULLFACE); + EnumLabel(osg::StateAttribute::FOG); + EnumLabel(osg::StateAttribute::FRONTFACE); + EnumLabel(osg::StateAttribute::LIGHT); + EnumLabel(osg::StateAttribute::POINT); + EnumLabel(osg::StateAttribute::LINEWIDTH); + EnumLabel(osg::StateAttribute::LINESTIPPLE); + EnumLabel(osg::StateAttribute::POLYGONSTIPPLE); + EnumLabel(osg::StateAttribute::SHADEMODEL); + EnumLabel(osg::StateAttribute::TEXENV); + EnumLabel(osg::StateAttribute::TEXENVFILTER); + EnumLabel(osg::StateAttribute::TEXGEN); + EnumLabel(osg::StateAttribute::TEXMAT); + EnumLabel(osg::StateAttribute::LIGHTMODEL); + EnumLabel(osg::StateAttribute::BLENDFUNC); + EnumLabel(osg::StateAttribute::BLENDEQUATION); + EnumLabel(osg::StateAttribute::LOGICOP); + EnumLabel(osg::StateAttribute::STENCIL); + EnumLabel(osg::StateAttribute::COLORMASK); + EnumLabel(osg::StateAttribute::DEPTH); + EnumLabel(osg::StateAttribute::VIEWPORT); + EnumLabel(osg::StateAttribute::BLENDCOLOR); + EnumLabel(osg::StateAttribute::MULTISAMPLE); + EnumLabel(osg::StateAttribute::CLIPPLANE); + EnumLabel(osg::StateAttribute::COLORMATRIX); + EnumLabel(osg::StateAttribute::VERTEXPROGRAM); + EnumLabel(osg::StateAttribute::FRAGMENTPROGRAM); + EnumLabel(osg::StateAttribute::POINTSPRITE); + EnumLabel(osg::StateAttribute::PROGRAMOBJECT); + EnumLabel(osg::StateAttribute::VALIDATOR); + EnumLabel(osg::StateAttribute::VIEWMATRIXEXTRACTOR); + EnumLabel(osg::StateAttribute::OSGNV_PARAMETER_BLOCK); + EnumLabel(osg::StateAttribute::OSGNVEXT_TEXTURE_SHADER); + EnumLabel(osg::StateAttribute::OSGNVEXT_VERTEX_PROGRAM); + EnumLabel(osg::StateAttribute::OSGNVEXT_REGISTER_COMBINERS); + EnumLabel(osg::StateAttribute::OSGNVCG_PROGRAM); + EnumLabel(osg::StateAttribute::OSGNVSLANG_PROGRAM); + EnumLabel(osg::StateAttribute::OSGNVPARSE_PROGRAM_PARSER); + EnumLabel(osg::StateAttribute::PROGRAM); END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::StateAttribute) + BaseType(osg::Object); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::StateAttribute &, sa, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, x); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method0(unsigned int, getMember); + Method0(osg::StateAttribute::TypeMemberPair, getTypeMemberPair); + Method0(bool, isTextureAttribute); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, x); + Method1(void, apply, IN, osg::State &, x); + Method1(void, compileGLObjects, IN, osg::State &, x); + MethodWithDefaults1(void, releaseGLObjects, IN, osg::State *, x, 0); + ReadOnlyProperty(unsigned int, Member); + ReadOnlyProperty(osg::StateAttribute::Type, Type); + ReadOnlyProperty(osg::StateAttribute::TypeMemberPair, TypeMemberPair); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::StateAttribute::ModeUsage) + Constructor0(); + Method1(void, usesMode, IN, osg::StateAttribute::GLMode, mode); + Method1(void, usesTextureMode, IN, osg::StateAttribute::GLMode, mode); +END_REFLECTOR + +STD_PAIR_REFLECTOR(std::pair< osg::StateAttribute::Type COMMA unsigned int >); + diff --git a/src/osgWrappers/osg/StateSet.cpp b/src/osgWrappers/osg/StateSet.cpp index 54393b2cd..67bd182de 100644 --- a/src/osgWrappers/osg/StateSet.cpp +++ b/src/osgWrappers/osg/StateSet.cpp @@ -1,18 +1,35 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include +#include +#include +#include +#include +#include #include +#include -using namespace osgIntrospection; +TYPE_NAME_ALIAS(std::map< osg::StateAttribute::GLMode COMMA osg::StateAttribute::GLModeValue >, osg::StateSet::ModeList); -BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::StateAttribute) - BaseType(osg::Object); -END_REFLECTOR +TYPE_NAME_ALIAS(std::pair< osg::ref_ptr< osg::StateAttribute > COMMA osg::StateAttribute::OverrideValue >, osg::StateSet::RefAttributePair); -BEGIN_OBJECT_REFLECTOR(osg::StateSet) - BaseType(osg::Object) -END_REFLECTOR +TYPE_NAME_ALIAS(std::map< osg::StateAttribute::TypeMemberPair COMMA osg::StateSet::RefAttributePair >, osg::StateSet::AttributeList); + +TYPE_NAME_ALIAS(std::vector< osg::StateSet::ModeList >, osg::StateSet::TextureModeList); + +TYPE_NAME_ALIAS(std::vector< osg::StateSet::AttributeList >, osg::StateSet::TextureAttributeList); + +TYPE_NAME_ALIAS(std::pair< osg::ref_ptr< osg::Uniform > COMMA osg::StateAttribute::OverrideValue >, osg::StateSet::RefUniformPair); + +TYPE_NAME_ALIAS(std::map< std::string COMMA osg::StateSet::RefUniformPair >, osg::StateSet::UniformList); BEGIN_ENUM_REFLECTOR(osg::StateSet::RenderingHint) EnumLabel(osg::StateSet::DEFAULT_BIN); @@ -21,33 +38,120 @@ BEGIN_ENUM_REFLECTOR(osg::StateSet::RenderingHint) END_REFLECTOR BEGIN_ENUM_REFLECTOR(osg::StateSet::RenderBinMode) - EnumLabel(osg::StateSet::ENCLOSE_RENDERBIN_DETAILS); EnumLabel(osg::StateSet::INHERIT_RENDERBIN_DETAILS); - EnumLabel(osg::StateSet::OVERRIDE_RENDERBIN_DETAILS); EnumLabel(osg::StateSet::USE_RENDERBIN_DETAILS); + EnumLabel(osg::StateSet::OVERRIDE_RENDERBIN_DETAILS); + EnumLabel(osg::StateSet::ENCLOSE_RENDERBIN_DETAILS); END_REFLECTOR -STD_MAP_REFLECTOR_WITH_TYPES(osg::StateSet::ModeList, unsigned int, osg::StateAttribute::Values); -STD_MAP_REFLECTOR(osg::StateSet::AttributeList); -STD_CONTAINER_REFLECTOR(osg::StateSet::TextureAttributeList); -STD_CONTAINER_REFLECTOR(osg::StateSet::TextureModeList); - BEGIN_OBJECT_REFLECTOR(osg::StateSet) - BaseType(osg::Object) + BaseType(osg::Object); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::StateSet &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + MethodWithDefaults2(int, compare, IN, const osg::StateSet &, rhs, , IN, bool, compareAttributeContents, false); + Method0(void, setGlobalDefaults); + Method0(void, clear); + Method1(void, merge, IN, const osg::StateSet &, rhs); + Method2(void, setMode, IN, osg::StateAttribute::GLMode, mode, IN, osg::StateAttribute::GLModeValue, value); + Method1(void, removeMode, IN, osg::StateAttribute::GLMode, mode); + Method1(osg::StateAttribute::GLModeValue, getMode, IN, osg::StateAttribute::GLMode, mode); + Method1(void, setModeList, IN, osg::StateSet::ModeList &, ml); + Method0(osg::StateSet::ModeList &, getModeList); + Method0(const osg::StateSet::ModeList &, getModeList); + MethodWithDefaults2(void, setAttribute, IN, osg::StateAttribute *, attribute, , IN, osg::StateAttribute::OverrideValue, value, osg::StateAttribute::OFF); + MethodWithDefaults2(void, setAttributeAndModes, IN, osg::StateAttribute *, attribute, , IN, osg::StateAttribute::GLModeValue, value, osg::StateAttribute::ON); + MethodWithDefaults2(void, removeAttribute, IN, osg::StateAttribute::Type, type, , IN, unsigned int, member, 0); + Method1(void, removeAttribute, IN, osg::StateAttribute *, attribute); + MethodWithDefaults2(osg::StateAttribute *, getAttribute, IN, osg::StateAttribute::Type, type, , IN, unsigned int, member, 0); + MethodWithDefaults2(const osg::StateAttribute *, getAttribute, IN, osg::StateAttribute::Type, type, , IN, unsigned int, member, 0); + MethodWithDefaults2(const osg::StateSet::RefAttributePair *, getAttributePair, IN, osg::StateAttribute::Type, type, , IN, unsigned int, member, 0); + Method1(void, setAttributeList, IN, osg::StateSet::AttributeList &, al); + Method0(osg::StateSet::AttributeList &, getAttributeList); + Method0(const osg::StateSet::AttributeList &, getAttributeList); + Method3(void, setTextureMode, IN, unsigned int, unit, IN, osg::StateAttribute::GLMode, mode, IN, osg::StateAttribute::GLModeValue, value); + Method2(void, removeTextureMode, IN, unsigned int, unit, IN, osg::StateAttribute::GLMode, mode); + Method2(osg::StateAttribute::GLModeValue, getTextureMode, IN, unsigned int, unit, IN, osg::StateAttribute::GLMode, mode); + Method1(void, setTextureModeList, IN, osg::StateSet::TextureModeList &, tml); + Method0(osg::StateSet::TextureModeList &, getTextureModeList); + Method0(const osg::StateSet::TextureModeList &, getTextureModeList); + MethodWithDefaults3(void, setTextureAttribute, IN, unsigned int, unit, , IN, osg::StateAttribute *, attribute, , IN, osg::StateAttribute::OverrideValue, value, osg::StateAttribute::OFF); + MethodWithDefaults3(void, setTextureAttributeAndModes, IN, unsigned int, unit, , IN, osg::StateAttribute *, attribute, , IN, osg::StateAttribute::GLModeValue, value, osg::StateAttribute::ON); + Method2(void, removeTextureAttribute, IN, unsigned int, unit, IN, osg::StateAttribute::Type, type); + Method2(void, removeTextureAttribute, IN, unsigned int, unit, IN, osg::StateAttribute *, attribute); + Method2(osg::StateAttribute *, getTextureAttribute, IN, unsigned int, unit, IN, osg::StateAttribute::Type, type); + Method2(const osg::StateAttribute *, getTextureAttribute, IN, unsigned int, unit, IN, osg::StateAttribute::Type, type); + Method2(const osg::StateSet::RefAttributePair *, getTextureAttributePair, IN, unsigned int, unit, IN, osg::StateAttribute::Type, type); + Method1(void, setTextureAttributeList, IN, osg::StateSet::TextureAttributeList &, tal); + Method0(osg::StateSet::TextureAttributeList &, getTextureAttributeList); + Method0(const osg::StateSet::TextureAttributeList &, getTextureAttributeList); + Method2(void, setAssociatedModes, IN, const osg::StateAttribute *, attribute, IN, osg::StateAttribute::GLModeValue, value); + Method3(void, setAssociatedTextureModes, IN, unsigned int, unit, IN, const osg::StateAttribute *, attribute, IN, osg::StateAttribute::GLModeValue, value); + MethodWithDefaults2(void, addUniform, IN, osg::Uniform *, uniform, , IN, osg::StateAttribute::OverrideValue, value, osg::StateAttribute::ON); + Method1(void, removeUniform, IN, const std::string &, name); + Method1(void, removeUniform, IN, osg::Uniform *, uniform); + Method1(osg::Uniform *, getUniform, IN, const std::string &, name); + Method1(const osg::Uniform *, getUniform, IN, const std::string &, name); + Method1(const osg::StateSet::RefUniformPair *, getUniformPair, IN, const std::string &, name); + Method1(void, setUniformList, IN, osg::StateSet::UniformList &, al); + Method0(osg::StateSet::UniformList &, getUniformList); + Method0(const osg::StateSet::UniformList &, getUniformList); + Method1(void, setProgram, IN, osg::Program *, program); + Method0(osg::Program *, getProgram); + Method0(const osg::Program *, getProgram); + Method1(void, setRenderingHint, IN, int, hint); + Method0(int, getRenderingHint); + MethodWithDefaults3(void, setRenderBinDetails, IN, int, binNum, , IN, const std::string &, binName, , IN, osg::StateSet::RenderBinMode, mode, osg::StateSet::USE_RENDERBIN_DETAILS); + Method0(void, setRenderBinToInherit); + Method0(bool, useRenderBinDetails); + Method1(void, setRenderBinMode, IN, osg::StateSet::RenderBinMode, mode); + Method0(osg::StateSet::RenderBinMode, getRenderBinMode); + Method1(void, setBinNumber, IN, int, num); + Method0(int, getBinNumber); + Method1(void, setBinName, IN, const std::string &, name); + Method0(const std::string &, getBinName); + Method1(void, compileGLObjects, IN, osg::State &, state); + MethodWithDefaults1(void, releaseGLObjects, IN, osg::State *, state, 0); + Property(osg::StateSet::AttributeList &, AttributeList); + Property(const std::string &, BinName); + Property(int, BinNumber); + + Property(osg::StateSet::ModeList &, ModeList); + Property(osg::Program *, Program); + Property(osg::StateSet::RenderBinMode, RenderBinMode); Property(int, RenderingHint); - Attribute(PropertyTypeAttribute(typeof(osg::StateSet::RenderingHint))); - - ReadOnlyProperty(const osg::StateSet::ModeList &, ModeList); - ReadOnlyProperty(const osg::StateSet::AttributeList &, AttributeList); - ReadOnlyProperty(const osg::StateSet::TextureModeList &, TextureModeList); - ReadOnlyProperty(const osg::StateSet::TextureAttributeList &, TextureAttributeList); - + Property(osg::StateSet::TextureAttributeList &, TextureAttributeList); + IndexedProperty2(osg::StateAttribute::GLModeValue, TextureMode, unsigned int, unit, osg::StateAttribute::GLMode, mode); + Property(osg::StateSet::TextureModeList &, TextureModeList); + Property(osg::StateSet::UniformList &, UniformList); END_REFLECTOR +BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::StateAttribute >) + Constructor0(); + Constructor1(IN, osg::StateAttribute *, t); + Constructor1(IN, const osg::ref_ptr< osg::StateAttribute > &, rp); + Method0(bool, valid); + Method0(osg::StateAttribute *, get); + Method0(const osg::StateAttribute *, get); + Method0(osg::StateAttribute *, take); + Method0(osg::StateAttribute *, release); + ReadOnlyProperty(osg::StateAttribute *, ); +END_REFLECTOR -typedef osg::ref_ptr RefStateAttribute; -STD_VALUE_REFLECTOR(RefStateAttribute); +STD_MAP_REFLECTOR_WITH_TYPES(std::map< osg::StateAttribute::GLMode COMMA osg::StateAttribute::GLModeValue >, osg::StateAttribute::GLMode, osg::StateAttribute::Values); +STD_MAP_REFLECTOR(std::map< osg::StateAttribute::TypeMemberPair COMMA osg::StateSet::RefAttributePair >); -STD_PAIR_REFLECTOR(osg::StateAttribute::TypeMemberPair) -STD_PAIR_REFLECTOR_WITH_TYPES(osg::StateSet::RefAttributePair, osg::StateAttribute *, osg::StateAttribute::Values) +STD_MAP_REFLECTOR(std::map< std::string COMMA osg::StateSet::RefUniformPair >); + +STD_PAIR_REFLECTOR(std::pair< osg::ref_ptr< osg::StateAttribute > COMMA osg::StateAttribute::OverrideValue >); + +STD_PAIR_REFLECTOR(std::pair< osg::ref_ptr< osg::Uniform > COMMA osg::StateAttribute::OverrideValue >); + +STD_VECTOR_REFLECTOR(std::vector< osg::StateSet::AttributeList >); + +STD_VECTOR_REFLECTOR(std::vector< osg::StateSet::ModeList >); diff --git a/src/osgWrappers/osg/Stencil.cpp b/src/osgWrappers/osg/Stencil.cpp new file mode 100644 index 000000000..39f8013d4 --- /dev/null +++ b/src/osgWrappers/osg/Stencil.cpp @@ -0,0 +1,76 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::Stencil::Function) + EnumLabel(osg::Stencil::NEVER); + EnumLabel(osg::Stencil::LESS); + EnumLabel(osg::Stencil::EQUAL); + EnumLabel(osg::Stencil::LEQUAL); + EnumLabel(osg::Stencil::GREATER); + EnumLabel(osg::Stencil::NOTEQUAL); + EnumLabel(osg::Stencil::GEQUAL); + EnumLabel(osg::Stencil::ALWAYS); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::Stencil::Operation) + EnumLabel(osg::Stencil::KEEP); + EnumLabel(osg::Stencil::ZERO); + EnumLabel(osg::Stencil::REPLACE); + EnumLabel(osg::Stencil::INCR); + EnumLabel(osg::Stencil::DECR); + EnumLabel(osg::Stencil::INVERT); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Stencil) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Stencil &, stencil, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method3(void, setFunction, IN, osg::Stencil::Function, func, IN, int, ref, IN, unsigned int, mask); + Method1(void, setFunction, IN, osg::Stencil::Function, func); + Method0(osg::Stencil::Function, getFunction); + Method1(void, setFunctionRef, IN, int, ref); + Method0(int, getFunctionRef); + Method1(void, setFunctionMask, IN, unsigned int, mask); + Method0(unsigned int, getFunctionMask); + Method3(void, setOperation, IN, osg::Stencil::Operation, sfail, IN, osg::Stencil::Operation, zfail, IN, osg::Stencil::Operation, zpass); + Method1(void, setStencilFailOperation, IN, osg::Stencil::Operation, sfail); + Method0(osg::Stencil::Operation, getStencilFailOperation); + Method1(void, setStencilPassAndDepthFailOperation, IN, osg::Stencil::Operation, zfail); + Method0(osg::Stencil::Operation, getStencilPassAndDepthFailOperation); + Method1(void, setStencilPassAndDepthPassOperation, IN, osg::Stencil::Operation, zpass); + Method0(osg::Stencil::Operation, getStencilPassAndDepthPassOperation); + Method1(void, setWriteMask, IN, unsigned int, mask); + Method0(unsigned int, getWriteMask); + Method1(void, apply, IN, osg::State &, state); + Property(osg::Stencil::Function, Function); + Property(unsigned int, FunctionMask); + Property(int, FunctionRef); + Property(osg::Stencil::Operation, StencilFailOperation); + Property(osg::Stencil::Operation, StencilPassAndDepthFailOperation); + Property(osg::Stencil::Operation, StencilPassAndDepthPassOperation); + ReadOnlyProperty(osg::StateAttribute::Type, Type); + Property(unsigned int, WriteMask); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Switch.cpp b/src/osgWrappers/osg/Switch.cpp new file mode 100644 index 000000000..9044dc27c --- /dev/null +++ b/src/osgWrappers/osg/Switch.cpp @@ -0,0 +1,55 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::vector< bool >, osg::Switch::ValueList); + +BEGIN_OBJECT_REFLECTOR(osg::Switch) + BaseType(osg::Group); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Switch &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, traverse, IN, osg::NodeVisitor &, nv); + Method1(void, setNewChildDefaultValue, IN, bool, value); + Method0(bool, getNewChildDefaultValue); + Method1(bool, addChild, IN, osg::Node *, child); + Method2(bool, addChild, IN, osg::Node *, child, IN, bool, value); + Method2(bool, insertChild, IN, unsigned int, index, IN, osg::Node *, child); + Method3(bool, insertChild, IN, unsigned int, index, IN, osg::Node *, child, IN, bool, value); + Method1(bool, removeChild, IN, osg::Node *, child); + Method2(void, setValue, IN, unsigned int, pos, IN, bool, value); + Method1(bool, getValue, IN, unsigned int, pos); + Method2(void, setChildValue, IN, const osg::Node *, child, IN, bool, value); + Method1(bool, getChildValue, IN, const osg::Node *, child); + Method0(bool, setAllChildrenOff); + Method0(bool, setAllChildrenOn); + Method1(bool, setSingleChildOn, IN, unsigned int, pos); + Method1(void, setValueList, IN, const osg::Switch::ValueList &, values); + Method0(const osg::Switch::ValueList &, getValueList); + IndexedProperty1(bool, ChildValue, const osg::Node *, child); + Property(bool, NewChildDefaultValue); + WriteOnlyPropertyWithReturnType(unsigned int, SingleChildOn, bool); + IndexedProperty1(bool, Value, unsigned int, pos); + Property(const osg::Switch::ValueList &, ValueList); +END_REFLECTOR + +STD_VECTOR_REFLECTOR(std::vector< bool >); + diff --git a/src/osgWrappers/osg/TexEnv.cpp b/src/osgWrappers/osg/TexEnv.cpp new file mode 100644 index 000000000..8f51be6bb --- /dev/null +++ b/src/osgWrappers/osg/TexEnv.cpp @@ -0,0 +1,49 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::TexEnv::Mode) + EnumLabel(osg::TexEnv::DECAL); + EnumLabel(osg::TexEnv::MODULATE); + EnumLabel(osg::TexEnv::BLEND); + EnumLabel(osg::TexEnv::REPLACE); + EnumLabel(osg::TexEnv::ADD); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TexEnv) + BaseType(osg::StateAttribute); + ConstructorWithDefaults1(IN, osg::TexEnv::Mode, mode, osg::TexEnv::MODULATE); + ConstructorWithDefaults2(IN, const osg::TexEnv &, texenv, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method0(bool, isTextureAttribute); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(void, setMode, IN, osg::TexEnv::Mode, mode); + Method0(osg::TexEnv::Mode, getMode); + Method1(void, setColor, IN, const osg::Vec4 &, color); + Method0(osg::Vec4 &, getColor); + Method0(const osg::Vec4 &, getColor); + Method1(void, apply, IN, osg::State &, state); + Property(const osg::Vec4 &, Color); + Property(osg::TexEnv::Mode, Mode); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/TexEnvCombine.cpp b/src/osgWrappers/osg/TexEnvCombine.cpp new file mode 100644 index 000000000..e8c19db0d --- /dev/null +++ b/src/osgWrappers/osg/TexEnvCombine.cpp @@ -0,0 +1,122 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::TexEnvCombine::CombineParam) + EnumLabel(osg::TexEnvCombine::REPLACE); + EnumLabel(osg::TexEnvCombine::MODULATE); + EnumLabel(osg::TexEnvCombine::ADD); + EnumLabel(osg::TexEnvCombine::ADD_SIGNED); + EnumLabel(osg::TexEnvCombine::INTERPOLATE); + EnumLabel(osg::TexEnvCombine::SUBTRACT); + EnumLabel(osg::TexEnvCombine::DOT3_RGB); + EnumLabel(osg::TexEnvCombine::DOT3_RGBA); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::TexEnvCombine::SourceParam) + EnumLabel(osg::TexEnvCombine::CONSTANT); + EnumLabel(osg::TexEnvCombine::PRIMARY_COLOR); + EnumLabel(osg::TexEnvCombine::PREVIOUS); + EnumLabel(osg::TexEnvCombine::TEXTURE); + EnumLabel(osg::TexEnvCombine::TEXTURE0); + EnumLabel(osg::TexEnvCombine::TEXTURE1); + EnumLabel(osg::TexEnvCombine::TEXTURE2); + EnumLabel(osg::TexEnvCombine::TEXTURE3); + EnumLabel(osg::TexEnvCombine::TEXTURE4); + EnumLabel(osg::TexEnvCombine::TEXTURE5); + EnumLabel(osg::TexEnvCombine::TEXTURE6); + EnumLabel(osg::TexEnvCombine::TEXTURE7); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::TexEnvCombine::OperandParam) + EnumLabel(osg::TexEnvCombine::SRC_COLOR); + EnumLabel(osg::TexEnvCombine::ONE_MINUS_SRC_COLOR); + EnumLabel(osg::TexEnvCombine::SRC_ALPHA); + EnumLabel(osg::TexEnvCombine::ONE_MINUS_SRC_ALPHA); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TexEnvCombine) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TexEnvCombine &, texenv, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method0(bool, isTextureAttribute); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(void, setCombine_RGB, IN, GLint, cm); + Method1(void, setCombine_Alpha, IN, GLint, cm); + Method0(GLint, getCombine_RGB); + Method0(GLint, getCombine_Alpha); + Method1(void, setSource0_RGB, IN, GLint, sp); + Method1(void, setSource1_RGB, IN, GLint, sp); + Method1(void, setSource2_RGB, IN, GLint, sp); + Method1(void, setSource0_Alpha, IN, GLint, sp); + Method1(void, setSource1_Alpha, IN, GLint, sp); + Method1(void, setSource2_Alpha, IN, GLint, sp); + Method0(GLint, getSource0_RGB); + Method0(GLint, getSource1_RGB); + Method0(GLint, getSource2_RGB); + Method0(GLint, getSource0_Alpha); + Method0(GLint, getSource1_Alpha); + Method0(GLint, getSource2_Alpha); + Method1(void, setOperand0_RGB, IN, GLint, op); + Method1(void, setOperand1_RGB, IN, GLint, op); + Method1(void, setOperand2_RGB, IN, GLint, op); + Method1(void, setOperand0_Alpha, IN, GLint, op); + Method1(void, setOperand1_Alpha, IN, GLint, op); + Method1(void, setOperand2_Alpha, IN, GLint, op); + Method0(GLint, getOperand0_RGB); + Method0(GLint, getOperand1_RGB); + Method0(GLint, getOperand2_RGB); + Method0(GLint, getOperand0_Alpha); + Method0(GLint, getOperand1_Alpha); + Method0(GLint, getOperand2_Alpha); + Method1(void, setScale_RGB, IN, float, scale); + Method1(void, setScale_Alpha, IN, float, scale); + Method0(float, getScale_RGB); + Method0(float, getScale_Alpha); + Method1(void, setConstantColor, IN, const osg::Vec4 &, color); + Method0(const osg::Vec4 &, getConstantColor); + Method1(void, setConstantColorAsLightDirection, IN, const osg::Vec3 &, direction); + Method0(osg::Vec3, getConstantColorAsLightDirection); + Method1(void, apply, IN, osg::State &, state); + Property(GLint, Combine_Alpha); + Property(GLint, Combine_RGB); + Property(const osg::Vec4 &, ConstantColor); + ReadOnlyProperty(osg::Vec3, ConstantColorAsLightDirection); + Property(GLint, Operand0_Alpha); + Property(GLint, Operand0_RGB); + Property(GLint, Operand1_Alpha); + Property(GLint, Operand1_RGB); + Property(GLint, Operand2_Alpha); + Property(GLint, Operand2_RGB); + Property(float, Scale_Alpha); + Property(float, Scale_RGB); + Property(GLint, Source0_Alpha); + Property(GLint, Source0_RGB); + Property(GLint, Source1_Alpha); + Property(GLint, Source1_RGB); + Property(GLint, Source2_Alpha); + Property(GLint, Source2_RGB); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/TexEnvFilter.cpp b/src/osgWrappers/osg/TexEnvFilter.cpp new file mode 100644 index 000000000..c3ff8699c --- /dev/null +++ b/src/osgWrappers/osg/TexEnvFilter.cpp @@ -0,0 +1,36 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::TexEnvFilter) + BaseType(osg::StateAttribute); + ConstructorWithDefaults1(IN, float, lodBias, 0.0f); + ConstructorWithDefaults2(IN, const osg::TexEnvFilter &, texenv, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method0(bool, isTextureAttribute); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(void, setLodBias, IN, float, lodBias); + Method0(float, getLodBias); + Method1(void, apply, IN, osg::State &, state); + Property(float, LodBias); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/TexGen.cpp b/src/osgWrappers/osg/TexGen.cpp new file mode 100644 index 000000000..016a6a565 --- /dev/null +++ b/src/osgWrappers/osg/TexGen.cpp @@ -0,0 +1,60 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::TexGen::Mode) + EnumLabel(osg::TexGen::OBJECT_LINEAR); + EnumLabel(osg::TexGen::EYE_LINEAR); + EnumLabel(osg::TexGen::SPHERE_MAP); + EnumLabel(osg::TexGen::NORMAL_MAP); + EnumLabel(osg::TexGen::REFLECTION_MAP); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::TexGen::Coord) + EnumLabel(osg::TexGen::S); + EnumLabel(osg::TexGen::T); + EnumLabel(osg::TexGen::R); + EnumLabel(osg::TexGen::Q); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TexGen) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TexGen &, texgen, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method0(bool, isTextureAttribute); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, apply, IN, osg::State &, state); + Method1(void, setMode, IN, osg::TexGen::Mode, mode); + Method0(osg::TexGen::Mode, getMode); + Method2(void, setPlane, IN, osg::TexGen::Coord, which, IN, const osg::Plane &, plane); + Method1(osg::Plane &, getPlane, IN, osg::TexGen::Coord, which); + Method1(const osg::Plane &, getPlane, IN, osg::TexGen::Coord, which); + Method1(void, setPlanesFromMatrix, IN, const osg::Matrixd &, matrix); + Property(osg::TexGen::Mode, Mode); + IndexedProperty1(const osg::Plane &, Plane, osg::TexGen::Coord, which); + WriteOnlyProperty(const osg::Matrixd &, PlanesFromMatrix); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/TexGenNode.cpp b/src/osgWrappers/osg/TexGenNode.cpp new file mode 100644 index 000000000..52a48d273 --- /dev/null +++ b/src/osgWrappers/osg/TexGenNode.cpp @@ -0,0 +1,37 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::TexGenNode) + BaseType(osg::Group); + Constructor0(); + Constructor1(IN, osg::TexGen *, texgen); + ConstructorWithDefaults2(IN, const osg::TexGenNode &, tgb, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method1(void, setTextureUnit, IN, unsigned int, textureUnit); + Method0(unsigned int, getTextureUnit); + Method1(void, setTexGen, IN, osg::TexGen *, texgen); + Method0(osg::TexGen *, getTexGen); + Method0(const osg::TexGen *, getTexGen); + Property(osg::TexGen *, TexGen); + Property(unsigned int, TextureUnit); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/TexMat.cpp b/src/osgWrappers/osg/TexMat.cpp new file mode 100644 index 000000000..f2faa3582 --- /dev/null +++ b/src/osgWrappers/osg/TexMat.cpp @@ -0,0 +1,38 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::TexMat) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TexMat &, texmat, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method0(bool, isTextureAttribute); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(void, setMatrix, IN, const osg::Matrix &, matrix); + Method0(osg::Matrix &, getMatrix); + Method0(const osg::Matrix &, getMatrix); + Method1(void, apply, IN, osg::State &, state); + Property(const osg::Matrix &, Matrix); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Texture.cpp b/src/osgWrappers/osg/Texture.cpp new file mode 100644 index 000000000..262b9f004 --- /dev/null +++ b/src/osgWrappers/osg/Texture.cpp @@ -0,0 +1,227 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::list< osg::ref_ptr< osg::Texture::TextureObject > >, osg::Texture::TextureObjectList); + +TYPE_NAME_ALIAS(std::map< unsigned int COMMA osg::Texture::TextureObjectList >, osg::Texture::TextureObjectListMap); + +BEGIN_ENUM_REFLECTOR(osg::Texture::WrapParameter) + EnumLabel(osg::Texture::WRAP_S); + EnumLabel(osg::Texture::WRAP_T); + EnumLabel(osg::Texture::WRAP_R); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::Texture::WrapMode) + EnumLabel(osg::Texture::CLAMP); + EnumLabel(osg::Texture::CLAMP_TO_EDGE); + EnumLabel(osg::Texture::CLAMP_TO_BORDER); + EnumLabel(osg::Texture::REPEAT); + EnumLabel(osg::Texture::MIRROR); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::Texture::FilterParameter) + EnumLabel(osg::Texture::MIN_FILTER); + EnumLabel(osg::Texture::MAG_FILTER); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::Texture::FilterMode) + EnumLabel(osg::Texture::LINEAR); + EnumLabel(osg::Texture::LINEAR_MIPMAP_LINEAR); + EnumLabel(osg::Texture::LINEAR_MIPMAP_NEAREST); + EnumLabel(osg::Texture::NEAREST); + EnumLabel(osg::Texture::NEAREST_MIPMAP_LINEAR); + EnumLabel(osg::Texture::NEAREST_MIPMAP_NEAREST); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::Texture::InternalFormatMode) + EnumLabel(osg::Texture::USE_IMAGE_DATA_FORMAT); + EnumLabel(osg::Texture::USE_USER_DEFINED_FORMAT); + EnumLabel(osg::Texture::USE_ARB_COMPRESSION); + EnumLabel(osg::Texture::USE_S3TC_DXT1_COMPRESSION); + EnumLabel(osg::Texture::USE_S3TC_DXT3_COMPRESSION); + EnumLabel(osg::Texture::USE_S3TC_DXT5_COMPRESSION); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::Texture::ShadowCompareFunc) + EnumLabel(osg::Texture::LEQUAL); + EnumLabel(osg::Texture::GEQUAL); +END_REFLECTOR + +BEGIN_ENUM_REFLECTOR(osg::Texture::ShadowTextureMode) + EnumLabel(osg::Texture::LUMINANCE); + EnumLabel(osg::Texture::INTENSITY); + EnumLabel(osg::Texture::ALPHA); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Texture) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Texture &, text, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method0(bool, isTextureAttribute); + Method2(void, setWrap, IN, osg::Texture::WrapParameter, which, IN, osg::Texture::WrapMode, wrap); + Method1(osg::Texture::WrapMode, getWrap, IN, osg::Texture::WrapParameter, which); + Method1(void, setBorderColor, IN, const osg::Vec4 &, color); + Method0(const osg::Vec4 &, getBorderColor); + Method1(void, setBorderWidth, IN, GLint, width); + Method0(GLint, getBorderWidth); + Method2(void, setFilter, IN, osg::Texture::FilterParameter, which, IN, osg::Texture::FilterMode, filter); + Method1(osg::Texture::FilterMode, getFilter, IN, osg::Texture::FilterParameter, which); + Method1(void, setMaxAnisotropy, IN, float, anis); + Method0(float, getMaxAnisotropy); + Method1(void, setUseHardwareMipMapGeneration, IN, bool, useHardwareMipMapGeneration); + Method0(bool, getUseHardwareMipMapGeneration); + Method1(void, setUnRefImageDataAfterApply, IN, bool, flag); + Method0(bool, getUnRefImageDataAfterApply); + Method1(void, setClientStorageHint, IN, bool, flag); + Method0(bool, getClientStorageHint); + Method1(void, setInternalFormatMode, IN, osg::Texture::InternalFormatMode, mode); + Method0(osg::Texture::InternalFormatMode, getInternalFormatMode); + Method1(void, setInternalFormat, IN, GLint, internalFormat); + Method0(GLint, getInternalFormat); + Method0(bool, isCompressedInternalFormat); + Method1(osg::Texture::TextureObject *, getTextureObject, IN, unsigned int, contextID); + Method0(void, dirtyTextureObject); + Method0(bool, areAllTextureObjectsLoaded); + Method1(unsigned int &, getTextureParameterDirty, IN, unsigned int, contextID); + Method0(void, dirtyTextureParameters); + Method1(void, setShadowComparison, IN, bool, flag); + Method1(void, setShadowCompareFunc, IN, osg::Texture::ShadowCompareFunc, func); + Method0(osg::Texture::ShadowCompareFunc, getShadowCompareFunc); + Method1(void, setShadowTextureMode, IN, osg::Texture::ShadowTextureMode, mode); + Method0(osg::Texture::ShadowTextureMode, getShadowTextureMode); + Method1(void, setShadowAmbient, IN, float, shadow_ambient); + Method0(float, getShadowAmbient); + Method2(void, setImage, IN, unsigned int, face, IN, osg::Image *, image); + Method1(osg::Image *, getImage, IN, unsigned int, face); + Method1(const osg::Image *, getImage, IN, unsigned int, face); + Method0(unsigned int, getNumImages); + Method1(void, apply, IN, osg::State &, state); + Method1(void, compileGLObjects, IN, osg::State &, state); + MethodWithDefaults1(void, releaseGLObjects, IN, osg::State *, state, 0); + Method6(void, applyTexImage2D_load, IN, osg::State &, state, IN, GLenum, target, IN, const osg::Image *, image, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, numMipmapLevels); + Method7(void, applyTexImage2D_subload, IN, osg::State &, state, IN, GLenum, target, IN, const osg::Image *, image, IN, GLsizei, width, IN, GLsizei, height, IN, GLint, inInternalFormat, IN, GLsizei, numMipmapLevels); + Method1(void, takeTextureObjects, IN, osg::Texture::TextureObjectListMap &, toblm); + Property(const osg::Vec4 &, BorderColor); + Property(GLint, BorderWidth); + Property(bool, ClientStorageHint); + IndexedProperty1(osg::Texture::FilterMode, Filter, osg::Texture::FilterParameter, which); + ArrayProperty_G(osg::Image *, Image, Images, unsigned int, void); + Property(GLint, InternalFormat); + Property(osg::Texture::InternalFormatMode, InternalFormatMode); + Property(float, MaxAnisotropy); + Property(float, ShadowAmbient); + Property(osg::Texture::ShadowCompareFunc, ShadowCompareFunc); + WriteOnlyProperty(bool, ShadowComparison); + Property(osg::Texture::ShadowTextureMode, ShadowTextureMode); + ReadOnlyProperty(osg::StateAttribute::Type, Type); + Property(bool, UnRefImageDataAfterApply); + Property(bool, UseHardwareMipMapGeneration); + IndexedProperty1(osg::Texture::WrapMode, Wrap, osg::Texture::WrapParameter, which); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Texture::Extensions) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::Texture::Extensions &, rhs); + Method1(void, lowestCommonDenominator, IN, const osg::Texture::Extensions &, rhs); + Method0(void, setupGLExtensions); + Method1(void, setMultiTexturingSupported, IN, bool, flag); + Method0(bool, isMultiTexturingSupported); + Method1(void, setTextureFilterAnisotropicSupported, IN, bool, flag); + Method0(bool, isTextureFilterAnisotropicSupported); + Method1(void, setTextureCompressionARBSupported, IN, bool, flag); + Method0(bool, isTextureCompressionARBSupported); + Method1(void, setTextureCompressionS3TCSupported, IN, bool, flag); + Method0(bool, isTextureCompressionS3TCSupported); + Method1(void, setTextureMirroredRepeatSupported, IN, bool, flag); + Method0(bool, isTextureMirroredRepeatSupported); + Method1(void, setTextureEdgeClampSupported, IN, bool, flag); + Method0(bool, isTextureEdgeClampSupported); + Method1(void, setTextureBorderClampSupported, IN, bool, flag); + Method0(bool, isTextureBorderClampSupported); + Method1(void, setGenerateMipMapSupported, IN, bool, flag); + Method0(bool, isGenerateMipMapSupported); + Method1(void, setShadowSupported, IN, bool, flag); + Method0(bool, isShadowSupported); + Method1(void, setShadowAmbientSupported, IN, bool, flag); + Method0(bool, isShadowAmbientSupported); + Method1(void, setMaxTextureSize, IN, GLint, maxsize); + Method0(GLint, maxTextureSize); + Method1(void, setNumTextureUnits, IN, GLint, nunits); + Method0(GLint, numTextureUnits); + Method0(bool, isCompressedTexImage2DSupported); + Method1(void, setCompressedTexImage2DProc, IN, void *, ptr); + Method8(void, glCompressedTexImage2D, IN, GLenum, target, IN, GLint, level, IN, GLenum, internalformat, IN, GLsizei, width, IN, GLsizei, height, IN, GLint, border, IN, GLsizei, imageSize, IN, const GLvoid *, data); + Method1(void, setCompressedTexSubImage2DProc, IN, void *, ptr); + Method9(void, glCompressedTexSubImage2D, IN, GLenum, target, IN, GLint, level, IN, GLint, xoffset, IN, GLint, yoffset, IN, GLsizei, width, IN, GLsizei, height, IN, GLenum, format, IN, GLsizei, type, IN, const GLvoid *, data); + Method1(void, setGetCompressedTexImageProc, IN, void *, ptr); + Method3(void, glGetCompressedTexImage, IN, GLenum, target, IN, GLint, level, IN, GLvoid *, data); + Method0(bool, isClientStorageSupported); + WriteOnlyProperty(void *, CompressedTexImage2DProc); + WriteOnlyProperty(void *, CompressedTexSubImage2DProc); + WriteOnlyProperty(bool, GenerateMipMapSupported); + WriteOnlyProperty(void *, GetCompressedTexImageProc); + WriteOnlyProperty(GLint, MaxTextureSize); + WriteOnlyProperty(bool, MultiTexturingSupported); + WriteOnlyProperty(GLint, NumTextureUnits); + WriteOnlyProperty(bool, ShadowAmbientSupported); + WriteOnlyProperty(bool, ShadowSupported); + WriteOnlyProperty(bool, TextureBorderClampSupported); + WriteOnlyProperty(bool, TextureCompressionARBSupported); + WriteOnlyProperty(bool, TextureCompressionS3TCSupported); + WriteOnlyProperty(bool, TextureEdgeClampSupported); + WriteOnlyProperty(bool, TextureFilterAnisotropicSupported); + WriteOnlyProperty(bool, TextureMirroredRepeatSupported); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::Texture::TextureObject) + BaseType(osg::Referenced); + Constructor2(IN, GLuint, id, IN, GLenum, target); + Constructor8(IN, GLuint, id, IN, GLenum, target, IN, GLint, numMipmapLevels, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border); + Method7(bool, match, IN, GLenum, target, IN, GLint, numMipmapLevels, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border); + Method0(void, bind); + MethodWithDefaults1(void, setAllocated, IN, bool, allocated, true); + Method6(void, setAllocated, IN, GLint, numMipmapLevels, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border); + Method0(bool, isAllocated); + Method0(bool, isReusable); + WriteOnlyProperty(bool, Allocated); +END_REFLECTOR + +BEGIN_VALUE_REFLECTOR(osg::ref_ptr< osg::Texture::TextureObject >) + Constructor0(); + Constructor1(IN, osg::Texture::TextureObject *, t); + Constructor1(IN, const osg::ref_ptr< osg::Texture::TextureObject > &, rp); + Method0(bool, valid); + Method0(osg::Texture::TextureObject *, get); + Method0(const osg::Texture::TextureObject *, get); + Method0(osg::Texture::TextureObject *, take); + Method0(osg::Texture::TextureObject *, release); + ReadOnlyProperty(osg::Texture::TextureObject *, ); +END_REFLECTOR + +STD_LIST_REFLECTOR(std::list< osg::ref_ptr< osg::Texture::TextureObject > >); + +STD_MAP_REFLECTOR(std::map< unsigned int COMMA osg::Texture::TextureObjectList >); + diff --git a/src/osgWrappers/osg/Texture1D.cpp b/src/osgWrappers/osg/Texture1D.cpp new file mode 100644 index 000000000..d6d47208b --- /dev/null +++ b/src/osgWrappers/osg/Texture1D.cpp @@ -0,0 +1,62 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Texture1D) + BaseType(osg::Texture); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Texture1D &, text, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, rhs); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setImage, IN, osg::Image *, image); + Method0(osg::Image *, getImage); + Method0(const osg::Image *, getImage); + Method1(unsigned int &, getModifiedCount, IN, unsigned int, contextID); + Method2(void, setImage, IN, unsigned, int, IN, osg::Image *, image); + Method1(osg::Image *, getImage, IN, unsigned, int); + Method1(const osg::Image *, getImage, IN, unsigned, int); + Method0(unsigned int, getNumImages); + Method1(void, setTextureSize, IN, int, width); + Method1(void, getTextureSize, IN, int &, width); + Method1(void, setSubloadCallback, IN, osg::Texture1D::SubloadCallback *, cb); + Method0(osg::Texture1D::SubloadCallback *, getSubloadCallback); + Method0(const osg::Texture1D::SubloadCallback *, getSubloadCallback); + Method1(void, setNumMipmapLevels, IN, unsigned int, num); + Method0(unsigned int, getNumMipmapLevels); + Method4(void, copyTexImage1D, IN, osg::State &, state, IN, int, x, IN, int, y, IN, int, width); + Method5(void, copyTexSubImage1D, IN, osg::State &, state, IN, int, xoffset, IN, int, x, IN, int, y, IN, int, width); + Method1(void, apply, IN, osg::State &, state); + Property(osg::Image *, Image); + WriteOnlyProperty(unsigned int, NumMipmapLevels); + Property(osg::Texture1D::SubloadCallback *, SubloadCallback); + WriteOnlyProperty(int, TextureSize); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Texture1D::SubloadCallback) + BaseType(osg::Referenced); + Constructor0(); + Method2(void, load, IN, const osg::Texture1D &, texture, IN, osg::State &, state); + Method2(void, subload, IN, const osg::Texture1D &, texture, IN, osg::State &, state); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Texture2D.cpp b/src/osgWrappers/osg/Texture2D.cpp new file mode 100644 index 000000000..90a42984b --- /dev/null +++ b/src/osgWrappers/osg/Texture2D.cpp @@ -0,0 +1,68 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Texture2D) + BaseType(osg::Texture); + Constructor0(); + Constructor1(IN, osg::Image *, image); + ConstructorWithDefaults2(IN, const osg::Texture2D &, text, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, rhs); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setImage, IN, osg::Image *, image); + Method0(osg::Image *, getImage); + Method0(const osg::Image *, getImage); + Method1(unsigned int &, getModifiedCount, IN, unsigned int, contextID); + Method2(void, setImage, IN, unsigned, int, IN, osg::Image *, image); + Method1(osg::Image *, getImage, IN, unsigned, int); + Method1(const osg::Image *, getImage, IN, unsigned, int); + Method0(unsigned int, getNumImages); + Method2(void, setTextureSize, IN, int, width, IN, int, height); + Method1(void, setTextureWidth, IN, int, width); + Method0(int, getTextureWidth); + Method1(void, setTextureHeight, IN, int, height); + Method0(int, getTextureHeight); + Method2(void, getTextureSize, IN, int &, width, IN, int &, height); + Method1(void, setSubloadCallback, IN, osg::Texture2D::SubloadCallback *, cb); + Method0(osg::Texture2D::SubloadCallback *, getSubloadCallback); + Method0(const osg::Texture2D::SubloadCallback *, getSubloadCallback); + Method1(void, setNumMipmapLevels, IN, unsigned int, num); + Method0(unsigned int, getNumMipmapLevels); + Method5(void, copyTexImage2D, IN, osg::State &, state, IN, int, x, IN, int, y, IN, int, width, IN, int, height); + Method7(void, copyTexSubImage2D, IN, osg::State &, state, IN, int, xoffset, IN, int, yoffset, IN, int, x, IN, int, y, IN, int, width, IN, int, height); + Method1(void, apply, IN, osg::State &, state); + Property(osg::Image *, Image); + WriteOnlyProperty(unsigned int, NumMipmapLevels); + Property(osg::Texture2D::SubloadCallback *, SubloadCallback); + Property(int, TextureHeight); + Property(int, TextureWidth); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Texture2D::SubloadCallback) + BaseType(osg::Referenced); + Constructor0(); + Method2(void, load, IN, const osg::Texture2D &, texture, IN, osg::State &, state); + Method2(void, subload, IN, const osg::Texture2D &, texture, IN, osg::State &, state); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Texture3D.cpp b/src/osgWrappers/osg/Texture3D.cpp new file mode 100644 index 000000000..e5ccd2182 --- /dev/null +++ b/src/osgWrappers/osg/Texture3D.cpp @@ -0,0 +1,97 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Texture3D) + BaseType(osg::Texture); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Texture3D &, text, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, rhs); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setImage, IN, osg::Image *, image); + Method0(osg::Image *, getImage); + Method0(const osg::Image *, getImage); + Method1(unsigned int &, getModifiedCount, IN, unsigned int, contextID); + Method2(void, setImage, IN, unsigned, int, IN, osg::Image *, image); + Method1(osg::Image *, getImage, IN, unsigned, int); + Method1(const osg::Image *, getImage, IN, unsigned, int); + Method0(unsigned int, getNumImages); + Method3(void, setTextureSize, IN, int, width, IN, int, height, IN, int, depth); + Method3(void, getTextureSize, IN, int &, width, IN, int &, height, IN, int &, depth); + Method1(void, setSubloadCallback, IN, osg::Texture3D::SubloadCallback *, cb); + Method0(osg::Texture3D::SubloadCallback *, getSubloadCallback); + Method0(const osg::Texture3D::SubloadCallback *, getSubloadCallback); + Method1(void, setNumMipmapLevels, IN, unsigned int, num); + Method0(unsigned int, getNumMipmapLevels); + Method8(void, copyTexSubImage3D, IN, osg::State &, state, IN, int, xoffset, IN, int, yoffset, IN, int, zoffset, IN, int, x, IN, int, y, IN, int, width, IN, int, height); + Method1(void, apply, IN, osg::State &, state); + Property(osg::Image *, Image); + WriteOnlyProperty(unsigned int, NumMipmapLevels); + Property(osg::Texture3D::SubloadCallback *, SubloadCallback); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Texture3D::Extensions) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::Texture3D::Extensions &, rhs); + Method1(void, lowestCommonDenominator, IN, const osg::Texture3D::Extensions &, rhs); + Method0(void, setupGLExtenions); + Method1(void, setTexture3DSupported, IN, bool, flag); + Method0(bool, isTexture3DSupported); + Method1(void, setTexture3DFast, IN, bool, flag); + Method0(bool, isTexture3DFast); + Method1(void, setMaxTexture3DSize, IN, GLint, maxsize); + Method0(GLint, maxTexture3DSize); + Method1(void, setTexImage3DProc, IN, void *, ptr); + Method10(void, glTexImage3D, IN, GLenum, target, IN, GLint, level, IN, GLenum, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border, IN, GLenum, format, IN, GLenum, type, IN, const GLvoid *, pixels); + Method1(void, setTexSubImage3DProc, IN, void *, ptr); + Method11(void, glTexSubImage3D, IN, GLenum, target, IN, GLint, level, IN, GLint, xoffset, IN, GLint, yoffset, IN, GLint, zoffset, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLenum, format, IN, GLenum, type, IN, const GLvoid *, pixels); + Method1(void, setCopyTexSubImage3DProc, IN, void *, ptr); + Method9(void, glCopyTexSubImage3D, IN, GLenum, target, IN, GLint, level, IN, GLint, xoffset, IN, GLint, yoffset, IN, GLint, zoffset, IN, GLint, x, IN, GLint, y, IN, GLsizei, width, IN, GLsizei, height); + Method0(bool, isCompressedTexImage3DSupported); + Method1(void, setCompressedTexImage3DProc, IN, void *, ptr); + Method9(void, glCompressedTexImage3D, IN, GLenum, target, IN, GLint, level, IN, GLenum, internalformat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLint, border, IN, GLsizei, imageSize, IN, const GLvoid *, data); + Method0(bool, isCompressedTexSubImage3DSupported); + Method1(void, setCompressedTexSubImage3DProc, IN, void *, ptr); + Method11(void, glCompressedTexSubImage3D, IN, GLenum, target, IN, GLint, level, IN, GLint, xoffset, IN, GLint, yoffset, IN, GLint, zoffset, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLenum, format, IN, GLsizei, imageSize, IN, const GLvoid *, data); + Method1(void, setBuild3DMipmapsProc, IN, void *, ptr); + Method8(void, gluBuild3DMipmaps, IN, GLenum, target, IN, GLint, internalFormat, IN, GLsizei, width, IN, GLsizei, height, IN, GLsizei, depth, IN, GLenum, format, IN, GLenum, type, IN, const GLvoid *, data); + WriteOnlyProperty(void *, Build3DMipmapsProc); + WriteOnlyProperty(void *, CompressedTexImage3DProc); + WriteOnlyProperty(void *, CompressedTexSubImage3DProc); + WriteOnlyProperty(void *, CopyTexSubImage3DProc); + WriteOnlyProperty(GLint, MaxTexture3DSize); + WriteOnlyProperty(void *, TexImage3DProc); + WriteOnlyProperty(void *, TexSubImage3DProc); + WriteOnlyProperty(bool, Texture3DFast); + WriteOnlyProperty(bool, Texture3DSupported); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::Texture3D::SubloadCallback) + BaseType(osg::Referenced); + Constructor0(); + Method2(void, load, IN, const osg::Texture3D &, texture, IN, osg::State &, state); + Method2(void, subload, IN, const osg::Texture3D &, texture, IN, osg::State &, state); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/TextureCubeMap.cpp b/src/osgWrappers/osg/TextureCubeMap.cpp new file mode 100644 index 000000000..ff79e65cf --- /dev/null +++ b/src/osgWrappers/osg/TextureCubeMap.cpp @@ -0,0 +1,76 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::TextureCubeMap::Face) + EnumLabel(osg::TextureCubeMap::POSITIVE_X); + EnumLabel(osg::TextureCubeMap::NEGATIVE_X); + EnumLabel(osg::TextureCubeMap::POSITIVE_Y); + EnumLabel(osg::TextureCubeMap::NEGATIVE_Y); + EnumLabel(osg::TextureCubeMap::POSITIVE_Z); + EnumLabel(osg::TextureCubeMap::NEGATIVE_Z); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TextureCubeMap) + BaseType(osg::Texture); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::TextureCubeMap &, cm, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, rhs); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method2(void, setImage, IN, unsigned int, face, IN, osg::Image *, image); + Method1(osg::Image *, getImage, IN, unsigned int, face); + Method1(const osg::Image *, getImage, IN, unsigned int, face); + Method0(unsigned int, getNumImages); + Method2(unsigned int &, getModifiedCount, IN, unsigned int, face, IN, unsigned int, contextID); + Method2(void, setTextureSize, IN, int, width, IN, int, height); + Method2(void, getTextureSize, IN, int &, width, IN, int &, height); + Method1(void, setSubloadCallback, IN, osg::TextureCubeMap::SubloadCallback *, cb); + Method0(osg::TextureCubeMap::SubloadCallback *, getSubloadCallback); + Method0(const osg::TextureCubeMap::SubloadCallback *, getSubloadCallback); + Method1(void, setNumMipmapLevels, IN, unsigned int, num); + Method0(unsigned int, getNumMipmapLevels); + Method1(void, apply, IN, osg::State &, state); + ArrayProperty_G(osg::Image *, Image, Images, unsigned int, void); + WriteOnlyProperty(unsigned int, NumMipmapLevels); + Property(osg::TextureCubeMap::SubloadCallback *, SubloadCallback); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::TextureCubeMap::Extensions) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::TextureCubeMap::Extensions &, rhs); + Method1(void, lowestCommonDenominator, IN, const osg::TextureCubeMap::Extensions &, rhs); + Method0(void, setupGLExtenions); + Method1(void, setCubeMapSupported, IN, bool, flag); + Method0(bool, isCubeMapSupported); + WriteOnlyProperty(bool, CubeMapSupported); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::TextureCubeMap::SubloadCallback) + BaseType(osg::Referenced); + Constructor0(); + Method2(void, load, IN, const osg::TextureCubeMap &, texture, IN, osg::State &, state); + Method2(void, subload, IN, const osg::TextureCubeMap &, texture, IN, osg::State &, state); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/TextureRectangle.cpp b/src/osgWrappers/osg/TextureRectangle.cpp new file mode 100644 index 000000000..ea47464fe --- /dev/null +++ b/src/osgWrappers/osg/TextureRectangle.cpp @@ -0,0 +1,57 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::TextureRectangle) + BaseType(osg::Texture); + Constructor0(); + Constructor1(IN, osg::Image *, image); + ConstructorWithDefaults2(IN, const osg::TextureRectangle &, text, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, rhs); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(void, setImage, IN, osg::Image *, image); + Method0(osg::Image *, getImage); + Method0(const osg::Image *, getImage); + Method1(unsigned int &, getModifiedCount, IN, unsigned int, contextID); + Method2(void, setImage, IN, unsigned, int, IN, osg::Image *, image); + Method1(osg::Image *, getImage, IN, unsigned, int); + Method1(const osg::Image *, getImage, IN, unsigned, int); + Method0(unsigned int, getNumImages); + Method2(void, setTextureSize, IN, int, width, IN, int, height); + Method2(void, getTextureSize, IN, int &, width, IN, int &, height); + Method1(void, setSubloadCallback, IN, osg::TextureRectangle::SubloadCallback *, cb); + Method0(osg::TextureRectangle::SubloadCallback *, getSubloadCallback); + Method0(const osg::TextureRectangle::SubloadCallback *, getSubloadCallback); + Method1(void, apply, IN, osg::State &, state); + Property(osg::Image *, Image); + Property(osg::TextureRectangle::SubloadCallback *, SubloadCallback); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR + +BEGIN_ABSTRACT_OBJECT_REFLECTOR(osg::TextureRectangle::SubloadCallback) + BaseType(osg::Referenced); + Constructor0(); + Method2(void, load, IN, const osg::TextureRectangle &, x, IN, osg::State &, x); + Method2(void, subload, IN, const osg::TextureRectangle &, x, IN, osg::State &, x); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Timer.cpp b/src/osgWrappers/osg/Timer.cpp new file mode 100644 index 000000000..2c2c73d24 --- /dev/null +++ b/src/osgWrappers/osg/Timer.cpp @@ -0,0 +1,26 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include + +BEGIN_VALUE_REFLECTOR(osg::Timer) + Constructor0(); + Method0(osg::Timer_t, tick); + Method2(double, delta_s, IN, osg::Timer_t, t1, IN, osg::Timer_t, t2); + Method2(double, delta_m, IN, osg::Timer_t, t1, IN, osg::Timer_t, t2); + Method2(double, delta_u, IN, osg::Timer_t, t1, IN, osg::Timer_t, t2); + Method2(double, delta_n, IN, osg::Timer_t, t1, IN, osg::Timer_t, t2); + Method0(double, getSecondsPerTick); + ReadOnlyProperty(double, SecondsPerTick); +END_REFLECTOR + +TYPE_NAME_ALIAS(unsigned long long, osg::Timer_t); + diff --git a/src/osgWrappers/osg/Transform.cpp b/src/osgWrappers/osg/Transform.cpp new file mode 100644 index 000000000..6c35edd75 --- /dev/null +++ b/src/osgWrappers/osg/Transform.cpp @@ -0,0 +1,47 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::Transform::ReferenceFrame) + EnumLabel(osg::Transform::RELATIVE_RF); + EnumLabel(osg::Transform::ABSOLUTE_RF); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Transform) + BaseType(osg::Group); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::Transform &, x, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, className); + Method0(const char *, libraryName); + Method1(void, accept, IN, osg::NodeVisitor &, nv); + Method0(osg::Transform *, asTransform); + Method0(const osg::Transform *, asTransform); + Method0(osg::MatrixTransform *, asMatrixTransform); + Method0(const osg::MatrixTransform *, asMatrixTransform); + Method0(osg::PositionAttitudeTransform *, asPositionAttitudeTransform); + Method0(const osg::PositionAttitudeTransform *, asPositionAttitudeTransform); + Method1(void, setReferenceFrame, IN, osg::Transform::ReferenceFrame, rf); + Method0(osg::Transform::ReferenceFrame, getReferenceFrame); + Method2(bool, computeLocalToWorldMatrix, IN, osg::Matrix &, matrix, IN, osg::NodeVisitor *, x); + Method2(bool, computeWorldToLocalMatrix, IN, osg::Matrix &, matrix, IN, osg::NodeVisitor *, x); + Property(osg::Transform::ReferenceFrame, ReferenceFrame); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/UByte4.cpp b/src/osgWrappers/osg/UByte4.cpp new file mode 100644 index 000000000..467658063 --- /dev/null +++ b/src/osgWrappers/osg/UByte4.cpp @@ -0,0 +1,29 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include + +BEGIN_VALUE_REFLECTOR(osg::UByte4) + Constructor0(); + Constructor4(IN, unsigned char, r, IN, unsigned char, g, IN, unsigned char, b, IN, unsigned char, a); + Method0(unsigned char *, ptr); + Method0(const unsigned char *, ptr); + Method4(void, set, IN, unsigned char, r, IN, unsigned char, g, IN, unsigned char, b, IN, unsigned char, a); + Method0(unsigned char &, r); + Method0(unsigned char &, g); + Method0(unsigned char &, b); + Method0(unsigned char &, a); + Method0(unsigned char, r); + Method0(unsigned char, g); + Method0(unsigned char, b); + Method0(unsigned char, a); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Uniform.cpp b/src/osgWrappers/osg/Uniform.cpp new file mode 100644 index 000000000..de7737089 --- /dev/null +++ b/src/osgWrappers/osg/Uniform.cpp @@ -0,0 +1,102 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +BEGIN_ENUM_REFLECTOR(osg::Uniform::Type) + EnumLabel(osg::Uniform::FLOAT); + EnumLabel(osg::Uniform::FLOAT_VEC2); + EnumLabel(osg::Uniform::FLOAT_VEC3); + EnumLabel(osg::Uniform::FLOAT_VEC4); + EnumLabel(osg::Uniform::INT); + EnumLabel(osg::Uniform::INT_VEC2); + EnumLabel(osg::Uniform::INT_VEC3); + EnumLabel(osg::Uniform::INT_VEC4); + EnumLabel(osg::Uniform::BOOL); + EnumLabel(osg::Uniform::BOOL_VEC2); + EnumLabel(osg::Uniform::BOOL_VEC3); + EnumLabel(osg::Uniform::BOOL_VEC4); + EnumLabel(osg::Uniform::FLOAT_MAT2); + EnumLabel(osg::Uniform::FLOAT_MAT3); + EnumLabel(osg::Uniform::FLOAT_MAT4); + EnumLabel(osg::Uniform::SAMPLER_1D); + EnumLabel(osg::Uniform::SAMPLER_2D); + EnumLabel(osg::Uniform::SAMPLER_3D); + EnumLabel(osg::Uniform::SAMPLER_CUBE); + EnumLabel(osg::Uniform::SAMPLER_1D_SHADOW); + EnumLabel(osg::Uniform::SAMPLER_2D_SHADOW); + EnumLabel(osg::Uniform::UNDEFINED); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::Uniform) + BaseType(osg::Object); + Constructor2(IN, const char *, name, IN, osg::Uniform::Type, type); + ConstructorWithDefaults2(IN, const osg::Uniform &, rhs, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(const std::string &, getName); + Method0(const osg::Uniform::Type, getType); + Constructor2(IN, const char *, name, IN, float, f); + Constructor2(IN, const char *, name, IN, int, i); + Constructor2(IN, const char *, name, IN, bool, b); + Constructor2(IN, const char *, name, IN, const osg::Vec2 &, v2); + Constructor2(IN, const char *, name, IN, const osg::Vec3 &, v3); + Constructor2(IN, const char *, name, IN, const osg::Vec4 &, v4); + Constructor2(IN, const char *, name, IN, const osg::Matrix &, m4); + Constructor3(IN, const char *, name, IN, int, i0, IN, int, i1); + Constructor4(IN, const char *, name, IN, int, i0, IN, int, i1, IN, int, i2); + Constructor5(IN, const char *, name, IN, int, i0, IN, int, i1, IN, int, i2, IN, int, i3); + Constructor3(IN, const char *, name, IN, bool, b0, IN, bool, b1); + Constructor4(IN, const char *, name, IN, bool, b0, IN, bool, b1, IN, bool, b2); + Constructor5(IN, const char *, name, IN, bool, b0, IN, bool, b1, IN, bool, b2, IN, bool, b3); + Method1(int, compare, IN, const osg::Uniform &, rhs); + Method1(int, compareData, IN, const osg::Uniform &, rhs); + Method1(void, copyData, IN, const osg::Uniform &, rhs); + Method1(bool, set, IN, float, f); + Method1(bool, set, IN, int, i); + Method1(bool, set, IN, bool, b); + Method1(bool, set, IN, const osg::Vec2 &, v2); + Method1(bool, set, IN, const osg::Vec3 &, v3); + Method1(bool, set, IN, const osg::Vec4 &, v4); + Method1(bool, set, IN, const osg::Matrix &, m4); + Method2(bool, set, IN, int, i0, IN, int, i1); + Method3(bool, set, IN, int, i0, IN, int, i1, IN, int, i2); + Method4(bool, set, IN, int, i0, IN, int, i1, IN, int, i2, IN, int, i3); + Method2(bool, set, IN, bool, b0, IN, bool, b1); + Method3(bool, set, IN, bool, b0, IN, bool, b1, IN, bool, b2); + Method4(bool, set, IN, bool, b0, IN, bool, b1, IN, bool, b2, IN, bool, b3); + Method1(bool, get, IN, float &, f); + Method1(bool, get, IN, int &, i); + Method1(bool, get, IN, bool &, b); + Method1(bool, get, IN, osg::Vec2 &, v2); + Method1(bool, get, IN, osg::Vec3 &, v3); + Method1(bool, get, IN, osg::Vec4 &, v4); + Method1(bool, get, IN, osg::Matrix &, m4); + Method2(bool, get, IN, int &, i0, IN, int &, i1); + Method3(bool, get, IN, int &, i0, IN, int &, i1, IN, int &, i2); + Method4(bool, get, IN, int &, i0, IN, int &, i1, IN, int &, i2, IN, int &, i3); + Method2(bool, get, IN, bool &, b0, IN, bool &, b1); + Method3(bool, get, IN, bool &, b0, IN, bool &, b1, IN, bool &, b2); + Method4(bool, get, IN, bool &, b0, IN, bool &, b1, IN, bool &, b2, IN, bool &, b3); + WriteOnlyPropertyWithReturnType(bool, , bool); + ReadOnlyProperty(const std::string &, Name); + ReadOnlyProperty(const osg::Uniform::Type, Type); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Vec2.cpp b/src/osgWrappers/osg/Vec2.cpp index 1c4daf44b..6471dbc15 100644 --- a/src/osgWrappers/osg/Vec2.cpp +++ b/src/osgWrappers/osg/Vec2.cpp @@ -1,10 +1,15 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include #include -using namespace osgIntrospection; +TYPE_NAME_ALIAS(osg::Vec2f, osg::Vec2); -// simple reflectors for types that are considered 'atomic' -STD_VALUE_REFLECTOR(osg::Vec2) diff --git a/src/osgWrappers/osg/Vec2d.cpp b/src/osgWrappers/osg/Vec2d.cpp new file mode 100644 index 000000000..e4e6055fc --- /dev/null +++ b/src/osgWrappers/osg/Vec2d.cpp @@ -0,0 +1,36 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include + +TYPE_NAME_ALIAS(double, osg::Vec2d::value_type); + +BEGIN_VALUE_REFLECTOR(osg::Vec2d) + ReaderWriter(osgIntrospection::StdReaderWriter); // user-defined + Comparator(osgIntrospection::PartialOrderComparator); // user-defined + Constructor0(); + Constructor2(IN, osg::Vec2d::value_type, x, IN, osg::Vec2d::value_type, y); + Constructor1(IN, const osg::Vec2f &, vec); + Method0(osg::Vec2d::value_type *, ptr); + Method0(const osg::Vec2d::value_type *, ptr); + Method2(void, set, IN, osg::Vec2d::value_type, x, IN, osg::Vec2d::value_type, y); + Method0(osg::Vec2d::value_type &, x); + Method0(osg::Vec2d::value_type &, y); + Method0(osg::Vec2d::value_type, x); + Method0(osg::Vec2d::value_type, y); + Method0(bool, valid); + Method0(bool, isNaN); + Method0(osg::Vec2d::value_type, length); + Method0(osg::Vec2d::value_type, length2); + Method0(osg::Vec2d::value_type, normalize); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Vec2f.cpp b/src/osgWrappers/osg/Vec2f.cpp new file mode 100644 index 000000000..30022991f --- /dev/null +++ b/src/osgWrappers/osg/Vec2f.cpp @@ -0,0 +1,34 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include + +TYPE_NAME_ALIAS(float, osg::Vec2f::value_type); + +BEGIN_VALUE_REFLECTOR(osg::Vec2f) + ReaderWriter(osgIntrospection::StdReaderWriter); // user-defined + Comparator(osgIntrospection::PartialOrderComparator); // user-defined + Constructor0(); + Constructor2(IN, osg::Vec2f::value_type, x, IN, osg::Vec2f::value_type, y); + Method0(osg::Vec2f::value_type *, ptr); + Method0(const osg::Vec2f::value_type *, ptr); + Method2(void, set, IN, osg::Vec2f::value_type, x, IN, osg::Vec2f::value_type, y); + Method0(osg::Vec2f::value_type &, x); + Method0(osg::Vec2f::value_type &, y); + Method0(osg::Vec2f::value_type, x); + Method0(osg::Vec2f::value_type, y); + Method0(bool, valid); + Method0(bool, isNaN); + Method0(osg::Vec2f::value_type, length); + Method0(osg::Vec2f::value_type, length2); + Method0(osg::Vec2f::value_type, normalize); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Vec3.cpp b/src/osgWrappers/osg/Vec3.cpp index 4009e3032..7a2c1cb19 100644 --- a/src/osgWrappers/osg/Vec3.cpp +++ b/src/osgWrappers/osg/Vec3.cpp @@ -1,10 +1,15 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include #include -using namespace osgIntrospection; +TYPE_NAME_ALIAS(osg::Vec3f, osg::Vec3); -// simple reflectors for types that are considered 'atomic' -STD_VALUE_REFLECTOR(osg::Vec3) diff --git a/src/osgWrappers/osg/Vec3d.cpp b/src/osgWrappers/osg/Vec3d.cpp new file mode 100644 index 000000000..b45082997 --- /dev/null +++ b/src/osgWrappers/osg/Vec3d.cpp @@ -0,0 +1,42 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include + +TYPE_NAME_ALIAS(double, osg::Vec3d::value_type); + +BEGIN_VALUE_REFLECTOR(osg::Vec3d) + ReaderWriter(osgIntrospection::StdReaderWriter); // user-defined + Comparator(osgIntrospection::PartialOrderComparator); // user-defined + Constructor0(); + Constructor1(IN, const osg::Vec3f &, vec); + Constructor3(IN, osg::Vec3d::value_type, x, IN, osg::Vec3d::value_type, y, IN, osg::Vec3d::value_type, z); + Constructor2(IN, const osg::Vec2d &, v2, IN, osg::Vec3d::value_type, zz); + Method0(osg::Vec3d::value_type *, ptr); + Method0(const osg::Vec3d::value_type *, ptr); + Method3(void, set, IN, osg::Vec3d::value_type, x, IN, osg::Vec3d::value_type, y, IN, osg::Vec3d::value_type, z); + Method1(void, set, IN, const osg::Vec3d &, rhs); + Method0(osg::Vec3d::value_type &, x); + Method0(osg::Vec3d::value_type &, y); + Method0(osg::Vec3d::value_type &, z); + Method0(osg::Vec3d::value_type, x); + Method0(osg::Vec3d::value_type, y); + Method0(osg::Vec3d::value_type, z); + Method0(bool, valid); + Method0(bool, isNaN); + Method0(osg::Vec3d::value_type, length); + Method0(osg::Vec3d::value_type, length2); + Method0(osg::Vec3d::value_type, normalize); + WriteOnlyProperty(const osg::Vec3d &, ); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Vec3f.cpp b/src/osgWrappers/osg/Vec3f.cpp new file mode 100644 index 000000000..5b6b56d1d --- /dev/null +++ b/src/osgWrappers/osg/Vec3f.cpp @@ -0,0 +1,40 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include + +TYPE_NAME_ALIAS(float, osg::Vec3f::value_type); + +BEGIN_VALUE_REFLECTOR(osg::Vec3f) + ReaderWriter(osgIntrospection::StdReaderWriter); // user-defined + Comparator(osgIntrospection::PartialOrderComparator); // user-defined + Constructor0(); + Constructor3(IN, osg::Vec3f::value_type, x, IN, osg::Vec3f::value_type, y, IN, osg::Vec3f::value_type, z); + Constructor2(IN, const osg::Vec2f &, v2, IN, osg::Vec3f::value_type, zz); + Method0(osg::Vec3f::value_type *, ptr); + Method0(const osg::Vec3f::value_type *, ptr); + Method3(void, set, IN, osg::Vec3f::value_type, x, IN, osg::Vec3f::value_type, y, IN, osg::Vec3f::value_type, z); + Method1(void, set, IN, const osg::Vec3f &, rhs); + Method0(osg::Vec3f::value_type &, x); + Method0(osg::Vec3f::value_type &, y); + Method0(osg::Vec3f::value_type &, z); + Method0(osg::Vec3f::value_type, x); + Method0(osg::Vec3f::value_type, y); + Method0(osg::Vec3f::value_type, z); + Method0(bool, valid); + Method0(bool, isNaN); + Method0(osg::Vec3f::value_type, length); + Method0(osg::Vec3f::value_type, length2); + Method0(osg::Vec3f::value_type, normalize); + WriteOnlyProperty(const osg::Vec3f &, ); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Vec4.cpp b/src/osgWrappers/osg/Vec4.cpp index 73d4ba2b9..a306a0349 100644 --- a/src/osgWrappers/osg/Vec4.cpp +++ b/src/osgWrappers/osg/Vec4.cpp @@ -1,10 +1,15 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + #include #include #include #include -using namespace osgIntrospection; +TYPE_NAME_ALIAS(osg::Vec4f, osg::Vec4); -// simple reflectors for types that are considered 'atomic' -STD_VALUE_REFLECTOR(osg::Vec4) diff --git a/src/osgWrappers/osg/Vec4d.cpp b/src/osgWrappers/osg/Vec4d.cpp new file mode 100644 index 000000000..1e4ad1e97 --- /dev/null +++ b/src/osgWrappers/osg/Vec4d.cpp @@ -0,0 +1,52 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include + +TYPE_NAME_ALIAS(double, osg::Vec4d::value_type); + +BEGIN_VALUE_REFLECTOR(osg::Vec4d) + ReaderWriter(osgIntrospection::StdReaderWriter); // user-defined + Comparator(osgIntrospection::PartialOrderComparator); // user-defined + Constructor0(); + Constructor4(IN, osg::Vec4d::value_type, x, IN, osg::Vec4d::value_type, y, IN, osg::Vec4d::value_type, z, IN, osg::Vec4d::value_type, w); + Constructor2(IN, const osg::Vec3d &, v3, IN, osg::Vec4d::value_type, w); + Constructor1(IN, const osg::Vec4f &, vec); + Method0(osg::Vec4d::value_type *, ptr); + Method0(const osg::Vec4d::value_type *, ptr); + Method4(void, set, IN, osg::Vec4d::value_type, x, IN, osg::Vec4d::value_type, y, IN, osg::Vec4d::value_type, z, IN, osg::Vec4d::value_type, w); + Method0(osg::Vec4d::value_type &, x); + Method0(osg::Vec4d::value_type &, y); + Method0(osg::Vec4d::value_type &, z); + Method0(osg::Vec4d::value_type &, w); + Method0(osg::Vec4d::value_type, x); + Method0(osg::Vec4d::value_type, y); + Method0(osg::Vec4d::value_type, z); + Method0(osg::Vec4d::value_type, w); + Method0(osg::Vec4d::value_type &, red); + Method0(osg::Vec4d::value_type &, green); + Method0(osg::Vec4d::value_type &, blue); + Method0(osg::Vec4d::value_type &, alpha); + Method0(osg::Vec4d::value_type, red); + Method0(osg::Vec4d::value_type, green); + Method0(osg::Vec4d::value_type, blue); + Method0(osg::Vec4d::value_type, alpha); + Method0(unsigned long, asABGR); + Method0(unsigned long, asRGBA); + Method0(bool, valid); + Method0(bool, isNaN); + Method0(osg::Vec4d::value_type, length); + Method0(osg::Vec4d::value_type, length2); + Method0(osg::Vec4d::value_type, normalize); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Vec4f.cpp b/src/osgWrappers/osg/Vec4f.cpp new file mode 100644 index 000000000..f41ed410d --- /dev/null +++ b/src/osgWrappers/osg/Vec4f.cpp @@ -0,0 +1,50 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include + +TYPE_NAME_ALIAS(float, osg::Vec4f::value_type); + +BEGIN_VALUE_REFLECTOR(osg::Vec4f) + ReaderWriter(osgIntrospection::StdReaderWriter); // user-defined + Comparator(osgIntrospection::PartialOrderComparator); // user-defined + Constructor0(); + Constructor4(IN, osg::Vec4f::value_type, x, IN, osg::Vec4f::value_type, y, IN, osg::Vec4f::value_type, z, IN, osg::Vec4f::value_type, w); + Constructor2(IN, const osg::Vec3f &, v3, IN, osg::Vec4f::value_type, w); + Method0(osg::Vec4f::value_type *, ptr); + Method0(const osg::Vec4f::value_type *, ptr); + Method4(void, set, IN, osg::Vec4f::value_type, x, IN, osg::Vec4f::value_type, y, IN, osg::Vec4f::value_type, z, IN, osg::Vec4f::value_type, w); + Method0(osg::Vec4f::value_type &, x); + Method0(osg::Vec4f::value_type &, y); + Method0(osg::Vec4f::value_type &, z); + Method0(osg::Vec4f::value_type &, w); + Method0(osg::Vec4f::value_type, x); + Method0(osg::Vec4f::value_type, y); + Method0(osg::Vec4f::value_type, z); + Method0(osg::Vec4f::value_type, w); + Method0(osg::Vec4f::value_type &, red); + Method0(osg::Vec4f::value_type &, green); + Method0(osg::Vec4f::value_type &, blue); + Method0(osg::Vec4f::value_type &, alpha); + Method0(osg::Vec4f::value_type, red); + Method0(osg::Vec4f::value_type, green); + Method0(osg::Vec4f::value_type, blue); + Method0(osg::Vec4f::value_type, alpha); + Method0(unsigned long, asABGR); + Method0(unsigned long, asRGBA); + Method0(bool, valid); + Method0(bool, isNaN); + Method0(osg::Vec4f::value_type, length); + Method0(osg::Vec4f::value_type, length2); + Method0(osg::Vec4f::value_type, normalize); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/VertexProgram.cpp b/src/osgWrappers/osg/VertexProgram.cpp new file mode 100644 index 000000000..e141a4bd4 --- /dev/null +++ b/src/osgWrappers/osg/VertexProgram.cpp @@ -0,0 +1,73 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +TYPE_NAME_ALIAS(std::map< GLuint COMMA osg::Vec4 >, osg::VertexProgram::LocalParamList); + +TYPE_NAME_ALIAS(std::map< GLenum COMMA osg::Matrix >, osg::VertexProgram::MatrixList); + +BEGIN_OBJECT_REFLECTOR(osg::VertexProgram) + BaseType(osg::StateAttribute); + Constructor0(); + ConstructorWithDefaults2(IN, const osg::VertexProgram &, vp, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method1(bool, getModeUsage, IN, osg::StateAttribute::ModeUsage &, usage); + Method1(GLuint &, getVertexProgramID, IN, unsigned int, contextID); + Method1(void, setVertexProgram, IN, const char *, program); + Method1(void, setVertexProgram, IN, const std::string &, program); + Method0(const std::string &, getVertexProgram); + Method2(void, setProgramLocalParameter, IN, const GLuint, index, IN, const osg::Vec4 &, p); + Method1(void, setLocalParameters, IN, const osg::VertexProgram::LocalParamList &, lpl); + Method0(osg::VertexProgram::LocalParamList &, getLocalParameters); + Method0(const osg::VertexProgram::LocalParamList &, getLocalParameters); + Method2(void, setMatrix, IN, const GLenum, mode, IN, const osg::Matrix &, matrix); + Method1(void, setMatrices, IN, const osg::VertexProgram::MatrixList &, matrices); + Method0(osg::VertexProgram::MatrixList &, getMatrices); + Method0(const osg::VertexProgram::MatrixList &, getMatrices); + Method0(void, dirtyVertexProgramObject); + Method1(void, apply, IN, osg::State &, state); + Method1(void, compileGLObjects, IN, osg::State &, state); + MethodWithDefaults1(void, releaseGLObjects, IN, osg::State *, state, 0); + Property(const osg::VertexProgram::LocalParamList &, LocalParameters); + Property(const osg::VertexProgram::MatrixList &, Matrices); + ReadOnlyProperty(osg::StateAttribute::Type, Type); + Property(const std::string &, VertexProgram); +END_REFLECTOR + +BEGIN_OBJECT_REFLECTOR(osg::VertexProgram::Extensions) + BaseType(osg::Referenced); + Constructor0(); + Constructor1(IN, const osg::VertexProgram::Extensions &, rhs); + Method1(void, lowestCommonDenominator, IN, const osg::VertexProgram::Extensions &, rhs); + Method0(void, setupGLExtenions); + Method1(void, setVertexProgramSupported, IN, bool, flag); + Method0(bool, isVertexProgramSupported); + Method2(void, glBindProgram, IN, GLenum, target, IN, GLuint, id); + Method2(void, glGenPrograms, IN, GLsizei, n, IN, GLuint *, programs); + Method2(void, glDeletePrograms, IN, GLsizei, n, IN, GLuint *, programs); + Method4(void, glProgramString, IN, GLenum, target, IN, GLenum, format, IN, GLsizei, len, IN, const void *, string); + Method3(void, glProgramLocalParameter4fv, IN, GLenum, target, IN, GLuint, index, IN, const GLfloat *, params); + WriteOnlyProperty(bool, VertexProgramSupported); +END_REFLECTOR + diff --git a/src/osgWrappers/osg/Viewport.cpp b/src/osgWrappers/osg/Viewport.cpp new file mode 100644 index 000000000..0a4c22098 --- /dev/null +++ b/src/osgWrappers/osg/Viewport.cpp @@ -0,0 +1,43 @@ +// *************************************************************************** +// +// Generated automatically by genwrapper. +// Please DO NOT EDIT this file! +// +// *************************************************************************** + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +BEGIN_OBJECT_REFLECTOR(osg::Viewport) + BaseType(osg::StateAttribute); + Constructor0(); + Constructor4(IN, int, x, IN, int, y, IN, int, width, IN, int, height); + ConstructorWithDefaults2(IN, const osg::Viewport &, vp, , IN, const osg::CopyOp &, copyop, osg::CopyOp::SHALLOW_COPY); + Method0(osg::Object *, cloneType); + Method1(osg::Object *, clone, IN, const osg::CopyOp &, copyop); + Method1(bool, isSameKindAs, IN, const osg::Object *, obj); + Method0(const char *, libraryName); + Method0(const char *, className); + Method0(osg::StateAttribute::Type, getType); + Method1(int, compare, IN, const osg::StateAttribute &, sa); + Method4(void, setViewport, IN, int, x, IN, int, y, IN, int, width, IN, int, height); + Method4(void, getViewport, IN, int &, x, IN, int &, y, IN, int &, width, IN, int &, height); + Method0(int, x); + Method0(int, y); + Method0(int, width); + Method0(int, height); + Method0(bool, valid); + Method0(float, aspectRatio); + Method0(const osg::Matrix, computeWindowMatrix); + Method1(void, apply, IN, osg::State &, state); + ReadOnlyProperty(osg::StateAttribute::Type, Type); +END_REFLECTOR +