FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

From Marco Jez, improvements to osgIntrospection, and new automatically generated

Browse Source 
osgWrappers/osg set.
This commit is contained in:
Robert Osfield 2005-04-07 20:00:17 +00:00
parent 5b4482c70d
commit 7a27a0bef7
132 changed files with 8608 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
include/osg/Vec2d
View File

@ -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

26
include/osg/Vec2f
View File

@ -15,6 +15,7 @@
#define OSG_VEC2F 1
#include <ostream>
#include <istream>
#include <osg/Math>
@ -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

12
include/osg/Vec3d
View File

@ -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

12
include/osg/Vec3f
View File

@ -15,6 +15,7 @@
#define OSG_VEC3F 1
#include <ostream>
#include <istream>
#include <osg/Vec2f>
#include <osg/Math>
@ -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

28
include/osg/Vec4f
View File

@ -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

70
include/osgIntrospection/Converter Normal file
View File

@ -0,0 +1,70 @@
#ifndef OSGINTROSPECTION_CONVERTER_
#define OSGINTROSPECTION_CONVERTER_
#include <osgIntrospection/Value>
#include <vector>
namespace osgIntrospection
{
struct Converter
{
virtual Value convert(const Value &) const = 0;
virtual ~Converter() {}
};
typedef std::vector<const Converter *> 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<typename S, typename D>
struct StaticConverter: Converter
{
virtual ~StaticConverter() {}
virtual Value convert(const Value &src) const
{
return static_cast<D>(variant_cast<S>(src));
}
};
template<typename S, typename D>
struct DynamicConverter: Converter
{
virtual ~DynamicConverter() {}
virtual Value convert(const Value &src) const
{
return dynamic_cast<D>(variant_cast<S>(src));
}
};
template<typename S, typename D>
struct ReinterpretConverter: Converter
{
virtual ~ReinterpretConverter() {}
virtual Value convert(const Value &src) const
{
return reinterpret_cast<D>(variant_cast<S>(src));
}
};
}
#endif

22
include/osgIntrospection/ConverterProxy Normal file
View File

@ -0,0 +1,22 @@
#ifndef OSGINTROSPECTION_CONVERTERPROXY_
#define OSGINTROSPECTION_CONVERTERPROXY_
#include <osgIntrospection/Reflection>
namespace osgIntrospection
{
struct Converter;
struct ConverterProxy
{
ConverterProxy(const Type &source, const Type &dest, const Converter *cvt)
{
Reflection::registerConverter(source, dest, cvt);
}
};
}
#endif

44
include/osgIntrospection/ReaderWriter
View File

@ -13,50 +13,6 @@
#include <iostream>
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<typename T>
std::ostream &operator << (std::ostream &s, const osg::ref_ptr<T> &r)
{
return s << r.get();
}
template<typename T>
std::istream &operator >> (std::istream &s, osg::ref_ptr<T> &r)
{
void *ptr;
s >> ptr;
r = (T *)ptr;
return s;
}
///
/// END OF TEMPORARY FIX
/// ----------------------------------------------------------------------
}
namespace osgIntrospection
{

16
include/osgIntrospection/Reflection
View File

@ -5,6 +5,7 @@
#include <typeinfo>
#include <map>
#include <vector>
/// 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<const Converter *> 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<typename C> friend class Reflector;
template<typename C> friend struct TypeNameAliasProxy;
friend struct ConverterProxy;
struct StaticData
{
TypeMap typemap;
const Type *type_void;
typedef std::map<const Type *, const Converter *> ConverterMap;
typedef std::map<const Type *, ConverterMap> 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<const Type *> &chain);
static StaticData *staticdata__;
};

49
include/osgIntrospection/ReflectionMacros
View File

@ -1,8 +1,11 @@
#ifndef OSGINTROSPECTION_REFLECTIONMACROS_
#define OSGINTROSPECTION_REFLECTIONMACROS_
#include <osgIntrospection/Type>
#include <osgIntrospection/Reflector>
#include <osgIntrospection/TypeNameAliasProxy>
#include <osgIntrospection/ConverterProxy>
#include <osgIntrospection/Converter>
// --------------------------------------------------------------------------
// "private" macros, not to be used outside this file
@ -20,6 +23,24 @@
#define TYPE_NAME_ALIAS(t, n) \
namespace { osgIntrospection::TypeNameAliasProxy<t > 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<s, d>);
#define DynamicConverter(s, d) \
Converter(s, d, osgIntrospection::DynamicConverter<s, d>);
#define ReinterpretConverter(s, d) \
Converter(s, d, osgIntrospection::ReinterpretConverter<s, d>);
// --------------------------------------------------------------------------
// 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<reflected_type *, x *>); \
osgIntrospection::ConverterProxy cp2(cst, cdt, new osgIntrospection::StaticConverter<const reflected_type *, const x *>); \
osgIntrospection::ConverterProxy cp1c(st, cdt, new osgIntrospection::StaticConverter<reflected_type *, const x *>); \
osgIntrospection::ConverterProxy cp3(dt, st, new osgIntrospection::StaticConverter<x *, reflected_type *>); \
osgIntrospection::ConverterProxy cp4(cdt, cst, new osgIntrospection::StaticConverter<const x *, const reflected_type *>); \
osgIntrospection::ConverterProxy cp3c(dt, cst, new osgIntrospection::StaticConverter<x *, const reflected_type *>); \
}
#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<reflected_type *, x *>); \
osgIntrospection::ConverterProxy cp2(cst, cdt, new osgIntrospection::StaticConverter<const reflected_type *, const x *>); \
osgIntrospection::ConverterProxy cp1c(st, cdt, new osgIntrospection::StaticConverter<reflected_type *, const x *>); \
}
#define EnumLabel(x) addEnumLabel(x, #x, true);

105
src/osgIntrospection/Reflection.cpp
View File

@ -1,6 +1,7 @@
#include <osgIntrospection/Reflection>
#include <osgIntrospection/Exceptions>
#include <osgIntrospection/Type>
#include <osgIntrospection/Converter>
#include <OpenThreads/Mutex>
#include <OpenThreads/ScopedLock>
@ -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; j<i->second->getNumAliases(); ++j)
if (i->second->getAlias(j).compare(qname) == 0)
return *i->second;
}
for (int j=0; j<i->second->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<std::string> 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<std::string> 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<const Type *> 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<const Type *> &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;
}

147
src/osgIntrospection/Value.cpp
View File

@ -3,6 +3,8 @@
#include <osgIntrospection/Exceptions>
#include <osgIntrospection/ReaderWriter>
#include <osgIntrospection/Comparator>
#include <osgIntrospection/Converter>
#include <osgIntrospection/Reflection>
#include <sstream>
#include <memory>
@ -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<CompositeConverter> cvt(new CompositeConverter(conv));
return cvt->convert(*this);
}
std::auto_ptr<ReaderWriter::Options> 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);
}

13
src/osgPlugins/ive/DataInputStream.cpp
View File

@ -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;

8
src/osgPlugins/ive/DataInputStream.h
View File

@ -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<std::string, osg::ref_ptr<osg::Image> > ImageMap;
typedef std::map<int,osg::ref_ptr<osg::StateSet> > StateSetMap;
typedef std::map<int,osg::ref_ptr<osg::StateAttribute> > StateAttributeMap;
@ -104,6 +108,8 @@ private:
DrawableMap _drawableMap;
ShapeMap _shapeMap;
NodeMap _nodeMap;
bool _loadExternalReferenceFiles;
osg::ref_ptr<const osgDB::ReaderWriter::Options> _options;

20
src/osgPlugins/ive/ProxyNode.cpp
View File

@ -166,17 +166,21 @@ void ProxyNode::read(DataInputStream* in)
fpl.pop_front();
}
for(i=0; i<numFileNames; i++)
if( in->getLoadExternalReferenceFiles() )
{
if(i>=numChildren && !getFileName(i).empty())
for(i=0; i<numFileNames; i++)
{
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)
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);
}
}
}
}

52
src/osgWrappers/osg/AlphaFunc.cpp Normal file
View File

@ -0,0 +1,52 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/AlphaFunc>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

120
src/osgWrappers/osg/AnimationPath.cpp Normal file
View File

@ -0,0 +1,120 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/AnimationPath>
#include <osg/CopyOp>
#include <osg/Matrixd>
#include <osg/Matrixf>
#include <osg/Node>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/Quat>
#include <osg/Vec3d>
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 >);

63
src/osgWrappers/osg/ApplicationUsage.cpp Normal file
View File

@ -0,0 +1,63 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ApplicationUsage>
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 >);

86
src/osgWrappers/osg/ArgumentParser.cpp Normal file
View File

@ -0,0 +1,86 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ApplicationUsage>
#include <osg/ArgumentParser>
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 >);

404
src/osgWrappers/osg/Array.cpp Normal file
View File

@ -0,0 +1,404 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/Array>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/UByte4>
#include <osg/Vec2>
#include <osg/Vec3>
#include <osg/Vec4>
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<GLfloat>);
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<osg::UByte4>);
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<osg::Vec2>);
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<osg::Vec3>);
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<osg::Vec4>);
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<GLbyte>);
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<GLint>);
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<GLshort>);
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<GLubyte>);
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<GLuint>);
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<GLushort>);
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<osg::UByte4>);
STD_VECTOR_REFLECTOR(std::vector<osg::Vec2>);
STD_VECTOR_REFLECTOR(std::vector<osg::Vec3>);
STD_VECTOR_REFLECTOR(std::vector<osg::Vec4>);
STD_VECTOR_REFLECTOR(std::vector<GLubyte>);
STD_VECTOR_REFLECTOR(std::vector<GLbyte>);
STD_VECTOR_REFLECTOR(std::vector<GLushort>);
STD_VECTOR_REFLECTOR(std::vector<GLshort>);
STD_VECTOR_REFLECTOR(std::vector<GLuint>);
STD_VECTOR_REFLECTOR(std::vector<GLint>);

63
src/osgWrappers/osg/AutoTransform.cpp Normal file
View File

@ -0,0 +1,63 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/AutoTransform>
#include <osg/CopyOp>
#include <osg/Matrix>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/Quat>
#include <osg/Vec3>
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

61
src/osgWrappers/osg/Billboard.cpp Normal file
View File

@ -0,0 +1,61 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/Billboard>
#include <osg/CopyOp>
#include <osg/Drawable>
#include <osg/Matrix>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/Vec3>
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 >);

51
src/osgWrappers/osg/BlendColor.cpp Normal file
View File

@ -0,0 +1,51 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BlendColor>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
#include <osg/Vec4>
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

62
src/osgWrappers/osg/BlendEquation.cpp Normal file
View File

@ -0,0 +1,62 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BlendEquation>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

40
src/osgWrappers/osg/BlendFunc.cpp
View File

@ -1,10 +1,19 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BlendFunc>
using namespace osgIntrospection;
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

48
src/osgWrappers/osg/BoundingBox.cpp Normal file
View File

@ -0,0 +1,48 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BoundingBox>
#include <osg/BoundingSphere>
#include <osg/Vec3>
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

36
src/osgWrappers/osg/BoundingSphere.cpp Normal file
View File

@ -0,0 +1,36 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BoundingBox>
#include <osg/BoundingSphere>
#include <osg/Vec3>
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

81
src/osgWrappers/osg/BufferObject.cpp Normal file
View File

@ -0,0 +1,81 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BufferObject>
#include <osg/CopyOp>
#include <osg/Image>
#include <osg/Object>
#include <osg/State>
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 * >);

35
src/osgWrappers/osg/ClearNode.cpp Normal file
View File

@ -0,0 +1,35 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ClearNode>
#include <osg/CopyOp>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/Vec4>
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

63
src/osgWrappers/osg/ClipNode.cpp Normal file
View File

@ -0,0 +1,63 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BoundingBox>
#include <osg/ClipNode>
#include <osg/ClipPlane>
#include <osg/CopyOp>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/StateAttribute>
#include <osg/StateSet>
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 > >);

48
src/osgWrappers/osg/ClipPlane.cpp Normal file
View File

@ -0,0 +1,48 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ClipPlane>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/Plane>
#include <osg/State>
#include <osg/StateAttribute>
#include <osg/Vec4d>
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

51
src/osgWrappers/osg/ClusterCullingCallback.cpp Normal file
View File

@ -0,0 +1,51 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ClusterCullingCallback>
#include <osg/CopyOp>
#include <osg/Drawable>
#include <osg/Matrixd>
#include <osg/Node>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/State>
#include <osg/Vec3>
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

55
src/osgWrappers/osg/CollectOccludersVisitor.cpp Normal file
View File

@ -0,0 +1,55 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CollectOccludersVisitor>
#include <osg/LOD>
#include <osg/Node>
#include <osg/OccluderNode>
#include <osg/Projection>
#include <osg/Switch>
#include <osg/Transform>
#include <osg/Vec3>
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 >);

46
src/osgWrappers/osg/ColorMask.cpp Normal file
View File

@ -0,0 +1,46 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ColorMask>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

37
src/osgWrappers/osg/ColorMatrix.cpp Normal file
View File

@ -0,0 +1,37 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ColorMatrix>
#include <osg/CopyOp>
#include <osg/Matrix>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

40
src/osgWrappers/osg/ConvexPlanarOccluder.cpp Normal file
View File

@ -0,0 +1,40 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ConvexPlanarOccluder>
#include <osg/ConvexPlanarPolygon>
#include <osg/CopyOp>
#include <osg/Object>
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 >);

25
src/osgWrappers/osg/ConvexPlanarPolygon.cpp Normal file
View File

@ -0,0 +1,25 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ConvexPlanarPolygon>
#include <osg/Vec3>
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

69
src/osgWrappers/osg/CoordinateSystemNode.cpp Normal file
View File

@ -0,0 +1,69 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CoordinateSystemNode>
#include <osg/CopyOp>
#include <osg/Matrixd>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/Vec3d>
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);

45
src/osgWrappers/osg/CopyOp.cpp Normal file
View File

@ -0,0 +1,45 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/Array>
#include <osg/CopyOp>
#include <osg/Drawable>
#include <osg/Image>
#include <osg/Node>
#include <osg/Object>
#include <osg/PrimitiveSet>
#include <osg/Referenced>
#include <osg/Shape>
#include <osg/StateAttribute>
#include <osg/StateSet>
#include <osg/Texture>
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

42
src/osgWrappers/osg/CullFace.cpp Normal file
View File

@ -0,0 +1,42 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/CullFace>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

119
src/osgWrappers/osg/CullSettings.cpp Normal file
View File

@ -0,0 +1,119 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ArgumentParser>
#include <osg/CullSettings>
#include <osg/Matrixd>
#include <osg/Matrixf>
#include <osg/Node>
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

29
src/osgWrappers/osg/CullStack.cpp Normal file
View File

@ -0,0 +1,29 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BoundingBox>
#include <osg/BoundingSphere>
#include <osg/CullStack>
#include <osg/CullingSet>
#include <osg/Matrix>
#include <osg/Node>
#include <osg/ShadowVolumeOccluder>
#include <osg/Vec3>
#include <osg/Viewport>
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 >);

72
src/osgWrappers/osg/CullingSet.cpp Normal file
View File

@ -0,0 +1,72 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BoundingBox>
#include <osg/BoundingSphere>
#include <osg/CullingSet>
#include <osg/Matrix>
#include <osg/Node>
#include <osg/Polytope>
#include <osg/ShadowVolumeOccluder>
#include <osg/Vec3>
#include <osg/Vec4>
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

57
src/osgWrappers/osg/Depth.cpp Normal file
View File

@ -0,0 +1,57 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Depth>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

111
src/osgWrappers/osg/DisplaySettings.cpp Normal file
View File

@ -0,0 +1,111 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ArgumentParser>
#include <osg/DisplaySettings>
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

43
src/osgWrappers/osg/DrawPixels.cpp Normal file
View File

@ -0,0 +1,43 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/DrawPixels>
#include <osg/Image>
#include <osg/Object>
#include <osg/State>
#include <osg/Vec3>
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

257
src/osgWrappers/osg/Drawable.cpp
View File

@ -1,13 +1,266 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BoundingBox>
#include <osg/CopyOp>
#include <osg/Drawable>
#include <osg/Geometry>
#include <osg/Node>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/PrimitiveSet>
#include <osg/Shape>
#include <osg/State>
#include <osg/StateSet>
#include <osg/UByte4>
#include <osg/Vec2>
#include <osg/Vec3>
#include <osg/Vec4>
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 * >);

63
src/osgWrappers/osg/Fog.cpp Normal file
View File

@ -0,0 +1,63 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Fog>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
#include <osg/Vec4>
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

77
src/osgWrappers/osg/FragmentProgram.cpp Normal file
View File

@ -0,0 +1,77 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/FragmentProgram>
#include <osg/Matrix>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
#include <osg/Vec4>
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 >);

28
src/osgWrappers/osg/FrameStamp.cpp Normal file
View File

@ -0,0 +1,28 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/FrameStamp>
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

40
src/osgWrappers/osg/FrontFace.cpp Normal file
View File

@ -0,0 +1,40 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/FrontFace>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

104
src/osgWrappers/osg/GNUmakefile
View File

@ -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)

53
src/osgWrappers/osg/Geode.cpp
View File

@ -1,12 +1,61 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BoundingBox>
#include <osg/CopyOp>
#include <osg/Drawable>
#include <osg/Geode>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/State>
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 > >);

218
src/osgWrappers/osg/Geometry.cpp
View File

@ -1,16 +1,226 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/Array>
#include <osg/CopyOp>
#include <osg/Drawable>
#include <osg/Geometry>
#include <osg/Object>
#include <osg/PrimitiveSet>
#include <osg/State>
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 > >);

54
src/osgWrappers/osg/Group.cpp
View File

@ -1,12 +1,60 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Group>
using namespace osgIntrospection;
#include <osg/Node>
#include <osg/NodeVisitor>
#include <osg/Object>
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 > >);

98
src/osgWrappers/osg/Image.cpp Normal file
View File

@ -0,0 +1,98 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BufferObject>
#include <osg/CopyOp>
#include <osg/Image>
#include <osg/Object>
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 >);

56
src/osgWrappers/osg/ImageStream.cpp Normal file
View File

@ -0,0 +1,56 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Image>
#include <osg/ImageStream>
#include <osg/Object>
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

55
src/osgWrappers/osg/Impostor.cpp Normal file
View File

@ -0,0 +1,55 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Impostor>
#include <osg/ImpostorSprite>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/Vec3>
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 > >);

80
src/osgWrappers/osg/ImpostorSprite.cpp Normal file
View File

@ -0,0 +1,80 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Drawable>
#include <osg/Impostor>
#include <osg/ImpostorSprite>
#include <osg/Matrix>
#include <osg/Object>
#include <osg/PrimitiveSet>
#include <osg/State>
#include <osg/StateSet>
#include <osg/Texture2D>
#include <osg/Vec2>
#include <osg/Vec3>
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

71
src/osgWrappers/osg/LOD.cpp Normal file
View File

@ -0,0 +1,71 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/LOD>
#include <osg/Node>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/Vec3>
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 >);

71
src/osgWrappers/osg/Light.cpp Normal file
View File

@ -0,0 +1,71 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Light>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
#include <osg/Vec3>
#include <osg/Vec4>
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

50
src/osgWrappers/osg/LightModel.cpp Normal file
View File

@ -0,0 +1,50 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/LightModel>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
#include <osg/Vec4>
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

46
src/osgWrappers/osg/LightSource.cpp Normal file
View File

@ -0,0 +1,46 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Light>
#include <osg/LightSource>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/StateAttribute>
#include <osg/StateSet>
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

37
src/osgWrappers/osg/LineSegment.cpp Normal file
View File

@ -0,0 +1,37 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BoundingBox>
#include <osg/BoundingSphere>
#include <osg/LineSegment>
#include <osg/Matrix>
#include <osg/Vec3>
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

39
src/osgWrappers/osg/LineStipple.cpp Normal file
View File

@ -0,0 +1,39 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/LineStipple>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

35
src/osgWrappers/osg/LineWidth.cpp Normal file
View File

@ -0,0 +1,35 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/LineWidth>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

56
src/osgWrappers/osg/LogicOp.cpp Normal file
View File

@ -0,0 +1,56 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/LogicOp>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

60
src/osgWrappers/osg/Material.cpp
View File

@ -1,10 +1,20 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Material>
using namespace osgIntrospection;
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
#include <osg/Vec4>
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

17
src/osgWrappers/osg/Matrix.cpp Normal file
View File

@ -0,0 +1,17 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/Matrix>
TYPE_NAME_ALIAS(osg::Matrixd, osg::Matrix);
TYPE_NAME_ALIAS(osg::RefMatrixd, osg::RefMatrix);

41
src/osgWrappers/osg/MatrixTransform.cpp Normal file
View File

@ -0,0 +1,41 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Matrix>
#include <osg/MatrixTransform>
#include <osg/NodeVisitor>
#include <osg/Object>
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

108
src/osgWrappers/osg/Matrixd.cpp Normal file
View File

@ -0,0 +1,108 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Matrixd>
#include <osg/Matrixf>
#include <osg/Object>
#include <osg/Quat>
#include <osg/Vec3d>
#include <osg/Vec3f>
#include <osg/Vec4d>
#include <osg/Vec4f>
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

108
src/osgWrappers/osg/Matrixf.cpp Normal file
View File

@ -0,0 +1,108 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Matrixd>
#include <osg/Matrixf>
#include <osg/Object>
#include <osg/Quat>
#include <osg/Vec3d>
#include <osg/Vec3f>
#include <osg/Vec4d>
#include <osg/Vec4f>
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

65
src/osgWrappers/osg/Multisample.cpp Normal file
View File

@ -0,0 +1,65 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Multisample>
#include <osg/Object>
#include <osg/State>
#include <osg/StateAttribute>
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

102
src/osgWrappers/osg/Node.cpp
View File

@ -1,23 +1,103 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/Node>
#include <osg/BoundingSphere>
#include <osg/CopyOp>
#include <osg/Group>
#include <osg/Node>
#include <osg/NodeCallback>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/StateSet>
#include <osg/Transform>
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 >);

35
src/osgWrappers/osg/NodeCallback.cpp Normal file
View File

@ -0,0 +1,35 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Node>
#include <osg/NodeCallback>
#include <osg/NodeVisitor>
#include <osg/Object>
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

123
src/osgWrappers/osg/NodeVisitor.cpp Normal file
View File

@ -0,0 +1,123 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/Billboard>
#include <osg/ClearNode>
#include <osg/ClipNode>
#include <osg/CoordinateSystemNode>
#include <osg/FrameStamp>
#include <osg/Geode>
#include <osg/Group>
#include <osg/Impostor>
#include <osg/LOD>
#include <osg/LightSource>
#include <osg/MatrixTransform>
#include <osg/Node>
#include <osg/NodeVisitor>
#include <osg/OccluderNode>
#include <osg/PagedLOD>
#include <osg/PositionAttitudeTransform>
#include <osg/Projection>
#include <osg/Referenced>
#include <osg/Sequence>
#include <osg/Switch>
#include <osg/TexGenNode>
#include <osg/Transform>
#include <osg/Vec3>
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

33
src/osgWrappers/osg/Object.cpp
View File

@ -1,23 +1,38 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Object>
using namespace osgIntrospection;
// simple reflectors for types that are considered 'atomic'
ABSTRACT_OBJECT_REFLECTOR(osg::Referenced)
#include <osg/Referenced>
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

33
src/osgWrappers/osg/OccluderNode.cpp Normal file
View File

@ -0,0 +1,33 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/ConvexPlanarOccluder>
#include <osg/CopyOp>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/OccluderNode>
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

70
src/osgWrappers/osg/PagedLOD.cpp Normal file
View File

@ -0,0 +1,70 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Group>
#include <osg/Node>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/PagedLOD>
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 >);

50
src/osgWrappers/osg/Plane.cpp Normal file
View File

@ -0,0 +1,50 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BoundingBox>
#include <osg/BoundingSphere>
#include <osg/Matrix>
#include <osg/Plane>
#include <osg/Vec3>
#include <osg/Vec4>
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

49
src/osgWrappers/osg/Point.cpp Normal file
View File

@ -0,0 +1,49 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/Point>
#include <osg/State>
#include <osg/StateAttribute>
#include <osg/Vec3>
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

34
src/osgWrappers/osg/PointSprite.cpp Normal file
View File

@ -0,0 +1,34 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/PointSprite>
#include <osg/State>
#include <osg/StateAttribute>
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

49
src/osgWrappers/osg/PolygonMode.cpp Normal file
View File

@ -0,0 +1,49 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/PolygonMode>
#include <osg/State>
#include <osg/StateAttribute>
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

40
src/osgWrappers/osg/PolygonOffset.cpp Normal file
View File

@ -0,0 +1,40 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/PolygonOffset>
#include <osg/State>
#include <osg/StateAttribute>
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

36
src/osgWrappers/osg/PolygonStipple.cpp Normal file
View File

@ -0,0 +1,36 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/PolygonStipple>
#include <osg/State>
#include <osg/StateAttribute>
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

83
src/osgWrappers/osg/Polytope.cpp Normal file
View File

@ -0,0 +1,83 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BoundingBox>
#include <osg/BoundingSphere>
#include <osg/Matrix>
#include <osg/Plane>
#include <osg/Polytope>
#include <osg/Vec3>
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 >);

47
src/osgWrappers/osg/PositionAttitudeTransform.cpp Normal file
View File

@ -0,0 +1,47 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Matrix>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/PositionAttitudeTransform>
#include <osg/Quat>
#include <osg/Vec3d>
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

241
src/osgWrappers/osg/PrimitiveSet.cpp Normal file
View File

@ -0,0 +1,241 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/PrimitiveSet>
#include <osg/State>
#include <osg/Vec2>
#include <osg/Vec3>
#include <osg/Vec4>
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 >);

174
src/osgWrappers/osg/Program.cpp Normal file
View File

@ -0,0 +1,174 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/Program>
#include <osg/Shader>
#include <osg/State>
#include <osg/StateAttribute>
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 >);

35
src/osgWrappers/osg/Projection.cpp Normal file
View File

@ -0,0 +1,35 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Matrix>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/Projection>
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

57
src/osgWrappers/osg/ProxyNode.cpp Normal file
View File

@ -0,0 +1,57 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Node>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/ProxyNode>
#include <osg/Vec3>
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

67
src/osgWrappers/osg/Quat.cpp Normal file
View File

@ -0,0 +1,67 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/Matrixd>
#include <osg/Matrixf>
#include <osg/Quat>
#include <osg/Vec3d>
#include <osg/Vec3f>
#include <osg/Vec4d>
#include <osg/Vec4f>
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

21
src/osgWrappers/osg/RefNodePath.cpp Normal file
View File

@ -0,0 +1,21 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/Node>
#include <osg/RefNodePath>
BEGIN_VALUE_REFLECTOR(osg::RefNodePath)
Constructor0();
Constructor1(IN, const osg::RefNodePath &, refNodePath);
Constructor1(IN, const osg::NodePath &, nodePath);
Method0(bool, valid);
END_REFLECTOR

32
src/osgWrappers/osg/Referenced.cpp Normal file
View File

@ -0,0 +1,32 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/Referenced>
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

54
src/osgWrappers/osg/Sequence.cpp Normal file
View File

@ -0,0 +1,54 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/NodeVisitor>
#include <osg/Object>
#include <osg/Sequence>
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

40
src/osgWrappers/osg/ShadeModel.cpp Normal file
View File

@ -0,0 +1,40 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/ShadeModel>
#include <osg/State>
#include <osg/StateAttribute>
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

48
src/osgWrappers/osg/Shader.cpp Normal file
View File

@ -0,0 +1,48 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Object>
#include <osg/Shader>
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

53
src/osgWrappers/osg/ShadowVolumeOccluder.cpp Normal file
View File

@ -0,0 +1,53 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/BoundingBox>
#include <osg/BoundingSphere>
#include <osg/ConvexPlanarOccluder>
#include <osg/CullStack>
#include <osg/Matrix>
#include <osg/Node>
#include <osg/Polytope>
#include <osg/ShadowVolumeOccluder>
#include <osg/Vec3>
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 >);

344
src/osgWrappers/osg/Shape.cpp Normal file
View File

@ -0,0 +1,344 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/Array>
#include <osg/CopyOp>
#include <osg/Matrix>
#include <osg/Object>
#include <osg/Quat>
#include <osg/Shape>
#include <osg/Vec3>
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 > >);

91
src/osgWrappers/osg/ShapeDrawable.cpp Normal file
View File

@ -0,0 +1,91 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CopyOp>
#include <osg/Drawable>
#include <osg/Object>
#include <osg/PrimitiveSet>
#include <osg/Shape>
#include <osg/ShapeDrawable>
#include <osg/State>
#include <osg/Vec4>
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

Some files were not shown because too many files have changed in this diff Show More