Home	Download	Screen shots	Discussion	Documentation

openvrml Namespace Reference

---

Detailed Description

The OpenVRML Runtime Library.

Classes
class	color
	A color. More...
class	vec2f
	Two-component single precision vector. More...
class	vec3f
	Three-component single precision vector. More...
class	rotation
	A rotation. More...
class	mat4f
	A class for all matrix operations. More...
class	quatf
	A quaternion. More...
class	image
	Pixmap data. More...
class	bounding_volume
	A bounding volume. More...
class	bounding_sphere
	A bounding sphere. More...
class	axis_aligned_bounding_box
	An axis-aligned bounding box. More...
class	invalid_vrml
	Exception thrown when the parser fails due to errors in the VRML input. More...
class	viewer_in_use
	Exception thrown when attempting to associate a viewer with a browser when the viewer is already associated with a browser. More...
class	browser
	Encapsulates a VRML browser. More...
class	bad_url
	Thrown when there is a problem resolving a URI. More...
class	invalid_url
	Thrown when parsing a URI fails. More...
class	unreachable_url
	Thrown when a URI cannot be reached. More...
class	no_alternative_url
	Exception thrown when no URI in an alternative URI list can be resolved. More...
class	scene
	A scene in the VRML world. More...
class	doc
	A class to contain document references. More...
class	doc2
	A class to contain document references. More...
class	event_listener
	Abstract base class of event listeners. More...
class	field_value_listener
	Concrete event listener template. More...
class	event_emitter
	Abstract base class of event emitters. More...
class	field_value_emitter
	Concrete event emitter template. More...
class	exposedfield
	Class template to simplify implementation of exposedFields. More...
class	field_value
	Abstract base class for the VRML field types. More...
struct	FieldValueConcept
	Concept checking class to validate that a template parameter is a model of the FieldValue concept. More...
class	sfbool
	A boolean node field value. More...
class	sfcolor
	A color node field value. More...
class	sffloat
	A single precision floating point node field value. More...
class	sfimage
	A pixmap. More...
class	sfint32
	A 32-bit integer node field value. More...
class	sfnode
	A node field value to hold a single node reference. More...
class	sfrotation
	A rotation node field value. More...
class	sfstring
	A string node field value. More...
class	sftime
	A double precision floating point node field value. More...
class	sfvec2f
	A 2-component vector node field value. More...
class	sfvec3f
	A 3-component vector node field value. More...
class	mfcolor
	A color array node field value. More...
class	mffloat
	A float array node field value. More...
class	mfint32
	An integer array node field value. More...
class	mfnode
	A node reference array node field value. More...
class	mfrotation
	A rotation array node field value. More...
class	mfstring
	A string array node field value. More...
class	mftime
	A double array node field value. More...
class	mfvec2f
	A 2-component vector array node field value. More...
class	mfvec3f
	A 3-component vector array node field value. More...
class	frustum
	A view frustum. More...
class	img
	Image data. More...
class	node_interface
	Type information for an interface of a node. More...
class	unsupported_interface
	Exception to indicate that a node interface is not supported. More...
struct	node_interface_matches_eventin
	Determine if a node_interface matches an eventIn identifier. More...
struct	node_interface_matches_eventout
	Determine if a node_interface matches an eventOut identifier. More...
struct	node_interface_matches_exposedfield
	Determine if a node_interface matches an exposedField identifier. More...
struct	node_interface_matches_field
	Determine if a node_interface matches an field identifier. More...
struct	node_interface_compare
	Function object to compare two node_interfaces based on their id. More...
class	node_class
	A class object for node instances. More...
class	node_type
	Type information object for nodes. More...
class	field_value_type_mismatch
	Thrown when field value types do not match, generally in a ROUTE or IS. More...
class	node
	A node in the scene graph. More...
class	appearance_node
	Abstract base class for appearance nodes. More...
class	child_node
	Abstract base class for child nodes. More...
class	color_node
	Abstract base class for color nodes. More...
class	coordinate_node
	Abstract base class for coordinate nodes. More...
class	font_style_node
	Abstract base class for font style nodes. More...
class	geometry_node
	Abstract base class for geometry nodes. More...
class	grouping_node
	Abstract base class for grouping nodes. More...
class	material_node
	Abstract base class for material nodes. More...
class	normal_node
	Abstract base class for normal nodes. More...
class	sound_source_node
	Abstract base class for sound source nodes. More...
class	texture_node
	Abstract base class for texture nodes. More...
class	texture_coordinate_node
	Abstract base class for texture coordinate nodes. More...
class	texture_transform_node
	Abstract base class for texture transform nodes. More...
class	transform_node
	Abstract base class for texture transform nodes. More...
class	viewpoint_node
	Abstract base class for texture transform nodes. More...
class	node_traverser
	Traverse the children of each node in a node hierarchy only once. More...
class	node_ptr
	A reference-counted smart pointer for nodes. More...
class	rendering_context
	Information needed during a render traversal. More...
class	scope
	The scope class keeps track of defined nodes and prototypes. More...
class	script
	Abstract class implemented by scripting language bindings. More...
class	script_node_class
	Class object for script_nodes. More...
class	script_node
	Represents a VRML Script node. More...
class	viewer
	Map the scene graph to the underlying graphics library. More...
Namespaces
namespace	vrml97_node
	Implementations of the VRML97 nodes.
namespace	gl
	OpenGL geometry renderer.
Typedefs
typedef int32_t	int32
	32-bit signed integer.
typedef field_value_listener< sfbool >	sfbool_listener
	sfbool event listener.
typedef field_value_listener< sfcolor >	sfcolor_listener
	sfcolor event listener.
typedef field_value_listener< sffloat >	sffloat_listener
	sffloat event listener.
typedef field_value_listener< sfimage >	sfimage_listener
	sfimage event listener.
typedef field_value_listener< sfint32 >	sfint32_listener
	sfint32 event listener.
typedef field_value_listener< sfnode >	sfnode_listener
	sfnode event listener.
typedef field_value_listener< sfrotation >	sfrotation_listener
	sfrotation event listener.
typedef field_value_listener< sfstring >	sfstring_listener
	sfstring event listener.
typedef field_value_listener< sftime >	sftime_listener
	sftime event listener.
typedef field_value_listener< sfvec2f >	sfvec2f_listener
	sfvec2f event listener.
typedef field_value_listener< sfvec3f >	sfvec3f_listener
	sfvec3f event listener.
typedef field_value_listener< mfcolor >	mfcolor_listener
	mfcolor event listener.
typedef field_value_listener< mffloat >	mffloat_listener
	mffloat event listener.
typedef field_value_listener< mfint32 >	mfint32_listener
	mfint32 event listener.
typedef field_value_listener< mfnode >	mfnode_listener
	mfnode event listener.
typedef field_value_listener< mfrotation >	mfrotation_listener
	mfrotation event listener.
typedef field_value_listener< mfstring >	mfstring_listener
	mfstring event listener.
typedef field_value_listener< mftime >	mftime_listener
	mftime event listener.
typedef field_value_listener< mfvec2f >	mfvec2f_listener
	mfvec2f event listener.
typedef field_value_listener< mfvec3f >	mfvec3f_listener
	mfvec3f event listener.
typedef field_value_emitter< sfbool >	sfbool_emitter
	sfbool event emitter.
typedef field_value_emitter< sfcolor >	sfcolor_emitter
	sfcolor event emitter.
typedef field_value_emitter< sffloat >	sffloat_emitter
	sffloat event emitter.
typedef field_value_emitter< sfimage >	sfimage_emitter
	sfimage event emitter.
typedef field_value_emitter< sfint32 >	sfint32_emitter
	sfint32 event emitter.
typedef field_value_emitter< sfnode >	sfnode_emitter
	sfnode event emitter.
typedef field_value_emitter< sfrotation >	sfrotation_emitter
	sfrotation event emitter.
typedef field_value_emitter< sfstring >	sfstring_emitter
	sfstring event emitter.
typedef field_value_emitter< sftime >	sftime_emitter
	sftime event emitter.
typedef field_value_emitter< sfvec2f >	sfvec2f_emitter
	sfvec2f event emitter.
typedef field_value_emitter< sfvec3f >	sfvec3f_emitter
	sfvec3f event emitter.
typedef field_value_emitter< mfcolor >	mfcolor_emitter
	mfcolor event emitter.
typedef field_value_emitter< mffloat >	mffloat_emitter
	mffloat event emitter.
typedef field_value_emitter< mfint32 >	mfint32_emitter
	mfint32 event emitter.
typedef field_value_emitter< mfnode >	mfnode_emitter
	mfnode event emitter.
typedef field_value_emitter< mfrotation >	mfrotation_emitter
	mfrotation event emitter.
typedef field_value_emitter< mfstring >	mfstring_emitter
	mfstring event emitter.
typedef field_value_emitter< mftime >	mftime_emitter
	mftime event emitter.
typedef field_value_emitter< mfvec2f >	mfvec2f_emitter
	mfvec2f event emitter.
typedef field_value_emitter< mfvec3f >	mfvec3f_emitter
	mfvec3f event emitter.
typedef boost::shared_ptr< field_value >	field_value_ptr
	A boost::shared_ptr to a field_value.
typedef std::set< node_interface, node_interface_compare >	node_interface_set
	A group of unique node_interfaces.
typedef boost::shared_ptr< node_type >	node_type_ptr
	A boost::shared_ptr to a node_type.
typedef boost::shared_ptr< node_class >	node_class_ptr
	A boost::shared_ptr to a node_class.
typedef std::map< std::string, boost::shared_ptr< field_value > >	initial_value_map
	A map of the initial values with which a node is instantiated.
typedef std::deque< node * >	node_path
	A path to a node in the scene starting with one of the scene root nodes and ending with the objective node.
Functions
bool	operator== (const color &lhs, const color &rhs) throw ()
	Compare for equality.
bool	operator!= (const color &lhs, const color &rhs) throw ()
	Compare for inequality.
std::ostream &	operator<< (std::ostream &out, const color &c)
	Stream output.
const vec2f	operator * (const vec2f &lhs, const float rhs) throw ()
	Multiply a vector by a scalar.
const vec2f	operator * (const float lhs, const vec2f &rhs) throw ()
	Multiply a vector by a scalar.
const vec2f	operator/ (const vec2f &lhs, const float rhs) throw ()
	Divide a vector by a scalar.
const vec2f	operator+ (const vec2f &lhs, const vec2f &rhs) throw ()
	Add two vectors.
const vec2f	operator- (const vec2f &lhs, const vec2f &rhs) throw ()
	Subtract two vectors.
bool	operator== (const vec2f &lhs, const vec2f &rhs) throw ()
	Compare for equality.
bool	operator!= (const vec2f &lhs, const vec2f &rhs) throw ()
	Compare for inequality.
std::ostream &	operator<< (std::ostream &out, const vec2f &v)
	Stream output.
const vec3f	operator * (const vec3f &lhs, const vec3f &rhs) throw ()
	Cross multiply two vectors.
const vec3f	operator * (const vec3f &vec, const mat4f &mat) throw ()
	Multiply a vector by a matrix.
const vec3f	operator * (const mat4f &mat, const vec3f &vec) throw ()
	Multiply a matrix by a vector.
const vec3f	operator * (const vec3f &lhs, const float rhs) throw ()
	Multiply a vector by a scalar.
const vec3f	operator * (const float lhs, const vec3f &rhs) throw ()
	Multiply a vector by a scalar.
const vec3f	operator/ (const vec3f &lhs, const float rhs) throw ()
	Divide a vector by a scalar.
const vec3f	operator+ (const vec3f &lhs, const vec3f &rhs) throw ()
	Add two vectors.
const vec3f	operator- (const vec3f &lhs, const vec3f &rhs) throw ()
	Subtract two vectors.
bool	operator== (const vec3f &lhs, const vec3f &rhs) throw ()
	Compare for equality.
bool	operator!= (const vec3f &lhs, const vec3f &rhs) throw ()
	Compare for inequality.
std::ostream &	operator<< (std::ostream &out, const vec3f &v)
	Stream output.
const rotation	operator * (const rotation &lhs, const rotation &rhs) throw ()
	Multiply rotations.
bool	operator== (const rotation &lhs, const rotation &rhs) throw ()
	Compare for equality.
bool	operator!= (const rotation &lhs, const rotation &rhs) throw ()
	Compare for inequality.
std::ostream &	operator<< (std::ostream &out, const rotation &r)
	Stream output.
const mat4f	operator * (const mat4f &mat, const float scalar) throw ()
	Multiply a matrix by a scalar value.
const mat4f	operator * (const float scalar, const mat4f &mat) throw ()
	Multiply a scalar value by matrix.
const mat4f	operator * (const mat4f &lhs, const mat4f &rhs) throw ()
	Multiply two matrices.
std::ostream &	operator<< (std::ostream &out, const mat4f &mat)
	Stream output.
bool	operator== (const mat4f &lhs, const mat4f &rhs) throw ()
	Equality comparison operator.
bool	operator!= (const mat4f &lhs, const mat4f &rhs) throw ()
	Inequality comparison operator.
const quatf	operator * (const quatf &lhs, const quatf &rhs) throw ()
	Multiply two quaternions.
const quatf	operator * (const quatf &quat, const float scalar) throw ()
	Multiply a quaternion by a scalar.
const quatf	operator * (const float scalar, const quatf &quat) throw ()
	Multiply a scalar by a quaternion.
const quatf	operator/ (const quatf &quat, const float scalar) throw ()
	Divide a quaternion by a scalar.
const quatf	operator+ (const quatf &lhs, const quatf &rhs) throw ()
	Add two quaternions.
const quatf	operator- (const quatf &lhs, const quatf &rhs) throw ()
	Take the difference between two quaternions.
std::ostream &	operator<< (std::ostream &out, const quatf &quat)
	Stream output.
bool	operator== (const quatf &lhs, const quatf &rhs) throw ()
	Compare for equality.
bool	operator!= (const quatf &lhs, const quatf &rhs) throw ()
	Compare for inequality.
bool	operator== (const image &lhs, const image &rhs) throw ()
	Compare for equality.
bool	operator!= (const image &lhs, const image &rhs) throw ()
	Compare for inequality.
std::ostream &	operator<< (std::ostream &out, const image &img)
	Stream output.
	float (&mat4f::operator[](size_t index) throw())[4]
	Row access.
const	float (&mat4f::operator[](size_t index) const throw())[4]
	Row access.
std::ostream &	operator<< (std::ostream &out, const field_value &value)
	Stream output.
std::ostream &	operator<< (std::ostream &out, const field_value::type_id type_id)
	Stream output.
std::istream &	operator>> (std::istream &in, field_value::type_id &type_id)
	Stream input.
bool	operator== (const sfbool &lhs, const sfbool &rhs) throw ()
	Compare for equality.
bool	operator!= (const sfbool &lhs, const sfbool &rhs) throw ()
	Compare for inequality.
bool	operator== (const sfcolor &lhs, const sfcolor &rhs) throw ()
	Compare for equality.
bool	operator!= (const sfcolor &lhs, const sfcolor &rhs) throw ()
	Compare for inequality.
bool	operator== (const sffloat &lhs, const sffloat &rhs) throw ()
	Compare for equality.
bool	operator!= (const sffloat &lhs, const sffloat &rhs) throw ()
	Compare for inequality.
bool	operator== (const sfimage &lhs, const sfimage &rhs) throw ()
	Compare for equality.
bool	operator!= (const sfimage &lhs, const sfimage &rhs) throw ()
	Compare for inequality.
bool	operator== (const sfint32 &lhs, const sfint32 &rhs) throw ()
	Compare for equality.
bool	operator!= (const sfint32 &lhs, const sfint32 &rhs) throw ()
	Compare for inequality.
bool	operator== (const sfnode &lhs, const sfnode &rhs) throw ()
	Compare for equality.
bool	operator!= (const sfnode &lhs, const sfnode &rhs) throw ()
	Compare for inequality.
bool	operator== (const sfrotation &lhs, const sfrotation &rhs) throw ()
	Compare for equality.
bool	operator!= (const sfrotation &lhs, const sfrotation &rhs) throw ()
	Compare for inequality.
bool	operator== (const sfstring &lhs, const sfstring &rhs) throw ()
	Compare for equality.
bool	operator!= (const sfstring &lhs, const sfstring &rhs) throw ()
	Compare for inequality.
bool	operator== (const sftime &lhs, const sftime &rhs) throw ()
	Compare for equality.
bool	operator!= (const sftime &lhs, const sftime &rhs) throw ()
	Compare for inequality.
bool	operator== (const sfvec2f &lhs, const sfvec2f &rhs) throw ()
	Compare for equality.
bool	operator!= (const sfvec2f &lhs, const sfvec2f &rhs) throw ()
	Compare for inequality.
bool	operator== (const sfvec3f &lhs, const sfvec3f &rhs) throw ()
	Compare for equality.
bool	operator!= (const sfvec3f &lhs, const sfvec3f &rhs) throw ()
	Compare for inequality.
bool	operator== (const mfcolor &lhs, const mfcolor &rhs) throw ()
	Compare for equality.
bool	operator!= (const mfcolor &lhs, const mfcolor &rhs) throw ()
	Compare for inequality.
bool	operator== (const mffloat &lhs, const mffloat &rhs) throw ()
	Compare for equality.
bool	operator!= (const mffloat &lhs, const mffloat &rhs) throw ()
	Compare for inequality.
bool	operator== (const mfint32 &lhs, const mfint32 &rhs) throw ()
	Compare for equality.
bool	operator!= (const mfint32 &lhs, const mfint32 &rhs) throw ()
	Compare for inequality.
bool	operator== (const mfnode &lhs, const mfnode &rhs) throw ()
	Compare for equality.
bool	operator!= (const mfnode &lhs, const mfnode &rhs) throw ()
	Compare for inequality.
bool	operator== (const mfrotation &lhs, const mfrotation &rhs) throw ()
	Compare for equality.
bool	operator!= (const mfrotation &lhs, const mfrotation &rhs) throw ()
	Compare for inequality.
bool	operator== (const mfstring &lhs, const mfstring &rhs) throw ()
	Compare for equality.
bool	operator!= (const mfstring &lhs, const mfstring &rhs) throw ()
	Compare for inequality.
bool	operator== (const mftime &lhs, const mftime &rhs) throw ()
	Compare for equality.
bool	operator!= (const mftime &lhs, const mftime &rhs) throw ()
	Compare for inequality.
bool	operator== (const mfvec2f &lhs, const mfvec2f &rhs) throw ()
	Compare for equality.
bool	operator!= (const mfvec2f &lhs, const mfvec2f &rhs) throw ()
	Compare for inequality.
bool	operator== (const mfvec3f &lhs, const mfvec3f &rhs) throw ()
	Compare for equality.
bool	operator!= (const mfvec3f &lhs, const mfvec3f &rhs) throw ()
	Compare for inequality.
std::ostream &	operator<< (std::ostream &out, const node_interface::type_id type)
	Stream inserter.
std::istream &	operator>> (std::istream &in, node_interface::type_id &type)
	Stream extractor.
bool	operator== (const node_interface &lhs, const node_interface &rhs) throw ()
	Compare for equality.
bool	operator!= (const node_interface &lhs, const node_interface &rhs) throw ()
	Compare for openvrml::inequality.
std::ostream &	operator<< (std::ostream &out, const node_interface &interface)
	Stream output.
std::istream &	operator>> (std::istream &in, node_interface &interface)
	Stream input.
const node_interface_set::const_iterator	find_interface (const node_interface_set &interfaces, const std::string &id) throw ()
	Find an interface matching id.
std::ostream &	operator<< (std::ostream &out, const node &n)
	Stream output.
bool	add_route (node &from_node, const std::string &from_eventout, node &to_node, const std::string &to_eventin) throw (std::bad_alloc, unsupported_interface, field_value_type_mismatch)
	Add a route from an eventOut of this node to an eventIn of another node.
bool	delete_route (node &from, const std::string &eventout, node &to, const std::string &eventin) throw (unsupported_interface)
	Remove a route from an eventOut of this node to an eventIn of another node.
template<typename To>
To	node_cast (node *n) throw ()
	Downcast a node to one of the abstract node types.
template<>
script_node *	node_cast< script_node * > (node *n) throw ()
	Cast to a script_node.
template<>
appearance_node *	node_cast< appearance_node * > (node *n) throw ()
	Cast to an appearance_node.
template<>
child_node *	node_cast< child_node * > (node *n) throw ()
	Cast to a child_node.
template<>
color_node *	node_cast< color_node * > (node *n) throw ()
	Cast to a color_node.
template<>
coordinate_node *	node_cast< coordinate_node * > (node *n) throw ()
	Cast to a coordinate_node.
template<>
font_style_node *	node_cast< font_style_node * > (node *n) throw ()
	Cast to a font_style_node.
template<>
geometry_node *	node_cast< geometry_node * > (node *n) throw ()
	Cast to a geometry_node.
template<>
grouping_node *	node_cast< grouping_node * > (node *n) throw ()
	Cast to a grouping_node.
template<>
material_node *	node_cast< material_node * > (node *n) throw ()
	Cast to a material_node.
template<>
normal_node *	node_cast< normal_node * > (node *n) throw ()
	Cast to a normal_node.
template<>
sound_source_node *	node_cast< sound_source_node * > (node *n) throw ()
	Cast to a sound_source_node.
template<>
texture_node *	node_cast< texture_node * > (node *n) throw ()
	Cast to a texture_node.
template<>
texture_coordinate_node *	node_cast< texture_coordinate_node * > (node *n) throw ()
	Cast to a texture_coordinate_node.
template<>
texture_transform_node *	node_cast< texture_transform_node * > (node *n) throw ()
	Cast to a texture_transform_node.
template<>
transform_node *	node_cast< transform_node * > (node *n) throw ()
	Cast to a transform_node.
template<>
viewpoint_node *	node_cast< viewpoint_node * > (node *n) throw ()
	Cast to a viewpoint_node.
bool	operator== (const node_ptr &lhs, const node_ptr &rhs) throw ()
	Compare for equality.
bool	operator!= (const node_ptr &lhs, const node_ptr &rhs) throw ()
	Compare for inequality.
Variables
const double	pi = 3.14159265358979323846
	pi
const double	pi_2 = 1.57079632679489661923
	pi/2
const double	pi_4 = 0.78539816339744830962
	pi/4
const double	inv_pi = 0.31830988618379067154
	1/pi
system *	the_system = &defaultSystem
	The global system object.

---

Typedef Documentation

openvrml::sfbool_listener

sfbool event listener.

openvrml::sfcolor_listener

sfcolor event listener.

openvrml::sffloat_listener

sffloat event listener.

openvrml::sfimage_listener

sfimage event listener.

openvrml::sfint32_listener

sfint32 event listener.

openvrml::sfnode_listener

sfnode event listener.

openvrml::sfrotation_listener

sfrotation event listener.

openvrml::sfstring_listener

sfstring event listener.

openvrml::sftime_listener

sftime event listener.

openvrml::sfvec2f_listener

sfvec2f event listener.

openvrml::sfvec3f_listener

sfvec3f event listener.

openvrml::mfcolor_listener

mfcolor event listener.

openvrml::mffloat_listener

mffloat event listener.

openvrml::mfint32_listener

mfint32 event listener.

openvrml::mfnode_listener

mfnode event listener.

openvrml::mfrotation_listener

mfrotation event listener.

openvrml::mfstring_listener

mfstring event listener.

openvrml::mftime_listener

mftime event listener.

openvrml::mfvec2f_listener

mfvec2f event listener.

openvrml::mfvec3f_listener

mfvec3f event listener.

openvrml::sfbool_emitter

sfbool event emitter.

openvrml::sfcolor_emitter

sfcolor event emitter.

openvrml::sffloat_emitter

sffloat event emitter.

openvrml::sfimage_emitter

sfimage event emitter.

openvrml::sfint32_emitter

sfint32 event emitter.

openvrml::sfnode_emitter

sfnode event emitter.

openvrml::sfrotation_emitter

sfrotation event emitter.

openvrml::sfstring_emitter

sfstring event emitter.

openvrml::sftime_emitter

sftime event emitter.

openvrml::sfvec2f_emitter

sfvec2f event emitter.

openvrml::sfvec3f_emitter

sfvec3f event emitter.

openvrml::mfcolor_emitter

mfcolor event emitter.

openvrml::mffloat_emitter

mffloat event emitter.

openvrml::mfint32_emitter

mfint32 event emitter.

openvrml::mfnode_emitter

mfnode event emitter.

openvrml::mfrotation_emitter

mfrotation event emitter.

openvrml::mfstring_emitter

mfstring event emitter.

openvrml::mftime_emitter

mftime event emitter.

openvrml::mfvec2f_emitter

mfvec2f event emitter.

openvrml::mfvec3f_emitter

mfvec3f event emitter.

openvrml::field_value_ptr

A boost::shared_ptr to a field_value.

typedef boost::shared_ptr< node_type > openvrml::node_type_ptr

A boost::shared_ptr to a node_type.

openvrml::node_class_ptr

A boost::shared_ptr to a node_class.

openvrml::initial_value_map

A map of the initial values with which a node is instantiated.

---

Function Documentation

bool openvrml::operator== (  const color &  lhs, const color &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const color &  lhs, const color &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs dot not have the same value; false otherwise.

std::ostream & openvrml::operator<< (  std::ostream &  out, const color &  c )

Stream output. Parameters: out  output stream. c  a color. Returns: out.

const vec2f openvrml::operator * (  const vec2f &  lhs, const float  rhs )  throw ()

Multiply a vector by a scalar. Parameters: lhs  left-hand operand (the vector). rhs  right-hand operand (the scalar). Returns: the result vector.

const vec2f openvrml::operator * (  const float  lhs, const vec2f &  rhs )  throw ()

Multiply a vector by a scalar. Parameters: lhs  left-hand operand (the scalar). rhs  right-hand operand (the vector). Returns: the result vector.

const vec2f openvrml::operator/ (  const vec2f &  lhs, const float  rhs )  throw ()

Divide a vector by a scalar. Precondition: rhs is nonzero. Parameters: lhs  left-hand operand (the vector). rhs  right-hand operand (the scalar). Returns: the result vector.

const vec2f openvrml::operator+ (  const vec2f &  lhs, const vec2f &  rhs )  throw ()

Add two vectors. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: the result vector.

const vec2f openvrml::operator- (  const vec2f &  lhs, const vec2f &  rhs )  throw ()

Subtract two vectors. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: the result vector.

bool openvrml::operator== (  const vec2f &  lhs, const vec2f &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const vec2f &  lhs, const vec2f &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs dot not have the same value; false otherwise.

std::ostream & openvrml::operator<< (  std::ostream &  out, const vec2f &  v )

Stream output. Parameters: out  output stream. v  a 2-component vector. Returns: out.

const vec3f openvrml::operator * (  const vec3f &  lhs, const vec3f &  rhs )  throw ()

Cross multiply two vectors. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: the result vector.

const vec3f openvrml::operator * (  const vec3f &  vec, const mat4f &  mat )  throw ()

Multiply a vector by a matrix. Parameters: vec  a 3-component vector. mat  a matrix. Returns: the result vector.

const vec3f openvrml::operator * (  const mat4f &  mat, const vec3f &  vec )  throw ()

Multiply a matrix by a vector. Parameters: mat  a matrix. vec  a 3-component vector. Returns: the result vector.

const vec3f openvrml::operator * (  const vec3f &  lhs, const float  rhs )  throw ()

Multiply a vector by a scalar. Parameters: lhs  left-hand operand (the vector). rhs  right-hand operand (the scalar). Returns: the result vector.

const vec3f openvrml::operator * (  const float  lhs, const vec3f &  rhs )  throw ()

Multiply a vector by a scalar. Parameters: lhs  left-hand operand (the scalar). rhs  right-hand operand (the vector). Returns: the result vector.

const vec3f openvrml::operator/ (  const vec3f &  lhs, const float  rhs )  throw ()

Divide a vector by a scalar. Precondition: rhs is nonzero. Parameters: lhs  left-hand operand (the vector). rhs  right-hand operand (the scalar). Returns: the result vector.

const vec3f openvrml::operator+ (  const vec3f &  lhs, const vec3f &  rhs )  throw ()

Add two vectors. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: the result vector.

const vec3f openvrml::operator- (  const vec3f &  lhs, const vec3f &  rhs )  throw ()

Subtract two vectors. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: the result vector.

bool openvrml::operator== (  const vec3f &  lhs, const vec3f &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const vec3f &  lhs, const vec3f &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs dot not have the same value; false otherwise.

std::ostream & openvrml::operator<< (  std::ostream &  out, const vec3f &  v )

Stream output. Parameters: out  output stream. v  a 3-component vector. Returns: out.

const rotation openvrml::operator * (  const rotation &  lhs, const rotation &  rhs )  throw ()

Multiply rotations. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: the product of lhs and rhs.

bool openvrml::operator== (  const rotation &  lhs, const rotation &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs is equal to rhs; false otherwise.

bool openvrml::operator!= (  const rotation &  lhs, const rotation &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs is not equal to rhs; false otherwise.

std::ostream & openvrml::operator<< (  std::ostream &  out, const rotation &  r )

Stream output. Parameters: out  output stream. r  a rotation. Returns: out.

const mat4f openvrml::operator * (  const mat4f &  mat, const float  scalar )  throw ()

Multiply a matrix by a scalar value. Parameters: mat  matrix. scalar  scalar. Returns: the result matrix.

const mat4f openvrml::operator * (  const float  scalar, const mat4f &  mat )  throw ()

Multiply a scalar value by matrix. Parameters: scalar  scalar. mat  matrix. Returns: the result matrix.

const mat4f openvrml::operator * (  const mat4f &  lhs, const mat4f &  rhs )  throw ()

Multiply two matrices. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: the result matrix.

std::ostream & openvrml::operator<< (  std::ostream &  out, const mat4f &  mat )

Stream output. Parameters: out  an output stream. mat  a matrix. Returns: out.

bool openvrml::operator== (  const mat4f &  lhs, const mat4f &  rhs )  throw ()

Equality comparison operator. All componenents must match exactly. Parameters: lhs  a matrix. rhs  a matrix. Returns: true if lhs and rhs are equivalent; false otherwise.

bool openvrml::operator!= (  const mat4f &  lhs, const mat4f &  rhs )  throw ()

Inequality comparison operator. Parameters: lhs  a matrix. rhs  a matrix. Returns: true if lhs and rhs are not equivalent; false otherwise.

const quatf openvrml::operator * (  const quatf &  lhs, const quatf &  rhs )  throw ()

Multiply two quaternions. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: the product of lhs and rhs.

const quatf openvrml::operator * (  const quatf &  quat, const float  scalar )  throw ()

Multiply a quaternion by a scalar. Parameters: quat  quaternion. scalar  scalar. Returns: the product of quat and scalar.

const quatf openvrml::operator * (  const float  scalar, const quatf &  quat )  throw ()

Multiply a scalar by a quaternion. Parameters: scalar  scalar. quat  quaternion. Returns: the product of scalar and quat.

const quatf openvrml::operator/ (  const quatf &  quat, const float  scalar )  throw ()

Divide a quaternion by a scalar. Parameters: quat  quaternion. scalar  scalar. Returns: the result of dividing quat by scalar.

const quatf openvrml::operator+ (  const quatf &  lhs, const quatf &  rhs )  throw ()

Add two quaternions. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: the sum of lhs and rhs.

const quatf openvrml::operator- (  const quatf &  lhs, const quatf &  rhs )  throw ()

Take the difference between two quaternions. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: the difference between lhs and rhs.

std::ostream & openvrml::operator<< (  std::ostream &  out, const quatf &  quat )

Stream output. Parameters: out  an output stream. quat  a quaternion. Returns: out.

bool openvrml::operator== (  const quatf &  lhs, const quatf &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs are equal; false otherwise.

bool openvrml::operator!= (  const quatf &  lhs, const quatf &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs are not equal; false otherwise.

bool openvrml::operator== (  const image &  lhs, const image &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs are equal; false otherwise.

bool openvrml::operator!= (  const image &  lhs, const image &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs are not equal; false otherwise.

std::ostream & openvrml::operator<< (  std::ostream &  out, const image &  img )

Stream output. Parameters: out  output stream. img  image.

openvrml::float (  &mat4f::  operator(size_t index) throw()[]  )  [inline]

Row access. Parameters: index  row index. Returns: row index.

openvrml::float (  &mat4f::  operator(size_t index) const throw()[]  )  [inline]

Row access. Parameters: index  row index. Returns: row index.

std::ostream & openvrml::operator<< (  std::ostream &  out, const field_value &  value )

Stream output. Parameters: out  an output stream. value  a field value. Returns: out.

std::ostream & openvrml::operator<< (  std::ostream &  out, const field_value::type_id  type_id )

Stream output. If type is field_value::invalid_type, failbit is set on out. Parameters: out  output stream. type_id  field_value type identifier. Returns: out.

std::istream & openvrml::operator>> (  std::istream &  in, field_value::type_id &  type_id )

Stream input. Parameters: in  input stream. type_id  field_value type identifier. Returns: in.

bool openvrml::operator== (  const sfbool &  lhs, const sfbool &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const sfbool &  lhs, const sfbool &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const sfcolor &  lhs, const sfcolor &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const sfcolor &  lhs, const sfcolor &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const sffloat &  lhs, const sffloat &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const sffloat &  lhs, const sffloat &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const sfimage &  lhs, const sfimage &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const sfimage &  lhs, const sfimage &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const sfint32 &  lhs, const sfint32 &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const sfint32 &  lhs, const sfint32 &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const sfnode &  lhs, const sfnode &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const sfnode &  lhs, const sfnode &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const sfrotation &  lhs, const sfrotation &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const sfrotation &  lhs, const sfrotation &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const sfstring &  lhs, const sfstring &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const sfstring &  lhs, const sfstring &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const sftime &  lhs, const sftime &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const sftime &  lhs, const sftime &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const sfvec2f &  lhs, const sfvec2f &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const sfvec2f &  lhs, const sfvec2f &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const sfvec3f &  lhs, const sfvec3f &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const sfvec3f &  lhs, const sfvec3f &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const mfcolor &  lhs, const mfcolor &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const mfcolor &  lhs, const mfcolor &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const mffloat &  lhs, const mffloat &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const mffloat &  lhs, const mffloat &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const mfint32 &  lhs, const mfint32 &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const mfint32 &  lhs, const mfint32 &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const mfnode &  lhs, const mfnode &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const mfnode &  lhs, const mfnode &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const mfrotation &  lhs, const mfrotation &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const mfrotation &  lhs, const mfrotation &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const mfstring &  lhs, const mfstring &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const mfstring &  lhs, const mfstring &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const mftime &  lhs, const mftime &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const mftime &  lhs, const mftime &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const mfvec2f &  lhs, const mfvec2f &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const mfvec2f &  lhs, const mfvec2f &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

bool openvrml::operator== (  const mfvec3f &  lhs, const mfvec3f &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs have the same value; false otherwise.

bool openvrml::operator!= (  const mfvec3f &  lhs, const mfvec3f &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs do not have the same value; false otherwise.

std::ostream & openvrml::operator<< (  std::ostream &  out, const node_interface::type_id  type )

Stream inserter. If type is node_interface::invalid_type_id, failbit is set on out. Parameters: out  an output stream. type  a node interface type. Returns: out.

std::istream & openvrml::operator>> (  std::istream &  in, node_interface::type_id &  type )

Stream extractor. Parameters: in  an input stream. type  a node interface type. Returns: in.

bool openvrml::operator== (  const node_interface &  lhs, const node_interface &  rhs )  throw ()

Compare for equality. Parameters: lhs  a node_interface. rhs  a node_interface. Returns: true if the two node_interfaces are equal, false otherwise.

bool openvrml::operator!= (  const node_interface &  lhs, const node_interface &  rhs )  throw ()

Compare for openvrml::inequality. Parameters: lhs  a node_interface. rhs  a node_interface. Returns: true if the two node_interfaces are equal, false otherwise.

std::ostream & openvrml::operator<< (  std::ostream &  out, const node_interface &  interface )

Stream output. Parameters: out  output stream. interface  node_interface. Returns: out.

std::istream & openvrml::operator>> (  std::istream &  in, node_interface &  interface )

Stream input. Parameters: in  input stream. interface  node_interface. Returns: in.

std::ostream & openvrml::operator<< (  std::ostream &  out, const node &  n )

Stream output. Parameters: out  output stream. n  a node. Returns: out.

template<> template<> script_node * openvrml::node_cast< script_node * > (  node *  n  )  throw () [inline]

Cast to a script_node. Parameters: n  node. Returns: a script_node pointer to the node pointed to by n, or 0 if the node is not a script_node.

template<> template<> appearance_node * openvrml::node_cast< appearance_node * > (  node *  n  )  throw () [inline]

Cast to an appearance_node. Parameters: n  node. Returns: an appearance_node pointer to the node pointed to by n, or 0 if the node is not an appearance_node.

template<> template<> child_node * openvrml::node_cast< child_node * > (  node *  n  )  throw () [inline]

Cast to a child_node. Parameters: n  node. Returns: a child_node pointer to the node pointed to by n, or 0 if the node is not a child_node.

template<> template<> color_node * openvrml::node_cast< color_node * > (  node *  n  )  throw () [inline]

Cast to a color_node. Parameters: n  node. Returns: a color_node pointer to the node pointed to by n, or 0 if the node is not a color_node.

template<> template<> coordinate_node * openvrml::node_cast< coordinate_node * > (  node *  n  )  throw () [inline]

Cast to a coordinate_node. Parameters: n  node. Returns: a coordinate_node pointer to the node pointed to by n, or 0 if the node is not a coordinate_node.

template<> template<> font_style_node * openvrml::node_cast< font_style_node * > (  node *  n  )  throw () [inline]

Cast to a font_style_node. Parameters: n  node. Returns: a font_style_node pointer to the node pointed to by n, or 0 if the node is not a font_style_node.

template<> template<> geometry_node * openvrml::node_cast< geometry_node * > (  node *  n  )  throw () [inline]

Cast to a geometry_node. Parameters: n  node. Returns: a geometry_node pointer to the node pointed to by n, or 0 if the node is not a geometry_node.

template<> template<> grouping_node * openvrml::node_cast< grouping_node * > (  node *  n  )  throw () [inline]

Cast to a grouping_node. Parameters: n  node. Returns: a grouping_node pointer to the node pointed to by n, or 0 if the node is not a grouping_node.

template<> template<> material_node * openvrml::node_cast< material_node * > (  node *  n  )  throw () [inline]

Cast to a material_node. Parameters: n  node. Returns: a material_node pointer to the node pointed to by n, or 0 if the node is not a material_node.

template<> template<> normal_node * openvrml::node_cast< normal_node * > (  node *  n  )  throw () [inline]

Cast to a normal_node. Parameters: n  node. Returns: a normal_node pointer to the node pointed to by n, or 0 if the node is not a normal_node.

template<> template<> sound_source_node * openvrml::node_cast< sound_source_node * > (  node *  n  )  throw () [inline]

Cast to a sound_source_node. Parameters: n  node. Returns: a sound_source_node pointer to the node pointed to by n, or 0 if the node is not a sound_source_node.

template<> template<> texture_node * openvrml::node_cast< texture_node * > (  node *  n  )  throw () [inline]

Cast to a texture_node. Parameters: n  node. Returns: a texture_node pointer to the node pointed to by n, or 0 if the node is not a texture_node.

template<> template<> texture_coordinate_node * openvrml::node_cast< texture_coordinate_node * > (  node *  n  )  throw () [inline]

Cast to a texture_coordinate_node. Parameters: n  node. Returns: a texture_coordinate_node pointer to the node pointed to by n, or 0 if the node is not a texture_coordinate_node.

template<> template<> texture_transform_node * openvrml::node_cast< texture_transform_node * > (  node *  n  )  throw () [inline]

Cast to a texture_transform_node. Parameters: n  node. Returns: a texture_transform_node pointer to the node pointed to by n, or 0 if the node is not a texture_transform_node.

template<> template<> transform_node * openvrml::node_cast< transform_node * > (  node *  n  )  throw () [inline]

Cast to a transform_node. Parameters: n  node. Returns: a transform_node pointer to the node pointed to by n, or 0 if the node is not a transform_node.

template<> template<> viewpoint_node * openvrml::node_cast< viewpoint_node * > (  node *  n  )  throw () [inline]

Cast to a viewpoint_node. Parameters: n  node. Returns: a viewpoint_node pointer to the node pointed to by n, or 0 if the node is not a viewpoint_node.

bool openvrml::operator== (  const node_ptr &  lhs, const node_ptr &  rhs )  throw ()

Compare for equality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs point to the same node; false otherwise.

bool openvrml::operator!= (  const node_ptr &  lhs, const node_ptr &  rhs )  throw ()

Compare for inequality. Parameters: lhs  left-hand operand. rhs  right-hand operand. Returns: true if lhs and rhs point to different nodes; false otherwise.

---

Variable Documentation

const double openvrml::pi = 3.14159265358979323846

pi

const double openvrml::pi_2 = 1.57079632679489661923

pi/2

const double openvrml::pi_4 = 0.78539816339744830962

pi/4

const double openvrml::inv_pi = 0.31830988618379067154

1/pi

system * openvrml::the_system = &defaultSystem

The global system object.