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.
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_nodenode_cast< script_node * > (node *n) throw ()
 Cast to a script_node.
template<>
appearance_nodenode_cast< appearance_node * > (node *n) throw ()
 Cast to an appearance_node.
template<>
child_nodenode_cast< child_node * > (node *n) throw ()
 Cast to a child_node.
template<>
color_nodenode_cast< color_node * > (node *n) throw ()
 Cast to a color_node.
template<>
coordinate_nodenode_cast< coordinate_node * > (node *n) throw ()
 Cast to a coordinate_node.
template<>
font_style_nodenode_cast< font_style_node * > (node *n) throw ()
 Cast to a font_style_node.
template<>
geometry_nodenode_cast< geometry_node * > (node *n) throw ()
 Cast to a geometry_node.
template<>
grouping_nodenode_cast< grouping_node * > (node *n) throw ()
 Cast to a grouping_node.
template<>
material_nodenode_cast< material_node * > (node *n) throw ()
 Cast to a material_node.
template<>
normal_nodenode_cast< normal_node * > (node *n) throw ()
 Cast to a normal_node.
template<>
sound_source_nodenode_cast< sound_source_node * > (node *n) throw ()
 Cast to a sound_source_node.
template<>
texture_nodenode_cast< texture_node * > (node *n) throw ()
 Cast to a texture_node.
template<>
texture_coordinate_nodenode_cast< texture_coordinate_node * > (node *n) throw ()
 Cast to a texture_coordinate_node.
template<>
texture_transform_nodenode_cast< texture_transform_node * > (node *n) throw ()
 Cast to a texture_transform_node.
template<>
transform_nodenode_cast< transform_node * > (node *n) throw ()
 Cast to a transform_node.
template<>
viewpoint_nodenode_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

sfbool event listener.

sfcolor event listener.

sffloat event listener.

sfimage event listener.

sfint32 event listener.

sfnode event listener.

sfrotation event listener.

sfstring event listener.

sftime event listener.

sfvec2f event listener.

sfvec3f event listener.

mfcolor event listener.

mffloat event listener.

mfint32 event listener.

mfnode event listener.

mfrotation event listener.

mfstring event listener.

mftime event listener.

mfvec2f event listener.

mfvec3f event listener.

sfbool event emitter.

sfcolor event emitter.

sffloat event emitter.

sfimage event emitter.

sfint32 event emitter.

sfnode event emitter.

sfrotation event emitter.

sfstring event emitter.

sftime event emitter.

sfvec2f event emitter.

sfvec3f event emitter.

mfcolor event emitter.

mffloat event emitter.

mfint32 event emitter.

mfnode event emitter.

mfrotation event emitter.

mfstring event emitter.

mftime event emitter.

mfvec2f event emitter.

mfvec3f event emitter.

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.

A boost::shared_ptr to a node_class.

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.

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.