osg Namespace Reference

Classes
class	AlphaFunc
class	AnimationPath
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
class	Billboard
class	BlendColor
class	BlendEquation
class	BlendFunc
class	BoundingBox
class	BoundingSphere
class	buffered_value
class	buffered_object
class	BufferObject
class	PixelBufferObject
class	CameraNode
class	CameraView
class	ClampColor
class	ClearNode
class	ClipNode
class	ClipPlane
class	ClusterCullingCallback
class	CollectOccludersVisitor
class	ColorMask
class	ColorMatrix
class	ConvexPlanarOccluder
class	ConvexPlanarPolygon
class	EllipsoidModel
class	CoordinateSystemNode
class	CopyOp
class	CullFace
class	CullingSet
class	CullSettings
class	CullStack
class	Depth
class	DisplaySettings
class	Drawable
class	DrawPixels
class	fast_back_stack
class	Fog
class	FragmentProgram
class	FBOExtensions
class	RenderBuffer
class	FrameBufferAttachment
class	FrameBufferObject
class	FrameStamp
class	FrontFace
class	Geode
class	Geometry
class	GL2Extensions
class	GraphicsContext
class	Block
class	GraphicsThread
struct	SwapBuffersOperation
struct	BarrierOperation
struct	ReleaseContext_Block_MakeCurrentOperation
class	Group
class	Image
class	ImageStream
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	Multisample
class	Node
class	NodeCallback
class	NodeTrackerCallback
class	NodeVisitor
struct	NodeAcceptOp
class	Object
class	Observer
class	observer_ptr
class	OccluderNode
class	PagedLOD
class	Plane
class	Point
class	PointSprite
class	PolygonMode
class	PolygonOffset
class	PolygonStipple
class	Polytope
class	PositionAttitudeTransform
class	VectorGLsizei
class	VectorGLubyte
class	VectorGLushort
class	VectorGLuint
class	PrimitiveFunctor
class	PrimitiveIndexFunctor
class	PrimitiveSet
class	DrawArrays
class	DrawArrayLengths
class	DrawElementsUByte
class	DrawElementsUShort
class	DrawElementsUInt
class	Program
class	Projection
class	ProxyNode
class	Quat
class	ref_ptr
class	Referenced
class	DeleteHandler
class	Scissor
class	Sequence
class	ShadeModel
class	Shader
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	ShapeDrawable
class	State
class	StateAttribute
class	StateSet
class	Stencil
class	Switch
class	TexEnv
class	TexEnvCombine
class	TexEnvFilter
class	TexGen
class	TexGenNode
class	TexMat
class	Texture
class	Texture1D
class	Texture2D
class	Texture3D
class	TextureCubeMap
class	TextureRectangle
class	Timer
class	Transform
class	TriangleFunctor
class	TriangleIndexFunctor
class	Matrix2
class	Matrix3
class	Uniform
class	Vec2b
class	Vec2d
class	Vec2f
class	Vec2s
class	Vec3b
class	Vec3d
class	Vec3f
class	Vec3s
class	Vec4b
class	Vec4d
class	Vec4f
class	Vec4s
class	Vec4ub
class	VertexProgram
class	Viewport
Typedefs
typedef TemplateIndexArray< GLbyte, Array::ByteArrayType, 1, GL_BYTE >	ByteArray
typedef TemplateIndexArray< GLshort, Array::ShortArrayType, 1, GL_SHORT >	ShortArray
typedef TemplateIndexArray< GLint, Array::IntArrayType, 1, GL_INT >	IntArray
typedef TemplateIndexArray< GLubyte, Array::UByteArrayType, 1, GL_UNSIGNED_BYTE >	UByteArray
typedef TemplateIndexArray< GLushort, Array::UShortArrayType, 1, GL_UNSIGNED_SHORT >	UShortArray
typedef TemplateIndexArray< GLuint, Array::UIntArrayType, 1, GL_UNSIGNED_INT >	UIntArray
typedef TemplateArray< GLfloat, Array::FloatArrayType, 1, GL_FLOAT >	FloatArray
typedef TemplateArray< Vec2, Array::Vec2ArrayType, 2, GL_FLOAT >	Vec2Array
typedef TemplateArray< Vec3, Array::Vec3ArrayType, 3, GL_FLOAT >	Vec3Array
typedef TemplateArray< Vec4, Array::Vec4ArrayType, 4, GL_FLOAT >	Vec4Array
typedef TemplateArray< Vec4ub, Array::Vec4ubArrayType, 4, GL_UNSIGNED_BYTE >	Vec4ubArray
typedef TemplateArray< Vec2s, Array::Vec2sArrayType, 2, GL_SHORT >	Vec2sArray
typedef TemplateArray< Vec3s, Array::Vec3sArrayType, 3, GL_SHORT >	Vec3sArray
typedef TemplateArray< Vec4s, Array::Vec4sArrayType, 4, GL_SHORT >	Vec4sArray
typedef TemplateArray< Vec2b, Array::Vec2bArrayType, 2, GL_BYTE >	Vec2bArray
typedef TemplateArray< Vec3b, Array::Vec3bArrayType, 3, GL_BYTE >	Vec3bArray
typedef TemplateArray< Vec4b, Array::Vec4bArrayType, 4, GL_BYTE >	Vec4bArray
typedef Matrixd	CoordinateFrame
typedef std::vector< ref_ptr< Node > >	NodeList
typedef Matrixd	Matrix
typedef RefMatrixd	RefMatrix
typedef std::vector< Node * >	NodePath
typedef std::vector< NodePath >	NodePathList
typedef std::vector< Matrix >	MatrixList
typedef std::vector< ShadowVolumeOccluder >	ShadowVolumeOccluderList
typedef HeightField	Grid
typedef unsigned long long	Timer_t
typedef Vec2f	Vec2
typedef Vec3f	Vec3
typedef Vec4f	Vec4
Enumerations
enum	Endian { BigEndian, LittleEndian }
enum	NotifySeverity {   ALWAYS = 0, FATAL = 1, WARN = 2, NOTICE = 3,   INFO = 4, DEBUG_INFO = 5, DEBUG_FP = 6 }
Functions
template<typename T>
void	clampGEQUAL (T &value, const T minValue, const char *valueName)
template<typename T>
void	clampLEQUAL (T &value, const T maxValue, const char *valueName)
template<typename T>
void	clampBetweenRange (T &value, const T minValue, const T maxValue, const char *valueName)
template<typename A, typename T>
void	clampArrayElementGEQUAL (A &value, unsigned int i, const T minValue, const char *valueName)
template<typename A, typename T>
void	clampArrayElementLEQUAL (A &value, unsigned int i, const T maxValue, const char *valueName)
template<typename A, typename T>
void	clampArrayElementBetweenRange (A &value, unsigned int i, const T minValue, const T maxValue, const char *valueName)
template<typename A, typename T>
void	clampArrayElementsGEQUAL (A &value, unsigned int first, unsigned int last, const T minValue, const char *valueName)
template<typename A, typename T>
void	clampArrayElementsLEQUAL (A &value, unsigned int first, unsigned int last, const T maxValue, const char *valueName)
template<typename A, typename T>
void	clampArrayElementsBetweenRange (A &value, unsigned int first, unsigned int last, const T minValue, const T maxValue, const char *valueName)
template<typename A, typename T>
void	clampArray3GEQUAL (A &value, const T minValue, const char *valueName)
template<typename A, typename T>
void	clampArray3LEQUAL (A &value, const T maxValue, const char *valueName)
template<typename A, typename T>
void	clampArray3BetweenRange (A &value, const T minValue, const T maxValue, const char *valueName)
template<typename A, typename T>
void	clampArray4GEQUAL (A &value, const T minValue, const char *valueName)
template<typename A, typename T>
void	clampArray4LEQUAL (A &value, const T maxValue, const char *valueName)
template<typename A, typename T>
void	clampArray4BetweenRange (A &value, const T minValue, const T maxValue, const char *valueName)
Endian	getCpuByteOrder ()
void	swapBytes (char *in, unsigned int size)
void	swapBytes2 (char *in)
void	swapBytes4 (char *in)
void	swapBytes8 (char *in)
void	swapBytes16 (char *in)
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	isGLExtensionSupported (unsigned int contextID, const char *extension)
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)
OSG_EXPORT bool	isGLUExtensionSupported (unsigned int contextID, const char *extension)
OSG_EXPORT Geode *	createGeodeForImage (Image *image)
OSG_EXPORT Geode *	createGeodeForImage (Image *image, float s, float t)
std::ostream &	operator<< (std::ostream &output, const Vec2f &vec)
std::istream &	operator>> (std::istream &input, Vec2f &vec)
std::ostream &	operator<< (std::ostream &output, const Vec2d &vec)
std::istream &	operator>> (std::istream &input, Vec2d &vec)
std::ostream &	operator<< (std::ostream &output, const Vec3f &vec)
std::istream &	operator>> (std::istream &input, Vec3f &vec)
std::ostream &	operator<< (std::ostream &output, const Vec3d &vec)
std::istream &	operator>> (std::istream &input, Vec3d &vec)
std::ostream &	operator<< (std::ostream &output, const Vec4f &vec)
std::istream &	operator>> (std::istream &input, Vec4f &vec)
std::ostream &	operator<< (std::ostream &output, const Vec4d &vec)
std::istream &	operator>> (std::istream &input, Vec4d &vec)
std::ostream &	operator<< (std::ostream &output, const Vec2b &vec)
std::istream &	operator>> (std::istream &input, Vec2b &vec)
std::ostream &	operator<< (std::ostream &output, const Vec3b &vec)
std::istream &	operator>> (std::istream &input, Vec3b &vec)
std::ostream &	operator<< (std::ostream &output, const Vec4b &vec)
std::istream &	operator>> (std::istream &input, Vec4b &vec)
std::ostream &	operator<< (std::ostream &output, const Vec2s &vec)
std::istream &	operator>> (std::istream &input, Vec2s &vec)
std::ostream &	operator<< (std::ostream &output, const Vec3s &vec)
std::istream &	operator>> (std::istream &input, Vec3s &vec)
std::ostream &	operator<< (std::ostream &output, const Vec4s &vec)
std::istream &	operator>> (std::istream &input, Vec4s &vec)
std::ostream &	operator<< (std::ostream &os, const Matrixf &m)
std::ostream &	operator<< (std::ostream &os, const Matrixd &m)
std::ostream &	operator<< (std::ostream &output, const Vec4ub &vec)
std::istream &	operator>> (std::istream &input, Vec4ub &vec)
std::ostream &	operator<< (std::ostream &output, const Quat &vec)
std::istream &	operator>> (std::istream &input, Quat &vec)
std::ostream &	operator<< (std::ostream &output, const Plane &pl)
std::istream &	operator>> (std::istream &input, Plane &vec)
template<typename T>
T	absolute (T v)
float	equivalent (float lhs, float rhs, float epsilon=1e-6)
double	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	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)
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)
OSG_EXPORT void	setNotifyLevel (NotifySeverity severity)
OSG_EXPORT NotifySeverity	getNotifyLevel ()
OSG_EXPORT bool	isNotifyEnabled (NotifySeverity severity)
OSG_EXPORT bool	initNotifyLevel ()
OSG_EXPORT std::ostream &	notify (const NotifySeverity severity)
std::ostream &	notify (void)
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)
OSG_EXPORT Matrix	computeLocalToWorld (const NodePath &nodePath, bool ignoreCameraNodes=true)
OSG_EXPORT Matrix	computeWorldToLocal (const NodePath &nodePath, bool ignoreCameraNodes=true)
OSG_EXPORT Matrix	computeLocalToEye (const Matrix &modelview, const NodePath &nodePath, bool ignoreCameraNodes=true)
OSG_EXPORT Matrix	computeEyeToLocal (const Matrix &modelview, const NodePath &nodePath, bool ignoreCameraNodes=true)
Vec4d::value_type	operator * (const Vec3d &lhs, const Vec4d &rhs)
Vec4d::value_type	operator * (const Vec4d &lhs, const Vec3d &rhs)
Vec4f::value_type	operator * (const Vec3f &lhs, const Vec4f &rhs)
Vec4f::value_type	operator * (const Vec4f &lhs, const Vec3f &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 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 TemplateIndexArray<GLshort,Array::ShortArrayType,1,GL_SHORT> osg::ShortArray

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

typedef Matrixd osg::CoordinateFrame

CoordinateFrame encapsulates the orientation of east, north and up.

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

typedef Matrixd osg::Matrix

typedef RefMatrixd osg::RefMatrix

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

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

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

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

typedef std::vector< Matrix > osg::MatrixList

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

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

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

typedef HeightField osg::Grid

typedef unsigned long long osg::Timer_t

typedef Vec2f osg::Vec2

typedef Vec3f osg::Vec3

typedef Vec4f osg::Vec4

---

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>

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

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

template<typename T>

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

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

template<typename T>

void osg::clampBetweenRange	(	T &	value,
		const T	minValue,
		const T	maxValue,
		const char *	valueName
	)			[inline]

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

template<typename A, typename T>

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

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

template<typename A, typename T>

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

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

template<typename A, typename T>

void osg::clampArrayElementBetweenRange	(	A &	value,
		unsigned int	i,
		const T	minValue,
		const T	maxValue,
		const char *	valueName
	)			[inline]

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

template<typename A, typename T>

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

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

template<typename A, typename T>

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

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

template<typename A, typename T>

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

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

template<typename A, typename T>

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

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

template<typename A, typename T>

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

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

template<typename A, typename T>

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

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

template<typename A, typename T>

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

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

template<typename A, typename T>

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

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

template<typename A, typename T>

void osg::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);

Endian osg::getCpuByteOrder

(

)

[inline]

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

void osg::swapBytes2

(

char *

in

)

[inline]

void osg::swapBytes4

(

char *

in

)

[inline]

void osg::swapBytes8

(

char *

in

)

[inline]

void osg::swapBytes16

(

char *

in

)

[inline]

OSG_EXPORT Geometry* osg::createTexturedQuadGeometry	(	const Vec3 &	corner,
		const Vec3 &	widthVec,
		const Vec3 &	heightVec,
		float	l,
		float	b,
		float	r,
		float	t
	)

Convenience function to be used for creating quad geometry with texture coords. Tex coords go from left bottom (l,b) to right top (r,t).

Geometry* osg::createTexturedQuadGeometry	(	const Vec3 &	corner,
		const Vec3 &	widthVec,
		const Vec3 &	heightVec,
		float	s = 1.0f,
		float	t = 1.0f
	)			[inline]

Convenience function to be used for creating quad geometry with texture coords. Tex coords go from bottom left (0,0) to top right (s,t).

OSG_EXPORT float osg::getGLVersionNumber

(

)

Return floating-point OpenGL version number. Note: Must only be called within a valid OpenGL context, undefined behavior may occur otherwise.

OSG_EXPORT bool osg::isGLExtensionSupported	(	unsigned int	contextID,
		const char *	extension
	)

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

OSG_EXPORT void* osg::getGLExtensionFuncPtr

(

const char *

funcName

)

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

OSG_EXPORT void osg::setGLExtensionDisableString

(

const std::string &

disableString

)

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

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

OSG_EXPORT bool osg::isGLUExtensionSupported	(	unsigned int	contextID,
		const char *	extension
	)

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

OSG_EXPORT Geode* osg::createGeodeForImage

(

Image *

image

)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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.

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.

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.

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::clampTo	(	T	v,
		T	minimum,
		T	maximum
	)			[inline]

template<typename T>

T osg::clampAbove	(	T	v,
		T	minimum
	)			[inline]

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<typename T>

T osg::sign

(

T

v

)

[inline]

template<typename T>

T osg::square

(

T

v

)

[inline]

template<typename T>

T osg::signedSquare

(

T

v

)

[inline]

float osg::inDegrees

(

float

angle

)

[inline]

double osg::inDegrees

(

double

angle

)

[inline]

template<typename T>

T osg::inRadians

(

T

angle

)

[inline]

float osg::DegreesToRadians

(

float

angle

)

[inline]

double osg::DegreesToRadians

(

double

angle

)

[inline]

float osg::RadiansToDegrees

(

float

angle

)

[inline]

double osg::RadiansToDegrees

(

double

angle

)

[inline]

float osg::round

(

float

v

)

[inline]

double osg::round

(

double

v

)

[inline]

bool osg::isNaN

(

float

v

)

[inline]

bool osg::isNaN

(

double

v

)

[inline]

template<typename T>

float osg::computeVolume	(	const T &	a,
		const T &	b,
		const T &	c,
		const T &	d
	)			[inline]

compute the volume of a tetrahedron.

template<typename T>

float osg::computeVolume	(	const T &	f1,
		const T &	f2,
		const T &	f3,
		const T &	b1,
		const T &	b2,
		const T &	b3
	)			[inline]

compute the volume of a prism.

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

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

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

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

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

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

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

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

OSG_EXPORT void osg::setNotifyLevel

(

NotifySeverity

severity

)

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

OSG_EXPORT NotifySeverity osg::getNotifyLevel

(

)

get the notify level.

OSG_EXPORT bool osg::isNotifyEnabled

(

NotifySeverity

severity

)

is notification enabled, given the current setNotifyLevel() setting?

OSG_EXPORT bool osg::initNotifyLevel

(

)

initialize notify level.

OSG_EXPORT std::ostream& osg::notify

(

const NotifySeverity

severity

)

notify messaging function for providing fatal through to verbose debugging messages. Level of messages sent to the console can be controlled by setting the NotifyLevel either within your application or via the an environmental variable. For instance setenv OSGNOTIFYLEVEL DEBUG (for tsh), export OSGNOTIFYLEVEL=DEBUG (for bourne shell) or set OSGNOTIFYLEVEL=DEBUG (for Windows) all tell the osg to redirect all debugging and more important messages to the console (useful for debugging :-) setting ALWAYS will force all messages to be absorbed, which might be appropriate for final applications. Default NotifyLevel is NOTICE. Check the enum NotifySeverity for full range of possibilities. To use the notify with your code simply use the notify function as a normal file stream (like cout) i.e osg::notify(osg::DEBUG) << "Hello Bugs!"<<endl;

std::ostream& osg::notify

(

void

)

[inline]

template<class T>

void osg::swap	(	ref_ptr< T > &	rp1,
		ref_ptr< T > &	rp2
	)			[inline]

template<class T>

T* osg::get_pointer

(

const ref_ptr< T > &

rp

)

[inline]

template<class T, class Y>

ref_ptr<T> osg::static_pointer_cast

(

const ref_ptr< Y > &

rp

)

[inline]

template<class T, class Y>

ref_ptr<T> osg::dynamic_pointer_cast

(

const ref_ptr< Y > &

rp

)

[inline]

template<class T, class Y>

ref_ptr<T> osg::const_pointer_cast

(

const ref_ptr< Y > &

rp

)

[inline]

OSG_EXPORT Matrix osg::computeLocalToWorld	(	const NodePath &	nodePath,
		bool	ignoreCameraNodes = true
	)

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

OSG_EXPORT Matrix osg::computeWorldToLocal	(	const NodePath &	nodePath,
		bool	ignoreCameraNodes = true
	)

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

OSG_EXPORT Matrix osg::computeLocalToEye	(	const Matrix &	modelview,
		const NodePath &	nodePath,
		bool	ignoreCameraNodes = true
	)

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

OSG_EXPORT Matrix osg::computeEyeToLocal	(	const Matrix &	modelview,
		const NodePath &	nodePath,
		bool	ignoreCameraNodes = true
	)

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

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

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

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

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

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

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

---

Variable Documentation

const double osg::WGS_84_RADIUS_EQUATOR = 6378137.0

const double osg::WGS_84_RADIUS_POLAR = 6356752.3142

const double osg::PI = 3.14159265358979323846

const double osg::PI_2 = 1.57079632679489661923

const double osg::PI_4 = 0.78539816339744830962

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)

---