Classes
class	AlphaFunc
class	AnimationPath
class	AnimationPathCallback
class	ApplicationUsage
class	ApplicationUsageProxy
class	ArgumentParser
class	Array
class	TemplateArray
	A concrete array holding elements of type T. More...
class	IndexArray
class	TemplateIndexArray
class	ArrayVisitor
class	ConstArrayVisitor
class	ValueVisitor
class	ConstValueVisitor
struct	AttributeDispatch
class	AttributeDispatchers
class	AudioSink
class	AudioStream
class	AutoTransform
class	Billboard
class	BindImageTexture
class	BlendColor
class	BlendEquation
class	BlendEquationi
class	BlendFunc
class	BlendFunci
class	BoundingSphereImpl
class	BoundingBoxImpl
class	buffered_value
class	buffered_object
class	BufferIndexBinding
class	UniformBufferBinding
class	TransformFeedbackBufferBinding
class	AtomicCounterBufferBinding
class	ShaderStorageBufferBinding
class	BufferObjectProfile
class	GLBufferObject
class	GLBufferObjectSet
class	GLBufferObjectManager
class	BufferObject
class	BufferData
class	VertexBufferObject
class	ElementBufferObject
class	DrawIndirectBufferObject
class	PixelBufferObject
class	PixelDataBufferObject
class	UniformBufferObject
class	AtomicCounterBufferObject
class	ShaderStorageBufferObject
class	BufferTemplate
class	BufferTemplate< std::vector< T > >
class	Callback
class	CallbackObject
class	NodeCallback
class	StateAttributeCallback
class	UniformCallback
class	DrawableUpdateCallback
class	DrawableEventCallback
class	DrawableCullCallback
class	Camera
struct	CameraRenderOrderSortOp
class	CameraView
class	Capability
class	Capabilityi
class	Enablei
class	Disablei
class	ClampColor
class	ClearNode
class	ClipControl
class	ClipNode
class	ClipPlane
class	ClusterCullingCallback
	Implements cluster culling to cull back facing subgraphs and drawables. Derived from Drawable::CullCallback and osg::NodeCallback. More...
class	CollectOccludersVisitor
class	ColorMask
class	ColorMaski
class	ColorMatrix
class	ComputeBoundsVisitor
class	ContextData
class	ConvexPlanarOccluder
class	ConvexPlanarPolygon
class	EllipsoidModel
class	CoordinateSystemNode
class	CopyOp
class	CullFace
class	CullingSet
class	CullSettings
class	CullStack
class	DeleteHandler
class	Depth
class	DepthRangeIndexed
class	DispatchCompute
class	DisplaySettings
class	Drawable
class	AttributeFunctorArrayVisitor
class	ConstAttributeFunctorArrayVisitor
class	DrawPixels
class	fast_back_stack
class	Fog
class	FragmentProgram
class	RenderBuffer
class	FrameBufferAttachment
class	FrameBufferObject
class	GLRenderBufferManager
class	GLFrameBufferObjectManager
class	FrameStamp
class	FrontFace
class	Geode
class	Geometry
class	ConfigureBufferObjectsVisitor
class	VertexAttribAlias
class	GLExtensions
class	GraphicsObject
class	GraphicsObjectManager
class	GLObjectManager
struct	PixelStorageModes
class	GraphicsContext
class	SyncSwapBuffersCallback
struct	WindowingSystemInterfaceProxy
struct	ClampedLinearCostFunction1D
class	GeometryCostEstimator
class	TextureCostEstimator
class	ProgramCostEstimator
class	GraphicsCostEstimator
class	GraphicsThread
struct	GraphicsOperation
struct	SwapBuffersOperation
struct	BarrierOperation
struct	ReleaseContext_Block_MakeCurrentOperation
struct	BlockAndFlushOperation
struct	FlushDeletedGLObjectsOperation
class	RunOperations
class	EndOfDynamicDrawBlock
class	Group
class	Hint
class	Identifier
class	Image
class	ImageSequence
class	ImageStream
struct	CastAndScaleToFloatOperation
class	MakeString
class	KdTree
class	KdTreeBuilder
class	Light
class	LightModel
class	LightSource
class	LineSegment
class	LineStipple
class	LineWidth
class	LOD
class	LogicOp
class	Material
class	Matrixd
class	RefMatrixd
class	Matrixf
class	RefMatrixf
class	MatrixTransform
class	MixinVector
class	Multisample
class	Node
class	NodeTrackerCallback
class	NodeVisitor
class	NodeAcceptOp
class	PushPopObject
class	PushPopValue
class	NotifyHandler
class	StandardNotifyHandler
class	Object
class	DummyObject
class	Observer
class	ObserverSet
class	observer_ptr
class	ObserverNodePath
class	OccluderNode
class	TestResult
class	QueryGeometry
class	OcclusionQueryNode
class	RefBlock
class	RefBlockCount
class	Operation
class	OperationQueue
class	OperationThread
class	PagedLOD
class	PatchParameter
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	PrimitiveRestartIndex
class	PrimitiveFunctor
class	PrimitiveIndexFunctor
class	PrimitiveSet
class	DrawArrays
class	DrawArrayLengths
class	DrawElements
class	DrawElementsUByte
class	DrawElementsUShort
class	DrawElementsUInt
class	MultiDrawArrays
class	IndirectCommandDrawArrays
	common interface for IndirectCommandDrawArrayss More...
class	IndirectCommandDrawElements
struct	DrawArraysIndirectCommand
	DrawArraysCommand. More...
class	DefaultIndirectCommandDrawArrays
struct	DrawElementsIndirectCommand
class	DefaultIndirectCommandDrawElements
	vector of DrawElementsCommand to be hosted on GPU More...
class	DrawElementsIndirect
	The DrawElementsIndirect base PrimitiveSet. More...
class	DrawElementsIndirectUByte
	The DrawElementsIndirectUByte PrimitiveSet. More...
class	DrawElementsIndirectUShort
	The DrawElementsIndirectUShort PrimitiveSet. More...
class	DrawElementsIndirectUInt
	The DrawElementsIndirectUInt PrimitiveSet. More...
class	MultiDrawElementsIndirectUShort
	The MultiDrawElementsIndirect PrimitiveSets. More...
class	MultiDrawElementsIndirectUByte
class	MultiDrawElementsIndirectUInt
class	DrawArraysIndirect
	The MultiDrawArraysIndirect PrimitiveSet. More...
class	MultiDrawArraysIndirect
	The MultiDrawArraysIndirect PrimitiveSet. More...
class	Program
class	Projection
class	ProxyNode
class	Quat
class	ref_ptr
struct	depends_on
class	Referenced
class	RenderInfo
class	SampleMaski
class	Sampler
class	Scissor
class	ScissorIndexed
class	Script
class	ScriptNodeCallback
class	ScriptEngine
class	Sequence
class	ShadeModel
class	ShaderBinary
class	Shader
class	ShaderComponent
class	ShaderAttribute
class	ShaderComposer
	deprecated More...
class	ShadowVolumeOccluder
class	Shape
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	BuildShapeGeometryVisitor
class	ShapeDrawable
class	State
class	StateAttribute
class	StateSet
class	Stats
class	Stencil
class	StencilTwoSided
class	Switch
class	TemplatePrimitiveFunctor
class	TemplatePrimitiveIndexFunctor
class	TexEnv
class	TexEnvCombine
class	TexEnvFilter
class	TexGen
class	TexGenNode
class	TexMat
class	Texture
class	TextureObjectSet
class	TextureObjectManager
class	Texture1D
class	Texture2D
class	Texture2DArray
class	Texture2DMultisample
class	Texture3D
class	TextureBuffer
class	TextureCubeMap
class	TextureRectangle
class	Timer
class	ElapsedTime
class	TransferFunction
class	TransferFunction1D
class	Transform
class	TriangleFunctor
class	TriangleIndexFunctor
class	TriangleLinePointIndexFunctor
class	MatrixTemplate
class	Matrix2Template
class	Matrix2x3Template
class	Matrix2x4Template
class	Matrix3x2Template
class	Matrix3Template
class	Matrix3x4Template
class	Matrix4x2Template
class	Matrix4x3Template
class	Uniform
class	UserDataContainer
class	DefaultUserDataContainer
class	ValueMap
class	GetScalarValue
class	SetScalarValue
class	ValueObject
class	GetScalarValue< bool >
struct	ValueObjectClassNameTrait
class	TemplateValueObject
class	ValueStack
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	VertexArrayState
class	VertexArrayStateList
class	VertexAttribDivisor
class	VertexProgram
class	View
class	Viewport
class	ViewportIndexed

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< GLdouble, Array::DoubleArrayType, 1, GL_DOUBLE >	DoubleArray
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_INT >	Vec2iArray
typedef TemplateArray< Vec3i, Array::Vec3iArrayType, 3, GL_INT >	Vec3iArray
typedef TemplateArray< Vec4i, Array::Vec4iArrayType, 4, GL_INT >	Vec4iArray
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_INT >	Vec2uiArray
typedef TemplateArray< Vec3ui, Array::Vec3uiArrayType, 3, GL_UNSIGNED_INT >	Vec3uiArray
typedef TemplateArray< Vec4ui, Array::Vec4uiArrayType, 4, GL_UNSIGNED_INT >	Vec4uiArray
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_DOUBLE >	Vec2dArray
typedef TemplateArray< Vec3d, Array::Vec3dArrayType, 3, GL_DOUBLE >	Vec3dArray
typedef TemplateArray< Vec4d, Array::Vec4dArrayType, 4, GL_DOUBLE >	Vec4dArray
typedef TemplateArray< Matrixf, Array::MatrixArrayType, 16, GL_FLOAT >	MatrixfArray
typedef TemplateArray< Matrixd, Array::MatrixdArrayType, 16, GL_DOUBLE >	MatrixdArray
typedef TemplateArray< Quat, Array::QuatArrayType, 4, GL_DOUBLE >	QuatArray
typedef TemplateIndexArray< GLuint64, Array::UInt64ArrayType, 1, GL_UNSIGNED_INT64_ARB >	UInt64Array
typedef TemplateIndexArray< GLint64, Array::Int64ArrayType, 1, GL_INT64_ARB >	Int64Array
typedef BoundingBoxImpl< Vec3f >	BoundingBoxf
typedef BoundingBoxImpl< Vec3d >	BoundingBoxd
typedef BoundingBoxd	BoundingBox
typedef BoundingSphereImpl< Vec3f >	BoundingSpheref
typedef BoundingSphereImpl< Vec3d >	BoundingSphered
typedef BoundingSphered	BoundingSphere
typedef std::list< ref_ptr< GLBufferObject > >	GLBufferObjectList
typedef std::vector< osg::ref_ptr< osg::Object > >	Parameters
typedef Matrixd	CoordinateFrame
typedef GLExtensions	GL2Extensions
typedef struct __GLsync *	GLsync
typedef ptrdiff_t	GLsizeiptr
typedef ptrdiff_t	GLintptr
typedef void(GL_APIENTRY *	GLTexImage3DProc) (GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
typedef GLUtesselator	GLUtesselatorObj
typedef GLUtesselator	GLUtriangulatorObj
typedef void(GL_APIENTRY *	_GLUfuncptr) ()
typedef void(GL_APIENTRY *	GLU_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< NodePath >	NodePathList
typedef std::vector< Matrix >	MatrixList
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::set< std::string >	ShaderDefines
typedef std::vector< osg::ShaderComponent * >	ShaderComponents
typedef std::vector< ShadowVolumeOccluder >	ShadowVolumeOccluderList
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)
unsigned int	computeBufferAlignment (unsigned int pos, unsigned int bufferAlignment)
CallbackObject *	getCallbackObject (osg::Object *object, const std::string &name)
const CallbackObject *	getCallbackObject (const osg::Object *object, const std::string &name)
bool	runNamedCallbackObjects (osg::Object *object, const std::string &name, osg::Parameters &inputParameters, osg::Parameters &outputParameters)
OSG_EXPORT ContextData *	getContextData (unsigned int contextID)
OSG_EXPORT ContextData *	getOrCreateContextData (unsigned int contextID)
template<typename T>
T *	get (unsigned int contextID)
template<>
ContextData *	get< ContextData > (unsigned int contextID)
template<class matrix_type, class value_type>
bool	clampProjectionMatrix (matrix_type &projection, double &znear, double &zfar, value_type nearFarRatio)
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 Geometry *	createTexturedQuadGeometry (const Vec3 &corner, const Vec3 &widthVec, const Vec3 &heightVec, float l, float b, float r, float t)
Geometry *	createTexturedQuadGeometry (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	isGLExtensionSupported (unsigned int contextID, const char extension1, const char extension2)
OSG_EXPORT bool	isGLExtensionOrVersionSupported (unsigned int contextID, const char *extension, float requiredGlVersion)
OSG_EXPORT void *	getGLExtensionFuncPtr (const char *funcName)
OSG_EXPORT void	setGLExtensionDisableString (const std::string &disableString)
OSG_EXPORT std::string &	getGLExtensionDisableString ()
void *	getGLExtensionFuncPtr (const char funcName, const char fallbackFuncName)
void *	getGLExtensionFuncPtr (const char funcName1, const char funcName2, const char *funcName3)
template<typename T, typename R>
bool	convertPointer (T &dest, R src)
template<typename T, typename R>
T	convertPointerType (R src)
template<typename T>
bool	setGLExtensionFuncPtr (T &t, const char *str1, bool validContext=true)
template<typename T>
bool	setGLExtensionFuncPtr (T &t, const char str1, const char str2, bool validContext=true)
template<typename T>
bool	setGLExtensionFuncPtr (T &t, const char str1, const char str2, const char *str3, bool validContext=true)
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)
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)
bool	iequals (const std::string &lhs, const std::string &rhs)
OSG_EXPORT Geode *	createGeodeForImage (Image *image)
template<class T>
Geode *	createGeodeForImage (const ref_ptr< T > &image)
OSG_EXPORT Geode *	createGeodeForImage (Image *image, float s, float t)
template<class T>
Geode *	createGeodeForImage (const ref_ptr< T > &image, float s, float t)
template<typename T, class O>
void	_readRow (unsigned int num, GLenum pixelFormat, const T *data, 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::Image *	createImage3D (const ImageList &imageList, GLenum desiredPixelFormat, int s_maximumImageSize=1024, int t_maximumImageSize=1024, int r_maximumImageSize=1024, bool resizeToPowerOfTwo=false)
OSG_EXPORT osg::Image *	createImage3DWithAlpha (const ImageList &imageList, int s_maximumImageSize=1024, int t_maximumImageSize=1024, int r_maximumImageSize=1024, bool resizeToPowerOfTwo=false)
OSG_EXPORT osg::Image *	createSpotLightImage (const osg::Vec4 &centerColour, const osg::Vec4 &backgroudColour, unsigned int size, float power)
OSG_EXPORT osg::Image *	colorSpaceConversion (ColorSpaceOperation op, osg::Image *image, const osg::Vec4 &colour)
OSG_EXPORT osg::Image *	createImageWithOrientationConversion (const osg::Image *srcImage, const osg::Vec3i &srcOrigin, const osg::Vec3i &srcRow, const osg::Vec3i &srcColumn, const osg::Vec3i &srcLayer)
std::ostream &	operator<< (std::ostream &output, const MakeString &str)
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 &output, const Vec2i &vec)
std::istream &	operator>> (std::istream &input, Vec2i &vec)
std::ostream &	operator<< (std::ostream &output, const Vec3i &vec)
std::istream &	operator>> (std::istream &input, Vec3i &vec)
std::ostream &	operator<< (std::ostream &output, const Vec4i &vec)
std::istream &	operator>> (std::istream &input, Vec4i &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>
T	default_value ()
template<>
float	default_value< float > ()
template<>
double	default_value< double > ()
template<>
char	default_value< char > ()
template<>
unsigned char	default_value< unsigned char > ()
template<>
short	default_value< short > ()
template<>
unsigned short	default_value< unsigned short > ()
template<>
int	default_value< int > ()
template<>
unsigned int	default_value< unsigned int > ()
template<typename T>
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>
T	minimum (T lhs, T rhs)
template<typename T>
T	maximum (T lhs, T rhs)
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	signOrZero (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)
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)
template<>
ValueStack *	getOrCreateUserObjectOfType< NodeVisitor, ValueStack > (NodeVisitor *nv)
template<>
ValueMap *	getOrCreateUserObjectOfType< NodeVisitor, ValueMap > (NodeVisitor *nv)
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 NotifyHandler *	getNotifyHandler ()
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)
void	resizeGLObjectBuffers (osg::Object *object, unsigned int maxSize)
template<class T>
void	resizeGLObjectBuffers (const osg::ref_ptr< T > &object, unsigned int maxSize)
void	releaseGLObjects (osg::Object object, osg::State state=0)
template<class T>
void	releaseGLObjects (const osg::ref_ptr< T > &object, osg::State *state=0)
osg::StateSet *	initOQState ()
osg::StateSet *	initOQDebugState ()
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 Geometry *	convertShapeToGeometry (const Shape &shape, const TessellationHints *hints)
OSG_EXPORT Geometry *	convertShapeToGeometry (const Shape &shape, const TessellationHints *hints, const Vec4 &color, Array::Binding colorBinding=Array::BIND_OVERALL)
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)
Object *	getUserObject (osg::Object *object, const std::string &name)
const Object *	getUserObject (const osg::Object *object, const std::string &name)
	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
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject Vec3fValueObject Vec2dValueObject Vec4dValueObject PlaneValueObject MatrixdValueObject	META_ValueObject (BoundingBoxf, BoundingBoxfValueObject) META_ValueObject(BoundingBoxd
BoolValueObject UCharValueObject UShortValueObject UIntValueObject DoubleValueObject Vec3fValueObject Vec2dValueObject Vec4dValueObject PlaneValueObject MatrixdValueObject BoundingBoxdValueObject	META_ValueObject (BoundingSpheref, BoundingSpherefValueObject) META_ValueObject(BoundingSphered
template<class P, class T>
T *	getOrCreateUserObjectOfType (P *parent)
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)
Vec4ub	convertToRGBA8 (const Vec4f &color)
Vec4ub	convertToRGBA8 (float r, float g, float b, float a)
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 float	PIf = 3.14159265358979323846f
const float	PI_2f = 1.57079632679489661923f
const float	PI_4f = 0.78539816339744830962f
const float	LN_2f = 0.69314718055994530942f
const float	INVLN_2f = 1.0f / LN_2f
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

◆ _GLUfuncptr

typedef void(GL_APIENTRY * osg::_GLUfuncptr) ()

◆ BoundingBox

typedef BoundingBoxd osg::BoundingBox

◆ BoundingBoxd

typedef BoundingBoxImpl<Vec3d> osg::BoundingBoxd

◆ BoundingBoxf

typedef BoundingBoxImpl<Vec3f> osg::BoundingBoxf

◆ BoundingSphere

typedef BoundingSphered osg::BoundingSphere

◆ BoundingSphered

typedef BoundingSphereImpl<Vec3d> osg::BoundingSphered

◆ BoundingSpheref

typedef BoundingSphereImpl<Vec3f> osg::BoundingSpheref

◆ ByteArray

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

◆ CoordinateFrame

typedef Matrixd osg::CoordinateFrame

CoordinateFrame encapsulates the orientation of east, north and up.

◆ CostPair

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.

◆ DoubleArray

typedef TemplateArray<GLdouble,Array::DoubleArrayType,1,GL_DOUBLE> osg::DoubleArray

◆ FloatArray

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

◆ GL2Extensions

typedef GLExtensions osg::GL2Extensions

◆ GLBufferObjectList

typedef std::list< ref_ptr<GLBufferObject> > osg::GLBufferObjectList

◆ GLintptr

typedef ptrdiff_t osg::GLintptr

◆ GLsizeiptr

typedef ptrdiff_t osg::GLsizeiptr

◆ GLsync

typedef struct __GLsync* osg::GLsync

◆ GLTexImage3DProc

typedef void(GL_APIENTRY * osg::GLTexImage3DProc) (GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)

◆ GLU_TESS_CALLBACK

typedef void(GL_APIENTRY * osg::GLU_TESS_CALLBACK) ()

◆ GLUtesselatorObj

typedef GLUtesselator osg::GLUtesselatorObj

◆ GLUtriangulatorObj

typedef GLUtesselator osg::GLUtriangulatorObj

◆ Grid

typedef HeightField osg::Grid

◆ ImageList

typedef std::vector< osg::ref_ptr<osg::Image> > osg::ImageList

◆ Int64Array

typedef TemplateIndexArray<GLint64,Array::Int64ArrayType,1,GL_INT64_ARB> osg::Int64Array

◆ IntArray

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

◆ Matrix

typedef Matrixd osg::Matrix

◆ Matrix2

typedef Matrix2Template<float> osg::Matrix2

◆ Matrix2d

typedef Matrix2Template<double> osg::Matrix2d

◆ Matrix2x3

typedef Matrix2x3Template<float> osg::Matrix2x3

◆ Matrix2x3d

typedef Matrix2x3Template<double> osg::Matrix2x3d

◆ Matrix2x4

typedef Matrix2x4Template<float> osg::Matrix2x4

◆ Matrix2x4d

typedef Matrix2x4Template<double> osg::Matrix2x4d

◆ Matrix3

typedef Matrix3Template<float> osg::Matrix3

◆ Matrix3d

typedef Matrix3Template<double> osg::Matrix3d

◆ Matrix3x2

typedef Matrix3x2Template<float> osg::Matrix3x2

◆ Matrix3x2d

typedef Matrix3x2Template<double> osg::Matrix3x2d

◆ Matrix3x4

typedef Matrix3x4Template<float> osg::Matrix3x4

◆ Matrix3x4d

typedef Matrix3x4Template<double> osg::Matrix3x4d

◆ Matrix4x2

typedef Matrix4x2Template<float> osg::Matrix4x2

◆ Matrix4x2d

typedef Matrix4x2Template<double> osg::Matrix4x2d

◆ Matrix4x3

typedef Matrix4x3Template<float> osg::Matrix4x3

◆ Matrix4x3d

typedef Matrix4x3Template<double> osg::Matrix4x3d

◆ MatrixdArray

typedef TemplateArray<Matrixd,Array::MatrixdArrayType,16,GL_DOUBLE> osg::MatrixdArray

◆ MatrixfArray

typedef TemplateArray<Matrixf,Array::MatrixArrayType,16,GL_FLOAT> osg::MatrixfArray

◆ MatrixList

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.

◆ NodeList

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

◆ NodePath

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.

◆ NodePathList

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.

◆ OperationsThread

typedef OperationThread osg::OperationsThread

◆ Parameters

typedef std::vector< osg::ref_ptr<osg::Object> > osg::Parameters

◆ QuatArray

typedef TemplateArray<Quat,Array::QuatArrayType,4,GL_DOUBLE> osg::QuatArray

◆ RefMatrix

typedef RefMatrixd osg::RefMatrix

◆ RefNodePath

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

◆ ShaderComponents

typedef std::vector<osg::ShaderComponent*> osg::ShaderComponents

◆ ShaderDefines

typedef std::set<std::string> osg::ShaderDefines

◆ ShadowVolumeOccluderList

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

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

◆ ShortArray

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

◆ Timer_t

typedef unsigned long long osg::Timer_t

◆ UByteArray

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

◆ UInt64Array

typedef TemplateIndexArray<GLuint64,Array::UInt64ArrayType,1,GL_UNSIGNED_INT64_ARB> osg::UInt64Array

◆ UIntArray

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

◆ UShortArray

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

◆ Vec2

typedef Vec2f osg::Vec2

◆ Vec2Array

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

◆ Vec2bArray

typedef TemplateArray<Vec2b,Array::Vec2bArrayType,2,GL_BYTE> osg::Vec2bArray

◆ Vec2dArray

typedef TemplateArray<Vec2d,Array::Vec2dArrayType,2,GL_DOUBLE> osg::Vec2dArray

◆ Vec2iArray

typedef TemplateArray<Vec2i,Array::Vec2iArrayType,2,GL_INT> osg::Vec2iArray

◆ Vec2sArray

typedef TemplateArray<Vec2s,Array::Vec2sArrayType,2,GL_SHORT> osg::Vec2sArray

◆ Vec2ubArray

typedef TemplateArray<Vec2ub,Array::Vec2ubArrayType,2,GL_UNSIGNED_BYTE> osg::Vec2ubArray

◆ Vec2uiArray

typedef TemplateArray<Vec2ui,Array::Vec2uiArrayType,2,GL_UNSIGNED_INT> osg::Vec2uiArray

◆ Vec2usArray

typedef TemplateArray<Vec2us,Array::Vec2usArrayType,2,GL_UNSIGNED_SHORT> osg::Vec2usArray

◆ Vec3

typedef Vec3f osg::Vec3

◆ Vec3Array

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

◆ Vec3bArray

typedef TemplateArray<Vec3b,Array::Vec3bArrayType,3,GL_BYTE> osg::Vec3bArray

◆ Vec3dArray

typedef TemplateArray<Vec3d,Array::Vec3dArrayType,3,GL_DOUBLE> osg::Vec3dArray

◆ Vec3iArray

typedef TemplateArray<Vec3i,Array::Vec3iArrayType,3,GL_INT> osg::Vec3iArray

◆ Vec3sArray

typedef TemplateArray<Vec3s,Array::Vec3sArrayType,3,GL_SHORT> osg::Vec3sArray

◆ Vec3ubArray

typedef TemplateArray<Vec3ub,Array::Vec3ubArrayType,3,GL_UNSIGNED_BYTE> osg::Vec3ubArray

◆ Vec3uiArray

typedef TemplateArray<Vec3ui,Array::Vec3uiArrayType,3,GL_UNSIGNED_INT> osg::Vec3uiArray

◆ Vec3usArray

typedef TemplateArray<Vec3us,Array::Vec3usArrayType,3,GL_UNSIGNED_SHORT> osg::Vec3usArray

◆ Vec4

typedef Vec4f osg::Vec4

◆ Vec4Array

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

◆ Vec4bArray

typedef TemplateArray<Vec4b,Array::Vec4bArrayType,4,GL_BYTE> osg::Vec4bArray

◆ Vec4dArray

typedef TemplateArray<Vec4d,Array::Vec4dArrayType,4,GL_DOUBLE> osg::Vec4dArray

◆ Vec4iArray

typedef TemplateArray<Vec4i,Array::Vec4iArrayType,4,GL_INT> osg::Vec4iArray

◆ Vec4sArray

typedef TemplateArray<Vec4s,Array::Vec4sArrayType,4,GL_SHORT> osg::Vec4sArray

◆ Vec4ubArray

typedef TemplateArray<Vec4ub,Array::Vec4ubArrayType,4,GL_UNSIGNED_BYTE> osg::Vec4ubArray

◆ Vec4uiArray

typedef TemplateArray<Vec4ui,Array::Vec4uiArrayType,4,GL_UNSIGNED_INT> osg::Vec4uiArray

◆ Vec4usArray

typedef TemplateArray<Vec4us,Array::Vec4usArrayType,4,GL_UNSIGNED_SHORT> osg::Vec4usArray

◆ VectorGLsizei

typedef MixinVector<GLsizei> osg::VectorGLsizei

◆ VectorGLubyte

typedef MixinVector<GLubyte> osg::VectorGLubyte

◆ VectorGLuint

typedef MixinVector<GLuint> osg::VectorGLuint

◆ VectorGLushort

typedef MixinVector<GLushort> osg::VectorGLushort

Enumeration Type Documentation

◆ ColorSpaceOperation

enum osg::ColorSpaceOperation

Enumerator
NO_COLOR_SPACE_OPERATION
MODULATE_ALPHA_BY_LUMINANCE
MODULATE_ALPHA_BY_COLOR
REPLACE_ALPHA_WITH_LUMINANCE
REPLACE_RGB_WITH_LUMINANCE

◆ Endian

enum osg::Endian

Enumerator
BigEndian
LittleEndian

◆ NotifySeverity

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 or OSG_NOTIFY_LEVEL. See documentation on osg::notify() for further details.

Enumerator
ALWAYS
FATAL
WARN
NOTICE
INFO
DEBUG_INFO
DEBUG_FP

Function Documentation

◆ _modifyRow()

template<typename T, class M>

void osg::_modifyRow	(	unsigned int	num,
		GLenum	pixelFormat,
		T *	data,
		float	scale,
		const M &	operation )

References GL_BGR, and GL_BGRA.

Referenced by modifyRow().

◆ _readRow()

template<typename T, class O>

void osg::_readRow	(	unsigned int	num,
		GLenum	pixelFormat,
		const T *	data,
		O &	operation )

References GL_BGR, GL_BGRA, and GL_INTENSITY.

Referenced by readRow().

◆ absolute()

template<typename T>

T osg::absolute ( T v )

inline

◆ asciiToDouble()

OSG_EXPORT double osg::asciiToDouble ( const char * str )

extern

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

References OSG_EXPORT.

Referenced by asciiToFloat().

◆ asciiToFloat()

float osg::asciiToFloat ( const char * str )

inline

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

References asciiToDouble().

◆ clampAbove()

template<typename T>

T osg::clampAbove	(	T	v,
		T	minimum )

inline

References minimum().

Referenced by clampBetween().

◆ clampArray3BetweenRange()

template<typename A, typename T>

void osg::clampArray3BetweenRange	(	A &	value,
		const T	minValue,
		const T	maxValue,
		const char *	valueName )

inline

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

References clampArrayElementsBetweenRange().

◆ clampArray3GEQUAL()

template<typename A, typename T>

void osg::clampArray3GEQUAL	(	A &	value,
		const T	minValue,
		const char *	valueName )

inline

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

References clampArrayElementsGEQUAL().

◆ clampArray3LEQUAL()

template<typename A, typename T>

void osg::clampArray3LEQUAL	(	A &	value,
		const T	maxValue,
		const char *	valueName )

inline

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

References clampArrayElementsLEQUAL().

◆ clampArray4BetweenRange()

template<typename A, typename T>

void osg::clampArray4BetweenRange	(	A &	value,
		const T	minValue,
		const T	maxValue,
		const char *	valueName )

inline

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

References clampArrayElementsBetweenRange().

◆ clampArray4GEQUAL()

template<typename A, typename T>

void osg::clampArray4GEQUAL	(	A &	value,
		const T	minValue,
		const char *	valueName )

inline

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

References clampArrayElementsGEQUAL().

◆ clampArray4LEQUAL()

template<typename A, typename T>

void osg::clampArray4LEQUAL	(	A &	value,
		const T	maxValue,
		const char *	valueName )

inline

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

References clampArrayElementsLEQUAL().

◆ clampArrayElementBetweenRange()

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. Equivalent to calling clampArrayElementGEQUAL( value, i, minValue, valueName ); clampArrayElementLEQUAL( value, i, maxValue, valueName );

References notify(), and WARN.

Referenced by clampArrayElementsBetweenRange().

◆ clampArrayElementGEQUAL()

template<typename A, typename T>

void osg::clampArrayElementGEQUAL	(	A &	value,
		unsigned int	i,
		const T	minValue,
		const char *	valueName )

inline

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

References notify(), and WARN.

Referenced by clampArrayElementsGEQUAL().

◆ clampArrayElementLEQUAL()

template<typename A, typename T>

void osg::clampArrayElementLEQUAL	(	A &	value,
		unsigned int	i,
		const T	maxValue,
		const char *	valueName )

inline

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

References notify(), and WARN.

Referenced by clampArrayElementsLEQUAL().

◆ clampArrayElementsBetweenRange()

template<typename A, typename T>

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

inline

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

References clampArrayElementBetweenRange().

Referenced by clampArray3BetweenRange(), and clampArray4BetweenRange().

◆ clampArrayElementsGEQUAL()

template<typename A, typename T>

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

inline

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

References clampArrayElementGEQUAL().

Referenced by clampArray3GEQUAL(), and clampArray4GEQUAL().

◆ clampArrayElementsLEQUAL()

template<typename A, typename T>

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

inline

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

References clampArrayElementLEQUAL().

Referenced by clampArray3LEQUAL(), and clampArray4LEQUAL().

◆ clampBelow()

template<typename T>

T osg::clampBelow	(	T	v,
		T	maximum )

inline

References maximum().

Referenced by clampBetween().

◆ clampBetween()

template<typename T>

T osg::clampBetween	(	T	v,
		T	minimum,
		T	maximum )

inline

References clampAbove(), clampBelow(), maximum(), and minimum().

Referenced by osgUtil::CubeMapGenerator::set_pixel().

◆ clampBetweenRange()

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. Equivalent to calling clampGEQUAL( value, minValue, valueName ); clampLEQUAL( value, maxValue, valueName );

References notify(), and WARN.

◆ clampGEQUAL()

template<typename T>

void osg::clampGEQUAL	(	T &	value,
		const T	minValue,
		const char *	valueName )

inline

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

References notify(), and WARN.

◆ clampLEQUAL()

template<typename T>

void osg::clampLEQUAL	(	T &	value,
		const T	maxValue,
		const char *	valueName )

inline

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

References notify(), and WARN.

◆ clampProjectionMatrix()

template<class matrix_type, class value_type>

bool osg::clampProjectionMatrix	(	matrix_type &	projection,
		double &	znear,
		double &	zfar,
		value_type	nearFarRatio )

References OSG_INFO.

◆ clampTo()

template<typename T>

T osg::clampTo	(	T	v,
		T	minimum,
		T	maximum )

inline

References maximum(), and minimum().

Referenced by osg::Vec4d::asABGR(), osg::Vec4f::asABGR(), osg::Vec4d::asRGBA(), and osg::Vec4f::asRGBA().

◆ clearImageToColor()

OSG_EXPORT bool osg::clearImageToColor	(	osg::Image *	image,
		const osg::Vec4 &	colour )

extern

Compute the min max colour values in the image.

References OSG_EXPORT.

◆ clone() [1/2]

template<typename T>

T * osg::clone	(	const T *	t,
		const osg::CopyOp &	copyop = osg::CopyOp::SHALLOW_COPY )

References osg::ref_ptr< T >::get(), OSG_WARN, osg::ref_ptr< T >::release(), and osg::CopyOp::SHALLOW_COPY.

Referenced by clone().

◆ clone() [2/2]

template<typename T>

T * osg::clone	(	const T *	t,
		const std::string &	name,
		const osg::CopyOp &	copyop = osg::CopyOp::SHALLOW_COPY )

References clone(), OSG_WARN, and osg::CopyOp::SHALLOW_COPY.

◆ cloneType()

template<typename T>

T * osg::cloneType ( const T * t )

References osg::ref_ptr< T >::get(), OSG_WARN, and osg::ref_ptr< T >::release().

◆ colorSpaceConversion()

OSG_EXPORT osg::Image * osg::colorSpaceConversion	(	ColorSpaceOperation	op,
		osg::Image *	image,
		const osg::Vec4 &	colour )

extern

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

References OSG_EXPORT.

◆ componentDivide() [1/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [2/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [3/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [4/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [5/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [6/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [7/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [8/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [9/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [10/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [11/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [12/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [13/14]

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

inline

divide rhs components by rhs vector components.

◆ componentDivide() [14/14]

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

inline

divide rhs components by rhs vector components.