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  VertexBufferObject
class  ElementBufferObject
class  PixelBufferObject
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  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  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  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  VectorGLsizei
class  VectorGLubyte
class  VectorGLushort
class  VectorGLuint
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
class  Referenced
class  RenderInfo
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  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  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 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 OperationThread OperationsThread
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 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)
template<typename T>
bool setGLExtensionFuncPtr (T &t, const char *str1)
template<typename T>
bool setGLExtensionFuncPtr (T &t, const char *str1, const char *str2)
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 discardAllDeletedGLObjects (unsigned int contextID)
OSG_EXPORT GeodecreateGeodeForImage (Image *image)
OSG_EXPORT GeodecreateGeodeForImage (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>
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)
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 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)
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)
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 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.

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


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

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]

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

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 *  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 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]

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

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

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 osg::BoundingBox::intersect(), osg::BoundingBox::intersects(), and osgParticle::ConstantRateCounter::numParticlesToCreate().

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 osg::BoundingBox::intersect(), and osg::BoundingBox::intersects().

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

Referenced by osgViewer::GraphicsWindow::bindPBufferToTextureImplementation(), clampArrayElementBetweenRange(), clampArrayElementGEQUAL(), clampArrayElementLEQUAL(), clampBetweenRange(), clampGEQUAL(), clampLEQUAL(), osgViewer::GraphicsWindow::closeImplementation(), osgUtil::CullVisitor::createOrReuseRenderLeaf(), osgViewer::GraphicsWindow::grabFocus(), osgViewer::GraphicsWindow::grabFocusIfPointerInWindow(), osgViewer::GraphicsWindow::isRealizedImplementation(), osgViewer::GraphicsWindow::makeContextCurrentImplementation(), osgViewer::GraphicsWindow::makeCurrentImplementation(), notify(), osgViewer::GraphicsWindow::realizeImplementation(), osgViewer::GraphicsWindow::releaseContextImplementation(), osgParticle::ParticleSystemUpdater::removeParticleSystem(), 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(), OpenThreads::ReentrantMutex::unlock(), and osgViewer::GraphicsWindow::valid().

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.

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

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

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 ( 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]

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 Wed Aug 13 17:03:31 2008 for openscenegraph by  doxygen 1.5.6