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

# openvrml Namespace Reference

The OpenVRML Runtime Library. More...

## Namespaces

namespace | node_impl_util

| Utility classes to facilitate node implementations.
namespace | gl

| OpenGL geometry renderer.

## Classes

class | bad_url
| Thrown when there is a problem resolving a URI. More...
class | invalid_url
| Thrown when parsing a URI fails. More...
class | bad_media_type
| Thrown when an unexpected media type is received. 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...
struct | color
| A POD-struct comprising a color. More...
struct | color_rgba
| A POD-struct comprising a color with an alpha channel. More...
struct | vec2f
| A POD-struct comprising a two-component single-precision vector. More...
struct | vec2d
| Two-component double-precision vector. More...
struct | vec3f
| Three-component single-precision vector. More...
struct | vec3d
| A POD-struct comprising a three-component double-precision vector. More...
struct | rotation
| A POD-struct comprising a rotation. More...
struct | mat4f
| A POD-struct comprising a 4x4 matrix. More...
struct | quatf
| A POD-struct comprising 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 | resource_istream
| An abstract input stream for network resources. More...
class | resource_fetcher
| An abstract factory for `resource_istreams`. More...
class | stream_listener
| An interface to simplify asynchronously reading a `resource_istream`. 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_event
| A `browser`-wide event. More...
class | browser_listener
| This class should be inherited by classes that want to listen for `browser_events`. More...
class | node_metatype_registry
| Registry for `node_metatypes`. More...
class | browser
| Encapsulates a VRML browser. More...
class | event_listener
| Abstract base class of event listeners. More...
class | node_event_listener
| Base class for event listeners of nodes. More...
class | field_value_listener
| Concrete event listener template. More...
class | node_field_value_listener
| Base class for `field_value_listeners` that are members of nodes. 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 Field Value concept. More...
class | sfbool
| A boolean `node` field value. More...
class | sfcolor
| A color node field value. More...
class | sfcolorrgba
| A color_rgba node field value. More...
class | sffloat
| A single precision floating point node field value. More...
class | sfdouble
| A single precision doubleing 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 | sfvec2d
| A 2-component vector node field value. More...
class | sfvec3f
| A 3-component vector node field value. More...
class | sfvec3d
| A 3-component vector node field value. More...
class | mfbool
| A `bool` array node field value. More...
class | mfcolor
| A color array node field value. More...
class | mfcolorrgba
| A color_rgba array node field value. More...
class | mffloat
| A float array node field value. More...
class | mfdouble
| A double array node field value. More...
class | mfimage
| A image 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 | mfvec2d
| A 2-component vector array node field value. More...
class | mfvec3f
| A 3-component vector array node field value. More...
class | mfvec3d
| A 3-component vector array node field value. More...
class | frustum
| A view frustum. 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_metatype_id
| Identifier for `node_metatypes`. More...
class | node_metatype
| A class object for node instances. More...
class | null_node_metatype
| A placeholder `node_metatype`. More...
class | node_type
| Type information object for `nodes`. More...
class | null_node_type
| A placeholder `node_type`. 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 | bounded_volume_node
| Abstract base class for nodes that represent a bounded volume in the scene graph. More...
class | child_node
| Abstract base class for child nodes. More...
class | background_node
| Abstract base class for background nodes. More...
class | color_node
| Abstract base class for color nodes. More...
class | color_rgba_node
| Abstract base class for RGBA 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 | light_node
| Abstract base class for light nodes. More...
class | material_node
| Abstract base class for material nodes. More...
class | navigation_info_node
| Abstract base class for normal nodes. More...
class | normal_node
| Abstract base class for normal nodes. More...
class | pointing_device_sensor_node
| A node that can be affected by a pointing device. More...
class | scoped_light_node
| A light that falls within a specified area. 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 | time_dependent_node
| Abstract base class for time-dependent nodes. More...
class | transform_node
| Abstract base class for transform nodes. More...
class | viewpoint_node
| Abstract base class for viewpoint nodes. More...
class | node_traverser
| Traverse the children of each `node` in a `node` hierarchy only once. More...
class | rendering_context
| Information needed during a render traversal. More...
class | scene
| A scene in the VRML world. 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_factory
| An abstract factory for `scripts`. More...
class | script_factory_registry
| Registry of `script_factories`. More...
class | script_node_metatype
| 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...
struct | vrml97_space_parser
| A Spirit space parser appropriate for use with VRML97 and VRML-encoded X3D. More...
struct | vrml97_skip_grammar
| A Spirit grammar appropriate for use as a skip parser for VRML97 and VRML-encoded X3D. More...
struct | vrml97_parse_error_handler
| A Spirit error handler that emits error and warning messages to a `std::ostream`. More...
struct | null_vrml97_parse_actions
| No-op semantic actions for `vrml97_grammar`. More...
struct | vrml97_grammar
| A Spirit grammar for parsing VRML97. More...
struct | x3d_vrml_parse_error_handler
| A Spirit error handler that emits error and warning messages to a `std::ostream`. More...
struct | color_rgba_parser
| The implementation of the `openvrml::color_rgba_p` functor parser. More...
struct | vec2d_parser
| The implementation of the `openvrml::vec2d_p` functor parser. More...
struct | vec3d_parser
| The implementation of the `openvrml::vec3d_p` functor parser. More...
struct | null_x3d_vrml_parse_actions
| No-op semantic actions for `x3d_vrml_grammar`. More...
struct | x3d_vrml_grammar
| A Spirit grammar for parsing Classic VRML X3D. More...

## Typedefs

typedef boost::int32_t | int32
| 32-bit signed integer.
typedef void(* | register_node_metatypes_func )(node_metatype_registry &)
| The signature of the node module entry point.
typedef field_value_listener < sfbool > | sfbool_listener
| `sfbool` event listener.
typedef field_value_listener < sfcolor > | sfcolor_listener
| `sfcolor` event listener.
typedef field_value_listener < sfcolorrgba > | sfcolorrgba_listener
| `sfcolorrgba` event listener.
typedef field_value_listener < sffloat > | sffloat_listener
| `sffloat` event listener.
typedef field_value_listener < sfdouble > | sfdouble_listener
| `sfdouble` 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 < sfvec2d > | sfvec2d_listener
| `sfvec2d` event listener.
typedef field_value_listener < sfvec3f > | sfvec3f_listener
| `sfvec3f` event listener.
typedef field_value_listener < sfvec3d > | sfvec3d_listener
| `sfvec3d` event listener.
typedef field_value_listener < mfbool > | mfbool_listener
| `mfbool` event listener.
typedef field_value_listener < mfcolor > | mfcolor_listener
| `mfcolor` event listener.
typedef field_value_listener < mfcolorrgba > | mfcolorrgba_listener
| `mfcolorrgba` event listener.
typedef field_value_listener < mffloat > | mffloat_listener
| `mffloat` event listener.
typedef field_value_listener < mfdouble > | mfdouble_listener
| `mfdouble` event listener.
typedef field_value_listener < mfimage > | mfimage_listener
| `mfimage` 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 < mfvec2d > | mfvec2d_listener
| `mfvec2d` event listener.
typedef field_value_listener < mfvec3f > | mfvec3f_listener
| `mfvec3f` event listener.
typedef field_value_listener < mfvec3d > | mfvec3d_listener
| `mfvec3d` 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 < sfcolorrgba > | sfcolorrgba_emitter
| `sfcolorrgba` event emitter.
typedef field_value_emitter < sffloat > | sffloat_emitter
| `sffloat` event emitter.
typedef field_value_emitter < sfdouble > | sfdouble_emitter
| `sfdouble` 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 < sfvec2d > | sfvec2d_emitter
| `sfvec2d` event emitter.
typedef field_value_emitter < sfvec3f > | sfvec3f_emitter
| `sfvec3f` event emitter.
typedef field_value_emitter < sfvec3d > | sfvec3d_emitter
| `sfvec3d` event emitter.
typedef field_value_emitter < mfbool > | mfbool_emitter
| `mfbool` event emitter.
typedef field_value_emitter < mfcolor > | mfcolor_emitter
| `mfcolor` event emitter.
typedef field_value_emitter < mfcolorrgba > | mfcolorrgba_emitter
| `mfcolorrgba` event emitter.
typedef field_value_emitter < mffloat > | mffloat_emitter
| `mffloat` event emitter.
typedef field_value_emitter < mfdouble > | mfdouble_emitter
| `mfdouble` event emitter.
typedef field_value_emitter < mfint32 > | mfint32_emitter
| `mfint32` event emitter.
typedef field_value_emitter < mfimage > | mfimage_emitter
| `mfimage` 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 < mfvec2d > | mfvec2d_emitter
| `mfvec2d` event emitter.
typedef field_value_emitter < mfvec3f > | mfvec3f_emitter
| `mfvec3f` event emitter.
typedef field_value_emitter < mfvec3d > | mfvec3d_emitter
| `mfvec3d` event emitter.
typedef std::set < node_interface, node_interface_compare > | node_interface_set
| A group of unique `node_interfaces`.
typedef std::map< std::string, node_interface_set > | node_type_decls
| A map of node type identifiers to their corresponding `node_interface_sets`.
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`.
typedef boost::spirit::classic::assertion < vrml_parse_error > | vrml_parse_assertion
typedef std::multimap < std::string, node_interface_set > | script_node_types_t
typedef std::pair < node_type_decls::key_type, node_type_decls::mapped_type > | node_type_decl
typedef std::map< std::string, const node_type_decls::value_type * > | defs_t

## Enumerations

enum

vrml_parse_error {
dot_expected,
lbrace_expected,
lbracket_expected,
id_expected,
to_expected,
is_expected,
interface_type_or_rbracket_expected,
field_type_expected,
bool_expected,
color_expected,
color_or_lbracket_expected,
color_or_rbracket_expected,
float_expected,
float_or_lbracket_expected,
float_or_rbracket_expected,
int32_expected,
int32_or_lbracket_expected,
int32_or_rbracket_expected,
rotation_expected,
rotation_or_lbracket_expected,
rotation_or_rbracket_expected,
string_expected,
string_or_lbracket_expected,
string_or_rbracket_expected,
vec2_expected,
vec2_or_lbracket_expected,
vec2_or_rbracket_expected,
vec3_expected,
vec3_or_lbracket_expected,
vec3_or_rbracket_expected,
node_expected,
node_or_lbracket_expected,
node_or_rbracket_expected,
interface_collision,
unknown_node_type_id,
node_type_already_exists,
unknown_node_name_id,
unknown_node_interface_id,
proto_interface_id_expected,
incompatible_proto_interface,
eventin_id_expected,
eventout_id_expected,
event_value_type_mismatch,
field_or_prototype_or_route_or_rbrace_expected,
script_interface_or_field_or_prototype_or_route_or_rbrace_expected,
rotation_axis_not_normalized,
vrml_parse_error_end,
vrml_parse_error_max = INT_MAX
}

| Identifiers used to designate parse error conditions. More...

## Functions

const color | make_color () throw ()
| Create a zero-initialized color.
const color | make_color (const float(&rgb)[3]) throw ()
| Create a color.
const color | make_color (float r, float g, float b) throw ()
| Create a color.
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::istream & | operator>> (std::istream &in, color &c)
| Stream input.
std::ostream & | operator<< (std::ostream &out, const color &c)
| Stream output.
const color_rgba | make_color_rgba () throw ()
| Create a zero-initialized `color_rgba`.
const color_rgba | make_color_rgba (const float(&rgba)[4]) throw ()
| Create a `color_rgba`.
const color_rgba | make_color_rgba (float r, float g, float b, float a) throw ()
| Create a `color_rgba`.
bool | operator== (const color_rgba &lhs, const color_rgba &rhs) throw ()
| Compare for equality.
bool | operator!= (const color_rgba &lhs, const color_rgba &rhs) throw ()
| Compare for inequality.
std::istream & | operator>> (std::istream &in, color_rgba &c)
| Stream input.
std::ostream & | operator<< (std::ostream &out, const color_rgba &c)
| Stream output.
const vec2f | make_vec2f () throw ()
| Create a `vec2f`.
const vec2f | make_vec2f (const float(&vec)[2]) throw ()
| Create a `vec2f` from an array.
const vec2f | make_vec2f (float x, float y) throw ()
| Create a `vec2f` from `x` and `y` components.
const vec2f | operator* (const vec2f &lhs, float rhs) throw ()
| Multiply a vector by a scalar.
const vec2f | operator* (float lhs, const vec2f &rhs) throw ()
| Multiply a vector by a scalar.
const vec2f | operator/ (const vec2f &lhs, 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::istream & | operator>> (std::istream &in, vec2f &v)
| Stream input.
std::ostream & | operator<< (std::ostream &out, const vec2f &v)
| Stream output.
const vec2d | make_vec2d () throw ()
| Create a `vec2d`.
const vec2d | make_vec2d (const double(&vec)[2]) throw ()
| Create a `vec2d` from an array.
const vec2d | make_vec2d (double x, double y) throw ()
| Create a `vec2d` from `x` and `y` components.
const vec2d | operator* (const vec2d &lhs, double rhs) throw ()
| Multiply a vector by a scalar.
const vec2d | operator* (double lhs, const vec2d &rhs) throw ()
| Multiply a vector by a scalar.
const vec2d | operator/ (const vec2d &lhs, double rhs) throw ()
| Divide a vector by a scalar.
const vec2d | operator+ (const vec2d &lhs, const vec2d &rhs) throw ()
| Add two vectors.
const vec2d | operator- (const vec2d &lhs, const vec2d &rhs) throw ()
| Subtract two vectors.
bool | operator== (const vec2d &lhs, const vec2d &rhs) throw ()
| Compare for equality.
bool | operator!= (const vec2d &lhs, const vec2d &rhs) throw ()
| Compare for inequality.
std::istream & | operator>> (std::istream &in, vec2d &v)
| Stream input.
std::ostream & | operator<< (std::ostream &out, const vec2d &v)
| Stream output.
const vec3f | make_vec3f () throw ()
| Create a `vec3f`.
const vec3f | make_vec3f (const float(&vec)[3]) throw ()
| Create a `vec3f` from an array.
const vec3f | make_vec3f (float x, float y, float z) throw ()
| Create a `vec3f` from `x`, `y`, and `z` components.
const vec3f | operator* (const vec3f &lhs, const vec3f &rhs) throw ()
| Cross multiply two vectors.
const vec3f | operator* (const vec3f &lhs, float rhs) throw ()
| Multiply a vector by a scalar.
const vec3f | operator* (float lhs, const vec3f &rhs) throw ()
| Multiply a vector by a scalar.
const vec3f | operator* (const vec3f &lhs, 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, 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::istream & | operator>> (std::istream &in, vec3f &v)
| Stream input.
std::ostream & | operator<< (std::ostream &out, const vec3f &v)
| Stream output.
const vec3d | make_vec3d () throw ()
| Create a `vec3d`.
const vec3d | make_vec3d (const double(&vec)[3]) throw ()
| Create a `vec3d` from an array.
const vec3d | make_vec3d (double x, double y, double z) throw ()
| Create a `vec3d` from `x`, `y`, and `z` components.
const vec3d | operator* (const vec3d &lhs, const vec3d &rhs) throw ()
| Cross multiply two vectors.
const vec3d | operator* (const vec3d &lhs, double rhs) throw ()
| Multiply a vector by a scalar.
const vec3d | operator* (double lhs, const vec3d &rhs) throw ()
| Multiply a vector by a scalar.
const vec3d | operator* (const vec3d &lhs, const mat4f &mat) throw ()
| Multiply a vector by a matrix.
const vec3d | operator* (const mat4f &mat, const vec3d &vec) throw ()
| Multiply a matrix by a vector.
const vec3d | operator/ (const vec3d &lhs, double rhs) throw ()
| Divide a vector by a scalar.
const vec3d | operator+ (const vec3d &lhs, const vec3d &rhs) throw ()
| Add two vectors.
const vec3d | operator- (const vec3d &lhs, const vec3d &rhs) throw ()
| Subtract two vectors.
bool | operator== (const vec3d &lhs, const vec3d &rhs) throw ()
| Compare for equality.
bool | operator!= (const vec3d &lhs, const vec3d &rhs) throw ()
| Compare for inequality.
std::istream & | operator>> (std::istream &in, vec3d &v)
| Stream input.
std::ostream & | operator<< (std::ostream &out, const vec3d &v)
| Stream output.
const rotation | make_rotation () throw ()
| Create a default `rotation`.
const rotation | make_rotation (const float(&rot)[4]) throw ()
| Create a `rotation` from an array.
const rotation | make_rotation (float x, float y, float z, float angle) throw ()
| Create a `rotation` from `x`, `y`, `z`, and `angle` components.
const rotation | make_rotation (const vec3f &axis, float angle) throw ()
| Create a `rotation` from an axis vector and an angle.
const rotation | make_rotation (const vec3f &from_vec, const vec3f &to_vec) throw ()
| Create a `rotation` equal to the rotation between two different vectors.
const rotation | make_rotation (const quatf &quat) throw ()
| Create a `rotation` from a quaternion.
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::istream & | operator>> (std::istream &in, rotation &rot)
| Stream input.
std::ostream & | operator<< (std::ostream &out, const rotation &r)
| Stream output.
const mat4f | make_mat4f () throw ()
| Create an identity matrix.
const mat4f | make_mat4f (float f11, float f12, float f13, float f14, float f21, float f22, float f23, float f24, float f31, float f32, float f33, float f34, float f41, float f42, float f43, float f44) throw ()
| Create a `mat4f` with given 16 elements in row-major order.
const mat4f | make_mat4f (const float mat[16]) throw ()
| Create a matrix from an array of 16 values.
const mat4f | make_mat4f (const float(&mat)[4][4]) throw ()
| Create a matrix from a 4x4 array.
const mat4f | make_rotation_mat4f (const rotation &rot) throw ()
| Create a rotation matrix.
const mat4f | make_rotation_mat4f (const quatf &quat) throw ()
| Create a rotation matrix.
const mat4f | make_scale_mat4f (float s) throw ()
| Create a uniform scale matrix.
const mat4f | make_scale_mat4f (const vec3f &s) throw ()
| Create a scale matrix.
const mat4f | make_translation_mat4f (const vec3f &t) throw ()
| Create a translation matrix.
const mat4f | make_transformation_mat4f (const vec3f &t, const rotation &r, const vec3f &s, const rotation &sr, const vec3f &c) throw ()
| Create a transformation matrix from a translation, a rotation, a scale, a scaleOrientation, and a center.
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 mat4f | operator* (const mat4f &lhs, const mat4f &rhs) throw ()
| Multiply two matrices.
const mat4f | operator* (const mat4f &mat, float scalar) throw ()
| Multiply a matrix by a scalar value.
const mat4f | operator* (float scalar, const mat4f &mat) throw ()
| Multiply a scalar value by matrix.
std::istream & | operator>> (std::istream &in, mat4f &mat)
| Stream input.
std::ostream & | operator<< (std::ostream &out, const mat4f &mat)
| Stream output.
const quatf | make_quatf () throw ()
| Create a default `quatf`.
const quatf | make_quatf (float x, float y, float z, float w) throw ()
| Create a `quatf` from four values.
const quatf | make_quatf (const float(&quat)[4]) throw ()
| Create a `quatf` from an array of four values.
const quatf | make_quatf (const rotation &rot) throw ()
| Create a `quatf` from a `rotation`.
const quatf | make_quatf (const mat4f &mat) throw ()
| Create a `quatf` from a rotation matrix.
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.
bool | operator== (const quatf &lhs, const quatf &rhs) throw ()
| Compare for equality.
bool | operator!= (const quatf &lhs, const quatf &rhs) throw ()
| Compare for inequality.
std::istream & | operator>> (std::istream &in, quatf &q)
| Stream input.
std::ostream & | operator<< (std::ostream &out, const quatf &quat)
| Stream output.
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::istream & | operator>> (std::istream &in, image &img)
| Stream input.
std::ostream & | operator<< (std::ostream &out, const image &img)
| Stream output.
std::auto_ptr< node_type_decls > | profile (const std::string &profile_id) throw ( std::invalid_argument , std::bad_alloc )
| Get a `node_type_decls` map corresponding to a particular profile.
void | add_component (node_type_decls &node_types, const std::string &component_id, size_t level) throw ( std::invalid_argument , std::bad_alloc )
| Add the nodes corresponding to a component level to a `node_type_decls` map.
std::ostream & | operator<< (std::ostream &out, const field_value &value)
| Stream output.
std::ostream & | operator<< (std::ostream &out, 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 sfcolorrgba &lhs, const sfcolorrgba &rhs) throw ()
| Compare for equality.
bool | operator!= (const sfcolorrgba &lhs, const sfcolorrgba &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 sfdouble &lhs, const sfdouble &rhs) throw ()
| Compare for equality.
bool | operator!= (const sfdouble &lhs, const sfdouble &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.
void | intrusive_ptr_add_ref (const node *) throw ()
| Increment the reference count.
void | intrusive_ptr_release (const node *) throw ()
| Decrement the reference count.
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 sfvec2d &lhs, const sfvec2d &rhs) throw ()
| Compare for equality.
bool | operator!= (const sfvec2d &lhs, const sfvec2d &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 sfvec3d &lhs, const sfvec3d &rhs) throw ()
| Compare for equality.
bool | operator!= (const sfvec3d &lhs, const sfvec3d &rhs) throw ()
| Compare for inequality.
bool | operator== (const mfbool &lhs, const mfbool &rhs) throw ()
| Compare for equality.
bool | operator!= (const mfbool &lhs, const mfbool &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 mfcolorrgba &lhs, const mfcolorrgba &rhs) throw ()
| Compare for equality.
bool | operator!= (const mfcolorrgba &lhs, const mfcolorrgba &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 mfdouble &lhs, const mfdouble &rhs) throw ()
| Compare for equality.
bool | operator!= (const mfdouble &lhs, const mfdouble &rhs) throw ()
| Compare for inequality.
bool | operator== (const mfimage &lhs, const mfimage &rhs) throw ()
| Compare for equality.
bool | operator!= (const mfimage &lhs, const mfimage &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 mfvec2d &lhs, const mfvec2d &rhs) throw ()
| Compare for equality.
bool | operator!= (const mfvec2d &lhs, const mfvec2d &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.
bool | operator== (const mfvec3d &lhs, const mfvec3d &rhs) throw ()
| Compare for equality.
bool | operator!= (const mfvec3d &lhs, const mfvec3d &rhs) throw ()
| Compare for inequality.
std::ostream & | operator<< (std::ostream &out, 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`.
bool | operator== (const node_metatype_id &lhs, const node_metatype_id &rhs) throw ()
bool | operator!= (const node_metatype_id &lhs, const node_metatype_id &rhs) throw ()
bool | operator== (const node_type &lhs, const node_type &rhs) throw ()
| Compare for equality.
bool | operator!= (const node_type &lhs, const node_type &rhs) throw ()
| Compare for inequality.
std::ostream & | operator<< (std::ostream &out, const node &n)
| Stream output.
template<typename To >
To | node_cast (node *n) throw ()
| Downcast a `node` to one of the abstract `node` types.
bool | is_proto_instance (const node &n)
| Check whether a `node` is a `PROTO` instance.
bool | add_route (node &from, const std::string &eventout, node &to, const std::string &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` from a `node` to an `eventIn` of another `node`.
template<>
script_node * | node_cast< script_node * > (node *n) throw ()
template<>
appearance_node * | node_cast< appearance_node * > (node *n) throw ()
template<>
background_node * | node_cast< background_node * > (node *n) throw ()
template<>
bounded_volume_node * | node_cast< bounded_volume_node * > (node *n) throw ()
template<>
child_node * | node_cast< child_node * > (node *n) throw ()
template<>
color_node * | node_cast< color_node * > (node *n) throw ()
template<>
color_rgba_node * | node_cast< color_rgba_node * > (node *n) throw ()
template<>
coordinate_node * | node_cast< coordinate_node * > (node *n) throw ()
template<>
font_style_node * | node_cast< font_style_node * > (node *n) throw ()
template<>
geometry_node * | node_cast< geometry_node * > (node *n) throw ()
template<>
grouping_node * | node_cast< grouping_node * > (node *n) throw ()
template<>
light_node * | node_cast< light_node * > (node *n) throw ()
template<>
material_node * | node_cast< material_node * > (node *n) throw ()
template<>
navigation_info_node * | node_cast< navigation_info_node * > (node *n) throw ()
template<>
normal_node * | node_cast< normal_node * > (node *n) throw ()
template<>
pointing_device_sensor_node * | node_cast< pointing_device_sensor_node * > (node *n) throw ()
template<>
scoped_light_node * | node_cast< scoped_light_node * > (node *n) throw ()
template<>
sound_source_node * | node_cast< sound_source_node * > (node *n) throw ()
template<>
texture_node * | node_cast< texture_node * > (node *n) throw ()
template<>
texture_coordinate_node * | node_cast< texture_coordinate_node * > (node *n) throw ()
template<>
texture_transform_node * | node_cast< texture_transform_node * > (node *n) throw ()
template<>
time_dependent_node * | node_cast< time_dependent_node * > (node *n) throw ()
template<>
transform_node * | node_cast< transform_node * > (node *n) throw ()
template<>
viewpoint_node * | node_cast< viewpoint_node * > (node *n) throw ()
const std::string | path (const scope &s) throw ( std::bad_alloc )
const char * | vrml97_parse_error_msg (const vrml_parse_error error)
| Get the error message associated with a `vrml_parse_error`.
const vrml_parse_assertion | expect_dot (dot_expected)
const vrml_parse_assertion | expect_lbrace (lbrace_expected)
const vrml_parse_assertion | expect_lbracket (lbracket_expected)
const vrml_parse_assertion | expect_id (id_expected)
const vrml_parse_assertion | expect_to (to_expected)
const vrml_parse_assertion | expect_is (is_expected)
const vrml_parse_assertion | expect_interface_type_or_rbracket (interface_type_or_rbracket_expected)
const vrml_parse_assertion | expect_field_type (field_type_expected)
const vrml_parse_assertion | expect_bool (bool_expected)
const vrml_parse_assertion | expect_color (color_expected)
const vrml_parse_assertion | expect_float (float_expected)
const vrml_parse_assertion | expect_int32 (int32_expected)
const vrml_parse_assertion | expect_rotation (rotation_expected)
const vrml_parse_assertion | expect_string (string_expected)
const vrml_parse_assertion | expect_vec2 (vec2_expected)
const vrml_parse_assertion | expect_vec3 (vec3_expected)
const vrml_parse_assertion | expect_node (node_expected)
const vrml_parse_assertion | expect_unique_node_interface (interface_collision)
const vrml_parse_assertion | expect_proto_interface_id (proto_interface_id_expected)
const vrml_parse_assertion | expect_compatible_proto_interface (incompatible_proto_interface)
const vrml_parse_assertion | expect_eventin_id (eventin_id_expected)
const vrml_parse_assertion | expect_eventout_id (eventout_id_expected)
const vrml_parse_assertion | expect_eventin_value_type_matches_eventout (event_value_type_mismatch)
const vrml_parse_assertion | expect_field_or_prototype_or_route_or_rbrace (field_or_prototype_or_route_or_rbrace_expected)
const vrml_parse_assertion | expect_script_interface_or_field_or_prototype_or_route_or_rbrace (script_interface_or_field_or_prototype_or_route_or_rbrace_expected)
const vrml_parse_assertion | expect_normalized_rotation (rotation_axis_not_normalized)
node_type_decls::value_type * | find_node_type (scope_stack_t &scope_stack, const std::string &node_type_id)
bool | in_proto_def (const scope_stack_t &scope_stack)
template<typename String , typename NodeType >
const add_def_t< String, NodeType > | add_def (scope_stack_t &scope_stack, String &node_name_id, NodeType &node_type)
const vrml_parse_assertion | expect_profile (profile_expected)
const vrml_parse_assertion | expect_colon (colon_expected)
const vrml_parse_assertion | expect_color_rgba (color_rgba_expected)
const vrml_parse_assertion | deprecated_eventin (eventin_deprecated)
const vrml_parse_assertion | deprecated_eventout (eventout_deprecated)
const vrml_parse_assertion | deprecated_exposedfield (exposedfield_deprecated)
const vrml_parse_assertion | deprecated_field (field_deprecated)
const char * | x3d_vrml_parse_error_msg (const vrml_parse_error error)
| Get the error messages associated with a `vrml_parse_error`.

## Variables

const char | vrml_media_type [11] = "model/vrml"
| VRML MIME media type.
const char | x_vrml_media_type [15] = "x-world/x-vrml"
| Experimental VRML MIME media type.
const char | x3d_vrml_media_type [15] = "model/x3d-vrml"
| X3D VRML MIME media type.
const vrml97_space_parser | vrml97_space_p = vrml97_space_parser()
| A Spirit space parser appropriate for use with VRML97 and VRML-encoded X3D.
const boost::spirit::classic::real_parser < float, boost::spirit::classic::real_parser_policies < float > > | float_p
const boost::spirit::classic::functor_parser < bool_parser > | bool_p
const boost::spirit::classic::functor_parser < int32_parser > | int32_p
const boost::spirit::classic::functor_parser < intensity_parser > | intensity_p
const boost::spirit::classic::functor_parser < color_parser > | color_p
const boost::spirit::classic::functor_parser < vec2f_parser > | vec2f_p
const boost::spirit::classic::functor_parser < vec3f_parser > | vec3f_p
const boost::spirit::classic::functor_parser < image_parser > | image_p
const phoenix::function < get_string_content_function > | get_string_content
const boost::spirit::classic::functor_parser < string_parser > | string_p
const phoenix::function < set_node_interface_type_function > | set_node_interface_type
const phoenix::function < set_node_interface_field_type_function > | set_node_interface_field_type
const phoenix::function < set_node_interface_id_function > | set_node_interface_id
const phoenix::function < set_node_type_id_function > | set_node_type_id
const phoenix::function < add_node_interface_function > | add_node_interface
const phoenix::function < check_function > | check
const phoenix::function < check_valid_proto_interface_function > | check_valid_proto_interface
const phoenix::function < get_route_eventout_function > | get_route_eventout
const phoenix::function < get_route_eventin_function > | get_route_eventin
const phoenix::function < check_consistent_value_type_function > | check_consistent_value_type
const phoenix::function < is_script_node_function > | is_script_node
const vrml_parse_error | profile_expected = vrml_parse_error_end
| The `PROFILE` keyword was expected.
const vrml_parse_error | unrecognized_profile_id
| The profile identifier was not recognized as a supported profile.
const vrml_parse_error | unrecognized_component_id_or_level
| The component identifier was unrecognized or the component level is unsupported.
const vrml_parse_error | colon_expected
| A “:” was expected.
const vrml_parse_error | bool_or_lbracket_expected
| A boolean value (i.e., `TRUE` or `FALSE`) or “[” was expected.
const vrml_parse_error | bool_or_rbracket_expected
| A boolean value (i.e., `TRUE` or `FALSE`) or “]” was expected.
const vrml_parse_error | color_rgba_expected
| An RGBA color value was expected.
const vrml_parse_error | color_rgba_or_lbracket_expected
| An RGBA color value or “[” was expected.
const vrml_parse_error | color_rgba_or_rbracket_expected
| An RGBA color value or “]” was expected.
const vrml_parse_error | eventin_deprecated
| The `eventIn` keyword is deprecated.
const vrml_parse_error | eventout_deprecated
| The `eventOut` keyword is deprecated.
const vrml_parse_error | exposedfield_deprecated
| The `exposedField` keyword is deprecated.
const vrml_parse_error | field_deprecated
| The `field` keyword is deprecated.
const boost::spirit::classic::functor_parser < color_rgba_parser > | color_rgba_p
| A Spirit parser for RGBA color values.
const boost::spirit::classic::functor_parser < vec2d_parser > | vec2d_p
| A Spirit parser for double-precision 2-component vector values.
const boost::spirit::classic::functor_parser < vec3d_parser > | vec3d_p
| A Spirit parser for double-precision 3-component vector values.
const phoenix::function < set_component_id_function > | set_component_id
const phoenix::function < set_component_level_function > | set_component_level
const phoenix::function < set_meta_name_function > | set_meta_name
const phoenix::function < set_meta_value_function > | set_meta_value

## Detailed Description

The OpenVRML Runtime Library.

## Typedef Documentation

openvrml::int32

32-bit signed integer.

void(* openvrml::register_node_metatypes_func)(openvrml::node_metatype_registry &)

The signature of the node module entry point.

A node module should have a function with this signature named `openvrml_register_node_metatypes`.

openvrml::sfbool_listener

`sfbool` event listener.

openvrml::sfcolor_listener

`sfcolor` event listener.

openvrml::sfcolorrgba_listener

`sfcolorrgba` event listener.

openvrml::sffloat_listener

`sffloat` event listener.

openvrml::sfdouble_listener

`sfdouble` 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::sfvec2d_listener

`sfvec2d` event listener.

openvrml::sfvec3f_listener

`sfvec3f` event listener.

openvrml::sfvec3d_listener

`sfvec3d` event listener.

openvrml::mfbool_listener

`mfbool` event listener.

openvrml::mfcolor_listener

`mfcolor` event listener.

openvrml::mfcolorrgba_listener

`mfcolorrgba` event listener.

openvrml::mffloat_listener

`mffloat` event listener.

openvrml::mfdouble_listener

`mfdouble` event listener.

openvrml::mfimage_listener

`mfimage` event listener.

openvrml::mfint32_listener

`mfint32` event listener.

openvrml::mfnode_listener

`mfnode` event listener.

openvrml::mfrotation_listener

`mfrotation` event listener.

c openvrml::mfstring_listener

`mfstring` event listener.

openvrml::mftime_listener

`mftime` event listener.

openvrml::mfvec2f_listener

`mfvec2f` event listener.

openvrml::mfvec2d_listener

`mfvec2d` event listener.

openvrml::mfvec3f_listener

`mfvec3f` event listener.

openvrml::mfvec3d_listener

`mfvec3d` event listener.

openvrml::sfbool_emitter

`sfbool` event emitter.

openvrml::sfcolor_emitter

`sfcolor` event emitter.

openvrml::sfcolorrgba_emitter

`sfcolorrgba` event emitter.

openvrml::sffloat_emitter

`sffloat` event emitter.

openvrml::sfdouble_emitter

`sfdouble` 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::sfvec2d_emitter

`sfvec2d` event emitter.

openvrml::sfvec3f_emitter

`sfvec3f` event emitter.

openvrml::sfvec3d_emitter

`sfvec3d` event emitter.

openvrml::mfbool_emitter

`mfbool` event emitter.

openvrml::mfcolor_emitter

`mfcolor` event emitter.

openvrml::mfcolorrgba_emitter

`mfcolorrgba` event emitter.

openvrml::mffloat_emitter

`mffloat` event emitter.

openvrml::mfdouble_emitter

`mfdouble` event emitter.

openvrml::mfint32_emitter

`mfint32` event emitter.

openvrml::mfimage_emitter

`mfimage` 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::mfvec2d_emitter

`mfvec2d` event emitter.

openvrml::mfvec3f_emitter

`mfvec3f` event emitter.

openvrml::mfvec3d_emitter

`mfvec3d` event emitter.

std::set< openvrml::node_interface, openvrml::node_interface_compare > openvrml::node_interface_set

A group of unique `node_interfaces`.

`node_interface_sets` are used to construct new `node_types`. `node_type` objects also expose their interfaces as a `node_interface_set`. The interfaces in a `node_interface_set` are guaranteed to be unique and nonconflicting.

openvrml::node_type_decls

A map of node type identifiers to their corresponding `node_interface_sets`.

openvrml::initial_value_map

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

std::deque< openvrml::node * > openvrml::node_path

A path to a `node` in the `scene` starting with one of the `scene` root `nodes` and ending with the objective `node`.

## Enumeration Type Documentation

enum openvrml::vrml_parse_error

Identifiers used to designate parse error conditions.

Enumerator:

  dot_expected | A “.” was expected.
  lbrace_expected | A “{” was expected.
  lbracket_expected | A “[” was expected.
  id_expected | An identifier was expected.
  to_expected | The `TO` keyword was expected.
  is_expected | The `IS` keyword was expected.
  interface_type_or_rbracket_expected | An interface type or “]” was expected.
  field_type_expected | A field type was expected.
  bool_expected | A keyword `TRUE` or `FALSE` was expected.
  color_expected | A color value was expected.
  color_or_lbracket_expected | A color value or “[” was expected.
  color_or_rbracket_expected | A color value or “]” was expected.
  float_expected | A floating-point value was expected.
  float_or_lbracket_expected | A floating-point value or “[” was expected.
  float_or_rbracket_expected | A floating-point value or “]” was expected.
  int32_expected | A integer value was expected.
  int32_or_lbracket_expected | A integer value or “[” was expected.
  int32_or_rbracket_expected | A integer value or “]” was expected.
  rotation_expected | A rotation value was expected.
  rotation_or_lbracket_expected | A rotation value or “[” was expected.
  rotation_or_rbracket_expected | A rotation value or “]” was expected.
  string_expected | A string value was expected.
  string_or_lbracket_expected | A string value or “[” was expected.
  string_or_rbracket_expected | A string value or “]” was expected.
  vec2_expected | A 2-component vector value was expected.
  vec2_or_lbracket_expected | A 2-component vector value or “[” was expected.
  vec2_or_rbracket_expected | A 2-component vector value or “]” was expected.
  vec3_expected | A 3-component vector value was expected.
  vec3_or_lbracket_expected | A 3-component vector value or “[” was expected.
  vec3_or_rbracket_expected | A 3-component vector value or “]” was expected.
  node_expected | A node was expected.
  node_or_lbracket_expected | A node or “[” was expected.
  node_or_rbracket_expected | A node or “]” was expected.
  interface_collision | An interface conflicts with one that was previously declared.
  unknown_node_type_id | Encountered an unknown node type identifier.

## Function Documentation

const openvrml::color make_color | ( |  | ) | throw ()

Create a zero-initialized color.

Returns:
  a zero-initialized color.

const openvrml::color make_color | ( | const float(&) | rgb[3] | ) | throw ()

Create a color.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | rgb | an array comprising red, green, and blue components.

Returns:
  a color.

const openvrml::color make_color | ( | float | r,
|  | float | g,
|  | float | b |
| ) |  |  | throw ()

Create a color.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | r | red component.
  `[in]` | g | green component.
  `[in]` | b | blue component.

Returns:
  a color.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

std::istream & operator>> | ( | std::istream & | in,
|  | color & | c |
| ) |  |  |

Stream input.

Consistent with the VRML97 convention, commas (“``,”) in the input are treated as whitespace.

If any of the color components is outside the the range [0.0, 1.0], the `failbit` will be set on `in` and `c` will be left in an arbitrary state.

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | c | a `color`.

Returns:
  `in`.

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

Stream output.

Parameters:

  `[in,out]` | out | output stream.
  `[in]` | c | a `color`.

Returns:
  `out`.

Examples:
  pretty_print.cpp.

const openvrml::color_rgba make_color_rgba | ( |  | ) | throw ()

Create a zero-initialized `color_rgba`.

Returns:
  a zero-initialized `color_rgba`.

const openvrml::color_rgba make_color_rgba | ( | const float(&) | rgba[4] | ) | throw ()

Create a `color_rgba`.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | rgba | an array comprising red, green, blue, and alpha components.

Returns:
  a `color_rgba`.

const openvrml::color_rgba make_color_rgba | ( | float | r,
|  | float | g,
|  | float | b,
|  | float | a |
| ) |  |  | throw ()

Create a `color_rgba`.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | r | red component.
  `[in]` | g | green component.
  `[in]` | b | blue component.
  `[in]` | a | alpha component.

Returns:
  a `color_rgba`.

bool operator== | ( | const color_rgba & | lhs,
|  | const color_rgba & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const color_rgba & | lhs,
|  | const color_rgba & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` dot not have the same value; `false` otherwise.

std::istream & operator>> | ( | std::istream & | in,
|  | color_rgba & | c |
| ) |  |  |

Stream input.

Consistent with the VRML97 convention, commas (“``,”) in the input are treated as whitespace.

If any of the color components is outside the the range [0.0, 1.0], the `failbit` will be set on `in` and `c` will be left in an arbitrary state.

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | c | a `color_rgba`.

Returns:
  `in`.

std::ostream & operator<< | ( | std::ostream & | out,
|  | const color_rgba & | c |
| ) |  |  |

Stream output.

Parameters:

  `[in,out]` | out | output stream.
  `[in]` | c | a color_rgba.

Returns:
  `out`.

const openvrml::vec2f make_vec2f | ( |  | ) | throw ()

Create a `vec2f`.

Returns:
  a zero-initialized `vec2f`.

const openvrml::vec2f make_vec2f | ( | const float(&) | vec[2] | ) | throw ()

Create a `vec2f` from an array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Precondition:
  Elements of `vec` are valid numeric values (i.e., not NaN).

Parameters:

  `[in]` | vec | an array comprising the vector components.

Returns:
  a `vec2f` with the values in `vec`.

const openvrml::vec2f make_vec2f | ( | float | x,
|  | float | y |
| ) |  |  | throw ()

Create a `vec2f` from `x` and `y` components.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Precondition:
  `x` and `y` are valid numeric values (i.e., not NaN).

Parameters:

  `[in]` | x | x component.
  `[in]` | y | y component.

Returns:
  a `vec2f` with the values `x` and `y`.

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

Multiply a vector by a scalar.

Parameters:

  `[in]` | lhs | left-hand operand (the vector).
  `[in]` | rhs | right-hand operand (the scalar).

Returns:
  the result vector.

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

Multiply a vector by a scalar.

Parameters:

  `[in]` | lhs | left-hand operand (the scalar).
  `[in]` | rhs | right-hand operand (the vector).

Returns:
  the result vector.

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

Divide a vector by a scalar.

Precondition:
  `rhs` is nonzero.

Parameters:

  `[in]` | lhs | left-hand operand (the vector).
  `[in]` | rhs | right-hand operand (the scalar).

Returns:
  the result vector.

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

Add two vectors.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the result vector.

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

Subtract two vectors.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the result vector.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` dot not have the same value; `false` otherwise.

std::istream & operator>> | ( | std::istream & | in,
|  | vec2f & | v |
| ) |  |  |

Stream input.

Consistent with the VRML97 convention, commas (“``,”) in the input are treated as whitespace.

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | v | a `vec2f`.

Returns:
  `in`.

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

Stream output.

Parameters:

  `[in,out]` | out | output stream.
  `[in]` | v | a 2-component vector.

Returns:
  `out`.

const openvrml::vec2d make_vec2d | ( |  | ) | throw ()

Create a `vec2d`.

Returns:
  a zero-initialized `vec2d`.

const openvrml::vec2d make_vec2d | ( | const double(&) | vec[2] | ) | throw ()

Create a `vec2d` from an array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Precondition:
  Elements of `vec` are valid numeric values (i.e., not NaN).

Parameters:

  `[in]` | vec | an array comprising the vector components.

Returns:
  a `vec2d` with the values in `vec`.

const openvrml::vec2d make_vec2d | ( | double | x,
|  | double | y |
| ) |  |  | throw ()

Create a `vec2d` from `x` and `y` components.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Precondition:
  `x` and `y` are valid numeric values (i.e., not NaN).

Parameters:

  `[in]` | x | x component.
  `[in]` | y | y component.

Returns:
  a `vec2d` with the values `x` and `y`.

const openvrml::vec2d operator* | ( | const vec2d & | lhs,
|  | double | rhs |
| ) |  |  | throw ()

Multiply a vector by a scalar.

Parameters:

  `[in]` | lhs | left-hand operand (the vector).
  `[in]` | rhs | right-hand operand (the scalar).

Returns:
  the result vector.

const openvrml::vec2d operator* | ( | double | lhs,
|  | const vec2d & | rhs |
| ) |  |  | throw ()

Multiply a vector by a scalar.

Parameters:

  `[in]` | lhs | left-hand operand (the scalar).
  `[in]` | rhs | right-hand operand (the vector).

Returns:
  the result vector.

const openvrml::vec2d operator/ | ( | const vec2d & | lhs,
|  | double | rhs |
| ) |  |  | throw ()

Divide a vector by a scalar.

Precondition:
  `rhs` is nonzero.

Parameters:

  `[in]` | lhs | left-hand operand (the vector).
  `[in]` | rhs | right-hand operand (the scalar).

Returns:
  the result vector.

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

Add two vectors.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the result vector.

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

Subtract two vectors.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the result vector.

bool operator== | ( | const vec2d & | lhs,
|  | const vec2d & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const vec2d & | lhs,
|  | const vec2d & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` dot not have the same value; `false` otherwise.

std::istream & operator>> | ( | std::istream & | in,
|  | vec2d & | v |
| ) |  |  |

Stream input.

Consistent with the VRML97 convention, commas (“``,”) in the input are treated as whitespace.

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | v | a `vec2d`.

Returns:
  `in`.

std::ostream & operator<< | ( | std::ostream & | out,
|  | const vec2d & | v |
| ) |  |  |

Stream output.

Parameters:

  `[in,out]` | out | output stream.
  `[in]` | v | a 2-component vector.

Returns:
  `out`.

const openvrml::vec3f make_vec3f | ( |  | ) | throw ()

Create a `vec3f`.

Returns:
  a zero-initialized `vec3f`.

const openvrml::vec3f make_vec3f | ( | const float(&) | vec[3] | ) | throw ()

Create a `vec3f` from an array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Precondition:
  Elements of `vec` are valid numeric values (i.e., not NaN).

Parameters:

  `[in]` | vec | an array comprising the vector components.

Returns:
  a `vec3f` with the values in `vec`.

const openvrml::vec3f make_vec3f | ( | float | x,
|  | float | y,
|  | float | z |
| ) |  |  | throw ()

Create a `vec3f` from `x`, `y`, and `z` components.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Precondition:
  `x`, `y` and `z` are valid numeric values (i.e., not NaN).

Parameters:

  `[in]` | x | x component.
  `[in]` | y | y component.
  `[in]` | z | z component.

Returns:
  a `vec3f` with the values `x`, `y`, and `z`.

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

Cross multiply two vectors.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the result vector.

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

Multiply a vector by a scalar.

Parameters:

  `[in]` | lhs | left-hand operand (the vector).
  `[in]` | rhs | right-hand operand (the scalar).

Returns:
  the result vector.

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

Multiply a vector by a scalar.

Parameters:

  `[in]` | lhs | left-hand operand (the scalar).
  `[in]` | rhs | right-hand operand (the vector).

Returns:
  the result vector.

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

Multiply a vector by a matrix.

Parameters:

  `[in]` | vec | a vector.
  `[in]` | mat | a matrix.

Returns:
  the result vector.

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

Multiply a matrix by a vector.

Parameters:

  `[in]` | mat | a matrix.
  `[in]` | vec | a 3-component vector.

Returns:
  the result vector.

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

Divide a vector by a scalar.

Precondition:
  `rhs` is nonzero.

Parameters:

  `[in]` | lhs | left-hand operand (the vector).
  `[in]` | rhs | right-hand operand (the scalar).

Returns:
  the result vector.

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

Add two vectors.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the result vector.

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

Subtract two vectors.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the result vector.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` dot not have the same value; `false` otherwise.

std::istream & operator>> | ( | std::istream & | in,
|  | vec3f & | v |
| ) |  |  |

Stream input.

Consistent with the VRML97 convention, commas (“``,”) in the input are treated as whitespace.

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | v | a `vec3f`.

Returns:
  `in`.

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

Stream output.

Parameters:

  `[in,out]` | out | output stream.
  `[in]` | v | a 3-component vector.

Returns:
  `out`.

const openvrml::vec3d make_vec3d | ( |  | ) | throw ()

Create a `vec3d`.

Returns:
  a zero-initialized `vec3d`.

const openvrml::vec3d make_vec3d | ( | const double(&) | vec[3] | ) | throw ()

Create a `vec3d` from an array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Precondition:
  Elements of `vec` are valid numeric values (i.e., not NaN).

Parameters:

  `[in]` | vec | an array comprising the vector components.

Returns:
  a `vec3d` with the values in `vec`.

const openvrml::vec3d make_vec3d | ( | double | x,
|  | double | y,
|  | double | z |
| ) |  |  | throw ()

Create a `vec3d` from `x`, `y`, and `z` components.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Precondition:
  `x`, `y` and `z` are valid numeric values (i.e., not NaN).

Parameters:

  `[in]` | x | x component.
  `[in]` | y | y component.
  `[in]` | z | z component.

Returns:
  a `vec3d` with the values `x`, `y`, and `z`.

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

Cross multiply two vectors.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the result vector.

const openvrml::vec3d operator* | ( | const vec3d & | lhs,
|  | double | rhs |
| ) |  |  | throw ()

Multiply a vector by a scalar.

Parameters:

  `[in]` | lhs | left-hand operand (the vector).
  `[in]` | rhs | right-hand operand (the scalar).

Returns:
  the result vector.

const openvrml::vec3d operator* | ( | double | lhs,
|  | const vec3d & | rhs |
| ) |  |  | throw ()

Multiply a vector by a scalar.

Parameters:

  `[in]` | lhs | left-hand operand (the scalar).
  `[in]` | rhs | right-hand operand (the vector).

Returns:
  the result vector.

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

Multiply a vector by a matrix.

Parameters:

  `[in]` | vec | a vector.
  `[in]` | mat | a matrix.

Returns:
  the result vector.

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

Multiply a matrix by a vector.

Parameters:

  `[in]` | mat | a matrix.
  `[in]` | vec | a 3-component vector.

Returns:
  the result vector.

const openvrml::vec3d operator/ | ( | const vec3d & | lhs,
|  | double | rhs |
| ) |  |  | throw ()

Divide a vector by a scalar.

Precondition:
  `rhs` is nonzero.

Parameters:

  `[in]` | lhs | left-hand operand (the vector).
  `[in]` | rhs | right-hand operand (the scalar).

Returns:
  the result vector.

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

Add two vectors.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the result vector.

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

Subtract two vectors.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the result vector.

bool operator== | ( | const vec3d & | lhs,
|  | const vec3d & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const vec3d & | lhs,
|  | const vec3d & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` dot not have the same value; `false` otherwise.

std::istream & operator>> | ( | std::istream & | in,
|  | vec3d & | v |
| ) |  |  |

Stream input.

Consistent with the VRML97 convention, commas (“``,”) in the input are treated as whitespace.

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | v | a `vec3d`.

Returns:
  `in`.

std::ostream & operator<< | ( | std::ostream & | out,
|  | const vec3d & | v |
| ) |  |  |

Stream output.

Parameters:

  `[in,out]` | out | output stream.
  `[in]` | v | a 3-component vector.

Returns:
  `out`.

const openvrml::rotation make_rotation | ( |  | ) | throw ()

Create a default `rotation`.

Returns:
  a default `rotation`.

const openvrml::rotation make_rotation | ( | const float(&) | rot[4] | ) | throw ()

Create a `rotation` from an array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | rot | an array comprising the rotation components.

Precondition:
  The vector represented by the first three components of `rot` is normalized.

Returns:
  a `rotation` initialized to the values in `rot`.

const openvrml::rotation make_rotation | ( | float | x,
|  | float | y,
|  | float | z,
|  | float | angle |
| ) |  |  | throw ()

Create a `rotation` from `x`, `y`, `z`, and `angle` components.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | x | x-component of the rotation axis.
  `[in]` | y | y-component of the rotation axis.
  `[in]` | z | z-component of the rotation axis.
  `[in]` | angle | rotation angle.

Precondition:
  The vector represented by `x`, `y`, and `z` is normalized.

Returns:
  a `rotation` initialized to [ `x`, `y`, `z`, `angle` ].

const openvrml::rotation make_rotation | ( | const vec3f & | axis,
|  | float | angle |
| ) |  |  | throw ()

Create a `rotation` from an axis vector and an angle.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | axis | rotation axis.
  `[in]` | angle | rotation angle.

Precondition:
  `axis` is a normalized vector.

Returns:
  a `rotation` initialized using `axis` and `angle`.

const openvrml::rotation make_rotation | ( | const vec3f & | from_vec,
|  | const vec3f & | to_vec |
| ) |  |  | throw ()

Create a `rotation` equal to the rotation between two different vectors.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | from_vec | the starting vector.
  `[in]` | to_vec | the ending vector.

Returns:
  a `rotation` equal to the rotation between `from_vec` and `to_vec`.

const openvrml::rotation make_rotation | ( | const quatf & | quat | ) | throw ()

Create a `rotation` from a quaternion.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | quat | a quaternion.

Returns:
  a `rotation` corresponding to `quat`.

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

Multiply rotations.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the product of `lhs` and `rhs`.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` is equal to `rhs`; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` is not equal to `rhs`; `false` otherwise.

std::istream & operator>> | ( | std::istream & | in,
|  | rotation & | rot |
| ) |  |  |

Stream input.

Consistent with the VRML97 convention, commas (“``,”) in the input are treated as whitespace.

If the axis components of the rotation do not represent a normalized vector, the `failbit` will be set on `in` and `rot` will not be modified.

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | rot | a `rotation`.

Returns:
  `in`.

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

Stream output.

Parameters:

  `[in,out]` | out | output stream.
  `[in]` | r | a rotation.

Returns:
  `out`.

const openvrml::mat4f make_mat4f | ( |  | ) | throw ()

Create an identity matrix.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Returns:
  an identity matrix.

const openvrml::mat4f make_mat4f | ( | float | f11,
|  | float | f12,
|  | float | f13,
|  | float | f14,
|  | float | f21,
|  | float | f22,
|  | float | f23,
|  | float | f24,
|  | float | f31,
|  | float | f32,
|  | float | f33,
|  | float | f34,
|  | float | f41,
|  | float | f42,
|  | float | f43,
|  | float | f44 |
| ) |  |  | throw ()

Create a `mat4f` with given 16 elements in row-major order.

Parameters:

  `[in]` | f11 |
  `[in]` | f12 |
  `[in]` | f13 |
  `[in]` | f14 |
  `[in]` | f21 |
  `[in]` | f22 |
  `[in]` | f23 |
  `[in]` | f24 |
  `[in]` | f31 |
  `[in]` | f32 |
  `[in]` | f33 |
  `[in]` | f34 |
  `[in]` | f41 |
  `[in]` | f42 |
  `[in]` | f43 |
  `[in]` | f44 |

Returns:
  a `mat4f` with given 16 elements in row-major order.

const openvrml::mat4f make_mat4f | ( | const float | mat[16] | ) | throw ()

Create a matrix from an array of 16 values.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Precondition:
  `mat` points to a sequence of at least 16 `float` values.

Parameters:

  `[in]` | mat | a pointer to a sequence of 16 `float` values in row-major order.

Returns:
  a `mat4f` containing the values in `mat`.

const openvrml::mat4f make_mat4f | ( | const float(&) | mat[4][4] | ) | throw ()

Create a matrix from a 4x4 array.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | mat | a 4x4 array of elements in row-major order.

Returns:
  a `mat4f` containing the values in `mat`.

const openvrml::mat4f make_rotation_mat4f | ( | const rotation & | rot | ) | throw ()

Create a rotation matrix.

Parameters:

  `[in]` | rot | a rotation.

Returns:
  a matrix representation of `rot`.

const openvrml::mat4f make_rotation_mat4f | ( | const quatf & | quat | ) | throw ()

Create a rotation matrix.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | quat | a quaternion.

Returns:
  a matrix representation of `quat`.

const openvrml::mat4f make_scale_mat4f | ( | float | s | ) | throw ()

Create a uniform scale matrix.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

  `[in]` | s | scale factor.

Returns:
  a uniform scale matrix.

const openvrml::mat4f make_scale_mat4f | ( | const vec3f & | s | ) | throw ()

Create a scale matrix.

Parameters:

  `[in]` | s | a vector.

Returns:
  a scale matrix.

const openvrml::mat4f make_translation_mat4f | ( | const vec3f & | t | ) | throw ()

Create a translation matrix.

Parameters:

  `[in]` | t | translation vector.

Returns:
  a translation matrix.

const openvrml::mat4f make_transformation_mat4f | ( | const vec3f & | t,
|  | const rotation & | r,
|  | const vec3f & | s,
|  | const rotation & | sr,
|  | const vec3f & | c |
| ) |  |  | throw ()

Create a transformation matrix from a translation, a rotation, a scale, a scaleOrientation, and a center.

Parameters:

  `[in]` | t | the translation.
  `[in]` | r | the rotation.
  `[in]` | s | the scale.
  `[in]` | sr | the scale orientation.
  `[in]` | c | the center.

Returns:
  a transformation matrix.

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

Equality comparison operator.

All componenents must match exactly.

Parameters:

  `[in]` | lhs | a matrix.
  `[in]` | rhs | a matrix.

Returns:
  `true` if `lhs` and `rhs` are equivalent; `false` otherwise.

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

Inequality comparison operator.

Parameters:

  `[in]` | lhs | a matrix.
  `[in]` | rhs | a matrix.

Returns:
  `true` if `lhs` and `rhs` are not equivalent; `false` otherwise.

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

Multiply two matrices.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the result matrix.

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

Multiply a matrix by a scalar value.

Parameters:

  `[in]` | mat | matrix.
  `[in]` | scalar | scalar.

Returns:
  the result matrix.

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

Multiply a scalar value by matrix.

Parameters:

  `[in]` | scalar | scalar.
  `[in]` | mat | matrix.

Returns:
  the result matrix.

std::istream & operator>> | ( | std::istream & | in,
|  | mat4f & | m |
| ) |  |  |

Stream input.

Consistent with the VRML97 convention, commas (“``,”) in the input are treated as whitespace.

Optionally, brackets may be used in the input to group the rows; i.e., the following syntaxes are accepted:

- [ f11, ... f14 ], ... [ f41, ... f44 ]
- f11, f12, ... f44

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | m | a matrix.

Returns:
  `in`.

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

Stream output.

Parameters:

  `[in,out]` | out | an output stream.
  `[in]` | mat | a matrix.

Returns:
  `out`.

const openvrml::quatf make_quatf | ( |  | ) | throw ()

Create a default `quatf`.

Returns:
  a `quatf` with the value [0.0, 0.0, 0.0, 1.0].

const openvrml::quatf make_quatf | ( | float | x,
|  | float | y,
|  | float | z,
|  | float | w |
| ) |  |  | throw ()

Create a `quatf` from four values.

Parameters:

  `[in]` | x | the x vector component.
  `[in]` | y | the y vector component.
  `[in]` | z | the z vector component.
  `[in]` | w | the scalar value w.

Returns:
  a `quatf` with the value [`x`, `y`, `z`, `w`].

const openvrml::quatf make_quatf | ( | const float(&) | quat[4] | ) | throw ()

Create a `quatf` from an array of four values.

Parameters:

  `[in]` | quat | the first three values in the array are used for the x, y, and z vector components, respectively. The fourth value in the array is used for the scalar part of the quaternion.

Returns:
  a `quatf` with the values in `quat`.

const openvrml::quatf make_quatf | ( | const rotation & | rot | ) | throw ()

Create a `quatf` from a `rotation`.

Parameters:

  `[in]` | rot | a rotation.

Returns:
  a `quatf` corresponding to the rotation applied by `rot`.

const openvrml::quatf make_quatf | ( | const mat4f & | mat | ) | throw ()

Create a `quatf` from a rotation matrix.

Parameters:

  `[in]` | mat | a rotation matrix.

Returns:
  a `quatf` corresponding to the rotation applied by `mat`.

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

Multiply two quaternions.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the product of `lhs` and `rhs`.

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

Multiply a quaternion by a scalar.

Parameters:

  `[in]` | quat | quaternion.
  `[in]` | scalar | scalar.

Returns:
  the product of `quat` and `scalar`.

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

Multiply a scalar by a quaternion.

Parameters:

  `[in]` | scalar | scalar.
  `[in]` | quat | quaternion.

Returns:
  the product of `scalar` and `quat`.

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

Divide a quaternion by a scalar.

Parameters:

  `[in]` | quat | quaternion.
  `[in]` | scalar | scalar.

Returns:
  the result of dividing `quat` by `scalar`.

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

Add two quaternions.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the sum of `lhs` and `rhs`.

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

Take the difference between two quaternions.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  the difference between `lhs` and `rhs`.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` are equal; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` are not equal; `false` otherwise.

std::istream & openvrml::operator>> | ( | std::istream & | in,
|  | quatf & | q |
| ) |  |  |

Stream input.

Consistent with the VRML97 convention, commas (“``,”) in the input are treated as whitespace.

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | q | a `quatf`.

Returns:
  `in`.

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

Stream output.

Parameters:

  `[in,out]` | out | an output stream.
  `[in]` | quat | a quaternion.

Returns:
  `out`.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` are equal; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` are not equal; `false` otherwise.

std::istream & operator>> | ( | std::istream & | in,
|  | image & | img |
| ) |  |  |

Stream input.

Consistent with the VRML97 convention, commas (“``,”) in the input are treated as whitespace.

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | img | an `image`.

Returns:
  `in`.

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

Stream output.

Parameters:

  `[in,out]` | out | output stream.
  `[in]` | img | an `image`.

std::auto_ptr< openvrml::node_type_decls > openvrml::profile | ( | const std::string & | profile_id | ) | throw ( std::invalid_argument , std::bad_alloc )

Get a `node_type_decls` map corresponding to a particular profile.

Parameters:

  `[in]` | profile_id | a profile identifier.

Returns:
  a `node_type_decls` map corresponding to `profile_id`.

Exceptions:

  | std::invalid_argument | if `profile_id` does not correspond to a known profile.
  | std::bad_alloc | if memory allocation fails.

void openvrml::add_component | ( | node_type_decls & | node_types,
|  | const std::string & | component_id,
|  | size_t | level |
| ) |  |  | throw ( std::invalid_argument , std::bad_alloc )

Add the nodes corresponding to a component level to a `node_type_decls` map.

Parameters:

  `[in,out]` | node_types | a `node_type_decls` map.
  `[in]` | component_id | a component identifier.
  `[in]` | level | a component level.

Exceptions:

  | std::invalid_argument | if `component_id` is not a recognized component identifier; or if `level` does not correspond to a supported level of `component_id`.
  | std::bad_alloc | if memory allocation fails.

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

Stream output.

Parameters:

  `[in,out]` | out | an output stream.
  `[in]` | value | a field value.

Returns:
  `out`.

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

Stream output.

If `type` is `field_value::invalid_type`, `failbit` is set on `out`.

Parameters:

  `[in,out]` | out | output stream.
  `[in]` | type_id | `field_value` type identifier.

Returns:
  `out`.

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

Stream input.

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | type_id | `field_value` type identifier.

Returns:
  `in`.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

bool operator== | ( | const sfcolorrgba & | lhs,
|  | const sfcolorrgba & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const sfcolorrgba & | lhs,
|  | const sfcolorrgba & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

bool operator== | ( | const sfdouble & | lhs,
|  | const sfdouble & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const sfdouble & | lhs,
|  | const sfdouble & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

void openvrml::intrusive_ptr_add_ref | ( | const node * | n | ) | throw ()`[inline]`

Increment the reference count.

This function is used by `boost::intrusive_ptr<node>`.

See also:
  http://boost.org/libs/smart_ptr/intrusive_ptr.html

void openvrml::intrusive_ptr_release | ( | const node * | n | ) | throw ()`[inline]`

Decrement the reference count.

This function is used by `boost::intrusive_ptr<node>`.

See also:
  http://boost.org/libs/smart_ptr/intrusive_ptr.html

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

bool operator== | ( | const sfvec2d & | lhs,
|  | const sfvec2d & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const sfvec2d & | lhs,
|  | const sfvec2d & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

bool operator== | ( | const sfvec3d & | lhs,
|  | const sfvec3d & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const sfvec3d & | lhs,
|  | const sfvec3d & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

bool operator== | ( | const mfbool & | lhs,
|  | const mfbool & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const mfbool & | lhs,
|  | const mfbool & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

bool operator== | ( | const mfcolorrgba & | lhs,
|  | const mfcolorrgba & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const mfcolorrgba & | lhs,
|  | const mfcolorrgba & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

bool operator== | ( | const mfdouble & | lhs,
|  | const mfdouble & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const mfdouble & | lhs,
|  | const mfdouble & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

bool operator== | ( | const mfimage & | lhs,
|  | const mfimage & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const mfimage & | lhs,
|  | const mfimage & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

bool operator== | ( | const mfvec2d & | lhs,
|  | const mfvec2d & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const mfvec2d & | lhs,
|  | const mfvec2d & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

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

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

bool operator== | ( | const mfvec3d & | lhs,
|  | const mfvec3d & | rhs |
| ) |  |  | throw ()

Compare for equality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` have the same value; `false` otherwise.

bool operator!= | ( | const mfvec3d & | lhs,
|  | const mfvec3d & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs | left-hand operand.
  `[in]` | rhs | right-hand operand.

Returns:
  `true` if `lhs` and `rhs` do not have the same value; `false` otherwise.

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

Stream inserter.

If `type` is `node_interface::invalid_type_id`, `failbit` is set on `out`.

Parameters:

  `[in,out]` | out | an output stream.
  `[in]` | type | a `node` interface type.

Returns:
  `out`.

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

Stream extractor.

Parameters:

  `[in,out]` | in | an input stream.
  `[out]` | type | a `node` interface type.

Returns:
  `in`.

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

Compare for equality.

Parameters:

  `[in]` | lhs | a `node_interface`.
  `[in]` | rhs | a `node_interface`.

Returns:
  `true` if the two `node_interfaces` are equal, `false` otherwise.

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

Compare for openvrml::inequality.

Parameters:

  `[in]` | lhs | a `node_interface`.
  `[in]` | rhs | a `node_interface`.

Returns:
  `true` if the two `node_interfaces` are equal, `false` otherwise.

std::ostream & operator<< | ( | std::ostream & | out,
|  | const node_interface & | interface_ |
| ) |  |  |

Stream output.

Parameters:

  `[in,out]` | out | output stream.
  `[in]` | interface_ | `node_interface`.

Returns:
  `out`.

std::istream & operator>> | ( | std::istream & | in,
|  | node_interface & | interface_ |
| ) |  |  |

Stream input.

Parameters:

  `[in,out]` | in | input stream.
  `[out]` | interface_ | `node_interface`.

Returns:
  `in`.

const openvrml::node_interface_set::const_iterator openvrml::find_interface | ( | const node_interface_set & | interfaces,
|  | const std::string & | id |
| ) |  |  | throw ()`[inline]`

Find an interface matching `id`.

If no interface is found with an interface identifier that is an exact match for `id`, this function will look for `set_` and `_changed` variants. If `interfaces` contains a `field` `zzz` along with an `eventIn` `set_zzz` and/or an `eventOut` `zzz_changed`, the `eventIn` or `eventOut` will only be found if the `set_zzz` or `zzz_changed` form, respectively, is used for `id`.

Parameters:

  `[in]` | interfaces | a set of `node_interfaces`.
  `[in]` | id | the interface identifier to look for.

Returns:
  a `const_iterator` to the interface, or `node_interface_set::end` if no interface is found.

bool operator== | ( | const node_metatype_id & | lhs,
|  | const node_metatype_id & | rhs |
| ) |  |  | throw ()

Parameters:

  `[in]` | lhs |
  `[in]` | rhs |

Returns:
  `true` if `lhs` and `rhs` are equal, `false` otherwise.

bool operator!= | ( | const node_metatype_id & | lhs,
|  | const node_metatype_id & | rhs |
| ) |  |  | throw ()

Parameters:

  `[in]` | lhs |
  `[in]` | rhs |

Returns:
  `true` if `lhs` and `rhs` are not equal, `false` otherwise.

bool operator== | ( | const node_type & | lhs,
|  | const node_type & | rhs |
| ) |  |  | throw ()

Compare for equality.

Two `node_types` `t` and `u` are considered equal if all of the following are true:

- `t.id() == u.id()`
- `t.interfaces() == u.interfaces()`
- `t.metatype().id()` is in the set of identifiers associated with `u` in the `browser`'s `node_metatype` map.

Note that the latter requirement makes this comparison a rather expensive operation.

Parameters:

  `[in]` | lhs |
  `[in]` | rhs |

Returns:
  `true` if `lhs` and `rhs` are equal; `false` otherwise.

bool operator!= | ( | const node_type & | lhs,
|  | const node_type & | rhs |
| ) |  |  | throw ()

Compare for inequality.

Parameters:

  `[in]` | lhs |
  `[in]` | rhs |

Returns:
  `true` if `lhs` and `rhs` are not equal; `false` otherwise.

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

Stream output.

Parameters:

  `[in,out]` | out | output stream.
  `[in]` | n | a `node`.

Returns:
  `out`.

template<typename To >

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

Downcast a `node` to one of the abstract `node` types.

Cast to a `viewpoint_node`.

Cast to a transform_node.

Cast to a `texture_transform_node`.

Cast to a `texture_coordinate_node`.

Cast to a `texture_node`.

Cast to a `sound_source_node`.

Cast to a `normal_node`.

Cast to a `material_node`.

Cast to a `grouping_node`.

Cast to a `geometry_node`.

Cast to a `font_style_node`.

Cast to a `coordinate_node`.

Cast to a `color_rgba_node`.

Cast to a `color_node`.

Cast to a `child_node`.

Cast to an `appearance_node`.

Cast to a `script_node`.

Template Parameters:

  | To | an abstract `node` type.

Parameters:

  `[in]` | n | a `node`.

Returns:
  a pointer to the downcast `node`, or 0 if the cast fails.

Parameters:

  `[in]` | n | node.

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

Parameters:

  `[in]` | n | `node`.

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

Parameters:

  `[in]` | n | `node`.

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

Parameters:

  `[in]` | n | `node`.

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

Parameters:

  `[in]` | n | node.

Returns:
  a `color_rgba_node` pointer to the node pointed to by `n`, or 0 if the node is not a `color_rgba_node`.

Parameters:

  `[in]` | n | `node`.

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

Parameters:

  `[in]` | 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`.

Parameters:

  `[in]` | n | `node`.

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

Parameters:

  `[in]` | n | `node`.

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

Parameters:

  `[in]` | n | `node`.

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

Parameters:

  `[in]` | n | `node`.

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

Parameters:

  `[in]` | 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`.

Parameters:

  `[in]` | n | `node`.

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

Parameters:

  `[in]` | 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`.

Parameters:

  `[in]` | 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`.

Parameters:

  `[in]` | n | `node`.

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

Parameters:

  `[in]` | 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 is_proto_instance | ( | const node & | n | ) |

Check whether a `node` is a `PROTO` instance.

Parameters:

  `[in]` | n | a `node`.

Returns:
  `true` if `n` is a `PROTO` instance; `false` otherwise.

bool openvrml::add_route | ( | node & | from,
|  | const std::string & | eventout,
|  | node & | to,
|  | const std::string & | 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.

If the route being added already exists, this method has no effect.

Parameters:

  `[in,out]` | from | source node.
  `[in]` | eventout | an eventOut of `from`.
  `[in,out]` | to | destination node.
  `[in]` | eventin | an eventIn of `to`.

Returns:
  `true` if a route was successfully added; `false` otherwise (if the route already existed).

Exceptions:

  | std::bad_alloc | if memory allocation fails.
  | unsupported_interface | if `from` has no eventOut `eventout`; or if `to` has no eventIn `eventin`.
  | field_value_type_mismatch | if `eventout` and `eventin` have different field value types.

Precondition:
  `from` and `to` are not null.

bool openvrml::delete_route | ( | node & | from,
|  | const std::string & | eventout,
|  | node & | to,
|  | const std::string & | eventin |
| ) |  |  | throw ( unsupported_interface )

Remove a route from an `eventOut` from a `node` to an `eventIn` of another `node`.

Parameters:

  `[in,out]` | from | source `node`.
  `[in]` | eventout | an `eventOut` of `from`.
  `[in,out]` | to | destination `node`.
  `[in]` | eventin | an `eventIn` of `to`.

Returns:
  `true` if a route was deleted; `false` otherwise (if no such route existed).

Exceptions:

  | unsupported_interface | if `from` has no `eventOut` `eventout` or if `to` has no `eventIn` `eventin`.

const std::string path | ( | const scope & | s | ) | throw ( std::bad_alloc )

Parameters:

  `[in]` | s | a `scope`.

Returns:
  the full “path” to the `scope`.

Examples:
  sdl_viewer.cpp.

const char * openvrml::vrml97_parse_error_msg | ( | const vrml_parse_error | error | ) | `[inline]`

Get the error message associated with a `vrml_parse_error`.

Parameters:

  `[in]` | error | error identifier.

Returns:
  the error message associated with `error`.

const char * openvrml::x3d_vrml_parse_error_msg | ( | const vrml_parse_error | error | ) | `[inline]`

Get the error messages associated with a `vrml_parse_error`.

Parameters:

  `[in]` | error | error identifier.

Returns:
  the error messages associated with `error`.

## Variable Documentation

const char openvrml::vrml_media_type = "model/vrml"

VRML MIME media type.

Examples:
  sdl_viewer.cpp.

const char openvrml::x_vrml_media_type = "x-world/x-vrml"

Experimental VRML MIME media type.

const char openvrml::x3d_vrml_media_type = "model/x3d-vrml"

X3D VRML MIME media type.

Examples:
  sdl_viewer.cpp.

const openvrml::vrml97_space_parser openvrml::vrml97_space_p = vrml97_space_parser()

A Spirit space parser appropriate for use with VRML97 and VRML-encoded X3D.

const boost::spirit::classic::real_parser<float, boost::spirit::classic::real_parser_policies<float> > openvrml::float_p

Initial value:

                boost::spirit::classic::real_parser<float, boost::spirit::classic::real_parser_policies<float> >()

const openvrml::vrml_parse_error openvrml::profile_expected = vrml_parse_error_end

The `PROFILE` keyword was expected.

const openvrml::vrml_parse_error openvrml::unrecognized_profile_id

Initial value:

            vrml_parse_error(vrml_parse_error_end + 1)

The profile identifier was not recognized as a supported profile.

const openvrml::vrml_parse_error openvrml::unrecognized_component_id_or_level

Initial value:

            vrml_parse_error(vrml_parse_error_end + 2)

The component identifier was unrecognized or the component level is unsupported.

const openvrml::vrml_parse_error openvrml::colon_expected

Initial value:

            vrml_parse_error(vrml_parse_error_end + 3)

A “:” was expected.

const openvrml::vrml_parse_error openvrml::bool_or_lbracket_expected

Initial value:

            vrml_parse_error(vrml_parse_error_end + 4)

A boolean value (i.e., `TRUE` or `FALSE`) or “[” was expected.

const openvrml::vrml_parse_error openvrml::bool_or_rbracket_expected

Initial value:

            vrml_parse_error(vrml_parse_error_end + 5)

A boolean value (i.e., `TRUE` or `FALSE`) or “]” was expected.

const openvrml::vrml_parse_error openvrml::color_rgba_expected

Initial value:

            vrml_parse_error(vrml_parse_error_end + 6)

An RGBA color value was expected.

const openvrml::vrml_parse_error openvrml::color_rgba_or_lbracket_expected

Initial value:

            vrml_parse_error(vrml_parse_error_end + 7)

An RGBA color value or “[” was expected.

const openvrml::vrml_parse_error openvrml::color_rgba_or_rbracket_expected

Initial value:

            vrml_parse_error(vrml_parse_error_end + 8)

An RGBA color value or “]” was expected.

const openvrml::vrml_parse_error openvrml::eventin_deprecated

Initial value:

            vrml_parse_error(vrml_parse_error_end + 9)

The `eventIn` keyword is deprecated.

const openvrml::vrml_parse_error openvrml::eventout_deprecated

Initial value:

            vrml_parse_error(vrml_parse_error_end + 10)

The `eventOut` keyword is deprecated.

const openvrml::vrml_parse_error openvrml::exposedfield_deprecated

Initial value:

            vrml_parse_error(vrml_parse_error_end + 11)

The `exposedField` keyword is deprecated.

const openvrml::vrml_parse_error openvrml::field_deprecated

Initial value:

            vrml_parse_error(vrml_parse_error_end + 12)

The `field` keyword is deprecated.

const boost::spirit::functor_parser< openvrml::color_rgba_parser > openvrml::color_rgba_p

A Spirit parser for RGBA color values.

const boost::spirit::functor_parser< openvrml::vec2d_parser > openvrml::vec2d_p

A Spirit parser for double-precision 2-component vector values.

const boost::spirit::functor_parser< openvrml::vec3d_parser > openvrml::vec3d_p

A Spirit parser for double-precision 3-component vector values.