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

osg Namespace Reference

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


Classes

class  AlphaFunc
 Encapsulates OpenGL glAlphaFunc. More...
class  AnimationPath
 AnimationPath encapsulates a time varying transformation pathway. More...
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
 AutoTransform is a derived form of Transform that automatically scales or rotates to keep its children aligned with screen coordinates. More...
class  Billboard
 Billboard is a derived form of Geode that orients its osg::Drawable children to face the eye point. More...
class  BlendColor
 Encapsulates OpenGL blend/transparency state. More...
class  BlendFunc
 Encapsulates OpenGL blend/transparency state. More...
class  BoundingBox
 General purpose axis-aligned bounding box class for enclosing objects/vertices. More...
class  BoundingSphere
 General purpose bounding sphere class for enclosing nodes/objects/vertices. More...
class  buffered_value
 Implements a simple buffered value for values that need to be buffered on a per graphics context basis. More...
class  buffered_object
class  ClearNode
 A Group node for clearing the color and depth buffers. More...
class  ClipNode
 Node for defining the position of ClipPlanes in the scene. More...
class  ClipPlane
 Encapsulates OpenGL glClipPlane(). More...
class  ClusterCullingCallback
 Implements cluster culling to cull back facing drawables. More...
class  CollectOccludersVisitor
class  ColorMask
 Encapsulates OpenGL glColorMaskFunc/Op/Mask functions. More...
class  ColorMatrix
 Encapsulates OpenGL color matrix functionality. More...
class  ConvexPlanarOccluder
 A class for representing convex clipping volumes made up of several ConvexPlanarPolygon. More...
class  ConvexPlanarPolygon
 A class for representing components of convex clipping volumes. More...
class  EllipsoidModel
 EllipsoidModel encapsulates the ellipsoid used to model astronomical bodies, such as sun, planets, moon etc. More...
class  CoordinateSystemNode
 CoordinateSystem encapsulate the coordinate system that is associated with objects in a scene. More...
class  CopyOp
 Copy Op(erator) used to control whether shallow or deep copy is used during copy construction and clone operation. More...
class  CullFace
 Class to globally enable/disable OpenGL's polygon culling mode. More...
class  CullingSet
 A CullingSet class which contains a frustum and a list of occluders. More...
class  CullSettings
class  CullStack
 A CullStack class which accumulates the current project, modelview matrices and the CullingSet. More...
class  Depth
 Encapsulate OpenGL glDepthFunc/Mask/Range functions. More...
class  DisplaySettings
 DisplaySettings class for encapsulating what visuals are required and have been set up, and the status of stereo viewing. More...
class  Drawable
 Pure virtual base class for drawable Geometry. More...
class  DrawPixels
 DrawPixels is an osg::Drawable subclass which encapsulates the drawing of images using glDrawPixels. More...
class  fast_back_stack
 Simple stack implementation that keeps the back() cached locally for fast access rather than at the back of the vector which is the traditional stack implementation. More...
class  Fog
 Fog - encapsulates OpenGL fog state. More...
class  FragmentProgram
 FragmentProgram - encapsulates the OpenGL ARB fragment program state. More...
class  FrameStamp
 Class which encapsulates the frame number, reference time and calendar time of specific frame, used to synchonize operations on the scene graph and other machines when using a graphics cluster. More...
class  FrontFace
 Class to specify the orientation of front-facing polygons. More...
class  Geode
 Leaf Node for grouping Drawables. More...
class  Geometry
class  Group
 General group node which maintains a list of children. More...
class  Image
 Image class for encapsulating the storage texture image data. More...
class  ImageStream
 Image Stream class. More...
class  Impostor
 Impostor - is a form of Level Of Detail group node which allows both switching between children depending on distance from eye point and image caching. More...
class  ImpostorSprite
 An ImposterSprite is a textured quad which is rendered in place of 3D geometry. More...
class  ImpostorSpriteManager
 Helper class for managing the reuse of ImpostorSprite resources. More...
class  Light
 Light state class which encapsulates OpenGL glLight() functionality. More...
class  LightModel
class  LightSource
 Leaf Node for defining a light in the scene. More...
class  LineSegment
 LineSegment class for representing a line segment. More...
class  LineStipple
class  LineWidth
 LineWidth - encapsulates the OpenGL glLineWidth for setting the width of lines in pixels. More...
class  LOD
 LOD - Level Of Detail group node which allows switching between children depending on distance from eye point. More...
class  Material
 Material - encapsulates OpenGL glMaterial state. More...
class  Matrixd
class  RefMatrixd
class  Matrixf
class  RefMatrixf
class  MatrixTransform
 MatrixTransform - is a subclass of Transform which has an osg::Matrix which represents a 4x4 transformation of its children from local coordinates into the Transform's parent coordinates. More...
class  Multisample
 Multisample - encapsulates the OpenGL Multisample state. More...
class  Node
 Base class for all internal nodes in the scene graph. More...
class  NodeCallback
class  NodeVisitor
 Visitor for type safe operations on osg::Nodes. More...
struct  NodeAcceptOp
 Convenience functor for assisting visiting of arrays of osg::Node's. More...
class  Object
 Base class/standard interface for objects which require IO support, cloning and reference counting. More...
class  OccluderNode
 OccluderNode is a Group node which allows OccluderNodeing between children. More...
class  PagedLOD
 PagedLOD. More...
class  Plane
 A plane class. More...
class  Point
 Point - encapsulates the OpenGL point smoothing and size state. More...
class  PointSprite
 PointSprite base class which encapsulates enabling of point sprites . More...
class  PolygonMode
 State Class for setting OpenGL's polygon culling mode. More...
class  PolygonOffset
 PolygonOffset - encapsulates the OpenGL glPolygonOffset state. More...
class  PolygonStipple
class  Polytope
 A Polytope class for representing convex clipping volumes made up of a set of planes. More...
class  PositionAttitudeTransform
 PositionAttitudeTransform - is a Transform. More...
class  PrimitiveSet
class  DrawArrays
class  DrawArrayLengths
class  DrawElementsUByte
class  DrawElementsUShort
class  DrawElementsUInt
class  Projection
 Projection nodes set up the frustum/orthographic projection used when rendering the scene. More...
class  Quat
 A quaternion class. More...
class  ref_ptr
 Smart pointer for handling referenced counted objects. More...
class  Referenced
 Base class from providing referencing counted objects. More...
class  DeleteHandler
 Class for override the default delete behavior so that users can implment their own object deletion schemes. More...
class  RefNodePath
class  Sequence
 Sequence is a Group node which allows automatic, time based switching between children. More...
class  ShadeModel
 Class which encapsulates glShadeModel(..). More...
class  ShadowVolumeOccluder
 ShadowVolumeOccluder is a helper class for implementating shadow occlusion culling. More...
class  Shape
 Base class for all shape types. More...
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
 State class for managing a state stack. More...
class  StateAttribute
 Base class for state attributes. More...
class  StateSet
 Encapsulates OpenGL state modes and attributes. More...
class  Stencil
 Encapsulate OpenGL glStencilFunc/Op/Mask functions. More...
class  Switch
 Switch is a Group node that allows switching between children. More...
class  TexEnv
 TexEnv encapsulates the OpenGL glTexEnv (texture environment) state. More...
class  TexEnvCombine
 TexEnvCombine encapsulates the OpenGL glTexEnvCombine (texture environment) state. More...
class  TexEnvFilter
 TexEnvFilter - encapsulates the OpenGL glTexEnv (GL_TEXTURE_FILTER_CONTROL) state. More...
class  TexGen
 TexGen encapsulates the OpenGL glTexGen (texture coordinate generation) state. More...
class  TexGenNode
 Node for defining the position of TexGen in the scene. More...
class  TexMat
 A texture matrix state class that encapsulates OpenGL texture matrix functionality. More...
class  Texture
 Texture pure virtual base class that encapsulates OpenGl texture functionality common to the various types of OSG textures. More...
class  Texture1D
 Encapsulates OpenGl 1D texture functionality. More...
class  Texture2D
 Encapsulates OpenGl 2D texture functionality. More...
class  Texture3D
 Encapsulates OpenGl 2D texture functionality. More...
class  TextureCubeMap
 TextureCubeMap state class which encapsulates OpenGL texture cubemap functionality. More...
class  TextureRectangle
 Texture state class which encapsulates OpenGL texture functionality. More...
class  Timer
 A high resolution, low latency time stamper. More...
class  Transform
 A Transform is a group node for which all children are transformed by a 4x4 matrix. More...
class  TriangleFunctor
class  TriangleIndexFunctor
class  UByte4
 General purpose float quad. More...
class  Vec2d
 General purpose double pair, uses include representation of texture coordinates. More...
class  Vec2f
 General purpose float pair. More...
class  Vec3d
 General purpose double triple for use as vertices, vectors and normals. More...
class  Vec3f
 General purpose float triple for use as vertices, vectors and normals. More...
class  Vec4d
 General purpose double quad. More...
class  Vec4f
 General purpose float quad. More...
class  VertexProgram
 VertexProgram - encapsulates the OpenGL ARB vertex program state. More...
class  Viewport
 Encapsulate OpenGL glViewport. More...

Typedefs

typedef TemplateIndexArray<
GLbyte, Array::ByteArrayType,
1, GL_BYTE > 
ByteArray
typedef TemplateIndexArray<
GLshort, Array::ShortArrayType,
1, GL_SHORT > 
ShortArray
typedef TemplateIndexArray<
GLint, Array::IntArrayType,
1, GL_INT > 
IntArray
typedef TemplateIndexArray<
GLubyte, Array::UByteArrayType,
1, GL_UNSIGNED_BYTE > 
UByteArray
typedef TemplateIndexArray<
GLushort, Array::UShortArrayType,
1, GL_UNSIGNED_SHORT > 
UShortArray
typedef TemplateIndexArray<
GLuint, Array::UIntArrayType,
1, GL_UNSIGNED_INT > 
UIntArray
typedef TemplateArray< GLfloat,
Array::FloatArrayType,
1, GL_FLOAT > 
FloatArray
typedef TemplateArray< UByte4,
Array::UByte4ArrayType,
4, GL_UNSIGNED_BYTE > 
UByte4Array
typedef TemplateArray< Vec2,
Array::Vec2ArrayType,
2, GL_FLOAT > 
Vec2Array
typedef TemplateArray< Vec3,
Array::Vec3ArrayType,
3, GL_FLOAT > 
Vec3Array
typedef TemplateArray< Vec4,
Array::Vec4ArrayType,
4, GL_FLOAT > 
Vec4Array
typedef Matrixd CoordinateFrame
 CoordinateFrame encapsulates the orientation of east, north and up.
typedef int GLsizeiptrARB
typedef std::vector< ref_ptr<
Node > > 
NodeList
typedef Matrixd Matrix
typedef RefMatrixd RefMatrix
typedef std::vector< Node * > NodePath
 A vector of Nodes pointers which is used to describe the path from a root node to a descendant.
typedef std::vector< GLsizei > VectorSizei
typedef std::vector< GLubyte > VectorUByte
typedef std::vector< GLushort > VectorUShort
typedef std::vector< GLuint > VectorUInt
typedef std::vector< ShadowVolumeOccluderShadowVolumeOccluderList
 A list of ShadowVolumeOccluder, used by CollectOccluderVisitor and CullVistor's.
typedef HeightField Grid
typedef std::clock_t 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
}
 Range of notify levels from DEBUG_FP through to FATAL, ALWAYS is reserved for forcing the absorption of all messages. More...

Functions

bool isWGLExtensionSupported (const char *extension)
template<class T>
void clampGEQUAL (T &value, const T minValue, const char *valueName)
 If value is greater than or equal to minValue do nothing - legal value, Otherwise set value to minValue, and warn that valueName was clamped.
template<class T>
void clampLEQUAL (T &value, const T maxValue, const char *valueName)
 If value is less than or equal to maxValue do nothing - legal value, Otherwise set value to maxValue, and warn that valueName was clamped.
template<class T>
void clampBetweenRange (T &value, const T minValue, const T maxValue, const char *valueName)
 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.
template<class A, class T>
void clampArrayElementGEQUAL (A &value, unsigned int i, const T minValue, const char *valueName)
 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.
template<class A, class T>
void clampArrayElementLEQUAL (A &value, unsigned int i, const T maxValue, const char *valueName)
 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.
template<class A, class T>
void clampArrayElementBetweenRange (A &value, unsigned int i, const T minValue, const T maxValue, const char *valueName)
 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.
template<class A, class T>
void clampArrayElementsGEQUAL (A &value, unsigned int first, unsigned int last, const T minValue, const char *valueName)
 For each element of value[] in the range (first,last), if the element is greater than or equal to minValue do nothing - legal value, Otherwise clamp the element to minValue, and warn that valueName[i] was clamped.
template<class A, class T>
void clampArrayElementsLEQUAL (A &value, unsigned int first, unsigned int last, const T maxValue, const char *valueName)
 For each element of value[] in the range (first,last), if the element is less than or equal to maxValue do nothing - legal value, Otherwise clamp the element to maxValue, and warn that valueName[i] was clamped.
template<class A, class T>
void clampArrayElementsBetweenRange (A &value, unsigned int first, unsigned int last, const T minValue, const T maxValue, const char *valueName)
 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.
template<class A, class T>
void clampArray3GEQUAL (A &value, const T minValue, const char *valueName)
 For each element of the three-element array value[], if the element is greater than or equal to minValue do nothing - legal value, Otherwise clamp the element to minValue, and warn that valueName[i] was clamped.
template<class A, class T>
void clampArray3LEQUAL (A &value, const T maxValue, const char *valueName)
 For each element of the three-element array value[], if the element is less than or equal to maxValue do nothing - legal value, Otherwise clamp the element to maxValue, and warn that valueName[i] was clamped.
template<class A, class T>
void clampArray3BetweenRange (A &value, const T minValue, const T maxValue, const char *valueName)
 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.
template<class A, class T>
void clampArray4GEQUAL (A &value, const T minValue, const char *valueName)
 For each element of the four-element array value[], if the element is greater than or equal to minValue do nothing - legal value, Otherwise clamp the element to minValue, and warn that valueName[i] was clamped.
template<class A, class T>
void clampArray4LEQUAL (A &value, const T maxValue, const char *valueName)
 For each element of the four-element array value[], if the element is less than or equal to maxValue do nothing - legal value, Otherwise clamp the element to maxValue, and warn that valueName[i] was clamped.
template<class A, class T>
void clampArray4BetweenRange (A &value, const T minValue, const T maxValue, const char *valueName)
 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.
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)
SG_EXPORT GeometrycreateTexturedQuadGeometry (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.
GeometrycreateTexturedQuadGeometry (const Vec3 &corner, const Vec3 &widthVec, const Vec3 &heightVec, float s=1.0f, float t=1.0f)
 Convenience function to be used for creating quad geometry with texture coords.
SG_EXPORT bool isGLExtensionSupported (const char *extension)
 Return true if OpenGL "extension" is supported.
void * getGLExtensionFuncPtr (const char *funcName)
 Return the address of the specified OpenGL function.
SG_EXPORT void setGLExtensionDisableString (const std::string &disableString)
 Set a list of extensions to disable for different OpenGL renderers.
SG_EXPORT std::string & getGLExtensionDisableString ()
 Get the list of extensions that are disabled for various OpenGL renderers.
void * getGLExtensionFuncPtr (const char *funcName, const char *fallbackFuncName)
 Return the address of the specified OpenGL function.
SG_EXPORT bool isGLUExtensionSupported (const char *extension)
 Return true if OpenGL "extension" is supported.
SG_EXPORT GeodecreateGeodeForImage (Image *image)
 Convenience function to be used by image loaders to generate a valid geode to return for readNode().
SG_EXPORT GeodecreateGeodeForImage (Image *image, float s, float t)
 Convenience function to be used by image loaders to generate a valid geode to return for readNode().
template<typename T>
absolute (T v)
 return the minimum of two values, equivalent to std::min.
float equivalent (float lhs, float rhs, float epsilon=1e-6)
 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.
double equivalent (double lhs, double rhs, double epsilon=1e-6)
 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.
template<typename T>
minimum (T lhs, T rhs)
 return the minimum of two values, equivilent to std::min.
template<typename T>
maximum (T lhs, T rhs)
 return the maximum of two values, equivilent to std::max.
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>
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)
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)
 compute the volume of a tetrahedron.
template<typename T>
float computeVolume (const T &f1, const T &f2, const T &f3, const T &b1, const T &b2, const T &b3)
 compute the volume of a prism.
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)
std::ostream & operator<< (std::ostream &os, 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)
std::ostream & operator<< (std::ostream &os, const Matrixf &m)
SG_EXPORT void setNotifyLevel (NotifySeverity severity)
 set the notify level, overriding the default or the value set by the environmental variable OSGNOTIFYLEVEL.
SG_EXPORT NotifySeverity getNotifyLevel ()
 get the notify level.
SG_EXPORT bool initNotifyLevel ()
 initialize notify level.
SG_EXPORT std::ostream & notify (const NotifySeverity severity)
 notify messaging function for providing fatal through to verbose debugging messages.
std::ostream & notify (void)
std::ostream & operator<< (std::ostream &output, const Plane &pl)
std::ostream & operator<< (std::ostream &output, const Quat &vec)
SG_EXPORT Matrix computeLocalToWorld (const NodePath &nodePath)
 Compute the matrix which transforms objects in local coords to world coords, by accumulating the Transform local to world matrices along the specified node path.
SG_EXPORT Matrix computeWorldToLocal (const NodePath &nodePath)
 Compute the matrix which transforms objects in world coords to local coords, by accumulating the Transform world to local matrices along the specified node path.
SG_EXPORT Matrix computeLocalToEye (const Matrix &modelview, const NodePath &nodePath)
 Compute the matrix which transforms objects in local coords to eye coords, by accumulating the Transform local to world matrices along the specified node path and multipling by the supplied initial camera modelview.
SG_EXPORT Matrix computeEyeToLocal (const Matrix &modelview, const NodePath &nodePath)
 Compute the matrix which transforms objects in eye coords to local coords, by accumulating the Transform world to local matrices along the specified node path and multipling by the inverse of the supplied initialial camera modelview.
std::ostream & operator<< (std::ostream &output, const Vec3d &vec)
std::ostream & operator<< (std::ostream &output, const Vec3f &vec)
Vec4d::value_type operator * (const Vec3d &lhs, const Vec4d &rhs)
 Compute the dot product of a (Vec3,1.0) and a Vec4d.
Vec4d::value_type operator * (const Vec4d &lhs, const Vec3d &rhs)
 Compute the dot product of a Vec4d and a (Vec3,1.0).
Vec4f::value_type operator * (const Vec3f &lhs, const Vec4f &rhs)
 Compute the dot product of a (Vec3,1.0) and a Vec4f.
Vec4f::value_type operator * (const Vec4f &lhs, const Vec3f &rhs)
 Compute the dot product of a Vec4f and a (Vec3,1.0).

Variables

const double WGS_84_RADIUS_EQUATOR = 6378137.0
const double WGS_84_RADIUS_POLAR = 6356752.3142
class class class class typedef
int 
GLintptrARB
const double PI = 3.14159265358979323846
const double PI_2 = 1.57079632679489661923
const double PI_4 = 0.78539816339744830962
const Vec3f X_AXIS (1.0, 0.0, 0.0)
const Vec3f Y_AXIS (0.0, 1.0, 0.0)
const Vec3f Z_AXIS (0.0, 0.0, 1.0)


Detailed Description

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

Typedef Documentation

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

typedef Matrixd osg::CoordinateFrame
 

CoordinateFrame encapsulates the orientation of east, north and up.

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

typedef int osg::GLsizeiptrARB
 

typedef HeightField osg::Grid
 

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

typedef Matrixd osg::Matrix
 

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

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

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

typedef RefMatrixd osg::RefMatrix
 

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

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

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

typedef std::clock_t osg::Timer_t
 

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

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

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

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

typedef Vec2f osg::Vec2
 

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

typedef Vec3f osg::Vec3
 

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

typedef Vec4f osg::Vec4
 

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

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

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

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

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


Enumeration Type Documentation

enum osg::Endian
 

Enumeration values:
BigEndian 
LittleEndian 

enum osg::NotifySeverity
 

Range of notify levels from DEBUG_FP through to FATAL, ALWAYS is reserved for forcing the absorption of all messages.

The keywords are also used verbatim when specified by the environmental variable OSGNOTIFYLEVEL. See documentation on osg::notify() for further details.

Enumeration values:
ALWAYS 
FATAL 
WARN 
NOTICE 
INFO 
DEBUG_INFO 
DEBUG_FP 


Function Documentation

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

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

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

Equivalent to calling clampArray3GEQUAL( value, minValue, valueName); clampArray3LEQUAL( value, maxValue, valueName);

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

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

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

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

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

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

Equivalent to calling clampArray4GEQUAL( value, minValue, valueName); clampArray4LEQUAL( value, maxValue, valueName);

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

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

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

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

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

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

Equivilant to calling clampArrayElementGEQUAL( value, i, minValue, valueName ); clampArrayElementLEQUAL( value, i, maxValue, valueName );

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

If value[i] is greater than or equal to minValue do nothing - legal value, Otherwise set value[i] to minValue, and warn that valueName[i] was clamped.

Note this is effectively A[i]=max(A[i],B).

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

If value[i] is less than or equal to maxValue do nothing - legal value, Otherwise set value[i] to maxValue, and warn that valueName[i] was clamped.

Note this is effectively A[i]=min(A[i],B).

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

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

Equivalent to calling clampArrayElementsGEQUAL( value, first, last, minValue, valueName); clampArrayElementsLEQUAL( value, first, last, maxValue, valueName);

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

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

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

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

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

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

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

If value is between or equal to minValue and maxValue do nothing - legal value, Otherwise clamp value to specified range and warn that valueName was clamped.

Equivilant to calling clampGEQUAL( value, minValue, valueName ); clampLEQUAL( value, maxValue, valueName );

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

If value is greater than or equal to minValue do nothing - legal value, Otherwise set value to minValue, and warn that valueName was clamped.

Note this is effectively A=max(A,B).

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

If value is less than or equal to maxValue do nothing - legal value, Otherwise set value to maxValue, and warn that valueName was clamped.

Note this is effectively A=min(A,B).

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

Matrix osg::computeEyeToLocal const Matrix modelview,
const NodePath nodePath
 

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

Matrix osg::computeLocalToEye const Matrix modelview,
const NodePath nodePath
 

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

Matrix osg::computeLocalToWorld const NodePath nodePath  ) 
 

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

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

compute the volume of a prism.

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

compute the volume of a tetrahedron.

Matrix osg::computeWorldToLocal const NodePath nodePath  ) 
 

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

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.

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

Geometry * osg::createTexturedQuadGeometry const Vec3 corner,
const Vec3 widthVec,
const Vec3 heightVec,
float  l,
float  b,
float  r,
float  t
 

Convenience function to be used for creating quad geometry with texture coords.

Tex coords go from left bottom (l,b) to right top (r,t).

double DegreesToRadians double  angle  )  [inline]
 

float DegreesToRadians float  angle  )  [inline]
 

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

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

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

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

Endian getCpuByteOrder  )  [inline]
 

std::string & osg::getGLExtensionDisableString  ) 
 

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

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

Return the address of the specified OpenGL function.

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

void* getGLExtensionFuncPtr const char *  funcName  )  [inline]
 

Return the address of the specified OpenGL function.

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

osg::NotifySeverity osg::getNotifyLevel  ) 
 

get the notify level.

double inDegrees double  angle  )  [inline]
 

float inDegrees float  angle  )  [inline]
 

bool osg::initNotifyLevel  ) 
 

initialize notify level.

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

bool osg::isGLExtensionSupported 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::isGLUExtensionSupported const char *  extension  ) 
 

Return true if OpenGL "extension" is supported.

Note: Must only be called within a valid OpenGL context, undefined behavior may occur otherwise.

bool isNaN double  v  )  [inline]
 

bool isNaN float  v  )  [inline]
 

bool isWGLExtensionSupported const char *  extension  ) 
 

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

return the maximum of two values, equivilent to std::max.

std::max not used because of STL implementation under IRIX not containing std::max.

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

return the minimum of two values, equivilent to std::min.

std::min not used because of STL implementation under IRIX not containing std::min.

std::ostream& notify void   )  [inline]
 

std::ostream & osg::notify const NotifySeverity  severity  ) 
 

notify messaging function for providing fatal through to verbose debugging messages.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double RadiansToDegrees double  angle  )  [inline]
 

float RadiansToDegrees float  angle  )  [inline]
 

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.

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

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

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

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

void swapBytes16 char *  in  )  [inline]
 

void swapBytes2 char *  in  )  [inline]
 

void swapBytes4 char *  in  )  [inline]
 

void swapBytes8 char *  in  )  [inline]
 


Variable Documentation

class class class class class typedef int osg::GLintptrARB
 

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 at Tue Apr 5 00:52:44 2005 for the OpenSceneGraph by doxygen 1.4.1.