Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

osg Namespace Reference


Classes

class  osg::AlphaFunc
class  osg::AnimationPath
class  osg::AnimationPath::ControlPoint
class  osg::AnimationPathCallback
class  osg::ApplicationUsage
class  osg::ApplicationUsageProxy
class  osg::ArgumentParser
class  osg::ArgumentParser::Parameter
union  osg::ArgumentParser::Parameter::ValueUnion
class  osg::Array
class  osg::TemplateArray< T, ARRAYTYPE, DataSize, DataType >
class  osg::IndexArray
class  osg::TemplateIndexArray< T, ARRAYTYPE, DataSize, DataType >
class  osg::ArrayVisitor
class  osg::ConstArrayVisitor
class  osg::ValueVisitor
class  osg::ConstValueVisitor
class  osg::AutoTransform
class  osg::Billboard
class  osg::BlendColor
class  osg::BlendColor::Extensions
class  osg::BlendEquation
class  osg::BlendEquation::Extensions
class  osg::BlendFunc
class  osg::BoundingBox
class  osg::BoundingSphere
class  osg::buffered_value< T >
class  osg::buffered_object< T >
class  osg::BufferObject
struct  osg::BufferObject::BufferEntry
class  osg::BufferObject::Extensions
class  osg::PixelBufferObject
class  osg::ClearNode
class  osg::ClipNode
class  osg::ClipPlane
class  osg::ClusterCullingCallback
class  osg::CollectOccludersVisitor
class  osg::ColorMask
class  osg::ColorMatrix
class  osg::ConvexPlanarOccluder
class  osg::ConvexPlanarPolygon
class  osg::EllipsoidModel
class  osg::CoordinateSystemNode
class  osg::CopyOp
class  osg::CullFace
class  osg::CullingSet
class  osg::CullSettings
struct  osg::CullSettings::ClampProjectionMatrixCallback
class  osg::CullStack
class  osg::Depth
class  osg::DisplaySettings
class  osg::Drawable
struct  osg::Drawable::ComputeBoundingBoxCallback
struct  osg::Drawable::UpdateCallback
struct  osg::Drawable::EventCallback
struct  osg::Drawable::CullCallback
struct  osg::Drawable::DrawCallback
class  osg::Drawable::AttributeFunctor
class  osg::Drawable::ConstAttributeFunctor
class  osg::Drawable::Extensions
class  osg::DrawPixels
class  osg::fast_back_stack< T >
class  osg::Fog
class  osg::FragmentProgram
class  osg::FragmentProgram::Extensions
class  osg::FrameStamp
class  osg::FrontFace
class  osg::Geode
class  osg::Geometry
struct  osg::Geometry::ArrayData
struct  osg::Geometry::Vec3ArrayData
class  osg::GL2Extensions
class  osg::Group
class  osg::Image
class  osg::ImageStream
class  osg::Light
class  osg::LightModel
class  osg::LightSource
class  osg::LineSegment
class  osg::LineStipple
class  osg::LineWidth
class  osg::LOD
class  osg::LogicOp
class  osg::Material
class  osg::Matrixd
class  osg::RefMatrixd
class  osg::Matrixf
class  osg::RefMatrixf
class  osg::MatrixTransform
class  osg::Multisample
class  osg::Multisample::Extensions
class  osg::Node
struct  osg::Node::ComputeBoundingSphereCallback
class  osg::NodeCallback
class  osg::NodeVisitor
class  osg::NodeVisitor::DatabaseRequestHandler
struct  osg::NodeAcceptOp
class  osg::Object
class  osg::OccluderNode
class  osg::PagedLOD
struct  osg::PagedLOD::PerRangeData
class  osg::Plane
class  osg::Point
class  osg::Point::Extensions
class  osg::PointSprite
class  osg::PolygonMode
class  osg::PolygonOffset
class  osg::PolygonStipple
class  osg::Polytope
class  osg::PositionAttitudeTransform
class  osg::PrimitiveFunctor
class  osg::PrimitiveIndexFunctor
class  osg::PrimitiveSet
class  osg::DrawArrays
class  osg::DrawArrayLengths
class  osg::DrawElementsUByte
class  osg::DrawElementsUShort
class  osg::DrawElementsUInt
class  osg::Program
class  osg::Program::PerContextProgram
class  osg::Projection
class  osg::ProxyNode
class  osg::Quat
class  osg::ref_ptr< T >
class  osg::Referenced
class  osg::DeleteHandler
class  osg::RefNodePath
class  osg::Sequence
class  osg::ShadeModel
class  osg::Shader
class  osg::Shader::PerContextShader
class  osg::ShadowVolumeOccluder
class  osg::Shape
class  osg::ShapeVisitor
class  osg::ConstShapeVisitor
class  osg::Sphere
class  osg::Box
class  osg::Cone
class  osg::Cylinder
class  osg::Capsule
class  osg::InfinitePlane
class  osg::TriangleMesh
class  osg::ConvexHull
class  osg::HeightField
class  osg::CompositeShape
class  osg::TessellationHints
class  osg::ShapeDrawable
class  osg::State
struct  osg::State::ModeStack
struct  osg::State::AttributeStack
struct  osg::State::UniformStack
struct  osg::State::EnabledArrayPair
class  osg::StateAttribute
struct  osg::StateAttribute::ModeUsage
struct  osg::StateAttribute::Callback
class  osg::StateSet
struct  osg::StateSet::Callback
class  osg::Stencil
class  osg::Switch
class  osg::TexEnv
class  osg::TexEnvCombine
class  osg::TexEnvFilter
class  osg::TexGen
class  osg::TexGenNode
class  osg::TexMat
class  osg::Texture
class  osg::Texture::Extensions
class  osg::Texture::TextureObject
class  osg::Texture1D
class  osg::Texture1D::SubloadCallback
class  osg::Texture2D
class  osg::Texture2D::SubloadCallback
class  osg::Texture3D
class  osg::Texture3D::SubloadCallback
class  osg::Texture3D::Extensions
class  osg::TextureCubeMap
class  osg::TextureCubeMap::SubloadCallback
class  osg::TextureCubeMap::Extensions
class  osg::TextureRectangle
class  osg::TextureRectangle::SubloadCallback
class  osg::Timer
class  osg::Transform
class  osg::TriangleFunctor< T >
class  osg::TriangleIndexFunctor< T >
class  osg::UByte4
class  osg::Uniform
struct  osg::Uniform::Callback
class  osg::Vec2d
class  osg::Vec2f
class  osg::Vec3d
class  osg::Vec3f
class  osg::Vec4d
class  osg::Vec4f
class  osg::VertexProgram
class  osg::VertexProgram::Extensions
class  osg::Viewport

Typedefs

typedef TemplateIndexArray<
GLbyte, Array::ByteArrayType,
1, GL_BYTE > 		ByteArray
typedef TemplateIndexArray<
GLshort, Array::ShortArrayType,
1, GL_SHORT > 		ShortArray
typedef TemplateIndexArray<
GLint, Array::IntArrayType,
1, GL_INT > 		IntArray
typedef TemplateIndexArray<
GLubyte, Array::UByteArrayType,
1, GL_UNSIGNED_BYTE > 		UByteArray
typedef TemplateIndexArray<
GLushort, Array::UShortArrayType,
1, GL_UNSIGNED_SHORT > 		UShortArray
typedef TemplateIndexArray<
GLuint, Array::UIntArrayType,
1, GL_UNSIGNED_INT > 		UIntArray
typedef TemplateArray< GLfloat,
Array::FloatArrayType,
1, GL_FLOAT > 		FloatArray
typedef TemplateArray< UByte4,
Array::UByte4ArrayType,
4, GL_UNSIGNED_BYTE > 		UByte4Array
typedef TemplateArray< Vec2,
Array::Vec2ArrayType,
2, GL_FLOAT > 		Vec2Array
typedef TemplateArray< Vec3,
Array::Vec3ArrayType,
3, GL_FLOAT > 		Vec3Array
typedef TemplateArray< Vec4,
Array::Vec4ArrayType,
4, GL_FLOAT > 		Vec4Array
typedef Matrixd CoordinateFrame
typedef std::vector< ref_ptr<
Node > > 		NodeList
typedef Matrixd Matrix
typedef RefMatrixd RefMatrix
typedef std::vector< Node * > NodePath
typedef std::vector< GLsizei > VectorSizei
typedef std::vector< GLubyte > VectorUByte
typedef std::vector< GLushort > VectorUShort
typedef std::vector< GLuint > VectorUInt
typedef std::vector< ShadowVolumeOccluder > ShadowVolumeOccluderList
typedef HeightField Grid
typedef unsigned long long Timer_t
typedef Vec2f Vec2
typedef Vec3f Vec3
typedef Vec4f Vec4

Enumerations

enum  Endian { BigEndian, LittleEndian }
enum  NotifySeverity {
  ALWAYS = 0, FATAL = 1, WARN = 2, NOTICE = 3,
  INFO = 4, DEBUG_INFO = 5, DEBUG_FP = 6
}

Functions

template<typename T>
void clampGEQUAL (T &value, const T minValue, const char *valueName)
template<typename T>
void clampLEQUAL (T &value, const T maxValue, const char *valueName)
template<typename T>
void clampBetweenRange (T &value, const T minValue, const T maxValue, const char *valueName)
template<typename A, typename T>
void clampArrayElementGEQUAL (A &value, unsigned int i, const T minValue, const char *valueName)
template<typename A, typename T>
void clampArrayElementLEQUAL (A &value, unsigned int i, const T maxValue, const char *valueName)
template<typename A, typename T>
void clampArrayElementBetweenRange (A &value, unsigned int i, const T minValue, const T maxValue, const char *valueName)
template<typename A, typename T>
void clampArrayElementsGEQUAL (A &value, unsigned int first, unsigned int last, const T minValue, const char *valueName)
template<typename A, typename T>
void clampArrayElementsLEQUAL (A &value, unsigned int first, unsigned int last, const T maxValue, const char *valueName)
template<typename A, typename T>
void clampArrayElementsBetweenRange (A &value, unsigned int first, unsigned int last, const T minValue, const T maxValue, const char *valueName)
template<typename A, typename T>
void clampArray3GEQUAL (A &value, const T minValue, const char *valueName)
template<typename A, typename T>
void clampArray3LEQUAL (A &value, const T maxValue, const char *valueName)
template<typename A, typename T>
void clampArray3BetweenRange (A &value, const T minValue, const T maxValue, const char *valueName)
template<typename A, typename T>
void clampArray4GEQUAL (A &value, const T minValue, const char *valueName)
template<typename A, typename T>
void clampArray4LEQUAL (A &value, const T maxValue, const char *valueName)
template<typename A, typename T>
void clampArray4BetweenRange (A &value, const T minValue, const T maxValue, const char *valueName)
Endian getCpuByteOrder ()
void swapBytes (char *in, unsigned int size)
void swapBytes2 (char *in)
void swapBytes4 (char *in)
void swapBytes8 (char *in)
void swapBytes16 (char *in)
OSG_EXPORT Geometry * createTexturedQuadGeometry (const Vec3 &corner, const Vec3 &widthVec, const Vec3 &heightVec, float l, float b, float r, float t)
Geometry * createTexturedQuadGeometry (const Vec3 &corner, const Vec3 &widthVec, const Vec3 &heightVec, float s=1.0f, float t=1.0f)
OSG_EXPORT bool isGLExtensionSupported (unsigned int contextID, const char *extension)
void * getGLExtensionFuncPtr (const char *funcName)
OSG_EXPORT void setGLExtensionDisableString (const std::string &disableString)
OSG_EXPORT std::string & getGLExtensionDisableString ()
void * getGLExtensionFuncPtr (const char *funcName, const char *fallbackFuncName)
OSG_EXPORT bool isGLUExtensionSupported (unsigned int contextID, const char *extension)
OSG_EXPORT Geode * createGeodeForImage (Image *image)
OSG_EXPORT Geode * createGeodeForImage (Image *image, float s, float t)
std::ostream & operator<< (std::ostream &output, const Vec2f &vec)
std::istream & operator>> (std::istream &input, Vec2f &vec)
std::ostream & operator<< (std::ostream &output, const Vec2d &vec)
std::istream & operator>> (std::istream &input, Vec2d &vec)
std::ostream & operator<< (std::ostream &output, const Vec3f &vec)
std::istream & operator>> (std::istream &input, Vec3f &vec)
std::ostream & operator<< (std::ostream &output, const Vec3d &vec)
std::istream & operator>> (std::istream &input, Vec3d &vec)
std::ostream & operator<< (std::ostream &output, const Vec4f &vec)
std::istream & operator>> (std::istream &input, Vec4f &vec)
std::ostream & operator<< (std::ostream &output, const Vec4d &vec)
std::istream & operator>> (std::istream &input, Vec4d &vec)
std::ostream & operator<< (std::ostream &os, const Matrixf &m)
std::ostream & operator<< (std::ostream &os, const Matrixd &m)
std::ostream & operator<< (std::ostream &output, const UByte4 &vec)
std::istream & operator>> (std::istream &input, UByte4 &vec)
std::ostream & operator<< (std::ostream &output, const Quat &vec)
std::istream & operator>> (std::istream &input, Quat &vec)
std::ostream & operator<< (std::ostream &output, const Plane &pl)
std::istream & operator>> (std::istream &input, Plane &vec)
template<typename T>
T absolute (T v)
float equivalent (float lhs, float rhs, float epsilon=1e-6)
double equivalent (double lhs, double rhs, double epsilon=1e-6)
template<typename T>
T minimum (T lhs, T rhs)
template<typename T>
T maximum (T lhs, T rhs)
template<typename T>
T clampTo (T v, T minimum, T maximum)
template<typename T>
T clampAbove (T v, T minimum)
template<typename T>
T clampBelow (T v, T maximum)
template<typename T>
T clampBetween (T v, T minimum, T maximum)
template<typename T>
T sign (T v)
template<typename T>
T square (T v)
template<typename T>
T signedSquare (T v)
float inDegrees (float angle)
double inDegrees (double angle)
template<typename T>
T inRadians (T angle)
float DegreesToRadians (float angle)
double DegreesToRadians (double angle)
float RadiansToDegrees (float angle)
double RadiansToDegrees (double angle)
bool isNaN (float v)
bool isNaN (double v)
template<typename T>
float computeVolume (const T &a, const T &b, const T &c, const T &d)
template<typename T>
float computeVolume (const T &f1, const T &f2, const T &f3, const T &b1, const T &b2, const T &b3)
Vec3f operator * (const Vec3f &v, const Matrixd &m)
Vec3d operator * (const Vec3d &v, const Matrixd &m)
Vec4f operator * (const Vec4f &v, const Matrixd &m)
Vec4d operator * (const Vec4d &v, const Matrixd &m)
Vec3f operator * (const Vec3f &v, const Matrixf &m)
Vec3d operator * (const Vec3d &v, const Matrixf &m)
Vec4f operator * (const Vec4f &v, const Matrixf &m)
Vec4d operator * (const Vec4d &v, const Matrixf &m)
OSG_EXPORT void setNotifyLevel (NotifySeverity severity)
OSG_EXPORT NotifySeverity getNotifyLevel ()
OSG_EXPORT bool initNotifyLevel ()
OSG_EXPORT std::ostream & notify (const NotifySeverity severity)
std::ostream & notify (void)
OSG_EXPORT Matrix computeLocalToWorld (const NodePath &nodePath)
OSG_EXPORT Matrix computeWorldToLocal (const NodePath &nodePath)
OSG_EXPORT Matrix computeLocalToEye (const Matrix &modelview, const NodePath &nodePath)
OSG_EXPORT Matrix computeEyeToLocal (const Matrix &modelview, const NodePath &nodePath)
Vec4d::value_type operator * (const Vec3d &lhs, const Vec4d &rhs)
Vec4d::value_type operator * (const Vec4d &lhs, const Vec3d &rhs)
Vec4f::value_type operator * (const Vec3f &lhs, const Vec4f &rhs)
Vec4f::value_type operator * (const Vec4f &lhs, const Vec3f &rhs)

Variables

const double WGS_84_RADIUS_EQUATOR = 6378137.0
const double WGS_84_RADIUS_POLAR = 6356752.3142
const double PI = 3.14159265358979323846
const double PI_2 = 1.57079632679489661923
const double PI_4 = 0.78539816339744830962
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)

Detailed Description

The core osg library provides the basic scene graph classes such as Nodes, State and Drawables, and maths and general helper classes.

Typedef Documentation

typedef TemplateIndexArray<GLbyte,Array::ByteArrayType,1,GL_BYTE> osg::ByteArray
 

typedef Matrixd osg::CoordinateFrame
 

CoordinateFrame encapsulates the orientation of east, north and up.

typedef TemplateArray<GLfloat,Array::FloatArrayType,1,GL_FLOAT> osg::FloatArray
 

typedef HeightField osg::Grid
 

typedef TemplateIndexArray<GLint,Array::IntArrayType,1,GL_INT> osg::IntArray
 

typedef Matrixd osg::Matrix
 

typedef std::vector< ref_ptr<Node> > osg::NodeList
 

typedef std::vector<Node*> osg::NodePath
 

A vector of Nodes pointers which is used to describe the path from a root node to a descendant.

typedef RefMatrixd osg::RefMatrix
 

typedef std::vector<ShadowVolumeOccluder> osg::ShadowVolumeOccluderList
 

A list of ShadowVolumeOccluder, used by CollectOccluderVisitor and CullVistor's.

typedef TemplateIndexArray<GLshort,Array::ShortArrayType,1,GL_SHORT> osg::ShortArray
 

typedef unsigned long long osg::Timer_t
 

typedef TemplateArray<UByte4,Array::UByte4ArrayType,4,GL_UNSIGNED_BYTE> osg::UByte4Array
 

typedef TemplateIndexArray<GLubyte,Array::UByteArrayType,1,GL_UNSIGNED_BYTE> osg::UByteArray
 

typedef TemplateIndexArray<GLuint,Array::UIntArrayType,1,GL_UNSIGNED_INT> osg::UIntArray
 

typedef TemplateIndexArray<GLushort,Array::UShortArrayType,1,GL_UNSIGNED_SHORT> osg::UShortArray
 

typedef Vec2f osg::Vec2
 

typedef TemplateArray<Vec2,Array::Vec2ArrayType,2,GL_FLOAT> osg::Vec2Array
 

typedef Vec3f osg::Vec3
 

typedef TemplateArray<Vec3,Array::Vec3ArrayType,3,GL_FLOAT> osg::Vec3Array
 

typedef Vec4f osg::Vec4
 

typedef TemplateArray<Vec4,Array::Vec4ArrayType,4,GL_FLOAT> osg::Vec4Array
 

typedef std::vector<GLsizei> osg::VectorSizei
 

typedef std::vector<GLubyte> osg::VectorUByte
 

typedef std::vector<GLuint> osg::VectorUInt
 

typedef std::vector<GLushort> osg::VectorUShort
 

Enumeration Type Documentation

enum Endian
 

Enumeration values:
BigEndian 
LittleEndian 

enum NotifySeverity
 

Range of notify levels from DEBUG_FP through to FATAL, ALWAYS is reserved for forcing the absorption of all messages. The keywords are also used verbatim when specified by the environmental variable OSGNOTIFYLEVEL. See documentation on osg::notify() for further details.

Enumeration values:
ALWAYS 
FATAL 
WARN 
NOTICE 
INFO 
DEBUG_INFO 
DEBUG_FP 

Function Documentation

template<typename T>
T absolute (  T  v  )  [inline]
 

return the minimum of two values, equivalent to std::min. std::min not used because of STL implementation under IRIX not containing std::min.

template<typename T>
T clampAbove (  T  v,
T  minimum
)  [inline]
 

template<typename A, typename T>
void clampArray3BetweenRange (  A &  value,
const T  minValue,
const T  maxValue,
const char *  valueName
)  [inline]
 

For each element of the three-element array value[], if the element is between or equal to minValue and maxValue do nothing - legal value, Otherwise clamp the element to the range and warn that valueName[i] was clamped. Equivalent to calling clampArray3GEQUAL( value, minValue, valueName); clampArray3LEQUAL( value, maxValue, valueName);

template<typename A, typename T>
void clampArray3GEQUAL (  A &  value,
const T  minValue,
const char *  valueName
)  [inline]
 

For each element of the three-element array value[], if the element is greater than or equal to minValue do nothing - legal value, Otherwise clamp the element to minValue, and warn that valueName[i] was clamped.

template<typename A, typename T>
void clampArray3LEQUAL (  A &  value,
const T  maxValue,
const char *  valueName
)  [inline]
 

For each element of the three-element array value[], if the element is less than or equal to maxValue do nothing - legal value, Otherwise clamp the element to maxValue, and warn that valueName[i] was clamped.

template<typename A, typename T>
void clampArray4BetweenRange (  A &  value,
const T  minValue,
const T  maxValue,
const char *  valueName
)  [inline]
 

For each element of the four-element array value[], if the element is between or equal to minValue and maxValue do nothing - legal value, Otherwise clamp the element to the range and warn that valueName[i] was clamped. Equivalent to calling clampArray4GEQUAL( value, minValue, valueName); clampArray4LEQUAL( value, maxValue, valueName);

template<typename A, typename T>
void clampArray4GEQUAL (  A &  value,
const T  minValue,
const char *  valueName
)  [inline]
 

For each element of the four-element array value[], if the element is greater than or equal to minValue do nothing - legal value, Otherwise clamp the element to minValue, and warn that valueName[i] was clamped.

template<typename A, typename T>
void clampArray4LEQUAL (  A &  value,
const T  maxValue,
const char *  valueName
)  [inline]
 

For each element of the four-element array value[], if the element is less than or equal to maxValue do nothing - legal value, Otherwise clamp the element to maxValue, and warn that valueName[i] was clamped.

template<typename A, typename T>
void clampArrayElementBetweenRange (  A &  value,
unsigned int  i,
const T  minValue,
const T  maxValue,
const char *  valueName
)  [inline]
 

If value[i] is between or equal to minValue and maxValue do nothing - legal value, Otherwise clamp value[i] to specified range and warn that valueName[i] was clamped. Equivilant to calling clampArrayElementGEQUAL( value, i, minValue, valueName ); clampArrayElementLEQUAL( value, i, maxValue, valueName );

template<typename A, typename T>
void clampArrayElementGEQUAL (  A &  value,
unsigned int  i,
const T  minValue,
const char *  valueName
)  [inline]
 

If value[i] is greater than or equal to minValue do nothing - legal value, Otherwise set value[i] to minValue, and warn that valueName[i] was clamped. Note this is effectively A[i]=max(A[i],B).

template<typename A, typename T>
void clampArrayElementLEQUAL (  A &  value,
unsigned int  i,
const T  maxValue,
const char *  valueName
)  [inline]
 

If value[i] is less than or equal to maxValue do nothing - legal value, Otherwise set value[i] to maxValue, and warn that valueName[i] was clamped. Note this is effectively A[i]=min(A[i],B).

template<typename A, typename T>
void clampArrayElementsBetweenRange (  A &  value,
unsigned int  first,
unsigned int  last,
const T  minValue,
const T  maxValue,
const char *  valueName
)  [inline]
 

For each element of value[] in the range (first,last), if the element is between or equal to minValue and maxValue do nothing - legal value, Otherwise clamp the element to the range and warn that valueName[i] was clamped. Equivalent to calling clampArrayElementsGEQUAL( value, first, last, minValue, valueName); clampArrayElementsLEQUAL( value, first, last, maxValue, valueName);

template<typename A, typename T>
void clampArrayElementsGEQUAL (  A &  value,
unsigned int  first,
unsigned int  last,
const T  minValue,
const char *  valueName
)  [inline]
 

For each element of value[] in the range (first,last), if the element is greater than or equal to minValue do nothing - legal value, Otherwise clamp the element to minValue, and warn that valueName[i] was clamped.

template<typename A, typename T>
void clampArrayElementsLEQUAL (  A &  value,
unsigned int  first,
unsigned int  last,
const T  maxValue,
const char *  valueName
)  [inline]
 

For each element of value[] in the range (first,last), if the element is less than or equal to maxValue do nothing - legal value, Otherwise clamp the element to maxValue, and warn that valueName[i] was clamped.

template<typename T>
T clampBelow (  T  v,
T  maximum
)  [inline]
 

template<typename T>
T clampBetween (  T  v,
T  minimum,
T  maximum
)  [inline]
 

template<typename T>
void clampBetweenRange (  T &  value,
const T  minValue,
const T  maxValue,
const char *  valueName
)  [inline]
 

If value is between or equal to minValue and maxValue do nothing - legal value, Otherwise clamp value to specified range and warn that valueName was clamped. Equivilant to calling clampGEQUAL( value, minValue, valueName ); clampLEQUAL( value, maxValue, valueName );

template<typename T>
void clampGEQUAL (  T &  value,
const T  minValue,
const char *  valueName
)  [inline]
 

If value is greater than or equal to minValue do nothing - legal value, Otherwise set value to minValue, and warn that valueName was clamped. Note this is effectively A=max(A,B).

template<typename T>
void clampLEQUAL (  T &  value,
const T  maxValue,
const char *  valueName
)  [inline]
 

If value is less than or equal to maxValue do nothing - legal value, Otherwise set value to maxValue, and warn that valueName was clamped. Note this is effectively A=min(A,B).

template<typename T>
T clampTo (  T  v,
T  minimum,
T  maximum
)  [inline]
 

OSG_EXPORT Matrix computeEyeToLocal (  const Matrix &  modelview,
const NodePath &  nodePath
) 
 

Compute the matrix which transforms objects in eye coords to local coords, by accumulating the Transform world to local matrices along the specified node path and multipling by the inverse of the supplied initialial camera modelview.

OSG_EXPORT Matrix computeLocalToEye (  const Matrix &  modelview,
const NodePath &  nodePath
) 
 

Compute the matrix which transforms objects in local coords to eye coords, by accumulating the Transform local to world matrices along the specified node path and multipling by the supplied initial camera modelview.

OSG_EXPORT Matrix computeLocalToWorld (  const NodePath &  nodePath  ) 
 

Compute the matrix which transforms objects in local coords to world coords, by accumulating the Transform local to world matrices along the specified node path.

template<typename T>
float computeVolume (  const T &  f1,
const T &  f2,
const T &  f3,
const T &  b1,
const T &  b2,
const T &  b3
)  [inline]
 

compute the volume of a prism.

template<typename T>
float computeVolume (  const T &  a,
const T &  b,
const T &  c,
const T &  d
)  [inline]
 

compute the volume of a tetrahedron.

OSG_EXPORT Matrix computeWorldToLocal (  const NodePath &  nodePath  ) 
 

Compute the matrix which transforms objects in world coords to local coords, by accumulating the Transform world to local matrices along the specified node path.

OSG_EXPORT Geode* createGeodeForImage (  Image *  image,
float  s,
float  t
) 
 

Convenience function to be used by image loaders to generate a valid geode to return for readNode(). Use the specified s and t values to scale the dimensions of the image.

OSG_EXPORT Geode* createGeodeForImage (  Image *  image  ) 
 

Convenience function to be used by image loaders to generate a valid geode to return for readNode(). Use the image's s and t values to scale the dimensions of the image.

Geometry* createTexturedQuadGeometry (  const Vec3 &  corner,
const Vec3 &  widthVec,
const Vec3 &  heightVec,
float  s = 1.0f,
float  t = 1.0f
)  [inline]
 

Convenience function to be used for creating quad geometry with texture coords. Tex coords go from bottom left (0,0) to top right (s,t).

OSG_EXPORT Geometry* createTexturedQuadGeometry (  const Vec3 &  corner,
const Vec3 &  widthVec,
const Vec3 &  heightVec,
float  l,
float  b,
float  r,
float  t
) 
 

Convenience function to be used for creating quad geometry with texture coords. Tex coords go from left bottom (l,b) to right top (r,t).

double DegreesToRadians (  double  angle  )  [inline]
 

float DegreesToRadians (  float  angle  )  [inline]
 

double equivalent (  double  lhs,
double  rhs,
double  epsilon = 1e-6
)  [inline]
 

return true if double lhs and rhs are equivalent, meaning that the difference between them is less than an epsilon value which defaults to 1e-6.

float equivalent (  float  lhs,
float  rhs,
float  epsilon = 1e-6
)  [inline]
 

return true if float lhs and rhs are equivalent, meaning that the difference between them is less than an epsilon value which defaults to 1e-6.

Endian getCpuByteOrder (   )  [inline]
 

OSG_EXPORT std::string& getGLExtensionDisableString (   ) 
 

Get the list of extensions that are disabled for various OpenGL renderers.

void* getGLExtensionFuncPtr (  const char *  funcName,
const char *  fallbackFuncName
)  [inline]
 

Return the address of the specified OpenGL function. If not found then check a second function name, if this fails then return NULL as function is not supported by OpenGL library. This is used for checking something like glActiveTexture (which is in OGL1.3) or glActiveTextureARB.

void* getGLExtensionFuncPtr (  const char *  funcName  )  [inline]
 

Return the address of the specified OpenGL function. Return NULL if function not supported by OpenGL library. Note, glGLExtensionFuncPtr is declared inline so that the code is compiled locally to the calling code. This should get by Windows' dumb implementation of having different GL function ptr's for each library when linked to it.

OSG_EXPORT NotifySeverity getNotifyLevel (   ) 
 

get the notify level.

double inDegrees (  double  angle  )  [inline]
 

float inDegrees (  float  angle  )  [inline]
 

OSG_EXPORT bool initNotifyLevel (   ) 
 

initialize notify level.

template<typename T>
T inRadians (  T  angle  )  [inline]
 

OSG_EXPORT bool isGLExtensionSupported (  unsigned int  contextID,
const char *  extension
) 
 

Return true if OpenGL "extension" is supported. Note: Must only be called within a valid OpenGL context, undefined behavior may occur otherwise.

OSG_EXPORT bool isGLUExtensionSupported (  unsigned int  contextID,
const char *  extension
) 
 

Return true if OpenGL "extension" is supported. Note: Must only be called within a valid OpenGL context, undefined behavior may occur otherwise.

bool isNaN (  double  v  )  [inline]
 

bool isNaN (  float  v  )  [inline]
 

template<typename T>
T maximum (  T  lhs,
T  rhs
)  [inline]
 

return the maximum of two values, equivilent to std::max. std::max not used because of STL implementation under IRIX not containing std::max.

template<typename T>
T minimum (  T  lhs,
T  rhs
)  [inline]
 

return the minimum of two values, equivilent to std::min. std::min not used because of STL implementation under IRIX not containing std::min.

std::ostream& notify (  void   )  [inline]
 

OSG_EXPORT std::ostream& notify (  const NotifySeverity  severity  ) 
 

notify messaging function for providing fatal through to verbose debugging messages. Level of messages sent to the console can be controlled by setting the NotifyLevel either within your application or via the an environmental variable. For instance setenv OSGNOTIFYLEVEL DEBUG (for tsh), export OSGNOTIFYLEVEL=DEBUG (for bourne shell) or set OSGNOTIFYLEVEL=DEBUG (for Windows) all tell the osg to redirect all debugging and more important messages to the console (useful for debugging :-) setting ALWAYS will force all messages to be absorbed, which might be appropriate for final applications. Default NotifyLevel is NOTICE. Check the enum NotifySeverity for full range of possibilities. To use the notify with your code simply use the notify function as a normal file stream (like cout) i.e osg::notify(osg::DEBUG) << "Hello Bugs!"<<endl;

Vec4f::value_type operator * (  const Vec4f &  lhs,
const Vec3f &  rhs
)  [inline]
 

Compute the dot product of a Vec4f and a (Vec3,1.0).

Vec4f::value_type operator * (  const Vec3f &  lhs,
const Vec4f &  rhs
)  [inline]
 

Compute the dot product of a (Vec3,1.0) and a Vec4f.

Vec4d::value_type operator * (  const Vec4d &  lhs,
const Vec3d &  rhs
)  [inline]
 

Compute the dot product of a Vec4d and a (Vec3,1.0).

Vec4d::value_type operator * (  const Vec3d &  lhs,
const Vec4d &  rhs
)  [inline]
 

Compute the dot product of a (Vec3,1.0) and a Vec4d.

Vec4d operator * (  const Vec4d &  v,
const Matrixf &  m
)  [inline]
 

Vec4f operator * (  const Vec4f &  v,
const Matrixf &  m
)  [inline]
 

Vec3d operator * (  const Vec3d &  v,
const Matrixf &  m
)  [inline]
 

Vec3f operator * (  const Vec3f &  v,
const Matrixf &  m
)  [inline]
 

Vec4d operator * (  const Vec4d &  v,
const Matrixd &  m
)  [inline]
 

Vec4f operator * (  const Vec4f &  v,
const Matrixd &  m
)  [inline]
 

Vec3d operator * (  const Vec3d &  v,
const Matrixd &  m
)  [inline]
 

Vec3f operator * (  const Vec3f &  v,
const Matrixd &  m
)  [inline]
 

std::ostream& operator<< (  std::ostream &  output,
const Plane &  pl
)  [inline]
 

std::ostream& operator<< (  std::ostream &  output,
const Quat &  vec
)  [inline]
 

std::ostream& operator<< (  std::ostream &  output,
const UByte4 &  vec
)  [inline]
 

std::ostream& operator<< (  std::ostream &  os,
const Matrixd &  m
)  [inline]
 

std::ostream& operator<< (  std::ostream &  os,
const Matrixf &  m
)  [inline]
 

std::ostream& operator<< (  std::ostream &  output,
const Vec4d &  vec
)  [inline]
 

std::ostream& operator<< (  std::ostream &  output,
const Vec4f &  vec
)  [inline]
 

std::ostream& operator<< (  std::ostream &  output,
const Vec3d &  vec
)  [inline]
 

std::ostream& operator<< (  std::ostream &  output,
const Vec3f &  vec
)  [inline]
 

std::ostream& operator<< (  std::ostream &  output,
const Vec2d &  vec
)  [inline]
 

std::ostream& operator<< (  std::ostream &  output,
const Vec2f &  vec
)  [inline]
 

std::istream& operator>> (  std::istream &  input,
Plane &  vec
)  [inline]
 

std::istream& operator>> (  std::istream &  input,
Quat &  vec
)  [inline]
 

std::istream& operator>> (  std::istream &  input,
UByte4 &  vec
)  [inline]
 

std::istream& operator>> (  std::istream &  input,
Vec4d &  vec
)  [inline]
 

std::istream& operator>> (  std::istream &  input,
Vec4f &  vec
)  [inline]
 

std::istream& operator>> (  std::istream &  input,
Vec3d &  vec
)  [inline]
 

std::istream& operator>> (  std::istream &  input,
Vec3f &  vec
)  [inline]
 

std::istream& operator>> (  std::istream &  input,
Vec2d &  vec
)  [inline]
 

std::istream& operator>> (  std::istream &  input,
Vec2f &  vec
)  [inline]
 

double RadiansToDegrees (  double  angle  )  [inline]
 

float RadiansToDegrees (  float  angle  )  [inline]
 

OSG_EXPORT void setGLExtensionDisableString (  const std::string &  disableString  ) 
 

Set a list of extensions to disable for different OpenGL renderers. This allows OSG applications to work around OpenGL drivers' bugs which are due to problematic extension support. The format of the string is: "GLRendererString : ExtensionName, ExtensionName; GLRenderString2 : ExtensionName;" An example of is : "SUN_XVR1000:GL_EXT_texture_filter_anisotropic" The default setting of GLExtensionDisableString is obtained from the OSG_GL_EXTENSION_DISABLE environmental variable.

OSG_EXPORT void setNotifyLevel (  NotifySeverity  severity  ) 
 

set the notify level, overriding the default or the value set by the environmental variable OSGNOTIFYLEVEL.

template<typename T>
T sign (  T  v  )  [inline]
 

template<typename T>
T signedSquare (  T  v  )  [inline]
 

template<typename T>
T square (  T  v  )  [inline]
 

void swapBytes (  char *  in,
unsigned int  size
)  [inline]
 

void swapBytes16 (  char *  in  )  [inline]
 

void swapBytes2 (  char *  in  )  [inline]
 

void swapBytes4 (  char *  in  )  [inline]
 

void swapBytes8 (  char *  in  )  [inline]
 

Variable Documentation

const double osg::PI = 3.14159265358979323846
 

const double osg::PI_2 = 1.57079632679489661923
 

const double osg::PI_4 = 0.78539816339744830962
 

const double osg::WGS_84_RADIUS_EQUATOR = 6378137.0
 

const double osg::WGS_84_RADIUS_POLAR = 6356752.3142
 

const Vec3f osg::X_AXIS(1.0, 0.0, 0.0)
 

const Vec3f osg::Y_AXIS(0.0, 1.0, 0.0)
 

const Vec3f osg::Z_AXIS(0.0, 0.0, 1.0)
 

Generated on Fri Dec 9 19:30:57 2005 for OpenSceneGraph by  doxygen 1.3.9.1