openscenegraph
Classes | Typedefs | Enumerations | Functions | Variables
osg Namespace Reference

Classes

class  AlphaFunc
 
class  AnimationPath
 
class  AnimationPathCallback
 
class  ApplicationUsage
 
class  ApplicationUsageProxy
 
class  ArgumentParser
 
class  Array
 
class  ArrayDispatchers
 
class  ArrayVisitor
 
class  AtomicCounterBufferBinding
 
class  AtomicCounterBufferObject
 
struct  AttributeDispatch
 
class  AudioSink
 
class  AudioStream
 
class  AutoTransform
 
struct  BarrierOperation
 
class  Billboard
 
class  BlendColor
 
class  BlendEquation
 
class  BlendFunc
 
struct  BlockAndFlushOperation
 
class  BoundingBoxImpl
 
class  BoundingSphereImpl
 
class  Box
 
class  BufferData
 
class  buffered_object
 
class  buffered_value
 
class  BufferIndexBinding
 
class  BufferObject
 
class  BufferObjectProfile
 
class  Camera
 
struct  CameraRenderOrderSortOp
 
class  CameraView
 
class  Capsule
 
class  ClampColor
 
struct  ClampedLinearCostFunction1D
 
class  ClearNode
 
class  ClipNode
 
class  ClipPlane
 
class  ClusterCullingCallback
 
class  CollectOccludersVisitor
 
class  ColorMask
 
class  ColorMatrix
 
class  CompositeShape
 
class  ComputeBoundsVisitor
 
class  Cone
 
class  ConstArrayVisitor
 
class  ConstShapeVisitor
 
class  ConstValueVisitor
 
class  ConvexHull
 
class  ConvexPlanarOccluder
 
class  ConvexPlanarPolygon
 
class  CoordinateSystemNode
 
class  CopyOp
 
class  CullFace
 
class  CullingSet
 
class  CullSettings
 
class  CullStack
 
class  Cylinder
 
class  DefaultUserDataContainer
 
class  DeleteHandler
 
struct  depends_on
 
class  Depth
 
class  DisplaySettings
 
class  Drawable
 
class  DrawArrayLengths
 
class  DrawArrays
 
class  DrawElements
 
class  DrawElementsUByte
 
class  DrawElementsUInt
 
class  DrawElementsUShort
 
class  DrawPixels
 
class  ElapsedTime
 
class  ElementBufferObject
 
class  EllipsoidModel
 
class  EndOfDynamicDrawBlock
 
class  fast_back_stack
 
class  FBOExtensions
 
struct  FlushDeletedGLObjectsOperation
 
class  Fog
 
class  FragmentProgram
 
class  FrameBufferAttachment
 
class  FrameBufferObject
 
class  FrameStamp
 
class  FrontFace
 
class  Geode
 
class  Geometry
 
class  GeometryCostEstimator
 
class  GL2Extensions
 
class  GLBeginEndAdapter
 
class  GLBufferObject
 
class  GLBufferObjectManager
 
class  GLBufferObjectSet
 
class  GraphicsContext
 
class  GraphicsCostEstimator
 
struct  GraphicsOperation
 
class  GraphicsThread
 
class  Group
 
class  HeightField
 
class  Hint
 
class  Image
 
class  ImageSequence
 
class  ImageStream
 
class  IndexArray
 
class  InfinitePlane
 
class  KdTree
 
class  KdTreeBuilder
 
class  Light
 
class  LightModel
 
class  LightSource
 
class  LineSegment
 
class  LineStipple
 
class  LineWidth
 
class  LOD
 
class  LogicOp
 
class  Material
 
class  Matrix2Template
 
class  Matrix2x3Template
 
class  Matrix2x4Template
 
class  Matrix3Template
 
class  Matrix3x2Template
 
class  Matrix3x4Template
 
class  Matrix4x2Template
 
class  Matrix4x3Template
 
class  Matrixd
 
class  Matrixf
 
class  MatrixTemplate
 
class  MatrixTransform
 
class  MixinVector
 
class  Multisample
 
class  Node
 
class  NodeAcceptOp
 
class  NodeCallback
 
class  NodeTrackerCallback
 
class  NodeVisitor
 
class  NotifyHandler
 
class  Object
 
class  Observer
 
class  observer_ptr
 
class  ObserverNodePath
 
class  ObserverSet
 
class  OccluderNode
 
class  OcclusionQueryNode
 
class  Operation
 
class  OperationQueue
 
class  OperationThread
 
class  PagedLOD
 
class  PatchParameter
 
class  PixelBufferObject
 
class  PixelDataBufferObject
 
struct  PixelStorageModes
 
class  Plane
 A plane class. It can be used to represent an infinite plane. More...
 
class  Point
 
class  PointSprite
 
class  PolygonMode
 
class  PolygonOffset
 
class  PolygonStipple
 
class  Polytope
 
class  PositionAttitudeTransform
 
class  PrimitiveFunctor
 
class  PrimitiveIndexFunctor
 
class  PrimitiveRestartIndex
 
class  PrimitiveSet
 
class  Program
 
class  ProgramCostEstimator
 
class  Projection
 
class  ProxyNode
 
class  Quat
 
class  QueryGeometry
 
class  ref_ptr
 
class  RefBlock
 
class  RefBlockCount
 
class  Referenced
 
class  RefMatrixd
 
class  RefMatrixf
 
struct  ReleaseContext_Block_MakeCurrentOperation
 
class  RenderBuffer
 
class  RenderInfo
 
class  RunOperations
 
class  SampleMaski
 
class  Scissor
 
class  Sequence
 
class  ShadeModel
 
class  Shader
 
class  ShaderAttribute
 
class  ShaderBinary
 
class  ShaderComponent
 
class  ShaderComposer
 
class  ShadowVolumeOccluder
 
class  Shape
 
class  ShapeDrawable
 
class  ShapeVisitor
 
class  Sphere
 
class  StandardNotifyHandler
 
class  State
 
class  StateAttribute
 
class  StateAttributeCallback
 
class  StateSet
 
class  Stats
 
class  Stencil
 
class  StencilTwoSided
 
struct  SwapBuffersOperation
 
class  Switch
 
class  TemplateArray
 
class  TemplateIndexArray
 
class  TemplatePrimitiveFunctor
 
class  TemplateValueObject
 
class  TessellationHints
 
class  TestResult
 
class  TexEnv
 
class  TexEnvCombine
 
class  TexEnvFilter
 
class  TexGen
 
class  TexGenNode
 
class  TexMat
 
class  Texture
 
class  Texture1D
 
class  Texture2D
 
class  Texture2DArray
 
class  Texture2DMultisample
 
class  Texture3D
 
class  TextureBuffer
 
class  TextureCostEstimator
 
class  TextureCubeMap
 
class  TextureRectangle
 
class  Timer
 
class  TransferFunction
 
class  TransferFunction1D
 
class  Transform
 
class  TransformFeedbackBufferBinding
 
class  TriangleFunctor
 
class  TriangleIndexFunctor
 
class  TriangleMesh
 
class  Uniform
 
class  UniformBufferBinding
 
class  UniformBufferObject
 
class  UserDataContainer
 
class  ValueObject
 
struct  ValueObjectClassNameTrait
 
class  ValueVisitor
 
class  Vec2b
 
class  Vec2d
 
class  Vec2f
 
class  Vec2i
 
class  Vec2s
 
class  Vec2ub
 
class  Vec2ui
 
class  Vec2us
 
class  Vec3b
 
class  Vec3d
 
class  Vec3f
 
class  Vec3i
 
class  Vec3s
 
class  Vec3ub
 
class  Vec3ui
 
class  Vec3us
 
class  Vec4b
 
class  Vec4d
 
class  Vec4f
 
class  Vec4i
 
class  Vec4s
 
class  Vec4ub
 
class  Vec4ui
 
class  Vec4us
 
class  VertexAttribAlias
 
class  VertexBufferObject
 
class  VertexProgram
 
class  View
 
class  Viewport
 

Typedefs

typedef TemplateIndexArray< GLbyte, Array::ByteArrayType, 1, GL_BYTE > ByteArray
 
typedef TemplateIndexArray< GLshort, Array::ShortArrayType, 1, GL_SHORT > ShortArray
 
typedef TemplateIndexArray< GLint, Array::IntArrayType, 1, GL_INTIntArray
 
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_INTUIntArray
 
typedef TemplateArray< GLfloat, Array::FloatArrayType, 1, GL_FLOAT > FloatArray
 
typedef TemplateArray< GLdouble, Array::DoubleArrayType, 1, GL_DOUBLEDoubleArray
 
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< 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< Vec2i, Array::Vec2iArrayType, 2, GL_INTVec2iArray
 
typedef TemplateArray< Vec3i, Array::Vec3iArrayType, 3, GL_INTVec3iArray
 
typedef TemplateArray< Vec4i, Array::Vec4iArrayType, 4, GL_INTVec4iArray
 
typedef TemplateArray< Vec2ub, Array::Vec2ubArrayType, 2, GL_UNSIGNED_BYTE > Vec2ubArray
 
typedef TemplateArray< Vec3ub, Array::Vec3ubArrayType, 3, GL_UNSIGNED_BYTE > Vec3ubArray
 
typedef TemplateArray< Vec4ub, Array::Vec4ubArrayType, 4, GL_UNSIGNED_BYTE > Vec4ubArray
 
typedef TemplateArray< Vec2us, Array::Vec2usArrayType, 2, GL_UNSIGNED_SHORT > Vec2usArray
 
typedef TemplateArray< Vec3us, Array::Vec3usArrayType, 3, GL_UNSIGNED_SHORT > Vec3usArray
 
typedef TemplateArray< Vec4us, Array::Vec4usArrayType, 4, GL_UNSIGNED_SHORT > Vec4usArray
 
typedef TemplateArray< Vec2ui, Array::Vec2uiArrayType, 2, GL_UNSIGNED_INTVec2uiArray
 
typedef TemplateArray< Vec3ui, Array::Vec3uiArrayType, 3, GL_UNSIGNED_INTVec3uiArray
 
typedef TemplateArray< Vec4ui, Array::Vec4uiArrayType, 4, GL_UNSIGNED_INTVec4uiArray
 
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< Vec2d, Array::Vec2dArrayType, 2, GL_DOUBLEVec2dArray
 
typedef TemplateArray< Vec3d, Array::Vec3dArrayType, 3, GL_DOUBLEVec3dArray
 
typedef TemplateArray< Vec4d, Array::Vec4dArrayType, 4, GL_DOUBLEVec4dArray
 
typedef TemplateArray< Matrixf, Array::MatrixArrayType, 16, GL_FLOAT > MatrixfArray
 
typedef TemplateArray< Matrixd, Array::MatrixdArrayType, 16, GL_DOUBLEMatrixdArray
 
typedef BoundingBoxImpl< Vec3fBoundingBoxf
 
typedef BoundingBoxImpl< Vec3dBoundingBoxd
 
typedef BoundingBoxd BoundingBox
 
typedef BoundingSphereImpl< Vec3fBoundingSpheref
 
typedef BoundingSphereImpl< Vec3dBoundingSphered
 
typedef BoundingSphered BoundingSphere
 
typedef std::list< ref_ptr< GLBufferObject > > GLBufferObjectList
 
typedef Matrixd CoordinateFrame
 
typedef GLint level
 
typedef GLint GLenum internalFormat
 
typedef GLint GLenum GLsizei width
 
typedef GLint GLenum GLsizei GLsizei height
 
typedef GLint GLenum GLsizei GLsizei GLsizei depth
 
typedef GLint GLenum GLsizei GLsizei GLsizei GLint border
 
typedef GLint GLenum GLsizei GLsizei GLsizei GLint GLenum format
 
typedef GLint GLenum GLsizei GLsizei GLsizei GLint GLenum GLenum type
 
typedef GLint GLenum GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
 
typedef GLUtesselator GLUtesselatorObj
 
typedef GLUtesselator GLUtriangulatorObj
 
typedef void(GL_APIENTRY_GLUfuncptr) ()
 
typedef void(GL_APIENTRYGLU_TESS_CALLBACK) ()
 
typedef std::pair< double, double > CostPair
 
typedef std::vector< ref_ptr< Node > > NodeList
 
typedef std::vector< osg::ref_ptr< osg::Image > > ImageList
 
typedef Matrixd Matrix
 
typedef RefMatrixd RefMatrix
 
typedef std::vector< Node * > NodePath
 
typedef std::vector< NodePathNodePathList
 
typedef std::vector< MatrixMatrixList
 
typedef std::vector< osg::ref_ptr< osg::Node > > RefNodePath
 
typedef OperationThread OperationsThread
 
typedef MixinVector< GLsizei > VectorGLsizei
 
typedef MixinVector< GLubyte > VectorGLubyte
 
typedef MixinVector< GLushort > VectorGLushort
 
typedef MixinVector< GLuint > VectorGLuint
 
typedef std::vector< osg::ShaderComponent * > ShaderComponents
 
typedef std::vector< ShadowVolumeOccluderShadowVolumeOccluderList
 
typedef HeightField Grid
 
typedef unsigned long long Timer_t
 
typedef Matrix2Template< float > Matrix2
 
typedef Matrix2x3Template< float > Matrix2x3
 
typedef Matrix2x4Template< float > Matrix2x4
 
typedef Matrix3x2Template< float > Matrix3x2
 
typedef Matrix3Template< float > Matrix3
 
typedef Matrix3x4Template< float > Matrix3x4
 
typedef Matrix4x2Template< float > Matrix4x2
 
typedef Matrix4x3Template< float > Matrix4x3
 
typedef Matrix2Template< double > Matrix2d
 
typedef Matrix2x3Template< double > Matrix2x3d
 
typedef Matrix2x4Template< double > Matrix2x4d
 
typedef Matrix3x2Template< double > Matrix3x2d
 
typedef Matrix3Template< double > Matrix3d
 
typedef Matrix3x4Template< double > Matrix3x4d
 
typedef Matrix4x2Template< double > Matrix4x2d
 
typedef Matrix4x3Template< double > Matrix4x3d
 
typedef Vec2f Vec2
 
typedef Vec3f Vec3
 
typedef Vec4f Vec4
 

Enumerations

enum  Endian { BigEndian, LittleEndian }
 
enum  ColorSpaceOperation {
  NO_COLOR_SPACE_OPERATION, MODULATE_ALPHA_BY_LUMINANCE, MODULATE_ALPHA_BY_COLOR, REPLACE_ALPHA_WITH_LUMINANCE,
  REPLACE_RGB_WITH_LUMINANCE
}
 
enum  NotifySeverity {
  ALWAYS =0, FATAL =1, WARN =2, NOTICE =3,
  INFO =4, DEBUG_INFO =5, DEBUG_FP =6
}
 

Functions

osg::Array::Binding getBinding (const osg::Array *array)
 
bool getNormalize (const osg::Array *array)
 
template<typename T >
void clampGEQUAL (T &value, const T minValue, const char *valueName)
 
template<typename T >
void clampLEQUAL (T &value, const T maxValue, const char *valueName)
 
template<typename T >
void clampBetweenRange (T &value, const T minValue, const T maxValue, const char *valueName)
 
template<typename A , typename T >
void clampArrayElementGEQUAL (A &value, unsigned int i, const T minValue, const char *valueName)
 
template<typename A , typename T >
void clampArrayElementLEQUAL (A &value, unsigned int i, const T maxValue, const char *valueName)
 
template<typename A , typename T >
void clampArrayElementBetweenRange (A &value, unsigned int i, const T minValue, const T maxValue, const char *valueName)
 
template<typename A , typename T >
void clampArrayElementsGEQUAL (A &value, unsigned int first, unsigned int last, const T minValue, const char *valueName)
 
template<typename A , typename T >
void clampArrayElementsLEQUAL (A &value, unsigned int first, unsigned int last, const T maxValue, const char *valueName)
 
template<typename A , typename T >
void clampArrayElementsBetweenRange (A &value, unsigned int first, unsigned int last, const T minValue, const T maxValue, const char *valueName)
 
template<typename A , typename T >
void clampArray3GEQUAL (A &value, const T minValue, const char *valueName)
 
template<typename A , typename T >
void clampArray3LEQUAL (A &value, const T maxValue, const char *valueName)
 
template<typename A , typename T >
void clampArray3BetweenRange (A &value, const T minValue, const T maxValue, const char *valueName)
 
template<typename A , typename T >
void clampArray4GEQUAL (A &value, const T minValue, const char *valueName)
 
template<typename A , typename T >
void clampArray4LEQUAL (A &value, const T maxValue, const char *valueName)
 
template<typename A , typename T >
void clampArray4BetweenRange (A &value, const T minValue, const T maxValue, const char *valueName)
 
Endian getCpuByteOrder ()
 
void swapBytes (char *in, unsigned int size)
 
void swapBytes2 (char *in)
 
void swapBytes4 (char *in)
 
void swapBytes8 (char *in)
 
void swapBytes16 (char *in)
 
template<typename T >
void swapBytes (T &t)
 
OSG_EXPORT GeometrycreateTexturedQuadGeometry (const Vec3 &corner, const Vec3 &widthVec, const Vec3 &heightVec, float l, float b, float r, float t)
 
GeometrycreateTexturedQuadGeometry (const Vec3 &corner, const Vec3 &widthVec, const Vec3 &heightVec, float s=1.0f, float t=1.0f)
 
OSG_EXPORT float getGLVersionNumber ()
 
OSG_EXPORT bool isExtensionInExtensionString (const char *extension, const char *extensionString)
 
OSG_EXPORT bool isGLExtensionSupported (unsigned int contextID, const char *extension)
 
OSG_EXPORT bool isGLExtensionOrVersionSupported (unsigned int contextID, const char *extension, float requiredGlVersion)
 
OSG_EXPORT voidgetGLExtensionFuncPtr (const char *funcName)
 
OSG_EXPORT void setGLExtensionDisableString (const std::string &disableString)
 
OSG_EXPORT std::string & getGLExtensionDisableString ()
 
voidgetGLExtensionFuncPtr (const char *funcName, const char *fallbackFuncName)
 
voidgetGLExtensionFuncPtr (const char *funcName1, const char *funcName2, const char *funcName3)
 
template<typename T , typename R >
convertPointerType (R src)
 
template<typename T >
bool setGLExtensionFuncPtr (T &t, const char *str1)
 
template<typename T >
bool setGLExtensionFuncPtr (T &t, const char *str1, const char *str2)
 
template<typename T >
bool setGLExtensionFuncPtr (T &t, const char *str1, const char *str2, const char *str3)
 
OSG_EXPORT void flushDeletedGLObjects (unsigned int contextID, double currentTime, double &availableTime)
 
OSG_EXPORT void flushAllDeletedGLObjects (unsigned int contextID)
 
OSG_EXPORT void deleteAllGLObjects (unsigned int contextID)
 
OSG_EXPORT void discardAllGLObjects (unsigned int contextID)
 
OSG_EXPORT const GLubyte * gluErrorString (GLenum error)
 
OSG_EXPORT GLint gluScaleImage (PixelStorageModes *psm, GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void *dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid *dataOut)
 
OSG_EXPORT GLint gluScaleImage (GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void *dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid *dataOut)
 
OSG_EXPORT GLint gluBuild1DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data)
 
OSG_EXPORT GLint gluBuild1DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void *data)
 
OSG_EXPORT GLint gluBuild2DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data)
 
OSG_EXPORT GLint gluBuild2DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *data)
 
typedef void (GL_APIENTRY *GLTexImage3DProc)(GLenum target
 
OSG_EXPORT GLint gluBuild3DMipmapLevels (GLTexImage3DProc glTextImage3DProc, GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data)
 
OSG_EXPORT GLint gluBuild3DMipmaps (GLTexImage3DProc glTextImage3DProc, GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)
 
OSG_EXPORT GLUtesselator *GL_APIENTRY gluNewTess (void)
 
OSG_EXPORT void GL_APIENTRY gluDeleteTess (GLUtesselator *tess)
 
OSG_EXPORT void GL_APIENTRY gluTessBeginContour (GLUtesselator *tess)
 
OSG_EXPORT void GL_APIENTRY gluTessCallback (GLUtesselator *tess, GLenum which, _GLUfuncptr CallBackFunc)
 
OSG_EXPORT void GL_APIENTRY gluTessEndContour (GLUtesselator *tess)
 
OSG_EXPORT void GL_APIENTRY gluTessNormal (GLUtesselator *tess, GLdouble valueX, GLdouble valueY, GLdouble valueZ)
 
OSG_EXPORT void GL_APIENTRY gluTessProperty (GLUtesselator *tess, GLenum which, GLdouble data)
 
OSG_EXPORT void GL_APIENTRY gluTessVertex (GLUtesselator *tess, GLdouble *location, GLvoid *data)
 
OSG_EXPORT void GL_APIENTRY gluTessBeginPolygon (GLUtesselator *tess, GLvoid *data)
 
OSG_EXPORT void GL_APIENTRY gluTessEndPolygon (GLUtesselator *tess)
 
OSG_EXPORT void GL_APIENTRY gluGetTessProperty (GLUtesselator *tess, GLenum which, GLdouble *value)
 
OSG_EXPORT GeodecreateGeodeForImage (Image *image)
 
OSG_EXPORT GeodecreateGeodeForImage (Image *image, float s, float t)
 
template<typename T , class O >
void _readRow (unsigned int num, GLenum pixelFormat, const T *data, float scale, O &operation)
 
template<class O >
void readRow (unsigned int num, GLenum pixelFormat, GLenum dataType, const unsigned char *data, O &operation)
 
template<class O >
void readImage (const osg::Image *image, O &operation)
 
template<typename T , class M >
void _modifyRow (unsigned int num, GLenum pixelFormat, T *data, float scale, const M &operation)
 
template<class M >
void modifyRow (unsigned int num, GLenum pixelFormat, GLenum dataType, unsigned char *data, const M &operation)
 
template<class M >
void modifyImage (osg::Image *image, const M &operation)
 
OSG_EXPORT bool computeMinMax (const osg::Image *image, osg::Vec4 &min, osg::Vec4 &max)
 
OSG_EXPORT bool offsetAndScaleImage (osg::Image *image, const osg::Vec4 &offset, const osg::Vec4 &scale)
 
OSG_EXPORT bool copyImage (const osg::Image *srcImage, int src_s, int src_t, int src_r, int width, int height, int depth, osg::Image *destImage, int dest_s, int dest_t, int dest_r, bool doRescale=false)
 
OSG_EXPORT bool clearImageToColor (osg::Image *image, const osg::Vec4 &colour)
 
OSG_EXPORT unsigned int maximimNumOfComponents (const ImageList &imageList)
 
OSG_EXPORT osg::ImagecreateImage3D (const ImageList &imageList, GLenum desiredPixelFormat, int s_maximumImageSize=1024, int t_maximumImageSize=1024, int r_maximumImageSize=1024, bool resizeToPowerOfTwo=false)
 
OSG_EXPORT osg::ImagecreateImage3DWithAlpha (const ImageList &imageList, int s_maximumImageSize=1024, int t_maximumImageSize=1024, int r_maximumImageSize=1024, bool resizeToPowerOfTwo=false)
 
OSG_EXPORT osg::ImagecreateSpotLightImage (const osg::Vec4 &centerColour, const osg::Vec4 &backgroudColour, unsigned int size, float power)
 
OSG_EXPORT osg::ImagecolorSpaceConversion (ColorSpaceOperation op, osg::Image *image, const osg::Vec4 &colour)
 
std::ostream & operator<< (std::ostream &output, const Vec2f &vec)
 
std::istream & operator>> (std::istream &input, Vec2f &vec)
 
std::ostream & operator<< (std::ostream &output, const Vec2d &vec)
 
std::istream & operator>> (std::istream &input, Vec2d &vec)
 
std::ostream & operator<< (std::ostream &output, const Vec3f &vec)
 
std::istream & operator>> (std::istream &input, Vec3f &vec)
 
std::ostream & operator<< (std::ostream &output, const Vec3d &vec)
 
std::istream & operator>> (std::istream &input, Vec3d &vec)
 
std::ostream & operator<< (std::ostream &output, const Vec4f &vec)
 
std::istream & operator>> (std::istream &input, Vec4f &vec)
 
std::ostream & operator<< (std::ostream &output, const Vec4d &vec)
 
std::istream & operator>> (std::istream &input, Vec4d &vec)
 
std::ostream & operator<< (std::ostream &output, const Vec2b &vec)
 
std::istream & operator>> (std::istream &input, Vec2b &vec)
 
std::ostream & operator<< (std::ostream &output, const Vec3b &vec)
 
std::istream & operator>> (std::istream &input, Vec3b &vec)
 
std::ostream & operator<< (std::ostream &output, const Vec4b &vec)
 
std::istream & operator>> (std::istream &input, Vec4b &vec)
 
std::ostream & operator<< (std::ostream &output, const Vec2s &vec)
 
std::istream & operator>> (std::istream &input, Vec2s &vec)
 
std::ostream & operator<< (std::ostream &output, const Vec3s &vec)
 
std::istream & operator>> (std::istream &input, Vec3s &vec)
 
std::ostream & operator<< (std::ostream &output, const Vec4s &vec)
 
std::istream & operator>> (std::istream &input, Vec4s &vec)
 
std::ostream & operator<< (std::ostream &os, const Matrixf &m)
 
std::ostream & operator<< (std::ostream &os, const Matrixd &m)
 
std::ostream & operator<< (std::ostream &output, const Vec4ub &vec)
 
std::istream & operator>> (std::istream &input, Vec4ub &vec)
 
std::ostream & operator<< (std::ostream &output, const Quat &vec)
 
std::istream & operator>> (std::istream &input, Quat &vec)
 
std::ostream & operator<< (std::ostream &output, const Plane &pl)
 
std::istream & operator>> (std::istream &input, Plane &vec)
 
template<typename T >
absolute (T v)
 
bool equivalent (float lhs, float rhs, float epsilon=1e-6)
 
bool equivalent (double lhs, double rhs, double epsilon=1e-6)
 
template<typename T >
minimum (T lhs, T rhs)
 
template<typename T >
maximum (T lhs, T rhs)
 
template<typename T >
clampTo (T v, T minimum, T maximum)
 
template<typename T >
clampAbove (T v, T minimum)
 
template<typename T >
clampBelow (T v, T maximum)
 
template<typename T >
clampBetween (T v, T minimum, T maximum)
 
template<typename T >
sign (T v)
 
template<typename T >
signOrZero (T v)
 
template<typename T >
square (T v)
 
template<typename T >
signedSquare (T v)
 
float inDegrees (float angle)
 
double inDegrees (double angle)
 
template<typename T >
inRadians (T angle)
 
float DegreesToRadians (float angle)
 
double DegreesToRadians (double angle)
 
float RadiansToDegrees (float angle)
 
double RadiansToDegrees (double angle)
 
float round (float v)
 
double round (double v)
 
bool isNaN (float v)
 
bool isNaN (double v)
 
template<typename T >
float computeVolume (const T &a, const T &b, const T &c, const T &d)
 
template<typename T >
float computeVolume (const T &f1, const T &f2, const T &f3, const T &b1, const T &b2, const T &b3)
 
OSG_EXPORT double asciiToDouble (const char *str)
 
float asciiToFloat (const char *str)
 
OSG_EXPORT double findAsciiToDouble (const char *str)
 
float findAsciiToFloat (const char *str)
 
Vec3f operator* (const Vec3f &v, const Matrixd &m)
 
Vec3d operator* (const Vec3d &v, const Matrixd &m)
 
Vec4f operator* (const Vec4f &v, const Matrixd &m)
 
Vec4d operator* (const Vec4d &v, const Matrixd &m)
 
Vec3f operator* (const Vec3f &v, const Matrixf &m)
 
Vec3d operator* (const Vec3d &v, const Matrixf &m)
 
Vec4f operator* (const Vec4f &v, const Matrixf &m)
 
Vec4d operator* (const Vec4d &v, const Matrixf &m)
 
template<class ValueT >
void swap (MixinVector< ValueT > &left, MixinVector< ValueT > &right)
 
template<class ValueT >
void swap (MixinVector< ValueT > &left, std::vector< ValueT > &right)
 
template<class ValueT >
void swap (std::vector< ValueT > &left, MixinVector< ValueT > &right)
 
OSG_EXPORT void setNotifyLevel (NotifySeverity severity)
 
OSG_EXPORT NotifySeverity getNotifyLevel ()
 
OSG_EXPORT bool initNotifyLevel ()
 
OSG_EXPORT bool isNotifyEnabled (NotifySeverity severity)
 
OSG_EXPORT std::ostream & notify (const NotifySeverity severity)
 
std::ostream & notify (void)
 
OSG_EXPORT void setNotifyHandler (NotifyHandler *handler)
 
OSG_EXPORT NotifyHandlergetNotifyHandler ()
 
template<typename T >
T * clone (const T *t, const osg::CopyOp &copyop=osg::CopyOp::SHALLOW_COPY)
 
template<typename T >
T * clone (const T *t, const std::string &name, const osg::CopyOp &copyop=osg::CopyOp::SHALLOW_COPY)
 
template<typename T >
T * cloneType (const T *t)
 
osg::StateSetinitOQState ()
 
osg::StateSetinitOQDebugState ()
 
template<class T >
void swap (ref_ptr< T > &rp1, ref_ptr< T > &rp2)
 
template<class T >
T * get_pointer (const ref_ptr< T > &rp)
 
template<class T , class Y >
ref_ptr< T > static_pointer_cast (const ref_ptr< Y > &rp)
 
template<class T , class Y >
ref_ptr< T > dynamic_pointer_cast (const ref_ptr< Y > &rp)
 
template<class T , class Y >
ref_ptr< T > const_pointer_cast (const ref_ptr< Y > &rp)
 
void intrusive_ptr_add_ref (Referenced *p)
 
void intrusive_ptr_release (Referenced *p)
 
OSG_EXPORT bool isTextureMode (StateAttribute::GLMode mode)
 
OSG_EXPORT Matrix computeLocalToWorld (const NodePath &nodePath, bool ignoreCameras=true)
 
OSG_EXPORT Matrix computeWorldToLocal (const NodePath &nodePath, bool ignoreCameras=true)
 
OSG_EXPORT Matrix computeLocalToEye (const Matrix &modelview, const NodePath &nodePath, bool ignoreCameras=true)
 
OSG_EXPORT Matrix computeEyeToLocal (const Matrix &modelview, const NodePath &nodePath, bool ignoreCameras=true)
 
 META_ValueObject (std::string, StringValueObject) META_ValueObject(bool
 
BoolValueObject META_ValueObject (char, CharValueObject) META_ValueObject(unsigned char
 
BoolValueObject UCharValueObject META_ValueObject (short, ShortValueObject) META_ValueObject(unsigned short
 
BoolValueObject UCharValueObject UShortValueObject META_ValueObject (int, IntValueObject) META_ValueObject(unsigned int
 
BoolValueObject UCharValueObject UShortValueObject UIntValueObject META_ValueObject (float, FloatValueObject) META_ValueObject(double
 
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject META_ValueObject (Vec2f, Vec2fValueObject) META_ValueObject(Vec3f
 
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject Vec3fValueObject META_ValueObject (Vec4f, Vec4fValueObject) META_ValueObject(Vec2d
 
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject Vec3fValueObject Vec2dValueObject META_ValueObject (Vec3d, Vec3dValueObject) META_ValueObject(Vec4d
 
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject Vec3fValueObject Vec2dValueObject Vec4dValueObject META_ValueObject (Quat, QuatValueObject) META_ValueObject(Plane
 
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject Vec3fValueObject Vec2dValueObject Vec4dValueObject PlaneValueObject META_ValueObject (Matrixf, MatrixfValueObject) META_ValueObject(Matrixd
 
Vec2d componentMultiply (const Vec2d &lhs, const Vec2d &rhs)
 
Vec2d componentDivide (const Vec2d &lhs, const Vec2d &rhs)
 
Vec2f componentMultiply (const Vec2f &lhs, const Vec2f &rhs)
 
Vec2f componentDivide (const Vec2f &lhs, const Vec2f &rhs)
 
Vec2s componentMultiply (const Vec2s &lhs, const Vec2s &rhs)
 
Vec2s componentDivide (const Vec2s &lhs, const Vec2s &rhs)
 
Vec2ub componentMultiply (const Vec2ub &lhs, const Vec2ub &rhs)
 
Vec2ub componentDivide (const Vec2ub &lhs, const Vec2ub &rhs)
 
Vec2us componentMultiply (const Vec2us &lhs, const Vec2us &rhs)
 
Vec2us componentDivide (const Vec2us &lhs, const Vec2us &rhs)
 
Vec3d componentMultiply (const Vec3d &lhs, const Vec3d &rhs)
 
Vec3d componentDivide (const Vec3d &lhs, const Vec3d &rhs)
 
Vec3f componentMultiply (const Vec3f &lhs, const Vec3f &rhs)
 
Vec3f componentDivide (const Vec3f &lhs, const Vec3f &rhs)
 
Vec3s componentMultiply (const Vec3s &lhs, const Vec3s &rhs)
 
Vec3s componentDivide (const Vec3s &lhs, const Vec3s &rhs)
 
Vec3ub componentMultiply (const Vec3ub &lhs, const Vec3ub &rhs)
 
Vec3ub componentDivide (const Vec3ub &lhs, const Vec3ub &rhs)
 
Vec3us componentMultiply (const Vec3us &lhs, const Vec3us &rhs)
 
Vec3us componentDivide (const Vec3us &lhs, const Vec3us &rhs)
 
Vec4d::value_type operator* (const Vec3d &lhs, const Vec4d &rhs)
 
Vec4d::value_type operator* (const Vec3f &lhs, const Vec4d &rhs)
 
Vec4d::value_type operator* (const Vec3d &lhs, const Vec4f &rhs)
 
Vec4d::value_type operator* (const Vec4d &lhs, const Vec3d &rhs)
 
Vec4d::value_type operator* (const Vec4d &lhs, const Vec3f &rhs)
 
Vec4d::value_type operator* (const Vec4f &lhs, const Vec3d &rhs)
 
Vec4d componentMultiply (const Vec4d &lhs, const Vec4d &rhs)
 
Vec4d componentDivide (const Vec4d &lhs, const Vec4d &rhs)
 
Vec4f::value_type operator* (const Vec3f &lhs, const Vec4f &rhs)
 
Vec4f::value_type operator* (const Vec4f &lhs, const Vec3f &rhs)
 
Vec4f componentMultiply (const Vec4f &lhs, const Vec4f &rhs)
 
Vec4f componentDivide (const Vec4f &lhs, const Vec4f &rhs)
 
Vec4s componentMultiply (const Vec4s &lhs, const Vec4s &rhs)
 
Vec4s componentDivide (const Vec4s &lhs, const Vec4s &rhs)
 
Vec4us componentMultiply (const Vec4us &lhs, const Vec4us &rhs)
 
Vec4us componentDivide (const Vec4us &lhs, const Vec4us &rhs)
 

Variables

const double WGS_84_RADIUS_EQUATOR = 6378137.0
 
const double WGS_84_RADIUS_POLAR = 6356752.3142
 
const double PI = 3.14159265358979323846
 
const double PI_2 = 1.57079632679489661923
 
const double PI_4 = 0.78539816339744830962
 
const double LN_2 = 0.69314718055994530942
 
const double INVLN_2 = 1.0 / LN_2
 
const unsigned int UNINITIALIZED_FRAME_NUMBER =0xffffffff
 
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 void(GL_APIENTRY * osg::_GLUfuncptr) ()
typedef GLint GLenum GLsizei GLsizei GLsizei GLint osg::border

CoordinateFrame encapsulates the orientation of east, north and up.

typedef std::pair<double, double> osg::CostPair

Pair of double representing CPU and GPU times in seconds as first and second elements in std::pair.

typedef GLint GLenum GLsizei GLsizei GLsizei osg::depth
typedef GLint GLenum GLsizei GLsizei GLsizei GLint GLenum osg::format
typedef void(GL_APIENTRY * osg::GLU_TESS_CALLBACK) ()
typedef GLUtesselator osg::GLUtesselatorObj
typedef GLUtesselator osg::GLUtriangulatorObj
typedef GLint GLenum GLsizei GLsizei osg::height
typedef std::vector< osg::ref_ptr<osg::Image> > osg::ImageList
typedef GLint GLenum osg::internalFormat
typedef GLint osg::level
typedef Matrix2Template<float> osg::Matrix2
typedef Matrix2Template<double> osg::Matrix2d
typedef Matrix3Template<float> osg::Matrix3
typedef Matrix3Template<double> osg::Matrix3d
typedef std::vector< Matrix > osg::MatrixList

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

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

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

typedef std::vector< NodePath > osg::NodePathList

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

typedef GLint GLenum GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid* osg::pixels
typedef std::vector< osg::ref_ptr<osg::Node> > osg::RefNodePath

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

typedef unsigned long long osg::Timer_t
typedef GLint GLenum GLsizei GLsizei GLsizei GLint GLenum GLenum osg::type
typedef TemplateIndexArray<GLubyte,Array::UByteArrayType,1,GL_UNSIGNED_BYTE> osg::UByteArray
typedef TemplateIndexArray<GLushort,Array::UShortArrayType,1,GL_UNSIGNED_SHORT> osg::UShortArray
typedef Vec2f osg::Vec2
typedef Vec3f osg::Vec3
typedef Vec4f osg::Vec4
typedef MixinVector<GLsizei> osg::VectorGLsizei
typedef MixinVector<GLubyte> osg::VectorGLubyte
typedef MixinVector<GLuint> osg::VectorGLuint
typedef MixinVector<GLushort> osg::VectorGLushort
typedef GLint GLenum GLsizei osg::width

Enumeration Type Documentation

Enumerator
NO_COLOR_SPACE_OPERATION 
MODULATE_ALPHA_BY_LUMINANCE 
MODULATE_ALPHA_BY_COLOR 
REPLACE_ALPHA_WITH_LUMINANCE 
REPLACE_RGB_WITH_LUMINANCE 
Enumerator
BigEndian 
LittleEndian 

Range of notify levels from DEBUG_FP through to FATAL, ALWAYS is reserved for forcing the absorption of all messages. The keywords are also used verbatim when specified by the environmental variable OSGNOTIFYLEVEL or OSG_NOTIFY_LEVEL. See documentation on osg::notify() for further details.

Enumerator
ALWAYS 
FATAL 
WARN 
NOTICE 
INFO 
DEBUG_INFO 
DEBUG_FP 

Function Documentation

template<typename T , class M >
void osg::_modifyRow ( unsigned int  num,
GLenum  pixelFormat,
T *  data,
float  scale,
const M &  operation 
)
template<typename T , class O >
void osg::_readRow ( unsigned int  num,
GLenum  pixelFormat,
const T *  data,
float  scale,
O &  operation 
)
template<typename T >
T osg::absolute ( v)
inline
OSG_EXPORT double osg::asciiToDouble ( const char *  str)

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

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

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

template<typename T >
T osg::clampAbove ( v,
minimum 
)
inline
template<typename A , typename T >
void osg::clampArray3BetweenRange ( A &  value,
const T  minValue,
const T  maxValue,
const char *  valueName 
)
inline

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

template<typename A , typename T >
void osg::clampArray3GEQUAL ( A &  value,
const T  minValue,
const char *  valueName 
)
inline

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

template<typename A , typename T >
void osg::clampArray3LEQUAL ( A &  value,
const T  maxValue,
const char *  valueName 
)
inline

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

template<typename A , typename T >
void osg::clampArray4BetweenRange ( A &  value,
const T  minValue,
const T  maxValue,
const char *  valueName 
)
inline

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

template<typename A , typename T >
void osg::clampArray4GEQUAL ( A &  value,
const T  minValue,
const char *  valueName 
)
inline

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

template<typename A , typename T >
void osg::clampArray4LEQUAL ( A &  value,
const T  maxValue,
const char *  valueName 
)
inline

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

template<typename A , typename T >
void osg::clampArrayElementBetweenRange ( A &  value,
unsigned int  i,
const T  minValue,
const T  maxValue,
const char *  valueName 
)
inline

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

template<typename A , typename T >
void osg::clampArrayElementGEQUAL ( A &  value,
unsigned int  i,
const T  minValue,
const char *  valueName 
)
inline

If value[i] is greater than or equal to minValue do nothing - legal value, Otherwise set value[i] to minValue, and warn that valueName[i] was clamped. Note this is effectively A[i]=max(A[i],B).

template<typename A , typename T >
void osg::clampArrayElementLEQUAL ( A &  value,
unsigned int  i,
const T  maxValue,
const char *  valueName 
)
inline

If value[i] is less than or equal to maxValue do nothing - legal value, Otherwise set value[i] to maxValue, and warn that valueName[i] was clamped. Note this is effectively A[i]=min(A[i],B).

template<typename A , typename T >
void osg::clampArrayElementsBetweenRange ( A &  value,
unsigned int  first,
unsigned int  last,
const T  minValue,
const T  maxValue,
const char *  valueName 
)
inline

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

template<typename A , typename T >
void osg::clampArrayElementsGEQUAL ( A &  value,
unsigned int  first,
unsigned int  last,
const T  minValue,
const char *  valueName 
)
inline

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

template<typename A , typename T >
void osg::clampArrayElementsLEQUAL ( A &  value,
unsigned int  first,
unsigned int  last,
const T  maxValue,
const char *  valueName 
)
inline

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

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

template<typename T >
void osg::clampGEQUAL ( T &  value,
const T  minValue,
const char *  valueName 
)
inline

If value is greater than or equal to minValue do nothing - legal value, Otherwise set value to minValue, and warn that valueName was clamped. Note this is effectively A=max(A,B).

template<typename T >
void osg::clampLEQUAL ( T &  value,
const T  maxValue,
const char *  valueName 
)
inline

If value is less than or equal to maxValue do nothing - legal value, Otherwise set value to maxValue, and warn that valueName was clamped. Note this is effectively A=min(A,B).

template<typename T >
T osg::clampTo ( 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 
)
template<typename T >
T* osg::cloneType ( const T *  t)
OSG_EXPORT osg::Image* osg::colorSpaceConversion ( ColorSpaceOperation  op,
osg::Image image,
const osg::Vec4 colour 
)

Convert the RGBA values in a Image based on a ColorSpaceOperation defined scheme.

Vec2us osg::componentDivide ( const Vec2us lhs,
const Vec2us rhs 
)
inline

divide rhs components by rhs vector components.

Vec2s osg::componentDivide ( const Vec2s lhs,
const Vec2s rhs 
)
inline

divide rhs components by rhs vector components.

Vec2ub osg::componentDivide ( const Vec2ub lhs,
const Vec2ub rhs 
)
inline

divide rhs components by rhs vector components.

Vec3us osg::componentDivide ( const Vec3us lhs,
const Vec3us rhs 
)
inline

divide rhs components by rhs vector components.

Vec3s osg::componentDivide ( const Vec3s lhs,
const Vec3s rhs 
)
inline

divide rhs components by rhs vector components.

Vec3ub osg::componentDivide ( const Vec3ub lhs,
const Vec3ub rhs 
)
inline

divide rhs components by rhs vector components.

Vec4us osg::componentDivide ( const Vec4us lhs,
const Vec4us rhs 
)
inline

divide rhs components by rhs vector components.

Vec2f osg::componentDivide ( const Vec2f lhs,
const Vec2f rhs 
)
inline

divide rhs components by rhs vector components.

Vec4s osg::componentDivide ( const Vec4s lhs,
const Vec4s rhs 
)
inline

divide rhs components by rhs vector components.

Vec2d osg::componentDivide ( const Vec2d lhs,
const Vec2d rhs 
)
inline

divide rhs components by rhs vector components.

Vec3f osg::componentDivide ( const Vec3f lhs,
const Vec3f rhs 
)
inline

divide rhs components by rhs vector components.

Vec3d osg::componentDivide ( const Vec3d lhs,
const Vec3d rhs 
)
inline

divide rhs components by rhs vector components.

Vec4f osg::componentDivide ( const Vec4f lhs,
const Vec4f rhs 
)
inline

divide rhs components by rhs vector components.

Vec4d osg::componentDivide ( const Vec4d lhs,
const Vec4d rhs 
)
inline

divide rhs components by rhs vector components.

Vec2us osg::componentMultiply ( const Vec2us lhs,
const Vec2us rhs 
)
inline

multiply by vector components.

Vec2s osg::componentMultiply ( const Vec2s lhs,
const Vec2s rhs 
)
inline

multiply by vector components.

Vec2ub osg::componentMultiply ( const Vec2ub lhs,
const Vec2ub rhs 
)
inline

multiply by vector components.

Vec3us osg::componentMultiply ( const Vec3us lhs,
const Vec3us rhs 
)
inline

multiply by vector components.

Vec3s osg::componentMultiply ( const Vec3s lhs,
const Vec3s rhs 
)
inline

multiply by vector components.

Vec3ub osg::componentMultiply ( const Vec3ub lhs,
const Vec3ub rhs 
)
inline

multiply by vector components.

Vec4us osg::componentMultiply ( const Vec4us lhs,
const Vec4us rhs 
)
inline

multiply by vector components.

Vec2f osg::componentMultiply ( const Vec2f lhs,
const Vec2f rhs 
)
inline

multiply by vector components.

Vec4s osg::componentMultiply ( const Vec4s lhs,
const Vec4s rhs 
)
inline

multiply by vector components.

Vec2d osg::componentMultiply ( const Vec2d lhs,
const Vec2d rhs 
)
inline

multiply by vector components.

Vec3f osg::componentMultiply ( const Vec3f lhs,
const Vec3f rhs 
)
inline

multiply by vector components.

Vec3d osg::componentMultiply ( const Vec3d lhs,
const Vec3d rhs 
)
inline

multiply by vector components.

Vec4f osg::componentMultiply ( const Vec4f lhs,
const Vec4f rhs 
)
inline

multiply by vector components.

Vec4d osg::componentMultiply ( const Vec4d lhs,
const Vec4d rhs 
)
inline

multiply by vector components.

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.

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.

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.

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.

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 osg::Image* osg::createImage3D ( const ImageList imageList,
GLenum  desiredPixelFormat,
int  s_maximumImageSize = 1024,
int  t_maximumImageSize = 1024,
int  r_maximumImageSize = 1024,
bool  resizeToPowerOfTwo = false 
)

create a 3D osg::Image from a list of osg::Image.

OSG_EXPORT osg::Image* osg::createImage3DWithAlpha ( const ImageList imageList,
int  s_maximumImageSize = 1024,
int  t_maximumImageSize = 1024,
int  r_maximumImageSize = 1024,
bool  resizeToPowerOfTwo = false 
)

create a 3D osg::Image from a list of osg::Image.

OSG_EXPORT osg::Image* osg::createSpotLightImage ( const osg::Vec4 centerColour,
const osg::Vec4 backgroudColour,
unsigned int  size,
float  power 
)

create a 2D osg::Image that provides a point at the center of the image. The colour across th image is computed from a balance between the center color and the background color controlled by the power of the radius from the center.

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

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

float osg::DegreesToRadians ( float  angle)
inline
double osg::DegreesToRadians ( double  angle)
inline
OSG_EXPORT void osg::deleteAllGLObjects ( unsigned int  contextID)

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

OSG_EXPORT void osg::discardAllGLObjects ( unsigned int  contextID)

Discard all OpenGL objects. Note, unlike deleteAllGLjects 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 double osg::findAsciiToDouble ( const char *  str)

Detect first ascii POSITIVE number in string and convert to double.

float osg::findAsciiToFloat ( const char *  str)
inline

Detect first ascii POSITIVE number in string and convert to double.

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
osg::Array::Binding osg::getBinding ( const osg::Array array)
inline

convinience function for getting the binding of array via a ptr that may be null.

Endian osg::getCpuByteOrder ( )
inline
OSG_EXPORT std::string& osg::getGLExtensionDisableString ( )

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

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.

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.

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.

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.

bool osg::getNormalize ( const osg::Array array)
inline

convinience function for getting the binding of array via a ptr that may be null.

OSG_EXPORT NotifyHandler* osg::getNotifyHandler ( )

Get currrent notification handler.

OSG_EXPORT NotifySeverity osg::getNotifyLevel ( )

get the notify level.

OSG_EXPORT GLint osg::gluBuild1DMipmapLevels ( GLenum  target,
GLint  internalFormat,
GLsizei  width,
GLenum  format,
GLenum  type,
GLint  level,
GLint  base,
GLint  max,
const void data 
)
OSG_EXPORT GLint osg::gluBuild1DMipmaps ( GLenum  target,
GLint  internalFormat,
GLsizei  width,
GLenum  format,
GLenum  type,
const void data 
)
OSG_EXPORT GLint osg::gluBuild2DMipmapLevels ( GLenum  target,
GLint  internalFormat,
GLsizei  width,
GLsizei  height,
GLenum  format,
GLenum  type,
GLint  level,
GLint  base,
GLint  max,
const void data 
)
OSG_EXPORT GLint osg::gluBuild2DMipmaps ( GLenum  target,
GLint  internalFormat,
GLsizei  width,
GLsizei  height,
GLenum  format,
GLenum  type,
const void data 
)
OSG_EXPORT GLint osg::gluBuild3DMipmapLevels ( GLTexImage3DProc  glTextImage3DProc,
GLenum  target,
GLint  internalFormat,
GLsizei  width,
GLsizei  height,
GLsizei  depth,
GLenum  format,
GLenum  type,
GLint  level,
GLint  base,
GLint  max,
const void data 
)

Small variation on normal gluBuild3DMipmapLevels as we pass in the function pointer to glTexImage3D rather than rely on GLU style querry for this functon pointer.

OSG_EXPORT GLint osg::gluBuild3DMipmaps ( GLTexImage3DProc  glTextImage3DProc,
GLenum  target,
GLint  internalFormat,
GLsizei  width,
GLsizei  height,
GLsizei  depth,
GLenum  format,
GLenum  type,
const void data 
)

Small variation on normal gluBuild3DMipmapLevels as we pass in the function pointer to glTexImage3D rather than rely on GLU style querry for this functon pointer.

OSG_EXPORT void GL_APIENTRY osg::gluDeleteTess ( GLUtesselator *  tess)
OSG_EXPORT const GLubyte* osg::gluErrorString ( GLenum  error)
OSG_EXPORT void GL_APIENTRY osg::gluGetTessProperty ( GLUtesselator *  tess,
GLenum  which,
GLdouble value 
)
OSG_EXPORT GLUtesselator* GL_APIENTRY osg::gluNewTess ( void  )
OSG_EXPORT GLint osg::gluScaleImage ( PixelStorageModes psm,
GLenum  format,
GLsizei  wIn,
GLsizei  hIn,
GLenum  typeIn,
const void dataIn,
GLsizei  wOut,
GLsizei  hOut,
GLenum  typeOut,
GLvoid *  dataOut 
)

OSG specific gluScaleImage function that allows you to pass in the PixelStoreModes, which enables the code to avoid glGet's that are associated with the conventional gluScaleImage function. Avoiding glGet's allows this gluScaleImage function to be called at any time, from any thread, there is no need to have a graphics context current.

OSG_EXPORT GLint osg::gluScaleImage ( GLenum  format,
GLsizei  wIn,
GLsizei  hIn,
GLenum  typeIn,
const void dataIn,
GLsizei  wOut,
GLsizei  hOut,
GLenum  typeOut,
GLvoid *  dataOut 
)

Traditional GLU gluScaleImage function that sets up the PixelStoreModes automatically by doing glGets.; The use of glGet's means that you can only call this function from a thread with a valid graphics context. The use of glGet's will also result in lower performance due to the round trip to the OpenGL driver.

OSG_EXPORT void GL_APIENTRY osg::gluTessBeginContour ( GLUtesselator *  tess)
OSG_EXPORT void GL_APIENTRY osg::gluTessBeginPolygon ( GLUtesselator *  tess,
GLvoid *  data 
)
OSG_EXPORT void GL_APIENTRY osg::gluTessCallback ( GLUtesselator *  tess,
GLenum  which,
_GLUfuncptr  CallBackFunc 
)
OSG_EXPORT void GL_APIENTRY osg::gluTessEndContour ( GLUtesselator *  tess)
OSG_EXPORT void GL_APIENTRY osg::gluTessEndPolygon ( GLUtesselator *  tess)
OSG_EXPORT void GL_APIENTRY osg::gluTessNormal ( GLUtesselator *  tess,
GLdouble  valueX,
GLdouble  valueY,
GLdouble  valueZ 
)
OSG_EXPORT void GL_APIENTRY osg::gluTessProperty ( GLUtesselator *  tess,
GLenum  which,
GLdouble  data 
)
OSG_EXPORT void GL_APIENTRY osg::gluTessVertex ( GLUtesselator *  tess,
GLdouble location,
GLvoid *  data 
)
float osg::inDegrees ( float  angle)
inline
double osg::inDegrees ( double  angle)
inline
OSG_EXPORT bool osg::initNotifyLevel ( )

initialize notify level.

osg::StateSet* osg::initOQDebugState ( )
osg::StateSet* osg::initOQState ( )
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.

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)
OSG_EXPORT unsigned int osg::maximimNumOfComponents ( const ImageList imageList)

Search through the list of Images and find the maximum number of components used amoung the images.

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.

osg::META_ValueObject ( std::string  ,
StringValueObject   
)
BoolValueObject osg::META_ValueObject ( char  ,
CharValueObject   
)
BoolValueObject UCharValueObject osg::META_ValueObject ( short  ,
ShortValueObject   
)
BoolValueObject UCharValueObject UShortValueObject osg::META_ValueObject ( int  ,
IntValueObject   
)
BoolValueObject UCharValueObject UShortValueObject UIntValueObject osg::META_ValueObject ( float  ,
FloatValueObject   
)
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject osg::META_ValueObject ( Vec2f  ,
Vec2fValueObject   
)
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject Vec3fValueObject osg::META_ValueObject ( Vec4f  ,
Vec4fValueObject   
)
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject Vec3fValueObject Vec2dValueObject osg::META_ValueObject ( Vec3d  ,
Vec3dValueObject   
)
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject Vec3fValueObject Vec2dValueObject Vec4dValueObject osg::META_ValueObject ( Quat  ,
QuatValueObject   
)
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject Vec3fValueObject Vec2dValueObject Vec4dValueObject PlaneValueObject osg::META_ValueObject ( Matrixf  ,
MatrixfValueObject   
)
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.

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 
)
OSG_EXPORT std::ostream& osg::notify ( const NotifySeverity  severity)

notify messaging function for providing fatal through to verbose debugging messages. Level of messages sent to the console can be controlled by setting the NotifyLevel either within your application or via the an environmental variable i.e.

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

All tell the osg to redirect all debugging and more important messages to the notification stream (useful for debugging) setting ALWAYS will force all messages to be absorbed, which might be appropriate for final applications. Default NotifyLevel is NOTICE. Check the enum NotifySeverity for full range of possibilities. To use the notify with your code simply use the notify function as a normal file stream (like std::cout) i.e

1 osg::notify(osg::DEBUG) << "Hello Bugs!" << std::endl;
See also
setNotifyLevel, setNotifyHandler
std::ostream& osg::notify ( void  )
inline
OSG_EXPORT bool osg::offsetAndScaleImage ( osg::Image image,
const osg::Vec4 offset,
const osg::Vec4 scale 
)

Compute the min max colour values in the image.

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

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

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 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 Vec3d rhs 
)
inline

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

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

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

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

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

Vec3f osg::operator* ( const Vec3f v,
const Matrixd m 
)
inline
Vec3d osg::operator* ( const Vec3d v,
const Matrixd m 
)
inline
Vec4f osg::operator* ( const Vec4f 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
Vec4f osg::operator* ( const Vec4f v,
const Matrixf m 
)
inline
Vec4d osg::operator* ( const Vec4d v,
const Matrixf m 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec2f vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec2d vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec3f vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec3d vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec4f vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec4d vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec2b vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec3b vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec4b vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec2s vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec3s vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Vec4s vec 
)
inline
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 Vec4ub vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Quat vec 
)
inline
std::ostream& osg::operator<< ( std::ostream &  output,
const Plane pl 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec2f vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec2d vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec3f vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec3d vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec4f vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec4d vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec2b vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec3b vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec4b vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec2s vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec3s vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec4s vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Vec4ub vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Quat vec 
)
inline
std::istream& osg::operator>> ( std::istream &  input,
Plane vec 
)
inline
float osg::RadiansToDegrees ( float  angle)
inline
double osg::RadiansToDegrees ( double  angle)
inline
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 
)
float osg::round ( float  v)
inline
double osg::round ( double  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::setNotifyHandler ( NotifyHandler handler)

Set notification handler, by default StandardNotifyHandler is used.

See also
NotifyHandler
OSG_EXPORT void osg::setNotifyLevel ( NotifySeverity  severity)

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

template<typename T >
T osg::sign ( v)
inline
template<typename T >
T osg::signedSquare ( v)
inline
template<typename T >
T osg::signOrZero ( v)
inline
template<typename T >
T osg::square ( v)
inline
template<class T , class Y >
ref_ptr<T> osg::static_pointer_cast ( const ref_ptr< Y > &  rp)
inline
template<class T >
void osg::swap ( ref_ptr< T > &  rp1,
ref_ptr< T > &  rp2 
)
inline
template<class ValueT >
void osg::swap ( MixinVector< ValueT > &  left,
MixinVector< ValueT > &  right 
)
inline
template<class ValueT >
void osg::swap ( MixinVector< ValueT > &  left,
std::vector< ValueT > &  right 
)
inline
template<class ValueT >
void osg::swap ( std::vector< ValueT > &  left,
MixinVector< ValueT > &  right 
)
inline
void osg::swapBytes ( char *  in,
unsigned int  size 
)
inline
template<typename T >
void osg::swapBytes ( T &  t)
void osg::swapBytes16 ( char *  in)
inline
void osg::swapBytes2 ( char *  in)
inline
void osg::swapBytes4 ( char *  in)
inline
void osg::swapBytes8 ( char *  in)
inline
typedef osg::void ( GL_APIENTRY GLTexImage3DProc)

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 unsigned int osg::UNINITIALIZED_FRAME_NUMBER =0xffffffff
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)