Home | Download | Screen shots | Discussion | Documentation
--- | --- | --- | --- | ---

Main Page | Modules | Namespace List | Class Hierarchy | Class List | Namespace Members | Class Members | Related Pages

# 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 `node`s. 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_interface`s.
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.