OpenSceneGraph 2.8.4
Classes | Typedefs | Enumerations | Functions | Variables
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  AudioSink
 Pure virtual AudioSink bass class that is used to connect the audio system with AudioStreams. More...
class  AudioStream
 Pure virtual AudioStream base class. More...
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  BlendEquation
 Encapsulates OpenGL BlendEquation state. More...
class  BlendFunc
 Encapsulates OpenGL blend/transparency state. More...
class  BoundingBoxImpl
 General purpose axis-aligned bounding box class for enclosing objects/vertices. More...
class  BoundingSphereImpl
 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  BufferObject
class  VertexBufferObject
class  ElementBufferObject
class  PixelBufferObject
class  PixelDataBufferObject
 This object represent a general class of pixel buffer objects, which are capable of allocating buffer object (memory) on the GPU. More...
class  Camera
 Camera - is a subclass of Transform which represents encapsulates the settings of a Camera. More...
class  CameraView
 CameraView - is a Transform that is used to specify camera views from within the scene graph. More...
class  ClampColor
 Encapsulates OpenGL ClampColor state. More...
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  ComputeBoundsVisitor
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  DeleteHandler
 Class for override the default delete behavior so that users can implement their own object deletion schemes. 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  FBOExtensions
class  RenderBuffer
class  FrameBufferAttachment
class  FrameBufferObject
class  FrameStamp
 Class which encapsulates the frame number, reference time and calendar time of specific frame, used to synchronize 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
 A Geode is a "geometry node", that is, a leaf node on the scene graph that can have "renderable things" attached to it. More...
class  Geometry
class  GL2Extensions
class  GraphicsContext
 Base class for providing Windowing API agnostic access to creating and managing graphics context. More...
class  GraphicsThread
 GraphicsThread is a helper class for running OpenGL GraphicsOperation within a single thread assigned to a specific GraphicsContext. More...
struct  GraphicsOperation
struct  SwapBuffersOperation
 SwapBufferOperation calls swap buffers on the GraphicsContext. More...
struct  BarrierOperation
 BarrierOperation allows one to synchronize multiple GraphicsThreads with each other. More...
struct  ReleaseContext_Block_MakeCurrentOperation
 ReleaseContext_Block_MakeCurrentOperation releases the context for another thread to acquire, then blocks waiting for context to be released, once the block is release the context is re-acquired. More...
struct  BlockAndFlushOperation
struct  FlushDeletedGLObjectsOperation
class  RunOperations
class  EndOfDynamicDrawBlock
class  Group
 General group node which maintains a list of children. More...
class  Hint
class  Image
 Image class for encapsulating the storage texture image data. More...
class  ImageSequence
 Image Buffer class. More...
class  ImageStream
 Image Stream class. More...
class  KdTree
 Implementation of a kdtree for Geometry leaves, to enable fast intersection tests. More...
class  KdTreeBuilder
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  LogicOp
 Encapsulates OpenGL LogicOp state. 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  MixinVector
 MixinVector is a base class that allows inheritance to be used to easily emulate derivation from std::vector but without introducing undefined behaviour through violation of virtual destructor rules. 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  NodeTrackerCallback
class  NodeVisitor
 Visitor for type safe operations on osg::Nodes. More...
class  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  Observer
class  observer_ptr
 Smart pointer for observed objects, that automatically set pointers to them to null when they deleted. More...
class  OccluderNode
 OccluderNode is a Group node which allows OccluderNodeing between children. More...
class  OcclusionQueryNode
class  RefBlock
class  RefBlockCount
class  Operation
 Base class for implementing graphics operations. More...
class  OperationQueue
class  OperationThread
 OperationThread is a helper class for running Operation within a single thread. 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  PrimitiveFunctor
 A PrimitiveFunctor is used (in conjunction with osg::Drawable::accept (PrimitiveFunctor&)) to get access to the primitives that compose the things drawn by OSG. More...
class  PrimitiveIndexFunctor
class  PrimitiveSet
class  DrawArrays
class  DrawArrayLengths
class  DrawElements
class  DrawElementsUByte
class  DrawElementsUShort
class  DrawElementsUInt
class  Program
 osg::Program is an application-level abstraction of an OpenGL glProgram. More...
class  Projection
 Projection nodes set up the frustum/orthographic projection used when rendering the scene. More...
class  ProxyNode
 ProxyNode. More...
class  Quat
 A quaternion class. More...
class  ref_ptr
 Smart pointer for handling referenced counted objects. More...
struct  depends_on
 template class to help enforce static initialization order. More...
class  Referenced
 Base class from providing referencing counted objects. More...
class  RenderInfo
class  Scissor
 Encapsulate OpenGL glScissor. More...
class  Sequence
 Sequence is a Group node which allows automatic, time based switching between children. More...
class  ShadeModel
 Class which encapsulates glShadeModel(..). More...
class  Shader
 osg::Shader is an application-level abstraction of an OpenGL glShader. More...
class  ShadowVolumeOccluder
 ShadowVolumeOccluder is a helper class for implementing 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
 Describe several hints that can be passed to a Tessellator (like the one used by ShapeDrawable) as a mean to try to influence the way it works. More...
class  ShapeDrawable
 Allow the use of Shapes as Drawables, so that they can be rendered with reduced effort. More...
class  State
 Encapsulates the current applied OpenGL modes, attributes and vertex arrays settings, implements lazy state updating and provides accessors for querying the current state. More...
class  StateAttribute
 Base class for state attributes. More...
class  StateAttributeCallback
class  StateSet
 Stores a set of modes and attributes which represent a set of OpenGL state. More...
class  Stats
class  Stencil
 Encapsulate OpenGL glStencilFunc/Op/Mask functions. More...
class  StencilTwoSided
 Encapsulate OpenGL two sided glStencilFunc/Op/Mask functions. More...
class  Switch
 Switch is a Group node that allows switching between children. More...
class  TemplatePrimitiveFunctor
 Provides access to the primitives that compose an osg::Drawable. 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  Texture2DArray
 Texture2DArray state class which encapsulates OpenGL 2D array 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
 Timer class is used for measuring elapsed time or time between two points. More...
class  TransferFunction
 TransferFunction is a class that provide a 1D,2D or 3D colour look up table that can be used on the GPU as a 1D, 2D or 3D texture. More...
class  TransferFunction1D
 1D variant of TransferFunction. More...
class  Transform
 A Transform is a group node for which all children are transformed by a 4x4 matrix. More...
class  TriangleFunctor
 Provides access to the triangles that compose an osg::Drawable. More...
class  TriangleIndexFunctor
class  Matrix2
class  Matrix3
class  Uniform
 Uniform encapsulates glUniform values. More...
class  Vec2b
 General purpose float triple. More...
class  Vec2d
 General purpose double pair, uses include representation of texture coordinates. More...
class  Vec2f
 General purpose float pair. More...
class  Vec2s
class  Vec3b
 General purpose float triple. 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  Vec3s
class  Vec4b
 General purpose float triple. More...
class  Vec4d
 General purpose double quad. More...
class  Vec4f
 General purpose float quad. More...
class  Vec4s
 General purpose float quad. More...
class  Vec4ub
 General purpose float quad. More...
class  VertexProgram
 VertexProgram - encapsulates the OpenGL ARB vertex program state. More...
class  View
 View - maintains a master camera view and a list of slave cameras that are relative to this master camera. 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< 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 Matrixd CoordinateFrame
 CoordinateFrame encapsulates the orientation of east, north and up.
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< NodePathNodePathList
 A vector of NodePath, typically used to describe all the paths from a node to the potential root nodes it has.
typedef std::vector< MatrixMatrixList
 A vector of NodePath, typically used to describe all the paths from a node to the potential root nodes it has.
typedef OperationThread OperationsThread
typedef MixinVector< GLsizei > VectorGLsizei
typedef MixinVector< GLubyte > VectorGLubyte
typedef MixinVector< GLushort > VectorGLushort
typedef MixinVector< GLuint > VectorGLuint
typedef std::vector
< ShadowVolumeOccluder
ShadowVolumeOccluderList
 A list of ShadowVolumeOccluder, used by CollectOccluderVisitor and CullVistor's.
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
}
 Range of notify levels from DEBUG_FP through to FATAL, ALWAYS is reserved for forcing the absorption of all messages. More...

Functions

template<typename 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<typename 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<typename 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<typename A , typename 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<typename A , typename 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<typename A , typename 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<typename A , typename 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<typename A , typename 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<typename A , typename 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<typename A , typename 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<typename A , typename 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<typename A , typename 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<typename A , typename 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<typename A , typename 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<typename A , typename 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)
OSG_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.
OSG_EXPORT float getGLVersionNumber ()
 Return floating-point OpenGL version number.
OSG_EXPORT bool isExtensionInExtensionString (const char *extension, const char *extensionString)
 Return true if "extension" is contained in "extensionString".
OSG_EXPORT bool isGLExtensionSupported (unsigned int contextID, const char *extension)
 Return true if OpenGL "extension" is supported.
OSG_EXPORT bool isGLExtensionOrVersionSupported (unsigned int contextID, const char *extension, float requiredGlVersion)
 Return true if OpenGL "extension" or minimum OpenGL version number is supported.
OSG_EXPORT void * getGLExtensionFuncPtr (const char *funcName)
 Return the address of the specified OpenGL function.
OSG_EXPORT void setGLExtensionDisableString (const std::string &disableString)
 Set a list of extensions to disable for different OpenGL renderers.
OSG_EXPORT std::string & getGLExtensionDisableString ()
 Get the list of extensions that are disabled for various OpenGL renderers.
void * getGLExtensionFuncPtr (const char *funcName, const char *fallbackFuncName)
 Return the address of the specified OpenGL function.
void * getGLExtensionFuncPtr (const char *funcName1, const char *funcName2, const char *funcName3)
 Return the address of the specified OpenGL function.
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)
 Return true if OpenGL "extension" is supported.
OSG_EXPORT void flushDeletedGLObjects (unsigned int contextID, double currentTime, double &availableTime)
 Flush all deleted OpenGL objects within the specified availableTime.
OSG_EXPORT void flushAllDeletedGLObjects (unsigned int contextID)
 Flush all deleted OpenGL objects.
OSG_EXPORT void discardAllDeletedGLObjects (unsigned int contextID)
 Discard all deleted OpenGL objects.
OSG_EXPORT GeodecreateGeodeForImage (Image *image)
 Convenience function to be used by image loaders to generate a valid geode to return for readNode().
OSG_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 , 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)
 Compute the min max colour values in the image.
OSG_EXPORT bool offsetAndScaleImage (osg::Image *image, const osg::Vec4 &offset, const osg::Vec4 &scale)
 Compute the min max colour values in the image.
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)
 Compute source image to destination image.
OSG_EXPORT bool clearImageToColor (osg::Image *image, const osg::Vec4 &colour)
 Compute the min max colour values in the image.
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)
 return the minimum of two values, equivalent to std::min.
bool 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.
bool 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, equivalent to std::min.
template<typename T >
maximum (T lhs, T rhs)
 return the maximum of two values, equivalent 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 >
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)
 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.
OSG_EXPORT double asciiToDouble (const char *str)
 Convert a ascii number to a double, ignoring locale settings.
float asciiToFloat (const char *str)
 Convert a ascii number to a float, ignoring locale settings.
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)
 set the notify level, overriding the default or the value set by the environmental variable OSGNOTIFYLEVEL.
OSG_EXPORT NotifySeverity getNotifyLevel ()
 get the notify level.
OSG_EXPORT bool isNotifyEnabled (NotifySeverity severity)
 is notification enabled, given the current setNotifyLevel() setting?
OSG_EXPORT bool initNotifyLevel ()
 initialize notify level.
OSG_EXPORT std::ostream & notify (const NotifySeverity severity)
 notify messaging function for providing fatal through to verbose debugging messages.
std::ostream & notify (void)
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)
 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.
OSG_EXPORT Matrix 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.
OSG_EXPORT Matrix 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 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.
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 Vec3f &lhs, const Vec4d &rhs)
 Compute the dot product of a (Vec3,1.0) and a Vec4d.
Vec4d::value_type operator* (const Vec3d &lhs, const Vec4f &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).
Vec4d::value_type operator* (const Vec4d &lhs, const Vec3f &rhs)
 Compute the dot product of a Vec4d and a (Vec3,1.0).
Vec4d::value_type operator* (const Vec4f &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
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
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. 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 
)

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 
)

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 osg::CopyOp copyop = osg::CopyOp::SHALLOW_COPY 
)
template<typename T >
T* osg::clone ( const T *  t,
const std::string &  name,
const osg::CopyOp copyop = osg::CopyOp::SHALLOW_COPY 
)
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 &  a,
const T &  b,
const T &  c,
const T &  d 
) [inline]

compute the volume of a tetrahedron.

Referenced by computeVolume().

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

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

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.

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

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

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

References PI.

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

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.

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

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

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

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

References PI.

double osg::inDegrees ( double  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 ( float  v) [inline]
bool osg::isNaN ( double  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(), 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 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 
)
template<class M >
void osg::modifyRow ( unsigned int  num,
GLenum  pixelFormat,
GLenum  dataType,
unsigned char *  data,
const M &  operation 
)

References _modifyRow().

Referenced by modifyImage().

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 osgWidget::_notify(), osgViewer::GraphicsWindow::bindPBufferToTextureImplementation(), clampArrayElementBetweenRange(), clampArrayElementGEQUAL(), clampArrayElementLEQUAL(), clampBetweenRange(), clampGEQUAL(), clampLEQUAL(), osgViewer::GraphicsWindow::closeImplementation(), osgAnimation::TransformVertexFunctor::UniqBoneSetVertexSet::computeMatrixForVertexSet(), osgAnimation::RigTransformSoftware::UniqBoneSetVertexSet::computeMatrixForVertexSet(), osgUtil::CullVisitor::createOrReuseRenderLeaf(), osgWidget::NotifyWidget::focus(), osgAnimation::TemplateInterpolatorBase< TYPE, KEY >::getKeyIndexFromTime(), osgAnimation::CompositeMotion::getValueInNormalizedRange(), osgViewer::GraphicsWindow::grabFocus(), osgViewer::GraphicsWindow::grabFocusIfPointerInWindow(), osgAnimation::TransformVertexFunctor::init(), 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().

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

References INFO, and notify().

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.

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

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

Vec4f osg::operator* ( const Vec4f &  v,
const Matrixf &  m 
) [inline]
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::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 Vec4f &  rhs 
) [inline]

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

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

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

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

Compute the dot product of a Vec4f 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).

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

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

Vec3f osg::operator* ( const Vec3f &  v,
const Matrixd &  m 
) [inline]
Vec3d osg::operator* ( const Vec3d &  v,
const Matrixd &  m 
) [inline]
Vec4d osg::operator* ( const Vec4d &  v,
const Matrixd &  m 
) [inline]
Vec3f osg::operator* ( const Vec3f &  v,
const Matrixf &  m 
) [inline]
Vec3d osg::operator* ( const Vec3d &  v,
const Matrixf &  m 
) [inline]
Vec4d osg::operator* ( const Vec4d &  v,
const Matrixf &  m 
) [inline]
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec2b &  vec 
) [inline]

References osg::Vec2b::_v.

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

References osg::Vec4b::_v.

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

References osg::Vec4d::_v.

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

References osg::Vec3b::_v.

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

References osg::Vec3d::_v.

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

References osg::Quat::_v.

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

References osg::Vec3f::_v.

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

References osg::Vec2f::_v.

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

References osg::Vec4ub::_v.

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

References osg::Vec2s::_v.

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

References osg::Vec2d::_v.

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

References osg::Vec4s::_v.

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

References osg::Vec4f::_v.

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

References osg::Vec3s::_v.

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

References osg::Vec4s::_v.

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

References osg::Vec3f::_v.

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

References osg::Vec4f::_v.

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

References osg::Vec2s::_v.

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

References osg::Vec3d::_v.

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

References osg::Vec4d::_v.

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

References osg::Vec4ub::_v.

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

References osg::Vec2d::_v.

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

References osg::Vec3s::_v.

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

References osg::Quat::_v.

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

References osg::Vec2b::_v.

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

References osg::Vec2f::_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.

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 
)
template<class O >
void osg::readRow ( unsigned int  num,
GLenum  pixelFormat,
GLenum  dataType,
const unsigned char *  data,
O &  operation 
)

References _readRow().

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 
)
template<typename T >
bool osg::setGLExtensionFuncPtr ( T &  t,
const char *  str1,
const char *  str2 
)
template<typename T >
bool osg::setGLExtensionFuncPtr ( T &  t,
const char *  str1,
const char *  str2,
const char *  str3 
)
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]
template<class ValueT >
void osg::swap ( std::vector< ValueT > &  left,
MixinVector< ValueT > &  right 
) [inline]
template<class ValueT >
void osg::swap ( MixinVector< ValueT > &  left,
MixinVector< ValueT > &  right 
) [inline]
template<class ValueT >
void osg::swap ( MixinVector< ValueT > &  left,
std::vector< 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)

osg logo
Generated at Sun Jan 8 2012 13:16:03 for the OpenSceneGraph by doxygen 1.7.4.