- Main Page
- Modules
- Namespaces
- Classes
- Files
- Related Pages

- Namespace List
- Namespace Members

# osg Namespace Reference

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

## Classes
class | AlphaFunc
| Encapsulates OpenGL glAlphaFunc. More...
class | AnimationPath
| AnimationPath encapsulates a time varying transformation pathway. More...
class | AnimationPathCallback
class | ApplicationUsage
class | ApplicationUsageProxy
class | ArgumentParser
class | Array
class | TemplateArray
class | IndexArray
class | TemplateIndexArray
class | ArrayVisitor
class | ConstArrayVisitor
class | ValueVisitor
class | ConstValueVisitor
class | AutoTransform
| AutoTransform is a derived form of Transform that automatically scales or rotates to keep its children aligned with screen coordinates. More...
class | Billboard
| Billboard is a derived form of Geode that orients its osg::Drawable children to face the eye point. More...
class | BlendColor
| Encapsulates OpenGL blend/transparency state. More...
class | BlendFunc
| Encapsulates OpenGL blend/transparency state. More...
class | BoundingBox
| General purpose axis-aligned bounding box class for enclosing objects/vertices. More...
class | BoundingSphere
| General purpose bounding sphere class for enclosing nodes/objects/vertices. More...
class | buffered_value
| Implements a simple buffered value for values that need to be buffered on a per graphics context basis. More...
class | buffered_object
class | ClearNode
| A Group node for clearing the color and depth buffers. More...
class | ClipNode
| Node for defining the position of ClipPlanes in the scene. More...
class | ClipPlane
| Encapsulates OpenGL glClipPlane(). More...
class | ClusterCullingCallback
| Implements cluster culling to cull back facing drawables. More...
class | CollectOccludersVisitor
class | ColorMask
| Encapsulates OpenGL glColorMaskFunc/Op/Mask functions. More...
class | ColorMatrix
| Encapsulates OpenGL color matrix functionality. More...
class | ConvexPlanarOccluder
| A class for representing convex clipping volumes made up of several ConvexPlanarPolygon. More...
class | ConvexPlanarPolygon
| A class for representing components of convex clipping volumes. More...
class | EllipsoidModel
| EllipsoidModel encapsulates the ellipsoid used to model astronomical bodies, such as sun, planets, moon etc. More...
class | CoordinateSystemNode
| CoordinateSystem encapsulate the coordinate system that is associated with objects in a scene. More...
class | CopyOp
| Copy Op(erator) used to control whether shallow or deep copy is used during copy construction and clone operation. More...
class | CullFace
| Class to globally enable/disable OpenGL's polygon culling mode. More...
class | CullingSet
| A CullingSet class which contains a frustum and a list of occluders. More...
class | CullSettings
class | CullStack
| A CullStack class which accumulates the current project, modelview matrices and the CullingSet. More...
class | Depth
| Encapsulate OpenGL glDepthFunc/Mask/Range functions. More...
class | DisplaySettings
| DisplaySettings class for encapsulating what visuals are required and have been set up, and the status of stereo viewing. More...
class | Drawable
| Pure virtual base class for drawable Geometry. More...
class | DrawPixels
| DrawPixels is an osg::Drawable subclass which encapsulates the drawing of images using glDrawPixels. More...
class | fast_back_stack
| Simple stack implementation that keeps the back() cached locally for fast access rather than at the back of the vector which is the traditional stack implementation. More...
class | Fog
| Fog - encapsulates OpenGL fog state. More...
class | FragmentProgram
| FragmentProgram - encapsulates the OpenGL ARB fragment program state. More...
class | FrameStamp
| Class which encapsulates the frame number, reference time and calendar time of specific frame, used to synchonize operations on the scene graph and other machines when using a graphics cluster. More...
class | FrontFace
| Class to specify the orientation of front-facing polygons. More...
class | Geode
| Leaf Node for grouping Drawables. More...
class | Geometry
class | Group
| General group node which maintains a list of children. More...
class | Image
| Image class for encapsulating the storage texture image data. More...
class | ImageStream
| Image Stream class. More...
class | Impostor
| Impostor - is a form of Level Of Detail group node which allows both switching between children depending on distance from eye point and image caching. More...
class | ImpostorSprite
| An ImposterSprite is a textured quad which is rendered in place of 3D geometry. More...
class | ImpostorSpriteManager
| Helper class for managing the reuse of ImpostorSprite resources. More...
class | Light
| Light state class which encapsulates OpenGL glLight() functionality. More...
class | LightModel
class | LightSource
| Leaf Node for defining a light in the scene. More...
class | LineSegment
| LineSegment class for representing a line segment. More...
class | LineStipple
class | LineWidth
| LineWidth - encapsulates the OpenGL glLineWidth for setting the width of lines in pixels. More...
class | LOD
| LOD - Level Of Detail group node which allows switching between children depending on distance from eye point. More...
class | Material
| Material - encapsulates OpenGL glMaterial state. More...
class | Matrixd
class | RefMatrixd
class | Matrixf
class | RefMatrixf
class | MatrixTransform
| MatrixTransform - is a subclass of Transform which has an osg::Matrix which represents a 4x4 transformation of its children from local coordinates into the Transform's parent coordinates. More...
class | Multisample
| Multisample - encapsulates the OpenGL Multisample state. More...
class | Node
| Base class for all internal nodes in the scene graph. More...
class | NodeCallback
class | NodeVisitor
| Visitor for type safe operations on osg::Nodes. More...
struct | NodeAcceptOp
| Convenience functor for assisting visiting of arrays of osg::Node's. More...
class | Object
| Base class/standard interface for objects which require IO support, cloning and reference counting. More...
class | OccluderNode
| OccluderNode is a Group node which allows OccluderNodeing between children. More...
class | PagedLOD
| PagedLOD. More...
class | Plane
| A plane class. More...
class | Point
| Point - encapsulates the OpenGL point smoothing and size state. More...
class | PointSprite
| PointSprite base class which encapsulates enabling of point sprites . More...
class | PolygonMode
| State Class for setting OpenGL's polygon culling mode. More...
class | PolygonOffset
| PolygonOffset - encapsulates the OpenGL glPolygonOffset state. More...
class | PolygonStipple
class | Polytope
| A Polytope class for representing convex clipping volumes made up of a set of planes. More...
class | PositionAttitudeTransform
| PositionAttitudeTransform - is a Transform. More...
class | PrimitiveSet
class | DrawArrays
class | DrawArrayLengths
class | DrawElementsUByte
class | DrawElementsUShort
class | DrawElementsUInt
class | Projection
| Projection nodes set up the frustum/orthographic projection used when rendering the scene. More...
class | Quat
| A quaternion class. More...
class | ref_ptr
| Smart pointer for handling referenced counted objects. More...
class | Referenced
| Base class from providing referencing counted objects. More...
class | DeleteHandler
| Class for override the default delete behavior so that users can implment their own object deletion schemes. More...
class | RefNodePath
class | Sequence
| Sequence is a Group node which allows automatic, time based switching between children. More...
class | ShadeModel
| Class which encapsulates glShadeModel(. More...
class | ShadowVolumeOccluder
| ShadowVolumeOccluder is a helper class for implementating shadow occlusion culling. More...
class | Shape
| Base class for all shape types. More...
class | ShapeVisitor
class | ConstShapeVisitor
class | Sphere
class | Box
class | Cone
class | Cylinder
class | Capsule
class | InfinitePlane
class | TriangleMesh
class | ConvexHull
class | HeightField
class | CompositeShape
class | TessellationHints
class | ShapeDrawable
class | State
| State class for managing a state stack. More...
class | StateAttribute
| Base class for state attributes. More...
class | StateSet
| Encapsulates OpenGL state modes and attributes. More...
class | Stencil
| Encapsulate OpenGL glStencilFunc/Op/Mask functions. More...
class | Switch
| Switch is a Group node that allows switching between children. More...
class | TexEnv
| TexEnv encapsulates the OpenGL glTexEnv (texture environment) state. More...
class | TexEnvCombine
| TexEnvCombine encapsulates the OpenGL glTexEnvCombine (texture environment) state. More...
class | TexEnvFilter
| TexEnvFilter - encapsulates the OpenGL glTexEnv (GL_TEXTURE_FILTER_CONTROL) state. More...
class | TexGen
| TexGen encapsulates the OpenGL glTexGen (texture coordinate generation) state. More...
class | TexGenNode
| Node for defining the position of TexGen in the scene. More...
class | TexMat
| A texture matrix state class that encapsulates OpenGL texture matrix functionality. More...
class | Texture
| Texture pure virtual base class that encapsulates OpenGl texture functionality common to the various types of OSG textures. More...
class | Texture1D
| Encapsulates OpenGl 1D texture functionality. More...
class | Texture2D
| Encapsulates OpenGl 2D texture functionality. More...
class | Texture3D
| Encapsulates OpenGl 2D texture functionality. More...
class | TextureCubeMap
| TextureCubeMap state class which encapsulates OpenGL texture cubemap functionality. More...
class | TextureRectangle
| Texture state class which encapsulates OpenGL texture functionality. More...
class | Timer
| A high resolution, low latency time stamper. More...
class | Transform
| A Transform is a group node for which all children are transformed by a 4x4 matrix. More...
class | TriangleFunctor
class | TriangleIndexFunctor
class | UByte4
| General purpose float quad. More...
class | Vec2d
| General purpose double pair, uses include representation of texture coordinates. More...
class | Vec2f
| General purpose float pair. More...
class | Vec3d
| General purpose double triple for use as vertices, vectors and normals. More...
class | Vec3f
| General purpose float triple for use as vertices, vectors and normals. More...
class | Vec4d
| General purpose double quad. More...
class | Vec4f
| General purpose float quad. More...
class | VertexProgram
| VertexProgram - encapsulates the OpenGL ARB vertex program state. More...
class | Viewport
| Encapsulate OpenGL glViewport. More...
## Typedefs
typedef TemplateIndexArray< GLbyte, Array::ByteArrayType, 1, GL_BYTE > | ByteArray
typedef TemplateIndexArray< GLshort, Array::ShortArrayType, 1, GL_SHORT > | ShortArray
typedef TemplateIndexArray< GLint, Array::IntArrayType, 1, GL_INT > | IntArray
typedef TemplateIndexArray< GLubyte, Array::UByteArrayType, 1, GL_UNSIGNED_BYTE > | UByteArray
typedef TemplateIndexArray< GLushort, Array::UShortArrayType, 1, GL_UNSIGNED_SHORT > | UShortArray
typedef TemplateIndexArray< GLuint, Array::UIntArrayType, 1, GL_UNSIGNED_INT > | UIntArray
typedef TemplateArray< GLfloat, Array::FloatArrayType, 1, GL_FLOAT > | FloatArray
typedef TemplateArray< UByte4, Array::UByte4ArrayType, 4, GL_UNSIGNED_BYTE > | UByte4Array
typedef TemplateArray< Vec2, Array::Vec2ArrayType, 2, GL_FLOAT > | Vec2Array
typedef TemplateArray< Vec3, Array::Vec3ArrayType, 3, GL_FLOAT > | Vec3Array
typedef TemplateArray< Vec4, Array::Vec4ArrayType, 4, GL_FLOAT > | Vec4Array
typedef Matrixd | CoordinateFrame
| CoordinateFrame encapsulates the orientation of east, north and up.
typedef int | GLintptrARB
typedef int | GLsizeiptrARB
typedef std::vector< ref_ptr< Node > > | NodeList
typedef Matrixd | Matrix
typedef RefMatrixd | RefMatrix
typedef std::vector< Node * > | NodePath
| A vector of Nodes pointers which is used to describe the path from a root node to a descendant.
typedef std::vector< GLsizei > | VectorSizei
typedef std::vector< GLubyte > | VectorUByte
typedef std::vector< GLushort > | VectorUShort
typedef std::vector< GLuint > | VectorUInt
typedef std::vector< ShadowVolumeOccluder > | ShadowVolumeOccluderList
| A list of ShadowVolumeOccluder, used by CollectOccluderVisitor and CullVistor's.
typedef HeightField | Grid
typedef std::clock_t | Timer_t
typedef Vec2f | Vec2
typedef Vec3f | Vec3
typedef Vec4f | Vec4
## Enumerations
enum | Endian { BigEndian, LittleEndian }
enum | NotifySeverity { ALWAYS = 0, FATAL = 1, WARN = 2, NOTICE = 3, INFO = 4, DEBUG_INFO = 5, DEBUG_FP = 6 }
| Range of notify levels from DEBUG_FP through to FATAL, ALWAYS is reserved for forcing the absorption of all messages. More...
## Functions
bool | isWGLExtensionSupported (const char *extension)
template<class T>
void | clampGEQUAL (T &value, const T minValue, const char *valueName)
| If value is greater than or equal to minValue do nothing - legal value, Otherwise set value to minValue, and warn that valueName was clamped.
template<class T>
void | clampLEQUAL (T &value, const T maxValue, const char *valueName)
| If value is less than or equal to maxValue do nothing - legal value, Otherwise set value to maxValue, and warn that valueName was clamped.
template<class T>
void | clampBetweenRange (T &value, const T minValue, const T maxValue, const char *valueName)
| If value is between or equal to minValue and maxValue do nothing - legal value, Otherwise clamp value to specified range and warn that valueName was clamped.
template<class A, class T>
void | clampArrayElementGEQUAL (A &value, unsigned int i, const T minValue, const char *valueName)
| If value[i] is greater than or equal to minValue do nothing - legal value, Otherwise set value[i] to minValue, and warn that valueName[i] was clamped.
template<class A, class T>
void | clampArrayElementLEQUAL (A &value, unsigned int i, const T maxValue, const char *valueName)
| If value[i] is less than or equal to maxValue do nothing - legal value, Otherwise set value[i] to maxValue, and warn that valueName[i] was clamped.
template<class A, class T>
void | clampArrayElementBetweenRange (A &value, unsigned int i, const T minValue, const T maxValue, const char *valueName)
| If value[i] is between or equal to minValue and maxValue do nothing - legal value, Otherwise clamp value[i] to specified range and warn that valueName[i] was clamped.
template<class A, class T>
void | clampArrayElementsGEQUAL (A &value, unsigned int first, unsigned int last, const T minValue, const char *valueName)
| For each element of value[] in the range (first,last), if the element is greater than or equal to minValue do nothing - legal value, Otherwise clamp the element to minValue, and warn that valueName[i] was clamped.
template<class A, class T>
void | clampArrayElementsLEQUAL (A &value, unsigned int first, unsigned int last, const T maxValue, const char *valueName)
| For each element of value[] in the range (first,last), if the element is less than or equal to maxValue do nothing - legal value, Otherwise clamp the element to maxValue, and warn that valueName[i] was clamped.
template<class A, class T>
void | clampArrayElementsBetweenRange (A &value, unsigned int first, unsigned int last, const T minValue, const T maxValue, const char *valueName)
| For each element of value[] in the range (first,last), if the element is between or equal to minValue and maxValue do nothing - legal value, Otherwise clamp the element to the range and warn that valueName[i] was clamped.
template<class A, class T>
void | clampArray3GEQUAL (A &value, const T minValue, const char *valueName)
| For each element of the three-element array value[], if the element is greater than or equal to minValue do nothing - legal value, Otherwise clamp the element to minValue, and warn that valueName[i] was clamped.
template<class A, class T>
void | clampArray3LEQUAL (A &value, const T maxValue, const char *valueName)
| For each element of the three-element array value[], if the element is less than or equal to maxValue do nothing - legal value, Otherwise clamp the element to maxValue, and warn that valueName[i] was clamped.
template<class A, class T>
void | clampArray3BetweenRange (A &value, const T minValue, const T maxValue, const char *valueName)
| For each element of the three-element array value[], if the element is between or equal to minValue and maxValue do nothing - legal value, Otherwise clamp the element to the range and warn that valueName[i] was clamped.
template<class A, class T>
void | clampArray4GEQUAL (A &value, const T minValue, const char *valueName)
| For each element of the four-element array value[], if the element is greater than or equal to minValue do nothing - legal value, Otherwise clamp the element to minValue, and warn that valueName[i] was clamped.
template<class A, class T>
void | clampArray4LEQUAL (A &value, const T maxValue, const char *valueName)
| For each element of the four-element array value[], if the element is less than or equal to maxValue do nothing - legal value, Otherwise clamp the element to maxValue, and warn that valueName[i] was clamped.
template<class A, class T>
void | clampArray4BetweenRange (A &value, const T minValue, const T maxValue, const char *valueName)
| For each element of the four-element array value[], if the element is between or equal to minValue and maxValue do nothing - legal value, Otherwise clamp the element to the range and warn that valueName[i] was clamped.
Endian | getCpuByteOrder ()
void | swapBytes (char *in, unsigned int size)
void | swapBytes2 (char *in)
void | swapBytes4 (char *in)
void | swapBytes8 (char *in)
void | swapBytes16 (char *in)
SG_EXPORT Geometry * | 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.
Geometry * | createTexturedQuadGeometry (const Vec3 &corner, const Vec3 &widthVec, const Vec3 &heightVec, float s=1.0f, float t=1.0f)
| Convenience function to be used for creating quad geometry with texture coords.
SG_EXPORT bool | isGLExtensionSupported (const char *extension)
| Return true if OpenGL "extension" is supported.
void * | getGLExtensionFuncPtr (const char *funcName)
| Return the address of the specified OpenGL function.
SG_EXPORT void | setGLExtensionDisableString (const std::string &disableString)
| Set a list of extensions to disable for different OpenGL renderers.
SG_EXPORT std::string & | getGLExtensionDisableString ()
| Get the list of extensions that are disabled for various OpenGL renderers.
void * | getGLExtensionFuncPtr (const char *funcName, const char *fallbackFuncName)
| Return the address of the specified OpenGL function.
SG_EXPORT bool | isGLUExtensionSupported (const char *extension)
| Return true if OpenGL "extension" is supported.
SG_EXPORT Geode * | createGeodeForImage (Image *image)
| Convenience function to be used by image loaders to generate a valid geode to return for readNode().
SG_EXPORT Geode * | createGeodeForImage (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>
T | absolute (T v)
| return the minimum of two values, equivalent to std::min.
float | equivalent (float lhs, float rhs, float epsilon=1e-6)
| return true if float lhs and rhs are equivalent, meaning that the difference between them is less than an epsilon value which defaults to 1e-6.
double | equivalent (double lhs, double rhs, double epsilon=1e-6)
| return true if double lhs and rhs are equivalent, meaning that the difference between them is less than an epsilon value which defaults to 1e-6.
template<typename T>
T | minimum (T lhs, T rhs)
| return the minimum of two values, equivilent to std::min.
template<typename T>
T | maximum (T lhs, T rhs)
| return the maximum of two values, equivilent to std::max.
template<typename T>
T | clampTo (T v, T minimum, T maximum)
template<typename T>
T | clampAbove (T v, T minimum)
template<typename T>
T | clampBelow (T v, T maximum)
template<typename T>
T | clampBetween (T v, T minimum, T maximum)
template<typename T>
T | sign (T v)
template<typename T>
T | square (T v)
template<typename T>
T | signedSquare (T v)
float | inDegrees (float angle)
double | inDegrees (double angle)
template<typename T>
T | inRadians (T angle)
float | DegreesToRadians (float angle)
double | DegreesToRadians (double angle)
float | RadiansToDegrees (float angle)
double | RadiansToDegrees (double angle)
bool | isNaN (float v)
bool | isNaN (double v)
template<typename T>
float | computeVolume (const T &a, const T &b, const T &c, const T &d)
| compute the volume of a tetrahedron.
template<typename T>
float | computeVolume (const T &f1, const T &f2, const T &f3, const T &b1, const T &b2, const T &b3)
| compute the volume of a prism.
Vec3f | operator * (const Vec3f &v, const Matrixd &m)
Vec3d | operator * (const Vec3d &v, const Matrixd &m)
Vec4f | operator * (const Vec4f &v, const Matrixd &m)
Vec4d | operator * (const Vec4d &v, const Matrixd &m)
std::ostream & | operator<< (std::ostream &os, const Matrixd &m)
Vec3f | operator * (const Vec3f &v, const Matrixf &m)
Vec3d | operator * (const Vec3d &v, const Matrixf &m)
Vec4f | operator * (const Vec4f &v, const Matrixf &m)
Vec4d | operator * (const Vec4d &v, const Matrixf &m)
std::ostream & | operator<< (std::ostream &os, const Matrixf &m)
SG_EXPORT void | setNotifyLevel (NotifySeverity severity)
| set the notify level, overriding the default or the value set by the environmental variable OSGNOTIFYLEVEL.
SG_EXPORT NotifySeverity | getNotifyLevel ()
| get the notify level.
SG_EXPORT bool | initNotifyLevel ()
| initialize notify level.
SG_EXPORT std::ostream & | notify (const NotifySeverity severity)
| notify messaging function for providing fatal through to verbose debugging messages.
std::ostream & | notify (void)
std::ostream & | operator<< (std::ostream &output, const Plane &pl)
std::ostream & | operator<< (std::ostream &output, const Quat &vec)
SG_EXPORT Matrix | computeLocalToWorld (const NodePath &nodePath)
| Compute the matrix which transforms objects in local coords to world coords, by accumulating the Transform local to world matrices along the specified node path.
SG_EXPORT Matrix | computeWorldToLocal (const NodePath &nodePath)
| Compute the matrix which transforms objects in world coords to local coords, by accumulating the Transform world to local matrices along the specified node path.
SG_EXPORT Matrix | computeLocalToEye (const Matrix &modelview, const NodePath &nodePath)
| Compute the matrix which transforms objects in local coords to eye coords, by accumulating the Transform local to world matrices along the specified node path and multipling by the supplied initial camera modelview.
SG_EXPORT Matrix | computeEyeToLocal (const Matrix &modelview, const NodePath &nodePath)
| Compute the matrix which transforms objects in eye coords to local coords, by accumulating the Transform world to local matrices along the specified node path and multipling by the inverse of the supplied initialial camera modelview.
std::ostream & | operator<< (std::ostream &output, const Vec3d &vec)
std::ostream & | operator<< (std::ostream &output, const Vec3f &vec)
Vec4d::value_type | operator * (const Vec3d &lhs, const Vec4d &rhs)
| Compute the dot product of a (Vec3,1.0) and a Vec4d.
Vec4d::value_type | operator * (const Vec4d &lhs, const Vec3d &rhs)
| Compute the dot product of a Vec4d and a (Vec3,1.0).
Vec4f::value_type | operator * (const Vec3f &lhs, const Vec4f &rhs)
| Compute the dot product of a (Vec3,1.0) and a Vec4f.
Vec4f::value_type | operator * (const Vec4f &lhs, const Vec3f &rhs)
| Compute the dot product of a Vec4f and a (Vec3,1.0).
Geometry * | 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.
bool | isGLExtensionSupported (const char *extension)
| Return true if OpenGL "extension" is supported.
void | setGLExtensionDisableString (const std::string &disableString)
| Set a list of extensions to disable for different OpenGL renderers.
std::string & | getGLExtensionDisableString ()
| Get the list of extensions that are disabled for various OpenGL renderers.
bool | isGLUExtensionSupported (const char *extension)
| Return true if OpenGL "extension" is supported.
Geode * | createGeodeForImage (osg::Image *image)
| Convenience function to be used by image loaders to generate a valid geode to return for readNode().
Geode * | createGeodeForImage (osg::Image *image, float s, float t)
| Convenience function to be used by image loaders to generate a valid geode to return for readNode().
void | setNotifyLevel (osg::NotifySeverity severity)
osg::NotifySeverity | getNotifyLevel ()
| get the notify level.
bool | initNotifyLevel ()
| initialize notify level.
std::ostream & | notify (const osg::NotifySeverity severity)
Matrix | computeLocalToWorld (const NodePath &nodePath)
| Compute the matrix which transforms objects in local coords to world coords, by accumulating the Transform local to world matrices along the specified node path.
Matrix | computeWorldToLocal (const NodePath &nodePath)
| Compute the matrix which transforms objects in world coords to local coords, by accumulating the Transform world to local matrices along the specified node path.
Matrix | computeLocalToEye (const Matrix &modelview, const NodePath &nodePath)
| Compute the matrix which transforms objects in local coords to eye coords, by accumulating the Transform local to world matrices along the specified node path and multipling by the supplied initial camera modelview.
Matrix | computeEyeToLocal (const Matrix &modelview, const NodePath &nodePath)
| Compute the matrix which transforms objects in eye coords to local coords, by accumulating the Transform world to local matrices along the specified node path and multipling by the inverse of the supplied initialial camera modelview.
## 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 Vec3f | X_AXIS (1.0, 0.0, 0.0)
const Vec3f | Y_AXIS (0.0, 1.0, 0.0)
const Vec3f | Z_AXIS (0.0, 0.0, 1.0)

## Detailed Description

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

## Typedef Documentation

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

typedef Matrixd osg::CoordinateFrame

| CoordinateFrame encapsulates the orientation of east, north and up.

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

typedef int osg::GLintptrARB

typedef int osg::GLsizeiptrARB

typedef HeightField osg::Grid

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

typedef Matrixd osg::Matrix

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

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

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

typedef RefMatrixd osg::RefMatrix

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

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

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

typedef std::clock_t osg::Timer_t

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

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

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

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

typedef Vec2f osg::Vec2

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

typedef Vec3f osg::Vec3

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

typedef Vec4f osg::Vec4

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

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

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

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

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

## Enumeration Type Documentation

enum osg::Endian

  | Enumerator:
  BigEndian |
  LittleEndian |

enum osg::NotifySeverity

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

## Function Documentation

template<typename T>
T osg::absolute | ( | T | v | ) | `[inline]`

| return the minimum of two values, equivalent to std::min. std::min not used because of STL implementation under IRIX not containing std::min.

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

template<class A, class 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<class A, class 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<class A, class 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<class A, class 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<class A, class 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<class A, class 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<class A, class 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<class A, class 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<class A, class 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<class A, class 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<class A, class 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<class A, class 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 | ( | T | v,
|  | T | maximum
| ) | `[inline]`

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

template<class 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<class 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<class 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 | ( | T | v,
|  | T | minimum,
|  | T | maximum
| ) | `[inline]`

Matrix osg::computeEyeToLocal | ( | const Matrix & | modelview,
|  | const NodePath & | nodePath
| ) |

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

SG_EXPORT Matrix osg::computeEyeToLocal | ( | const Matrix & | modelview,
|  | const NodePath & | nodePath
| ) |

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

Matrix osg::computeLocalToEye | ( | const Matrix & | modelview,
|  | const NodePath & | nodePath
| ) |

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

SG_EXPORT Matrix osg::computeLocalToEye | ( | const Matrix & | modelview,
|  | const NodePath & | nodePath
| ) |

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

Matrix osg::computeLocalToWorld | ( | const NodePath & | nodePath | ) |

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

SG_EXPORT Matrix osg::computeLocalToWorld | ( | const NodePath & | nodePath | ) |

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

template<typename T>
float 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.

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.

Matrix osg::computeWorldToLocal | ( | const NodePath & | nodePath | ) |

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

SG_EXPORT Matrix osg::computeWorldToLocal | ( | const NodePath & | nodePath | ) |

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

Geode* osg::createGeodeForImage | ( | Image * | image,
|  | float | s,
|  | float | t
| ) |

| Convenience function to be used by image loaders to generate a valid geode to return for readNode(). Use the specified s and t values to scale the dimensions of the image.

Geode* osg::createGeodeForImage | ( | Image * | image | ) |

| Convenience function to be used by image loaders to generate a valid geode to return for readNode(). Use the image's s and t values to scale the dimensions of the image.

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

SG_EXPORT Geode* osg::createGeodeForImage | ( | Image * | image | ) |

| Convenience function to be used by image loaders to generate a valid geode to return for readNode(). Use the image's s and t values to scale the dimensions of the image.

Geometry* osg::createTexturedQuadGeometry | ( | const Vec3 & | corner,
|  | const Vec3 & | widthVec,
|  | const Vec3 & | heightVec,
|  | float | 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).

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

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

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

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

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

Endian osg::getCpuByteOrder | ( |  | ) | `[inline]`

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

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

SG_EXPORT std::string& osg::getGLExtensionDisableString | ( |  | ) |

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

void* osg::getGLExtensionFuncPtr | ( | const char * | funcName,
|  | const char * | fallbackFuncName
| ) | `[inline]`

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

void* osg::getGLExtensionFuncPtr | ( | const char * | funcName | ) | `[inline]`

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

osg::NotifySeverity osg::getNotifyLevel | ( |  | ) |

| get the notify level.

SG_EXPORT NotifySeverity osg::getNotifyLevel | ( |  | ) |

| get the notify level.

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

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

bool osg::initNotifyLevel | ( |  | ) |

| initialize notify level.

SG_EXPORT bool osg::initNotifyLevel | ( |  | ) |

| initialize notify level.

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

bool osg::isGLExtensionSupported | ( | const char * | extension | ) |

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

SG_EXPORT bool osg::isGLExtensionSupported | ( | const char * | extension | ) |

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

bool osg::isGLUExtensionSupported | ( | const char * | extension | ) |

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

SG_EXPORT bool osg::isGLUExtensionSupported | ( | const char * | extension | ) |

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

bool osg::isNaN | ( | double | v | ) | `[inline]`

bool osg::isNaN | ( | float | v | ) | `[inline]`

bool osg::isWGLExtensionSupported | ( | const char * | extension | ) |

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

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

template<typename T>
T osg::minimum | ( | T | lhs,
|  | T | rhs
| ) | `[inline]`

| return the minimum of two values, equivilent to std::min. std::min not used because of STL implementation under IRIX not containing std::min.

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

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

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

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

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

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

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

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

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

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

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

Vec4d osg::operator * | ( | const Vec4d & | v,
|  | const Matrixf & | m
| ) | `[inline]`

Vec4f osg::operator * | ( | const Vec4f & | v,
|  | const Matrixf & | m
| ) | `[inline]`

Vec3d osg::operator * | ( | const Vec3d & | v,
|  | const Matrixf & | m
| ) | `[inline]`

Vec3f osg::operator * | ( | const Vec3f & | v,
|  | const Matrixf & | m
| ) | `[inline]`

Vec4d osg::operator * | ( | const Vec4d & | v,
|  | const Matrixd & | m
| ) | `[inline]`

Vec4f osg::operator * | ( | const Vec4f & | v,
|  | const Matrixd & | m
| ) | `[inline]`

Vec3d osg::operator * | ( | const Vec3d & | v,
|  | const Matrixd & | m
| ) | `[inline]`

Vec3f osg::operator * | ( | const Vec3f & | v,
|  | const Matrixd & | m
| ) | `[inline]`

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

std::ostream& osg::operator<< | ( | std::ostream & | output,
|  | const Vec3d & | 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::ostream& osg::operator<< | ( | std::ostream & | os,
|  | const Matrixf & | m
| ) | `[inline]`

std::ostream& osg::operator<< | ( | std::ostream & | os,
|  | const Matrixd & | m
| ) | `[inline]`

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

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

void osg::setGLExtensionDisableString | ( | const std::string & | disableString | ) |

| Set a list of extensions to disable for different OpenGL renderers. This allows OSG applications to work around OpenGL drivers' bugs which are due to problematic extension support. The format of the string is: "GLRendererString : ExtensionName, ExtensionName; GLRenderString2 : ExtensionName;" An example of is : "SUN_XVR1000:GL_EXT_texture_filter_anisotropic" The default setting of GLExtensionDisableString is obtained from the OSG_GL_EXTENSION_DISABLE environmental variable.

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

void osg::setNotifyLevel | ( | osg::NotifySeverity | severity | ) |

SG_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 | ( | T | v | ) | `[inline]`

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

template<typename T>
T osg::square | ( | T | v | ) | `[inline]`

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

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

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

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

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

## Variable Documentation

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)