## namespace osg

class SG_EXPORT AlphaFunc: public StateAttribute
  Encapsulate OpenGL glAlphaFunc
class SG_EXPORT AnimationPath: public virtual osg::Object
  AnimationPath for specify the time varying transformation pathway to use when update camera and model objects.
class SG_EXPORT AnimationPathCallback: public NodeCallback
class SG_EXPORT ApplicationUsage
class ApplicationUsageProxy
class SG_EXPORT ArgumentParser
class SG_EXPORT Array: public Object
template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType> class TemplateArray: public Array, public std::vector<T>
class SG_EXPORT IndexArray: public Array
template<typename T, Array::Type ARRAYTYPE, int DataSize, int DataType> class TemplateIndexArray: public IndexArray, public std::vector<T>
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
class ArrayVisitor
class ConstArrayVisitor
class ValueVisitor
class ConstValueVisitor
class SG_EXPORT AutoTransform: public Transform
  AutoTransform - is Transform the automatically scales or rotates to keep its children relative to screen space coordinates
class SG_EXPORT Billboard: public Geode
  Billboard - a Geode which orientates its child osg::Drawable's to face the eye point.
class SG_EXPORT BlendColor: public StateAttribute
  BlendColor - encapsulates the OpenGL blend/transparency state
class SG_EXPORT BlendFunc: public StateAttribute
  BlendFunc - encapsulates the OpenGL blend/transparency state
class SG_EXPORT BoundingBox
  General purpose axis-aligned bounding box class for enclosing objects/vertices.
class SG_EXPORT BoundingSphere
  General purpose bounding sphere class for enclosing nodes/objects/vertices.
template<class T>inline void clampGEQUAL(T& value, const T minValue, const char* valueName)
  if value is greater than or equal to minValue do nothing - legal value, otherwise clamp value to specified maximum value and return warning with valueName specifying which variable was clamped
template<class T>inline void clampLEQUAL(T& value, const T maxValue, const char* valueName)
  if value is less than or equal to maxValue do nothing - legal value, otherwise clamp value to specified maximum value and return warning with valueName specifying which variable was clamped
template<class T>inline 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 to range and return warning with valueName specifying which variable was clamped.
template<class A, class T>inline void clampArrayElementGEQUAL(A& value, unsigned int i, const T minValue, const char* valueName)
  if array element value[i] is greater than or equal to minValue do nothing - legal value, otherwise clamp value to specified maximum value and return warning with valueName specifying which variable was clamped
template<class A, class T>inline void clampArrayElementLEQUAL(A& value, unsigned int i, const T maxValue, const char* valueName)
  if array element value[i] is less than or equal to maxValue do nothing - legal value, otherwise clamp value to specified maximum value and return warning with valueName specifying which variable was clamped
template<class A, class T>inline void clampArrayElementBetweenRange(A& value, unsigned int i, const T minValue, const T maxValue, const char* valueName)
  if array element value[i] is between or equal to minValue and maxValue do nothing - legal value, otherwise clamp value to specified to range and return warning with valueName specifying which variable was clamped.
template<class A, class T>inline void clampArrayElementsGEQUAL(A& value, unsigned int first, unsigned int last, const T minValue, const char* valueName)
  if array elements are greater than or equal to minValue do nothing - legal value, otherwise clamp value to specified maximum value and return warning with valueName specifying which variable was clamped
template<class A, class T>inline void clampArrayElementsLEQUAL(A& value, unsigned int first, unsigned int last, const T maxValue, const char* valueName)
  if array elements are less than or equal to maxValue do nothing - legal value, otherwise clamp value to specified maximum value and return warning with valueName specifying which variable was clamped
template<class A, class T>inline void clampArrayElementsBetweenRange(A& value, unsigned int first, unsigned int last, const T minValue, const T maxValue, const char* valueName)
  if array elements are between or equal to minValue and maxValue do nothing - legal value, otherwise clamp value to specified to range and return warning with valueName specifying which variable was clamped.
template<class A, class T>inline void clampArray3GEQUAL(A& value, const T minValue, const char* valueName)
  if array4 elements are greater than or equal to minValue do nothing - legal value, otherwise clamp value to specified maximum value and return warning with valueName specifying which variable was clamped
template<class A, class T>inline void clampArray3LEQUAL(A& value, const T maxValue, const char* valueName)
  if array4 elements are is less than or equal to maxValue do nothing - legal value, otherwise clamp value to specified maximum value and return warning with valueName specifying which variable was clamped
template<class A, class T>inline void clampArray3BetweenRange(A& value, const T minValue, const T maxValue, const char* valueName)
  if array4 elements are between or equal to minValue and maxValue do nothing - legal value, otherwise clamp value to specified to range and return warning with valueName specifying which variable was clamped.
template<class A, class T>inline void clampArray4GEQUAL(A& value, const T minValue, const char* valueName)
  if array4 elements are greater than or equal to minValue do nothing - legal value, otherwise clamp value to specified maximum value and return warning with valueName specifying which variable was clamped
template<class A, class T>inline void clampArray4LEQUAL(A& value, unsigned int first, unsigned int last, const T maxValue, const char* valueName)
  if array4 elements are is less than or equal to maxValue do nothing - legal value, otherwise clamp value to specified maximum value and return warning with valueName specifying which variable was clamped
template<class A, class T>inline void clampArray4BetweenRange(A& value, const T minValue, const T maxValue, const char* valueName)
  if array4 elements are between or equal to minValue and maxValue do nothing - legal value, otherwise clamp value to specified to range and return warning with valueName specifying which variable was clamped.
class SG_EXPORT ClearNode: public Group
  ClearNode is a Group node which controls the clearing of the color and depth buffers at the start of each frame.
class SG_EXPORT ClipNode: public Group
  Leaf Node for defining the position of ClipPlanes in the scene
class SG_EXPORT ClipPlane: public StateAttribute
  ClipPlane state class which encapsulates OpenGL glClipPlane() functionality
class SG_EXPORT CollectOccludersVisitor: public osg::NodeVisitor, public osg::CullStack
class SG_EXPORT ColorMask: public StateAttribute
  Encapsulate OpenGL glColorMaskFunc/Op/Mask functions
class SG_EXPORT ColorMatrix: public StateAttribute
  Texture Matrix state class for encapsulating OpenGL texture matrix functionality
class SG_EXPORT ConvexPlanarOccluder: public Object
  A class for representing convex clipping volumes made up.
class SG_EXPORT ConvexPlanarPolygon
  A class for representing convex clipping volumes made up.
class SG_EXPORT CopyOp
  Copy Op(erator) used to control the whether shallow or deep copy is used during copy construction and clone operation
class SG_EXPORT CullFace: public StateAttribute
  Class to globally enable/disable OpenGL's polygon culling mode=
class SG_EXPORT CullingSet: public Referenced
  A CullingSet class which contains a frustum and a list of occluder.
class SG_EXPORT DOFTransform: public Transform
  DOFTransform - encapsulates Multigen DOF behavior
class SG_EXPORT Depth: public StateAttribute
  Encapsulate OpenGL glDepthFunc/Mask/Range functions
class SG_EXPORT DisplaySettings: public osg::Referenced
  DisplaySettings class for encapsulating what visuals are required and have been set up, and the status of stereo viewing
class SG_EXPORT DrawPixels: public Drawable
  DrawPixels is an osg::Drawable subclass which encapsulates the drawing of images using glDrawPixels
typedef __int64 GLintptrARB
typedef __int64 GLsizeiptrARB
elifdefined (__ia64__)(__x86_64__)
typedef long int GLsizeiptrARB
typedef int GLintptrARB
typedef int GLsizeiptrARB
#define USE_SEPARATE_COMPILE_AND_EXECUTE
class SG_EXPORT Drawable: public Object
  Pure virtual base class for drawable Geometry.
enum Endian
inline Endian getCpuByteOrder()
template<class T>inline void swapBytes( T& in )
class SG_EXPORT Fog: public StateAttribute
  Fog - encapsulates OpenGL fog state.
class SG_EXPORT FragmentProgram: public StateAttribute
  FragmentProgram - encapsulates the OpenGL ARB fragment program state
class SG_EXPORT FrameStamp: public Referenced
  Class which encapsulates the frame number, reference time and calander time of specific frame, used to synchonize operations on the scene graph and other machines when using a graphics cluster.
class SG_EXPORT FrontFace: public StateAttribute
  Class to specifies the orientation of front-facing polygons
extern SG_EXPORT bool isGLExtensionSupported(const char* extension)
  return true if OpenGL "extension" is supported.
inline void* getGLExtensionFuncPtr(const char* funcName)
  return the address of the specified OpenGL function.
extern SG_EXPORT void setGLExtensionDisableString(const std::string& disableString)
  Set a list of extensions to disable for different OpenGL renders, this allows OSG applications to work around OpenGL drivers bugs which are due to problemenatic extension support.
extern SG_EXPORT std::string& getGLExtensionDisableString()
  Get the list of extensions that are disabled for various OpenGL renders
inline void* getGLExtensionFuncPtr(const char* funcName, const char* fallbackFuncName)
  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.
extern SG_EXPORT bool isGLUExtensionSupported(const char* extension)
  return true if OpenGL "extension" is supported.
class SG_EXPORT Geode: public Node
  Leaf Node for grouping Drawables
class SG_EXPORT Geometry: public Drawable
extern SG_EXPORT Geometry* createTexturedQuadGeometry(const Vec3& corner, const Vec3& widthVec, const Vec3& heightVec)
  Convenience function to be used for creating quad geometry with texture coords.
typedef std::vector< ref_ptr<Node> > NodeList
class SG_EXPORT Group: public Node
  General group node which maintains a list of children.
class SG_EXPORT Image: public Object
  Image class for encapsulating the storage texture image data
extern SG_EXPORT Geode* createGeodeForImage(Image* image)
  Convenience function to be used by images loaders to generate a valid geode to return for readNode().
extern SG_EXPORT Geode* createGeodeForImage(Image* image, float s, float t)
  Convenience function to be used by images loaders to generate a valid geode to return for readNode().
class SG_EXPORT Impostor: public LOD
  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.
class SG_EXPORT ImpostorSprite: public Drawable
  An ImposterSprite is a textured quad which is rendered in place a 3D geometry.
class SG_EXPORT ImpostorSpriteManager: public Referenced
  Helper class for managing the reuse of ImpostorSprite resources
class SG_EXPORT LOD: public Group
  LOD - Level Of Detail group node which allows switching between children depending on distance from eye point.
class SG_EXPORT Light: public StateAttribute
  Light state class which encapsulates OpenGL glLight() functionality
class SG_EXPORT LightModel: public StateAttribute
class SG_EXPORT LightSource: public Group
  Leaf Node for defining a light in the scene
class SG_EXPORT LineSegment: public Referenced
  LineSegment class for representing a line segment
class SG_EXPORT LineStipple: public StateAttribute
class SG_EXPORT LineWidth: public StateAttribute
  LineWidth - encapsulates the OpenGL glLineWidth for setting the width of lines in pixels
class SG_EXPORT Material: public StateAttribute
  Material - encapsulates OpenGL glMaterial state
typedef Matrixd Matrix
typedef RefMatrixd RefMatrix
typedef Matrixf Matrix
typedef RefMatrixf RefMatrix
class SG_EXPORT MatrixTransform: public Transform
  MatrixTransform - is a subclass of Transform which has an osg::Matrix which represent a 4x4 transformation of its children from local cordinates into the Transform's parent coordinates
class SG_EXPORT Matrixd
class RefMatrixd: public Object, public Matrixd
inline Vec3 operator* (const Vec3& v, const Matrixd& m )
inline Vec4 operator* (const Vec4& v, const Matrixd& m )
inline std::ostream& operator<< (std::ostream& os, const Matrixd& m )
class SG_EXPORT Matrixf
class RefMatrixf: public Object, public Matrixf
inline Vec3 operator* (const Vec3& v, const Matrixf& m )
inline Vec4 operator* (const Vec4& v, const Matrixf& m )
inline std::ostream& operator<< (std::ostream& os, const Matrixf& m )
class SG_EXPORT Multisample: public StateAttribute
  Multisample - encapsulates the OpenGL Multisample state
#define META_Node(library,name)
  META_Node macro define the standard clone, isSameKindAs, className and accept methods.
class SG_EXPORT Node: public Object
  Base class for all internal nodes in the scene graph.
typedef std::vector<Node*> NodePath
  A vector of Nodes pointers which is used to describe the path from a root node to a descendant
class SG_EXPORT NodeCallback: public virtual Object
class SG_EXPORT NodeVisitor: public virtual Referenced
  Visitor for type safe operations on osg::Node's.
struct NodeAcceptOp
  Convenience functor for assisting visiting of arrays of osg::Node's
enum NotifySeverity
  Range of notify levels from DEBUG_FP through to FATAL, ALWAYS is reserved for forcing the absorption of all messages.
global notify level.
xtern SG_EXPORT NotifySeverity g_NotifyLevel;
xtern SG_EXPORT std::auto_ptr g_NotifyNulStream;
global notify nul stream.
xtern SG_EXPORT bool g_NotifyInit;
extern SG_EXPORT void setNotifyLevel(NotifySeverity severity)
  set the notify level, overriding the default or value set by the environmental variable OSGNOTIFYLEVEL
extern SG_EXPORT NotifySeverity getNotifyLevel()
  get the notify level.
extern SG_EXPORT bool initNotifyLevel()
  initialize notify level.
extern SG_EXPORT std::ostream& notify(const NotifySeverity severity)
  notify messaging function for providing fatal through to verbose debugging messages.
inline std::ostream& notify(void)
#define META_Object(library,name)
  META_Object macro define the standard clone, isSameKindAs and className methods.
class SG_EXPORT Object: public Referenced
  Base class/standard interface for objects which require IO support, cloning and reference counting.
class SG_EXPORT OccluderNode: public Group
  OccluderNode is a Group node which allows OccluderNodeing between children.
class SG_EXPORT PagedLOD: public LOD
  PagedLOD
class SG_EXPORT Plane
  A plane class.
inline std::ostream& operator << (std::ostream& output, const Plane& pl)
class SG_EXPORT Point: public StateAttribute
  Point - encapsulates the OpenGL point smoothing and size state
class SG_EXPORT PolygonMode: public StateAttribute
  Class to for setting OpenGL's polygon culling mode
class SG_EXPORT PolygonOffset: public StateAttribute
  PolygonOffset - encapsulates the OpenGL glPolygonOffset state
class SG_EXPORT PolygonStipple: public StateAttribute
class SG_EXPORT Polytope
  A Polytope class for representing convex clipping volumes made up.
class SG_EXPORT PositionAttitudeTransform: public Transform
  PositionAttitideTransform - is Transform the set the coordinates transform up via a Vec3 position and Quat attitude
typedef std::vector<GLsizei> VectorSizei
typedef std::vector<GLubyte> VectorUByte
typedef std::vector<GLushort> VectorUShort
typedef std::vector<GLuint> VectorUInt
class VectorSizei: public std::vector<GLsizei>
class VectorUByte: public std::vector<GLubyte>
class VectorUShort: public std::vector<GLushort>
class VectorUInt: public std::vector<GLuint>
class PrimitiveSet: public Object
class SG_EXPORT DrawArrays: public PrimitiveSet
class SG_EXPORT DrawArrayLengths: public PrimitiveSet, public VectorSizei
class SG_EXPORT DrawElementsUByte: public PrimitiveSet, public VectorUByte
class SG_EXPORT DrawElementsUShort: public PrimitiveSet, public VectorUShort
class SG_EXPORT DrawElementsUInt: public PrimitiveSet, public VectorUInt
class SG_EXPORT Projection: public Group
  Projection nodes set up the frustum/orthographic projection used when rendering the scene
class SG_EXPORT Quat
  A quaternion class.
inline std::ostream& operator << (std::ostream& output, const Quat& vec)
class SG_EXPORT Referenced
  Base class from providing referencing counted objects
class DeleteHandler
  Class for override the default delete behavior so that users can implment their own object deletion schemes.
class SG_EXPORT Sequence: public Group
  Sequence is a Group node which allows automatic, time based switching between children
class SG_EXPORT ShadeModel: public StateAttribute
  Class which encapsulates glShadeModel()
class SG_EXPORT ShadowVolumeOccluder
  ShadowVolumeOccluder is a helper class for implementating shadow occlusion culling.
typedef std::vector<ShadowVolumeOccluder> ShadowVolumeOccluderList
  A list of ShadowVolumeOccluder, used by CollectOccluderVisitor and CullVistor's
#define META_Shape(library,name)
  META_StateAttribute macro define the standard clone, isSameKindAs, className and getType methods.
class SG_EXPORT Shape: public Object
  Base class for all shape types.
class ShapeVisitor
class ConstShapeVisitor
class Sphere: public Shape
class Box: public Shape
class Cone: public Shape
class Cylinder: public Shape
class InfinitePlane: public Shape, public Plane
class TriangleMesh: public Shape
class ConvexHull: public TriangleMesh
class SG_EXPORT HeightField: public Shape
class SG_EXPORT Grid: public HeightField
class CompositeShape: public Shape
class TessellationHints: public Object
class SG_EXPORT ShapeDrawable: public Drawable
#define GL_TEXTURE0
#define GL_FOG_COORDINATE_ARRAY
#define GL_SECONDARY_COLOR_ARRAY
#define OSG_GL_DEBUG(message)
  macro for use with osg::StateAttrbiute::apply methods for detected and reporting OpenGL error messages
class SG_EXPORT State: public Referenced
  State class for managing a state stack.
#define META_StateAttribute(library,name,type)
  META_StateAttribute macro define the standard clone, isSameKindAs, className and getType methods.
#define COMPARE_StateAttribute_Types(TYPE,rhs_attribute)
  COMPARE_StateAttribute_Types macro is a helper for implementing the StatateAtribute::compare() method
#define COMPARE_StateAttribute_Parameter(parameter)
  COMPARE_StateAttribute_Parameter macro is a helper for implementing the StatateAtribute::compare() method.
#define GL_COLOR_SUM
class SG_EXPORT StateAttribute: public Object
  Base class for state attribuets
class SG_EXPORT StateSet: public Object
  Encapsulates OpenGL state modes and attributes.
class SG_EXPORT Stencil: public StateAttribute
  Encapsulate OpenGL glStencilFunc/Op/Mask functions
class SG_EXPORT Switch: public Group
  Switch is a Group node which allows switching between children.
class SG_EXPORT TexEnv: public StateAttribute
  TexEnv - encapsulates the OpenGL glTexEnv (texture environment) state
class SG_EXPORT TexEnvCombine: public StateAttribute
  TexEnvCombine - encapsulates the OpenGL glTexEnvCombine (texture environment) state
#define GL_NORMAL_MAP_ARB
#define GL_REFLECTION_MAP_ARB
class SG_EXPORT TexGen: public StateAttribute
  TexGen - encapsulates the OpenGL glTexGen (texture coordinate generation) state
class SG_EXPORT TexMat: public StateAttribute
  Texture Matrix state class for encapsulating OpenGL texture matrix functionality
class SG_EXPORT Texture: public osg::StateAttribute
  Texture base class which encapsulates OpenGl texture functionality which common betweent the various types of OpenGL textures
class SG_EXPORT Texture1D: public Texture
  Texture state class which encapsulates OpenGl 1D texture functionality
class SG_EXPORT Texture2D: public Texture
  Texture state class which encapsulates OpenGl texture functionality
class SG_EXPORT Texture3D: public Texture
  Texture state class which encapsulates OpenGl 3D texture functionality
class SG_EXPORT TextureCubeMap: public Texture
  TextureCubeMap state class which encapsulates OpenGl texture cubemap functionality
class SG_EXPORT TextureRectangle: public Texture
  Texture state class which encapsulates OpenGL texture functionality
typedef __int64 Timer_t
typedef unsigned long long Timer_t
typedef double Timer_t
typedef std::clock_t Timer_t
class SG_EXPORT Timer
  A high resolution, low latency time stamper
extern SG_EXPORT Matrix computeLocalToWorld(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
extern SG_EXPORT Matrix computeWorldToLocal(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
extern SG_EXPORT Matrix computeLocalToEye(const Matrix& modelview, 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 the supplied initialial camera modelview
extern SG_EXPORT Matrix computeEyeToLocal(const Matrix& modelview, 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 the inverse of the supplied initialial camera modelview
class SG_EXPORT Transform: public Group
  A Transform is a group node for which all children are transformed by a 4x4 matrix.
template<class T> class TriangleFunctor: public Drawable::PrimitiveFunctor, public T
class UByte4
  General purpose float quad, uses include representation of colour coordinates.
class Vec2
  General purpose float pair, uses include representation of texture coordinates.
class Vec3
  General purpose float triple for use as vertices, vectors and normals.
inline std::ostream& operator << (std::ostream& output, const Vec3& vec)
const Vec3 X_AXIS(1.0f, 0.0f, 0.0f)
const Vec3 Y_AXIS(0.0f, 1.0f, 0.0f)
const Vec3 Z_AXIS(0.0f, 0.0f, 1.0f)
class Vec4
  General purpose float quad, uses include representation of colour coordinates.
inline float operator * (const Vec3& lhs, const Vec4& rhs)
  Compute the dot product of a (Vec3,10) and a Vec4
inline float operator * (const Vec4& lhs, const Vec3& rhs)
  Compute the dot product of a Vec4 and a (Vec3,10)
class SG_EXPORT VertexProgram: public StateAttribute
  VertexProgram - encapsulates the OpenGL ARB vertex program state
class SG_EXPORT Viewport: public StateAttribute
  Encapsulte OpenGL glViewport
template<class T> class buffered_value
  Simple buffered value array which is used for values that need to multibuffered on one per graphics context basis
template<class T> class buffered_object
template<class T> 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.
class SG_EXPORT CullStack
  A CullStack class which accumulates the current project, modelview matrices and the CullingSet.A CullStack class which accumulates the current project, modelview matrices and the CullingSet.A CullStack class which accumulates the current project, modelview matrices and the CullingSet.
template<class T> class ref_ptr
  Smart pointer for handling referenced counted objects

## Documentation

`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 __int64 GLintptrARB`

`typedef __int64 GLsizeiptrARB`

`elifdefined (__ia64__)(__x86_64__)`

`typedef long int GLsizeiptrARB`

`typedef int GLintptrARB`

`typedef int GLsizeiptrARB`

`#define USE_SEPARATE_COMPILE_AND_EXECUTE`

`inline Endian getCpuByteOrder()`

`template<class T>inline void swapBytes( T& in )`

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

`typedef Matrixd Matrix`

`typedef RefMatrixd RefMatrix`

`typedef Matrixf Matrix`

`typedef RefMatrixf RefMatrix`

`inline Vec3 operator* (const Vec3& v, const Matrixd& m )`

`inline Vec4 operator* (const Vec4& v, const Matrixd& m )`

`inline std::ostream& operator<< (std::ostream& os, const Matrixd& m )`

`inline Vec3 operator* (const Vec3& v, const Matrixf& m )`

`inline Vec4 operator* (const Vec4& v, const Matrixf& m )`

`inline std::ostream& operator<< (std::ostream& os, const Matrixf& m )`

`inline std::ostream& notify(void)`

`inline std::ostream& operator << (std::ostream& output, const Plane& pl)`

`inline std::ostream& operator << (std::ostream& output, const Quat& vec)`

`#define GL_TEXTURE0`

`#define GL_FOG_COORDINATE_ARRAY`

`#define GL_SECONDARY_COLOR_ARRAY`

`#define GL_COLOR_SUM`

`#define GL_NORMAL_MAP_ARB`

`#define GL_REFLECTION_MAP_ARB`

`typedef __int64 Timer_t`

`typedef unsigned long long Timer_t`

`typedef double Timer_t`

`typedef std::clock_t Timer_t`

`inline std::ostream& operator << (std::ostream& output, const Vec3& vec)`

`const Vec3 X_AXIS(1.0f, 0.0f, 0.0f)`

`const Vec3 Y_AXIS(0.0f, 1.0f, 0.0f)`

`const Vec3 Z_AXIS(0.0f, 0.0f, 1.0f)`

Alphabetic index HTML hierarchy of classes or Java

This page was generated with the help of DOC++.