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
struct  AttributeDispatch
class  ArrayDispatchers
class  AudioSink
class  AudioStream
class  AutoTransform
class  Billboard
class  BlendColor
class  BlendEquation
class  BlendFunc
class  BoundingBoxImpl
class  BoundingSphereImpl
class  buffered_value
class  buffered_object
class  BufferObjectProfile
class  GLBufferObject
class  GLBufferObjectSet
class  GLBufferObjectManager
class  BufferObject
class  BufferData
class  VertexBufferObject
class  ElementBufferObject
class  PixelBufferObject
class  PixelDataBufferObject
class  Camera
class  CameraView
class  ClampColor
class  ClearNode
class  ClipNode
class  ClipPlane
class  ClusterCullingCallback
class  CollectOccludersVisitor
class  ColorMask
class  ColorMatrix
class  ComputeBoundsVisitor
class  ConvexPlanarOccluder
class  ConvexPlanarPolygon
class  EllipsoidModel
class  CoordinateSystemNode
class  CopyOp
class  CullFace
class  CullingSet
class  CullSettings
class  CullStack
class  DeleteHandler
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  GLBeginEndAdapter
class  GraphicsContext
class  GraphicsThread
struct  GraphicsOperation
struct  SwapBuffersOperation
struct  BarrierOperation
struct  ReleaseContext_Block_MakeCurrentOperation
struct  BlockAndFlushOperation
struct  FlushDeletedGLObjectsOperation
class  RunOperations
class  EndOfDynamicDrawBlock
class  Group
class  Hint
class  Image
class  ImageSequence
class  ImageStream
class  KdTree
class  KdTreeBuilder
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  MixinVector
class  Multisample
class  Node
class  NodeCallback
class  NodeTrackerCallback
class  NodeVisitor
class  NodeAcceptOp
class  NotifyHandler
class  StandardNotifyHandler
class  Object
class  Observer
class  ObserverSet
class  observer_ptr
class  ObserverNodePath
class  OccluderNode
class  OcclusionQueryNode
class  RefBlock
class  RefBlockCount
class  Operation
class  OperationQueue
class  OperationThread
class  PagedLOD
class  Plane
class  Point
class  PointSprite
class  PolygonMode
class  PolygonOffset
class  PolygonStipple
class  Polytope
class  PositionAttitudeTransform
class  PrimitiveFunctor
class  PrimitiveIndexFunctor
class  PrimitiveSet
class  DrawArrays
class  DrawArrayLengths
class  DrawElements
class  DrawElementsUByte
class  DrawElementsUShort
class  DrawElementsUInt
class  Program
class  Projection
class  ProxyNode
class  Quat
class  ref_ptr
struct  depends_on
class  Referenced
class  RenderInfo
class  Scissor
class  Sequence
class  ShadeModel
class  ShaderBinary
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  VertexAttribAlias
class  State
class  StateAttribute
class  StateAttributeCallback
class  StateSet
class  Stats
class  Stencil
class  StencilTwoSided
class  Switch
class  TemplatePrimitiveFunctor
class  TexEnv
class  TexEnvCombine
class  TexEnvFilter
class  TexGen
class  TexGenNode
class  TexMat
class  Texture
class  Texture1D
class  Texture2D
class  Texture2DArray
class  Texture3D
class  TextureCubeMap
class  TextureRectangle
class  Timer
class  ElapsedTime
class  TransferFunction
class  TransferFunction1D
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  View
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 TemplateArray
< GLdouble,
Array::DoubleArrayType,
1, GL_DOUBLE > 
DoubleArray
typedef TemplateArray< Vec2d,
Array::Vec2dArrayType,
2, GL_DOUBLE > 
Vec2dArray
typedef TemplateArray< Vec3d,
Array::Vec3dArrayType,
3, GL_DOUBLE > 
Vec3dArray
typedef TemplateArray< Vec4d,
Array::Vec4dArrayType,
4, GL_DOUBLE > 
Vec4dArray
typedef BoundingBoxImpl< Vec3fBoundingBoxf
typedef BoundingBoxImpl< Vec3dBoundingBoxd
typedef BoundingBoxd BoundingBox
typedef BoundingSphereImpl< Vec3fBoundingSpheref
typedef BoundingSphereImpl< Vec3dBoundingSphered
typedef BoundingSphered BoundingSphere
typedef std::list< ref_ptr
< GLBufferObject > > 
GLBufferObjectList
typedef Matrixd CoordinateFrame
typedef std::vector< ref_ptr
< Node > > 
NodeList
typedef Matrixd Matrix
typedef RefMatrixd RefMatrix
typedef std::vector< Node * > NodePath
typedef std::vector< NodePathNodePathList
typedef std::vector< MatrixMatrixList
typedef std::list
< osg::ref_ptr< osg::Node > > 
RefNodePath
typedef OperationThread OperationsThread
typedef MixinVector< GLsizei > VectorGLsizei
typedef MixinVector< GLubyte > VectorGLubyte
typedef MixinVector< GLushort > VectorGLushort
typedef MixinVector< GLuint > VectorGLuint
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 GeometrycreateTexturedQuadGeometry (const Vec3 &corner, const Vec3 &widthVec, const Vec3 &heightVec, float l, float b, float r, float t)
GeometrycreateTexturedQuadGeometry (const Vec3 &corner, const Vec3 &widthVec, const Vec3 &heightVec, float s=1.0f, float t=1.0f)
OSG_EXPORT float getGLVersionNumber ()
OSG_EXPORT bool isExtensionInExtensionString (const char *extension, const char *extensionString)
OSG_EXPORT bool isGLExtensionSupported (unsigned int contextID, const char *extension)
OSG_EXPORT bool isGLExtensionOrVersionSupported (unsigned int contextID, const char *extension, float requiredGlVersion)
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)
void * getGLExtensionFuncPtr (const char *funcName1, const char *funcName2, const char *funcName3)
template<typename T, typename R>
convertPointerType (R src)
template<typename T>
bool setGLExtensionFuncPtr (T &t, const char *str1)
template<typename T>
bool setGLExtensionFuncPtr (T &t, const char *str1, const char *str2)
template<typename T>
bool setGLExtensionFuncPtr (T &t, const char *str1, const char *str2, const char *str3)
OSG_EXPORT bool isGLUExtensionSupported (unsigned int contextID, const char *extension)
OSG_EXPORT void flushDeletedGLObjects (unsigned int contextID, double currentTime, double &availableTime)
OSG_EXPORT void flushAllDeletedGLObjects (unsigned int contextID)
OSG_EXPORT void deleteAllGLObjects (unsigned int contextID)
OSG_EXPORT void discardAllDeletedGLObjects (unsigned int contextID)
OSG_EXPORT void discardAllGLObjects (unsigned int contextID)
OSG_EXPORT GeodecreateGeodeForImage (Image *image)
OSG_EXPORT GeodecreateGeodeForImage (Image *image, float s, float t)
template<typename T, class O>
void _readRow (unsigned int num, GLenum pixelFormat, const T *data, float scale, O &operation)
template<class O>
void readRow (unsigned int num, GLenum pixelFormat, GLenum dataType, const unsigned char *data, O &operation)
template<class O>
void readImage (const osg::Image *image, O &operation)
template<typename T, class M>
void _modifyRow (unsigned int num, GLenum pixelFormat, T *data, float scale, const M &operation)
template<class M>
void modifyRow (unsigned int num, GLenum pixelFormat, GLenum dataType, unsigned char *data, const M &operation)
template<class M>
void modifyImage (osg::Image *image, const M &operation)
OSG_EXPORT bool computeMinMax (const osg::Image *image, osg::Vec4 &min, osg::Vec4 &max)
OSG_EXPORT bool offsetAndScaleImage (osg::Image *image, const osg::Vec4 &offset, const osg::Vec4 &scale)
OSG_EXPORT bool copyImage (const osg::Image *srcImage, int src_s, int src_t, int src_r, int width, int height, int depth, osg::Image *destImage, int dest_s, int dest_t, int dest_r, bool doRescale=false)
OSG_EXPORT bool clearImageToColor (osg::Image *image, const osg::Vec4 &colour)
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>
absolute (T v)
bool equivalent (float lhs, float rhs, float epsilon=1e-6)
bool equivalent (double lhs, double rhs, double epsilon=1e-6)
template<typename T>
minimum (T lhs, T rhs)
template<typename T>
maximum (T lhs, T rhs)
template<typename T>
clampTo (T v, T minimum, T maximum)
template<typename T>
clampAbove (T v, T minimum)
template<typename T>
clampBelow (T v, T maximum)
template<typename T>
clampBetween (T v, T minimum, T maximum)
template<typename T>
sign (T v)
template<typename T>
signOrZero (T v)
template<typename T>
square (T v)
template<typename T>
signedSquare (T v)
float inDegrees (float angle)
double inDegrees (double angle)
template<typename 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)
OSG_EXPORT double asciiToDouble (const char *str)
float asciiToFloat (const char *str)
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)
template<class ValueT>
void swap (MixinVector< ValueT > &left, MixinVector< ValueT > &right)
template<class ValueT>
void swap (MixinVector< ValueT > &left, std::vector< ValueT > &right)
template<class ValueT>
void swap (std::vector< ValueT > &left, MixinVector< ValueT > &right)
OSG_EXPORT void setNotifyLevel (NotifySeverity severity)
OSG_EXPORT NotifySeverity getNotifyLevel ()
OSG_EXPORT bool initNotifyLevel ()
OSG_EXPORT bool isNotifyEnabled (NotifySeverity severity)
OSG_EXPORT std::ostream & notify (const NotifySeverity severity)
std::ostream & notify (void)
OSG_EXPORT void setNotifyHandler (NotifyHandler *handler)
OSG_EXPORT NotifyHandlergetNotifyHandler ()
template<typename T>
T * clone (const T *t, const osg::CopyOp &copyop=osg::CopyOp::SHALLOW_COPY)
template<typename T>
T * clone (const T *t, const std::string &name, const osg::CopyOp &copyop=osg::CopyOp::SHALLOW_COPY)
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)
void intrusive_ptr_add_ref (Referenced *p)
void intrusive_ptr_release (Referenced *p)
OSG_EXPORT bool isTextureMode (StateAttribute::GLMode mode)
OSG_EXPORT Matrix computeLocalToWorld (const NodePath &nodePath, bool ignoreCameras=true)
OSG_EXPORT Matrix computeWorldToLocal (const NodePath &nodePath, bool ignoreCameras=true)
OSG_EXPORT Matrix computeLocalToEye (const Matrix &modelview, const NodePath &nodePath, bool ignoreCameras=true)
OSG_EXPORT Matrix computeEyeToLocal (const Matrix &modelview, const NodePath &nodePath, bool ignoreCameras=true)
Vec2d componentMultiply (const Vec2d &lhs, const Vec2d &rhs)
Vec2d componentDivide (const Vec2d &lhs, const Vec2d &rhs)
Vec2f componentMultiply (const Vec2f &lhs, const Vec2f &rhs)
Vec2f componentDivide (const Vec2f &lhs, const Vec2f &rhs)
Vec2s componentMultiply (const Vec2s &lhs, const Vec2s &rhs)
Vec2s componentDivide (const Vec2s &lhs, const Vec2s &rhs)
Vec3d componentMultiply (const Vec3d &lhs, const Vec3d &rhs)
Vec3d componentDivide (const Vec3d &lhs, const Vec3d &rhs)
Vec3f componentMultiply (const Vec3f &lhs, const Vec3f &rhs)
Vec3f componentDivide (const Vec3f &lhs, const Vec3f &rhs)
Vec3s componentMultiply (const Vec3s &lhs, const Vec3s &rhs)
Vec3s componentDivide (const Vec3s &lhs, const Vec3s &rhs)
Vec4d::value_type operator* (const Vec3d &lhs, const Vec4d &rhs)
Vec4d::value_type operator* (const Vec3f &lhs, const Vec4d &rhs)
Vec4d::value_type operator* (const Vec3d &lhs, const Vec4f &rhs)
Vec4d::value_type operator* (const Vec4d &lhs, const Vec3d &rhs)
Vec4d::value_type operator* (const Vec4d &lhs, const Vec3f &rhs)
Vec4d::value_type operator* (const Vec4f &lhs, const Vec3d &rhs)
Vec4d componentMultiply (const Vec4d &lhs, const Vec4d &rhs)
Vec4d componentDivide (const Vec4d &lhs, const Vec4d &rhs)
Vec4f::value_type operator* (const Vec3f &lhs, const Vec4f &rhs)
Vec4f::value_type operator* (const Vec4f &lhs, const Vec3f &rhs)
Vec4f componentMultiply (const Vec4f &lhs, const Vec4f &rhs)
Vec4f componentDivide (const Vec4f &lhs, const Vec4f &rhs)
Vec4s componentMultiply (const Vec4s &lhs, const Vec4s &rhs)
Vec4s componentDivide (const Vec4s &lhs, const Vec4s &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 double LN_2 = 0.69314718055994530942
const double INVLN_2 = 1.0 / LN_2
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

CoordinateFrame encapsulates the orientation of east, north and up.

typedef TemplateArray<GLdouble,Array::DoubleArrayType,1,GL_DOUBLE> osg::DoubleArray

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

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

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 std::list< osg::ref_ptr<osg::Node> > osg::RefNodePath

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<Vec2d,Array::Vec2dArrayType,2,GL_DOUBLE> osg::Vec2dArray

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<Vec3d,Array::Vec3dArrayType,3,GL_DOUBLE> osg::Vec3dArray

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<Vec4d,Array::Vec4dArrayType,4,GL_DOUBLE> osg::Vec4dArray

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

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

typedef MixinVector<GLsizei> osg::VectorGLsizei

typedef MixinVector<GLubyte> osg::VectorGLubyte

typedef MixinVector<GLuint> osg::VectorGLuint

typedef MixinVector<GLushort> osg::VectorGLushort


Enumeration Type Documentation

Enumerator:
BigEndian 
LittleEndian 

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 or OSG_NOTIFY_LEVEL. See documentation on osg::notify() for further details.

Enumerator:
ALWAYS 
FATAL 
WARN 
NOTICE 
INFO 
DEBUG_INFO 
DEBUG_FP 


Function Documentation

template<typename T, class M>
void osg::_modifyRow ( unsigned int  num,
GLenum  pixelFormat,
T *  data,
float  scale,
const M &  operation 
) [inline]

References GL_BGR, and GL_BGRA.

Referenced by modifyRow().

template<typename T, class O>
void osg::_readRow ( unsigned int  num,
GLenum  pixelFormat,
const T *  data,
float  scale,
O &  operation 
) [inline]

References GL_BGR, and GL_BGRA.

Referenced by readRow().

template<typename T>
T osg::absolute ( 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.

OSG_EXPORT double osg::asciiToDouble ( const char *  str  ) 

Convert a ascii number to a double, ignoring locale settings.

Referenced by asciiToFloat().

float osg::asciiToFloat ( const char *  str  )  [inline]

Convert a ascii number to a float, ignoring locale settings.

References asciiToDouble().

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

Referenced by clampBetween().

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

References clampArrayElementsBetweenRange().

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.

References clampArrayElementsGEQUAL().

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.

References clampArrayElementsLEQUAL().

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

References clampArrayElementsBetweenRange().

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.

References clampArrayElementsGEQUAL().

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.

References clampArrayElementsLEQUAL().

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

References notify(), and WARN.

Referenced by clampArrayElementsBetweenRange().

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

References notify(), and WARN.

Referenced by clampArrayElementsGEQUAL().

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

References notify(), and WARN.

Referenced by clampArrayElementsLEQUAL().

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

References clampArrayElementBetweenRange().

Referenced by clampArray3BetweenRange(), and clampArray4BetweenRange().

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.

References clampArrayElementGEQUAL().

Referenced by clampArray3GEQUAL(), and clampArray4GEQUAL().

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.

References clampArrayElementLEQUAL().

Referenced by clampArray3LEQUAL(), and clampArray4LEQUAL().

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

Referenced by clampBetween().

template<typename T>
T osg::clampBetween ( v,
minimum,
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 );

References notify(), and WARN.

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

References notify(), and WARN.

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

References notify(), and WARN.

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

OSG_EXPORT bool osg::clearImageToColor ( osg::Image image,
const osg::Vec4 colour 
)

Compute the min max colour values in the image.

template<typename T>
T* osg::clone ( const T *  t,
const std::string &  name,
const osg::CopyOp copyop = osg::CopyOp::SHALLOW_COPY 
) [inline]

template<typename T>
T* osg::clone ( const T *  t,
const osg::CopyOp copyop = osg::CopyOp::SHALLOW_COPY 
) [inline]

Vec4s osg::componentDivide ( const Vec4s &  lhs,
const Vec4s &  rhs 
) [inline]

divide rhs components by rhs vector components.

Vec4f osg::componentDivide ( const Vec4f &  lhs,
const Vec4f &  rhs 
) [inline]

divide rhs components by rhs vector components.

Vec4d osg::componentDivide ( const Vec4d &  lhs,
const Vec4d &  rhs 
) [inline]

divide rhs components by rhs vector components.

Vec3s osg::componentDivide ( const Vec3s &  lhs,
const Vec3s &  rhs 
) [inline]

divide rhs components by rhs vector components.

Vec3f osg::componentDivide ( const Vec3f &  lhs,
const Vec3f &  rhs 
) [inline]

divide rhs components by rhs vector components.

Vec3d osg::componentDivide ( const Vec3d &  lhs,
const Vec3d &  rhs 
) [inline]

divide rhs components by rhs vector components.

Vec2s osg::componentDivide ( const Vec2s &  lhs,
const Vec2s &  rhs 
) [inline]

divide rhs components by rhs vector components.

Vec2f osg::componentDivide ( const Vec2f &  lhs,
const Vec2f &  rhs 
) [inline]

divide rhs components by rhs vector components.

Vec2d osg::componentDivide ( const Vec2d &  lhs,
const Vec2d &  rhs 
) [inline]

divide rhs components by rhs vector components.

Vec4s osg::componentMultiply ( const Vec4s &  lhs,
const Vec4s &  rhs 
) [inline]

multiply by vector components.

Vec4f osg::componentMultiply ( const Vec4f &  lhs,
const Vec4f &  rhs 
) [inline]

multiply by vector components.

Vec4d osg::componentMultiply ( const Vec4d &  lhs,
const Vec4d &  rhs 
) [inline]

multiply by vector components.

Vec3s osg::componentMultiply ( const Vec3s &  lhs,
const Vec3s &  rhs 
) [inline]

multiply by vector components.

Vec3f osg::componentMultiply ( const Vec3f &  lhs,
const Vec3f &  rhs 
) [inline]

multiply by vector components.

Vec3d osg::componentMultiply ( const Vec3d &  lhs,
const Vec3d &  rhs 
) [inline]

multiply by vector components.

Vec2s osg::componentMultiply ( const Vec2s &  lhs,
const Vec2s &  rhs 
) [inline]

multiply by vector components.

Vec2f osg::componentMultiply ( const Vec2f &  lhs,
const Vec2f &  rhs 
) [inline]

multiply by vector components.

Vec2d osg::componentMultiply ( const Vec2d &  lhs,
const Vec2d &  rhs 
) [inline]

multiply by vector components.

OSG_EXPORT Matrix osg::computeEyeToLocal ( const Matrix &  modelview,
const NodePath &  nodePath,
bool  ignoreCameras = 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 multiplying by the inverse of the supplied initial camera modelview.

OSG_EXPORT Matrix osg::computeLocalToEye ( const Matrix &  modelview,
const NodePath &  nodePath,
bool  ignoreCameras = 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 multiplying by the supplied initial camera modelview.

OSG_EXPORT Matrix osg::computeLocalToWorld ( const NodePath &  nodePath,
bool  ignoreCameras = 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.

Referenced by osgParticle::ParticleProcessor::getLocalToWorldMatrix().

OSG_EXPORT bool osg::computeMinMax ( const osg::Image image,
osg::Vec4 min,
osg::Vec4 max 
)

Compute the min max colour values in the image.

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.

References computeVolume().

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.

Referenced by computeVolume().

OSG_EXPORT Matrix osg::computeWorldToLocal ( const NodePath &  nodePath,
bool  ignoreCameras = 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.

Referenced by osgParticle::ParticleProcessor::getWorldToLocalMatrix().

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

template<typename T, typename R>
T osg::convertPointerType ( src  )  [inline]

OSG_EXPORT bool osg::copyImage ( const osg::Image srcImage,
int  src_s,
int  src_t,
int  src_r,
int  width,
int  height,
int  depth,
osg::Image destImage,
int  dest_s,
int  dest_t,
int  dest_r,
bool  doRescale = false 
)

Compute source image to destination image.

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

References createTexturedQuadGeometry().

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

Referenced by createTexturedQuadGeometry().

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

References PI.

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

References PI.

OSG_EXPORT void osg::deleteAllGLObjects ( unsigned int  contextID  ) 

Do a GL delete all OpenGL objects. Note, must be called from a thread which has current the graphics context associated with contextID.

OSG_EXPORT void osg::discardAllDeletedGLObjects ( unsigned int  contextID  ) 

Discard all deleted OpenGL objects. Note, unlike flushAllDeletedObjectObjects discard does not do any OpenGL calls so can be called from any thread, but as a consequence it also doesn't remove the associated OpenGL resource so discard should only be called when the associated graphics context is being/has been closed.

OSG_EXPORT void osg::discardAllGLObjects ( unsigned int  contextID  ) 

Discard all OpenGL objects. Note, unlike deletedAllObjectObjects discard does not do any OpenGL calls so can be called from any thread, but as a consequence it also doesn't remove the associated OpenGL resource so discard should only be called when the associated graphics context is being/has been closed.

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

bool 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.

bool 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.

OSG_EXPORT void osg::flushAllDeletedGLObjects ( unsigned int  contextID  ) 

Flush all deleted OpenGL objects. Note, must be called from a thread which has current the graphics context associated with contextID.

OSG_EXPORT void osg::flushDeletedGLObjects ( unsigned int  contextID,
double  currentTime,
double &  availableTime 
)

Flush all deleted OpenGL objects within the specified availableTime. Note, must be called from a thread which has current the graphics context associated with contextID.

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

Endian osg::getCpuByteOrder (  )  [inline]

References BigEndian, and LittleEndian.

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

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

void* osg::getGLExtensionFuncPtr ( const char *  funcName1,
const char *  funcName2,
const char *  funcName3 
) [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.

References getGLExtensionFuncPtr().

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.

References getGLExtensionFuncPtr().

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.

Referenced by getGLExtensionFuncPtr(), and setGLExtensionFuncPtr().

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 NotifyHandler* osg::getNotifyHandler (  ) 

Get currrent notification handler.

OSG_EXPORT NotifySeverity osg::getNotifyLevel (  ) 

get the notify level.

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

References PI.

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

References PI.

OSG_EXPORT bool osg::initNotifyLevel (  ) 

initialize notify level.

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

void osg::intrusive_ptr_add_ref ( Referenced *  p  )  [inline]

void osg::intrusive_ptr_release ( Referenced *  p  )  [inline]

OSG_EXPORT bool osg::isExtensionInExtensionString ( const char *  extension,
const char *  extensionString 
)

Return true if "extension" is contained in "extensionString".

OSG_EXPORT bool osg::isGLExtensionOrVersionSupported ( unsigned int  contextID,
const char *  extension,
float  requiredGlVersion 
)

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

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?

OSG_EXPORT bool osg::isTextureMode ( StateAttribute::GLMode  mode  ) 

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

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

Referenced by osgAnimation::Vec3ArrayPacked::analyze(), osg::BoundingBoxImpl< VT >::intersect(), osg::BoundingBoxImpl< VT >::intersects(), osgParticle::ConstantRateCounter::numParticlesToCreate(), and osg::State::setActiveTextureUnit().

template<typename T>
T osg::minimum ( lhs,
rhs 
) [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.

Referenced by osgAnimation::Vec3ArrayPacked::analyze(), osgAnimation::Vec3Packed::compress(), osg::BoundingBoxImpl< VT >::intersect(), and osg::BoundingBoxImpl< VT >::intersects().

template<class M>
void osg::modifyImage ( osg::Image image,
const M &  operation 
) [inline]

template<class M>
void osg::modifyRow ( unsigned int  num,
GLenum  pixelFormat,
GLenum  dataType,
unsigned char *  data,
const M &  operation 
) [inline]

References _modifyRow(), GL_INT, and GL_UNSIGNED_INT.

Referenced by modifyImage().

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

References INFO, and notify().

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 i.e.

  • setenv OSGNOTIFYLEVEL DEBUG (for tsh)
  • export OSGNOTIFYLEVEL=DEBUG (for bourne shell)
  • set OSGNOTIFYLEVEL=DEBUG (for Windows)

All tell the osg to redirect all debugging and more important messages to the notification stream (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 std::cout) i.e

 osg::notify(osg::DEBUG) << "Hello Bugs!" << std::endl;
See also:
setNotifyLevel, setNotifyHandler

Referenced by osgWidget::_notify(), osgDB::IntLookup::add(), osgViewer::GraphicsWindow::bindPBufferToTextureImplementation(), clampArrayElementBetweenRange(), clampArrayElementGEQUAL(), clampArrayElementLEQUAL(), clampBetweenRange(), clampGEQUAL(), clampLEQUAL(), osgViewer::GraphicsWindow::closeImplementation(), osgAnimation::RigTransformSoftware::UniqBoneSetVertexSet::computeMatrixForVertexSet(), osgUtil::CullVisitor::createOrReuseRenderLeaf(), osgWidget::NotifyWidget::focus(), osgAnimation::TemplateInterpolatorBase< TYPE, KEY >::getKeyIndexFromTime(), osgAnimation::CompositeMotion::getValueInNormalizedRange(), osgViewer::GraphicsWindow::grabFocus(), osgViewer::GraphicsWindow::grabFocusIfPointerInWindow(), osgViewer::GraphicsWindow::isRealizedImplementation(), osgWidget::NotifyWidget::keyPress(), osgWidget::NotifyWidget::keyRelease(), osgAnimation::AnimationUpdateCallback< osg::StateAttributeCallback >::link(), osgViewer::GraphicsWindow::makeContextCurrentImplementation(), osgViewer::GraphicsWindow::makeCurrentImplementation(), osgWidget::NotifyWidget::mouseDrag(), osgWidget::NotifyWidget::mouseEnter(), osgWidget::NotifyWidget::mouseLeave(), osgWidget::NotifyWidget::mouseOver(), osgWidget::NotifyWidget::mousePush(), osgWidget::NotifyWidget::mouseRelease(), osgWidget::NotifyWidget::mouseScroll(), notify(), osgViewer::GraphicsWindow::raiseWindow(), osgViewer::GraphicsWindow::realizeImplementation(), osgViewer::GraphicsWindow::releaseContextImplementation(), osgUtil::CubeMapGenerator::set_pixel(), osgViewer::GraphicsWindow::setCursor(), osg::TriangleFunctor< T >::setVertexArray(), osg::TemplatePrimitiveFunctor< T >::setVertexArray(), osgViewer::GraphicsWindow::setWindowDecorationImplementation(), osgViewer::GraphicsWindow::setWindowName(), osgViewer::GraphicsWindow::setWindowRectangleImplementation(), osgViewer::GraphicsWindow::swapBuffersImplementation(), osgWidget::NotifyWidget::unfocus(), osgAnimation::RigGeometry::UpdateVertex::update(), and osgViewer::GraphicsWindow::valid().

OSG_EXPORT bool osg::offsetAndScaleImage ( osg::Image image,
const osg::Vec4 offset,
const osg::Vec4 scale 
)

Compute the min max colour values in the image.

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 Vec4f &  lhs,
const Vec3d &  rhs 
) [inline]

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

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

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

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 Vec4f &  rhs 
) [inline]

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

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

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

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]

References osg::Quat::_v.

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

References osg::Vec4ub::_v.

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]

References osg::Vec4s::_v.

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

References osg::Vec3s::_v.

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

References osg::Vec2s::_v.

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

References osg::Vec4b::_v.

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

References osg::Vec3b::_v.

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

References osg::Vec2b::_v.

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

References osg::Vec4d::_v.

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

References osg::Vec4f::_v.

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

References osg::Vec3d::_v.

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

References osg::Vec3f::_v.

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

References osg::Vec2d::_v.

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

References osg::Vec2f::_v.

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

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

References osg::Quat::_v.

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

References osg::Vec4ub::_v.

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

References osg::Vec4s::_v.

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

References osg::Vec3s::_v.

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

References osg::Vec2s::_v.

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

References osg::Vec4b::_v.

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

References osg::Vec3b::_v.

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

References osg::Vec2b::_v.

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

References osg::Vec4d::_v.

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

References osg::Vec4f::_v.

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

References osg::Vec3d::_v.

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

References osg::Vec3f::_v.

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

References osg::Vec2d::_v.

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

References osg::Vec2f::_v.

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

References PI.

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

References PI.

template<class O>
void osg::readImage ( const osg::Image image,
O &  operation 
) [inline]

template<class O>
void osg::readRow ( unsigned int  num,
GLenum  pixelFormat,
GLenum  dataType,
const unsigned char *  data,
O &  operation 
) [inline]

References _readRow(), GL_INT, and GL_UNSIGNED_INT.

Referenced by readImage().

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.

template<typename T>
bool osg::setGLExtensionFuncPtr ( T &  t,
const char *  str1,
const char *  str2,
const char *  str3 
) [inline]

template<typename T>
bool osg::setGLExtensionFuncPtr ( T &  t,
const char *  str1,
const char *  str2 
) [inline]

template<typename T>
bool osg::setGLExtensionFuncPtr ( T &  t,
const char *  str1 
) [inline]

OSG_EXPORT void osg::setNotifyHandler ( NotifyHandler *  handler  ) 

Set notification handler, by default StandardNotifyHandler is used.

See also:
NotifyHandler

OSG_EXPORT void osg::setNotifyLevel ( NotifySeverity  severity  ) 

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

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

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

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

template<typename T>
T osg::square ( 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]

template<class ValueT>
void osg::swap ( std::vector< ValueT > &  left,
MixinVector< ValueT > &  right 
) [inline]

template<class ValueT>
void osg::swap ( MixinVector< ValueT > &  left,
std::vector< ValueT > &  right 
) [inline]

template<class ValueT>
void osg::swap ( MixinVector< ValueT > &  left,
MixinVector< ValueT > &  right 
) [inline]

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

References swap().

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

References swap().

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

References swap().

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

References swap().

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

References swap().


Variable Documentation

const double osg::INVLN_2 = 1.0 / LN_2

const double osg::LN_2 = 0.69314718055994530942

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 Mar 19 19:52:49 2010 for openscenegraph by  doxygen 1.5.6