osg Namespace Reference


Classes

class  AlphaFunc
class  AnimationPath
class  AnimationPathCallback
class  ApplicationUsage
class  ApplicationUsageProxy
class  ArgumentParser
class  Array
class  TemplateArray
class  IndexArray
class  TemplateIndexArray
class  ArrayVisitor
class  ConstArrayVisitor
class  ValueVisitor
class  ConstValueVisitor
class  AutoTransform
class  Billboard
class  BlendColor
class  BlendEquation
class  BlendFunc
class  BoundingBox
class  BoundingSphere
class  buffered_value
class  buffered_object
class  BufferObject
class  PixelBufferObject
class  CameraNode
class  CameraView
class  ClampColor
class  ClearNode
class  ClipNode
class  ClipPlane
class  ClusterCullingCallback
class  CollectOccludersVisitor
class  ColorMask
class  ColorMatrix
class  ConvexPlanarOccluder
class  ConvexPlanarPolygon
class  EllipsoidModel
class  CoordinateSystemNode
class  CopyOp
class  CullFace
class  CullingSet
class  CullSettings
class  CullStack
class  Depth
class  DisplaySettings
class  Drawable
class  DrawPixels
class  fast_back_stack
class  Fog
class  FragmentProgram
class  FBOExtensions
class  RenderBuffer
class  FrameBufferAttachment
class  FrameBufferObject
class  FrameStamp
class  FrontFace
class  Geode
class  Geometry
class  GL2Extensions
class  GraphicsContext
class  Block
class  GraphicsThread
struct  SwapBuffersOperation
struct  BarrierOperation
struct  ReleaseContext_Block_MakeCurrentOperation
class  Group
class  Image
class  ImageStream
class  Light
class  LightModel
class  LightSource
class  LineSegment
class  LineStipple
class  LineWidth
class  LOD
class  LogicOp
class  Material
class  Matrixd
class  RefMatrixd
class  Matrixf
class  RefMatrixf
class  MatrixTransform
class  Multisample
class  Node
class  NodeCallback
class  NodeTrackerCallback
class  NodeVisitor
struct  NodeAcceptOp
class  Object
class  Observer
class  observer_ptr
class  OccluderNode
class  PagedLOD
class  Plane
class  Point
class  PointSprite
class  PolygonMode
class  PolygonOffset
class  PolygonStipple
class  Polytope
class  PositionAttitudeTransform
class  VectorGLsizei
class  VectorGLubyte
class  VectorGLushort
class  VectorGLuint
class  PrimitiveFunctor
class  PrimitiveIndexFunctor
class  PrimitiveSet
class  DrawArrays
class  DrawArrayLengths
class  DrawElementsUByte
class  DrawElementsUShort
class  DrawElementsUInt
class  Program
class  Projection
class  ProxyNode
class  Quat
class  ref_ptr
class  Referenced
class  DeleteHandler
class  Scissor
class  Sequence
class  ShadeModel
class  Shader
class  ShadowVolumeOccluder
class  Shape
class  ShapeVisitor
class  ConstShapeVisitor
class  Sphere
class  Box
class  Cone
class  Cylinder
class  Capsule
class  InfinitePlane
class  TriangleMesh
class  ConvexHull
class  HeightField
class  CompositeShape
class  TessellationHints
class  ShapeDrawable
class  State
class  StateAttribute
class  StateSet
class  Stencil
class  Switch
class  TexEnv
class  TexEnvCombine
class  TexEnvFilter
class  TexGen
class  TexGenNode
class  TexMat
class  Texture
class  Texture1D
class  Texture2D
class  Texture3D
class  TextureCubeMap
class  TextureRectangle
class  Timer
class  Transform
class  TriangleFunctor
class  TriangleIndexFunctor
class  Matrix2
class  Matrix3
class  Uniform
class  Vec2b
class  Vec2d
class  Vec2f
class  Vec2s
class  Vec3b
class  Vec3d
class  Vec3f
class  Vec3s
class  Vec4b
class  Vec4d
class  Vec4f
class  Vec4s
class  Vec4ub
class  VertexProgram
class  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< 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 TemplateArray< Vec4ub,
Array::Vec4ubArrayType,
4, GL_UNSIGNED_BYTE > 		Vec4ubArray
typedef TemplateArray< Vec2s,
Array::Vec2sArrayType,
2, GL_SHORT > 		Vec2sArray
typedef TemplateArray< Vec3s,
Array::Vec3sArrayType,
3, GL_SHORT > 		Vec3sArray
typedef TemplateArray< Vec4s,
Array::Vec4sArrayType,
4, GL_SHORT > 		Vec4sArray
typedef TemplateArray< Vec2b,
Array::Vec2bArrayType,
2, GL_BYTE > 		Vec2bArray
typedef TemplateArray< Vec3b,
Array::Vec3bArrayType,
3, GL_BYTE > 		Vec3bArray
typedef TemplateArray< Vec4b,
Array::Vec4bArrayType,
4, GL_BYTE > 		Vec4bArray
typedef Matrixd CoordinateFrame
typedef std::vector< ref_ptr<
Node > > 		NodeList
typedef Matrixd Matrix
typedef RefMatrixd RefMatrix
typedef std::vector< Node * > NodePath
typedef std::vector< NodePath > NodePathList
typedef std::vector< Matrix > MatrixList
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 float getGLVersionNumber ()
OSG_EXPORT bool isGLExtensionSupported (unsigned int contextID, const char *extension)
OSG_EXPORT 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 &output, const Vec2b &vec)
std::istream & operator>> (std::istream &input, Vec2b &vec)
std::ostream & operator<< (std::ostream &output, const Vec3b &vec)
std::istream & operator>> (std::istream &input, Vec3b &vec)
std::ostream & operator<< (std::ostream &output, const Vec4b &vec)
std::istream & operator>> (std::istream &input, Vec4b &vec)
std::ostream & operator<< (std::ostream &output, const Vec2s &vec)
std::istream & operator>> (std::istream &input, Vec2s &vec)
std::ostream & operator<< (std::ostream &output, const Vec3s &vec)
std::istream & operator>> (std::istream &input, Vec3s &vec)
std::ostream & operator<< (std::ostream &output, const Vec4s &vec)
std::istream & operator>> (std::istream &input, Vec4s &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 Vec4ub &vec)
std::istream & operator>> (std::istream &input, Vec4ub &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)
float round (float v)
double round (double v)
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 isNotifyEnabled (NotifySeverity severity)
OSG_EXPORT bool initNotifyLevel ()
OSG_EXPORT std::ostream & notify (const NotifySeverity severity)
std::ostream & notify (void)
template<class T>
void swap (ref_ptr< T > &rp1, ref_ptr< T > &rp2)
template<class T>
T * get_pointer (const ref_ptr< T > &rp)
template<class T, class Y>
ref_ptr< T > static_pointer_cast (const ref_ptr< Y > &rp)
template<class T, class Y>
ref_ptr< T > dynamic_pointer_cast (const ref_ptr< Y > &rp)
template<class T, class Y>
ref_ptr< T > const_pointer_cast (const ref_ptr< Y > &rp)
OSG_EXPORT Matrix computeLocalToWorld (const NodePath &nodePath, bool ignoreCameraNodes=true)
OSG_EXPORT Matrix computeWorldToLocal (const NodePath &nodePath, bool ignoreCameraNodes=true)
OSG_EXPORT Matrix computeLocalToEye (const Matrix &modelview, const NodePath &nodePath, bool ignoreCameraNodes=true)
OSG_EXPORT Matrix computeEyeToLocal (const Matrix &modelview, const NodePath &nodePath, bool ignoreCameraNodes=true)
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< Matrix > osg::MatrixList
 

A vector of NodePath, typically used to describe all the paths from a node to the potential root nodes it has.

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 std::vector< NodePath > osg::NodePathList
 

A vector of NodePath, typically used to describe all the paths from a node to the potential root nodes it has.

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 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 TemplateArray<Vec2b,Array::Vec2bArrayType,2,GL_BYTE> osg::Vec2bArray
 

typedef TemplateArray<Vec2s,Array::Vec2sArrayType,2,GL_SHORT> osg::Vec2sArray
 

typedef Vec3f osg::Vec3
 

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

typedef TemplateArray<Vec3b,Array::Vec3bArrayType,3,GL_BYTE> osg::Vec3bArray
 

typedef TemplateArray<Vec3s,Array::Vec3sArrayType,3,GL_SHORT> osg::Vec3sArray
 

typedef Vec4f osg::Vec4
 

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

typedef TemplateArray<Vec4b,Array::Vec4bArrayType,4,GL_BYTE> osg::Vec4bArray
 

typedef TemplateArray<Vec4s,Array::Vec4sArrayType,4,GL_SHORT> osg::Vec4sArray
 

typedef TemplateArray<Vec4ub,Array::Vec4ubArrayType,4,GL_UNSIGNED_BYTE> osg::Vec4ubArray
 

Enumeration Type Documentation

enum osg::Endian
 

Enumerator:
BigEndian 
LittleEndian 

enum osg::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.

Enumerator:
ALWAYS 
FATAL 
WARN 
NOTICE 
INFO 
DEBUG_INFO 
DEBUG_FP 

Function Documentation

template<typename T>
T osg::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 osg::clampAbove (  T  v,
T  minimum
)  [inline]
 

template<typename A, typename T>
void osg::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 osg::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 osg::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 osg::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 osg::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 osg::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 osg::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 osg::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 osg::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 osg::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 osg::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 osg::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 osg::clampBelow (  T  v,
T  maximum
)  [inline]
 

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

template<typename T>
void osg::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 osg::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 osg::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 osg::clampTo (  T  v,
T  minimum,
T  maximum
)  [inline]
 

OSG_EXPORT Matrix osg::computeEyeToLocal (  const Matrix &  modelview,
const NodePath &  nodePath,
bool  ignoreCameraNodes = true
) 
 

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 osg::computeLocalToEye (  const Matrix &  modelview,
const NodePath &  nodePath,
bool  ignoreCameraNodes = true
) 
 

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 osg::computeLocalToWorld (  const NodePath &  nodePath,
bool  ignoreCameraNodes = true
) 
 

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 osg::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 osg::computeVolume (  const T &  a,
const T &  b,
const T &  c,
const T &  d
)  [inline]
 

compute the volume of a tetrahedron.

OSG_EXPORT Matrix osg::computeWorldToLocal (  const NodePath &  nodePath,
bool  ignoreCameraNodes = true
) 
 

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.

template<class T, class Y>
ref_ptr<T> osg::const_pointer_cast (  const ref_ptr< Y > &  rp  )  [inline]
 

OSG_EXPORT Geode* osg::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* osg::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* osg::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* osg::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 osg::DegreesToRadians (  double  angle  )  [inline]
 

float osg::DegreesToRadians (  float  angle  )  [inline]
 

template<class T, class Y>
ref_ptr<T> osg::dynamic_pointer_cast (  const ref_ptr< Y > &  rp  )  [inline]
 

double osg::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 osg::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.

template<class T>
T* osg::get_pointer (  const ref_ptr< T > &  rp  )  [inline]
 

Endian osg::getCpuByteOrder (   )  [inline]
 

OSG_EXPORT std::string& osg::getGLExtensionDisableString (   ) 
 

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

void* osg::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.

OSG_EXPORT void* osg::getGLExtensionFuncPtr (  const char *  funcName  ) 
 

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 float osg::getGLVersionNumber (   ) 
 

Return floating-point OpenGL version number. Note: Must only be called within a valid OpenGL context, undefined behavior may occur otherwise.

OSG_EXPORT NotifySeverity osg::getNotifyLevel (   ) 
 

get the notify level.

double osg::inDegrees (  double  angle  )  [inline]
 

float osg::inDegrees (  float  angle  )  [inline]
 

OSG_EXPORT bool osg::initNotifyLevel (   ) 
 

initialize notify level.

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

OSG_EXPORT bool osg::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 osg::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 osg::isNaN (  double  v  )  [inline]
 

bool osg::isNaN (  float  v  )  [inline]
 

OSG_EXPORT bool osg::isNotifyEnabled (  NotifySeverity  severity  ) 
 

is notification enabled, given the current setNotifyLevel() setting?

template<typename T>
T osg::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 osg::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& osg::notify (  void   )  [inline]
 

OSG_EXPORT std::ostream& osg::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 osg::operator * (  const Vec4f &  lhs,
const Vec3f &  rhs
)  [inline]
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double osg::RadiansToDegrees (  double  angle  )  [inline]
 

float osg::RadiansToDegrees (  float  angle  )  [inline]
 

double osg::round (  double  v  )  [inline]
 

float osg::round (  float  v  )  [inline]
 

OSG_EXPORT void osg::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 osg::setNotifyLevel (  NotifySeverity  severity  ) 
 

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

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

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

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

template<class T, class Y>
ref_ptr<T> osg::static_pointer_cast (  const ref_ptr< Y > &  rp  )  [inline]
 

template<class T>
void osg::swap (  ref_ptr< T > &  rp1,
ref_ptr< T > &  rp2
)  [inline]
 

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

void osg::swapBytes16 (  char *  in  )  [inline]
 

void osg::swapBytes2 (  char *  in  )  [inline]
 

void osg::swapBytes4 (  char *  in  )  [inline]
 

void osg::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 Wed Nov 29 06:19:15 2006 for OpenSceneGraph by  doxygen 1.4.6