openvrml Namespace Reference


Detailed Description

The OpenVRML Runtime Library.


Classes

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  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...
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  browser
 Encapsulates a VRML browser. More...
class  scene
 A scene in the VRML world. 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  node_type
 Type information object for nodes. More...
class  field_value_type_mismatch
 Thrown when field value types do not match, generally in a ROUTE or IS. More...
class  node
 A node in the scene graph. More...
class  appearance_node
 Abstract base class for appearance nodes. More...
class  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  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  read_write_mutex
 A read/write mutex with an interface that follows the patterns established in the Boost thread library. More...
class  rendering_context
 Information needed during a render traversal. More...
class  scope
 The scope class keeps track of defined nodes and prototypes. More...
class  script
 Abstract class implemented by scripting language bindings. More...
class  script_node_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...

Namespaces

namespace  node_impl_util
 Utility classes to facilitate node implementations.
namespace  gl
 OpenGL geometry renderer.

Typedefs

typedef boost::int32_t int32
 32-bit signed integer.
typedef std::list
< node_path_element > 
node_path_t
 A node path is used to store the path to a node for the purpose of duplicating a route in a cloned node hierarchy.
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
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::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 openvrml::color make_color () throw ()
 Create a zero-initialized color.
const openvrml::color make_color (const float(&rgb)[3]) throw ()
 Create a color.
const openvrml::color make_color (const float r, const float g, const 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 openvrml::color_rgba make_color_rgba () throw ()
 Create a zero-initialized color_rgba.
const openvrml::color_rgba make_color_rgba (const float(&rgba)[4]) throw ()
 Create a color_rgba.
const openvrml::color_rgba make_color_rgba (const float r, const float g, const float b, const 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 openvrml::vec2f make_vec2f () throw ()
 Create a vec2f.
const openvrml::vec2f make_vec2f (const float(&vec)[2]) throw ()
 Create a vec2f from an array.
const openvrml::vec2f make_vec2f (const float x, const float y) throw ()
 Create a vec2f from x and y components.
const openvrml::vec2f operator * (const vec2f &lhs, const float rhs) throw ()
 Multiply a vector by a scalar.
const openvrml::vec2f operator * (const float lhs, const vec2f &rhs) throw ()
 Multiply a vector by a scalar.
const openvrml::vec2f operator/ (const vec2f &lhs, const float rhs) throw ()
 Divide a vector by a scalar.
const openvrml::vec2f operator+ (const vec2f &lhs, const vec2f &rhs) throw ()
 Add two vectors.
const openvrml::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 openvrml::vec2d make_vec2d () throw ()
 Create a vec2d.
const openvrml::vec2d make_vec2d (const double(&vec)[2]) throw ()
 Create a vec2d from an array.
const openvrml::vec2d make_vec2d (const double x, const double y) throw ()
 Create a vec2d from x and y components.
const openvrml::vec2d operator * (const vec2d &lhs, const double rhs) throw ()
 Multiply a vector by a scalar.
const openvrml::vec2d operator * (const double lhs, const vec2d &rhs) throw ()
 Multiply a vector by a scalar.
const openvrml::vec2d operator/ (const vec2d &lhs, const double rhs) throw ()
 Divide a vector by a scalar.
const openvrml::vec2d operator+ (const vec2d &lhs, const vec2d &rhs) throw ()
 Add two vectors.
const openvrml::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 openvrml::vec3f make_vec3f () throw ()
 Create a vec3f.
const openvrml::vec3f make_vec3f (const float(&vec)[3]) throw ()
 Create a vec3f from an array.
const openvrml::vec3f make_vec3f (const float x, const float y, const float z) throw ()
 Create a vec3f from x, y, and z components.
const openvrml::vec3f operator * (const vec3f &lhs, const vec3f &rhs) throw ()
 Cross multiply two vectors.
const openvrml::vec3f operator * (const vec3f &vec, const mat4f &mat) throw ()
 Multiply a vector by a matrix.
const openvrml::vec3f operator * (const mat4f &mat, const vec3f &vec) throw ()
 Multiply a matrix by a vector.
const openvrml::vec3f operator * (const vec3f &lhs, const float rhs) throw ()
 Multiply a vector by a scalar.
const openvrml::vec3f operator * (const float lhs, const vec3f &rhs) throw ()
 Multiply a vector by a scalar.
const openvrml::vec3f operator/ (const vec3f &lhs, const float rhs) throw ()
 Divide a vector by a scalar.
const openvrml::vec3f operator+ (const vec3f &lhs, const vec3f &rhs) throw ()
 Add two vectors.
const openvrml::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 openvrml::vec3d make_vec3d () throw ()
 Create a vec3d.
const openvrml::vec3d make_vec3d (const double(&vec)[3]) throw ()
 Create a vec3d from an array.
const openvrml::vec3d make_vec3d (const double x, const double y, const double z) throw ()
 Create a vec3d from x, y, and z components.
const openvrml::vec3d operator * (const vec3d &lhs, const vec3d &rhs) throw ()
 Cross multiply two vectors.
const openvrml::vec3d operator * (const vec3d &vec, const mat4f &mat) throw ()
 Multiply a vector by a matrix.
const openvrml::vec3d operator * (const mat4f &mat, const vec3d &vec) throw ()
 Multiply a matrix by a vector.
const openvrml::vec3d operator * (const vec3d &lhs, const double rhs) throw ()
 Multiply a vector by a scalar.
const openvrml::vec3d operator * (const double lhs, const vec3d &rhs) throw ()
 Multiply a vector by a scalar.
const openvrml::vec3d operator/ (const vec3d &lhs, const double rhs) throw ()
 Divide a vector by a scalar.
const openvrml::vec3d operator+ (const vec3d &lhs, const vec3d &rhs) throw ()
 Add two vectors.
const openvrml::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 openvrml::rotation make_rotation () throw ()
 Create a default rotation.
const openvrml::rotation make_rotation (const float(&rot)[4]) throw ()
 Create a rotation from an array.
const openvrml::rotation make_rotation (const float x, const float y, const float z, const float angle) throw ()
 Create a rotation from x, y, z, and angle components.
const openvrml::rotation make_rotation (const vec3f &axis, const float angle) throw ()
 Create a rotation from an axis vector and an 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.
const openvrml::rotation make_rotation (const quatf &quat) throw ()
 Create a rotation from a quaternion.
const openvrml::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 openvrml::mat4f make_rotation_mat4f (const rotation &rot) throw ()
 Create a rotation matrix.
const openvrml::mat4f make_rotation_mat4f (const quatf &quat) throw ()
 Create a rotation matrix.
const openvrml::mat4f make_scale_mat4f (const vec3f &s) throw ()
 Create a scale matrix.
const openvrml::mat4f make_scale_mat4f (const float s) throw ()
 Create a uniform scale matrix.
const openvrml::mat4f make_translation_mat4f (const vec3f &t) throw ()
 Create 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.
const openvrml::mat4f make_mat4f (const float f11, const float f12, const float f13, const float f14, const float f21, const float f22, const float f23, const float f24, const float f31, const float f32, const float f33, const float f34, const float f41, const float f42, const float f43, const float f44) throw ()
 Create a mat4f with given 16 elements in row-major order.
const openvrml::mat4f make_mat4f () throw ()
 Create an identity matrix.
const openvrml::mat4f make_mat4f (const float mat[16]) throw ()
 Create a matrix from an array of 16 values.
const openvrml::mat4f make_mat4f (const float(&mat)[4][4]) throw ()
 Create a matrix from a 4x4 array.
const openvrml::mat4f operator * (const mat4f &mat, const float scalar) throw ()
 Multiply a matrix by a scalar value.
const openvrml::mat4f operator * (const float scalar, const mat4f &mat) throw ()
 Multiply a scalar value by matrix.
const openvrml::mat4f operator * (const mat4f &lhs, const mat4f &rhs) throw ()
 Multiply two matrices.
std::istream & operator>> (std::istream &in, mat4f &m)
 Stream input.
std::ostream & operator<< (std::ostream &out, const mat4f &mat)
 Stream output.
bool operator== (const mat4f &lhs, const mat4f &rhs) throw ()
 Equality comparison operator.
bool operator!= (const mat4f &lhs, const mat4f &rhs) throw ()
 Inequality comparison operator.
const openvrml::quatf make_quatf () throw ()
 Create a default quatf.
const openvrml::quatf make_quatf (const float x, const float y, const float z, const float w) throw ()
 Create a quatf from four values.
const openvrml::quatf make_quatf (const float(&quat)[4]) throw ()
 Create a quatf from an array of four values.
const openvrml::quatf make_quatf (const mat4f &mat) throw ()
 Create a quatf from a rotation matrix.
const openvrml::quatf make_quatf (const rotation &rot) throw ()
 Create a quatf from a rotation.
const openvrml::quatf operator * (const quatf &lhs, const quatf &rhs) throw ()
 Multiply two quaternions.
const openvrml::quatf operator * (const quatf &quat, const float scalar) throw ()
 Multiply a quaternion by a scalar.
const openvrml::quatf operator * (const float scalar, const quatf &quat) throw ()
 Multiply a scalar by a quaternion.
const openvrml::quatf operator/ (const quatf &quat, const float scalar) throw ()
 Divide a quaternion by a scalar.
const openvrml::quatf operator+ (const quatf &lhs, const quatf &rhs) throw ()
 Add two quaternions.
const openvrml::quatf operator- (const quatf &lhs, const quatf &rhs) throw ()
 Take the difference between two quaternions.
std::istream & operator>> (std::istream &in, quatf &q)
 Stream input.
std::ostream & operator<< (std::ostream &out, const quatf &quat)
 Stream output.
bool operator== (const quatf &lhs, const quatf &rhs) throw ()
 Compare for equality.
bool operator!= (const quatf &lhs, const quatf &rhs) throw ()
 Compare for inequality.
bool operator== (const image &lhs, const image &rhs) throw ()
 Compare for equality.
bool operator!= (const image &lhs, const image &rhs) throw ()
 Compare for inequality.
std::istream & operator>> (std::istream &in, image &img)
 Stream input.
std::ostream & operator<< (std::ostream &out, const image &img)
 Stream output.
const node_path_t get_path (const std::vector< boost::intrusive_ptr< node > > &root, const node &objective) throw ( std::bad_alloc )
 Get the path to a node.
noderesolve_node_path (const node_path_t &path, const std::vector< boost::intrusive_ptr< node > > &root)
 Resolve a node path against a node hierarchy.
std::auto_ptr
< openvrml::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, const 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, const field_value::type_id type_id)
 Stream output.
std::istream & operator>> (std::istream &in, field_value::type_id &type_id)
 Stream input.
bool operator== (const sfbool &lhs, const sfbool &rhs) throw ()
 Compare for equality.
bool operator!= (const sfbool &lhs, const sfbool &rhs) throw ()
 Compare for inequality.
bool operator== (const sfcolor &lhs, const sfcolor &rhs) throw ()
 Compare for equality.
bool operator!= (const sfcolor &lhs, const sfcolor &rhs) throw ()
 Compare for inequality.
bool operator== (const 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.
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.
void intrusive_ptr_add_ref (const node *) throw ()
 Increment the reference count.
void intrusive_ptr_release (const node *) throw ()
 Decrement the reference count.
std::ostream & operator<< (std::ostream &out, const node_interface::type_id type)
 Stream inserter.
std::istream & operator>> (std::istream &in, node_interface::type_id &type)
 Stream extractor.
bool operator== (const node_interface &lhs, const node_interface &rhs) throw ()
 Compare for equality.
bool operator!= (const node_interface &lhs, const node_interface &rhs) throw ()
 Compare for openvrml::inequality.
std::ostream & operator<< (std::ostream &out, const node_interface &interface_)
 Stream output.
std::istream & operator>> (std::istream &in, node_interface &interface_)
 Stream input.
std::ostream & operator<< (std::ostream &out, const node &n)
 Stream output.
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.
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 ()
bool operator!= (const node_type &lhs, const node_type &rhs) throw ()
template<typename To>
To node_cast (node *n) throw ()
 Downcast a node to one of the abstract node types.
template<>
script_nodenode_cast< script_node * > (node *n) throw ()
template<>
appearance_nodenode_cast< appearance_node * > (node *n) throw ()
template<>
bounded_volume_nodenode_cast< bounded_volume_node * > (node *n) throw ()
template<>
child_nodenode_cast< child_node * > (node *n) throw ()
template<>
color_nodenode_cast< color_node * > (node *n) throw ()
template<>
color_rgba_nodenode_cast< color_rgba_node * > (node *n) throw ()
template<>
coordinate_nodenode_cast< coordinate_node * > (node *n) throw ()
template<>
font_style_nodenode_cast< font_style_node * > (node *n) throw ()
template<>
geometry_nodenode_cast< geometry_node * > (node *n) throw ()
template<>
grouping_nodenode_cast< grouping_node * > (node *n) throw ()
template<>
light_nodenode_cast< light_node * > (node *n) throw ()
template<>
material_nodenode_cast< material_node * > (node *n) throw ()
template<>
navigation_info_nodenode_cast< navigation_info_node * > (node *n) throw ()
template<>
normal_nodenode_cast< normal_node * > (node *n) throw ()
template<>
pointing_device_sensor_nodenode_cast< pointing_device_sensor_node * > (node *n) throw ()
template<>
scoped_light_nodenode_cast< scoped_light_node * > (node *n) throw ()
template<>
sound_source_nodenode_cast< sound_source_node * > (node *n) throw ()
template<>
texture_nodenode_cast< texture_node * > (node *n) throw ()
template<>
texture_coordinate_nodenode_cast< texture_coordinate_node * > (node *n) throw ()
template<>
texture_transform_nodenode_cast< texture_transform_node * > (node *n) throw ()
template<>
time_dependent_nodenode_cast< time_dependent_node * > (node *n) throw ()
template<>
transform_nodenode_cast< transform_node * > (node *n) throw ()
template<>
viewpoint_nodenode_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::real_parser
< float,
boost::spirit::real_parser_policies
< float > > 
float_p
const
boost::spirit::functor_parser
< bool_parser > 
bool_p
const
boost::spirit::functor_parser
< int32_parser > 
int32_p
const
boost::spirit::functor_parser
< intensity_parser > 
intensity_p
const
boost::spirit::functor_parser
< color_parser > 
color_p
const
boost::spirit::functor_parser
< vec2f_parser > 
vec2f_p
const
boost::spirit::functor_parser
< vec3f_parser > 
vec3f_p
const
boost::spirit::functor_parser
< image_parser > 
image_p
const phoenix::function
< get_string_content_function > 
get_string_content
const
boost::spirit::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::functor_parser
< color_rgba_parser
color_rgba_p
 A Spirit parser for RGBA color values.
const
boost::spirit::functor_parser
< vec2d_parser
vec2d_p
 A Spirit parser for double-precision 2-component vector values.
const
boost::spirit::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

Typedef Documentation

32-bit signed integer.

typedef std::list<node_path_element> openvrml::node_path_t

A node path is used to store the path to a node for the purpose of duplicating a route in a cloned node hierarchy.

sfbool event listener.

sfcolor event listener.

sfcolorrgba event listener.

sffloat event listener.

sfdouble event listener.

sfimage event listener.

sfint32 event listener.

sfnode event listener.

sfrotation event listener.

sfstring event listener.

sftime event listener.

sfvec2f event listener.

sfvec2d event listener.

sfvec3f event listener.

sfvec3d event listener.

mfbool event listener.

mfcolor event listener.

mfcolorrgba event listener.

mffloat event listener.

mfdouble event listener.

mfimage event listener.

mfint32 event listener.

mfnode event listener.

mfrotation event listener.

mfstring event listener.

mftime event listener.

mfvec2f event listener.

mfvec2d event listener.

mfvec3f event listener.

mfvec3d event listener.

sfbool event emitter.

sfcolor event emitter.

sfcolorrgba event emitter.

sffloat event emitter.

sfdouble event emitter.

sfimage event emitter.

sfint32 event emitter.

sfnode event emitter.

sfrotation event emitter.

sfstring event emitter.

sftime event emitter.

sfvec2f event emitter.

sfvec2d event emitter.

sfvec3f event emitter.

sfvec3d event emitter.

mfbool event emitter.

mfcolor event emitter.

mfcolorrgba event emitter.

mffloat event emitter.

mfdouble event emitter.

mfint32 event emitter.

mfimage event emitter.

mfnode event emitter.

mfrotation event emitter.

mfstring event emitter.

mftime event emitter.

mfvec2f event emitter.

mfvec2d event emitter.

mfvec3f event emitter.

mfvec3d event emitter.

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.

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

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

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 color openvrml::make_color (  )  throw ()

Create a zero-initialized color.

Returns:
a zero-initialized color.

const color openvrml::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 color openvrml::make_color ( const float  r,
const float  g,
const 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 openvrml::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 openvrml::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 & openvrml::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 & openvrml::operator<< ( std::ostream &  out,
const color &  c 
)

Stream output.

Parameters:
[in,out] out output stream.
[in] c a color.
Returns:
out.

const color_rgba openvrml::make_color_rgba (  )  throw ()

Create a zero-initialized color_rgba.

Returns:
a zero-initialized color_rgba.

const color_rgba openvrml::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 color_rgba openvrml::make_color_rgba ( const float  r,
const float  g,
const float  b,
const 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 openvrml::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 openvrml::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 & openvrml::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 & openvrml::operator<< ( std::ostream &  out,
const color_rgba &  c 
)

Stream output.

Parameters:
[in,out] out output stream.
[in] c a color_rgba.
Returns:
out.

const vec2f openvrml::make_vec2f (  )  throw ()

Create a vec2f.

Returns:
a zero-initialized vec2f.

const vec2f openvrml::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 vec2f openvrml::make_vec2f ( const float  x,
const 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 vec2f openvrml::operator * ( const vec2f &  lhs,
const 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 vec2f openvrml::operator * ( const 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 vec2f openvrml::operator/ ( const vec2f &  lhs,
const 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 vec2f openvrml::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 vec2f openvrml::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 openvrml::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 openvrml::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 & openvrml::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 & openvrml::operator<< ( std::ostream &  out,
const vec2f &  v 
)

Stream output.

Parameters:
[in,out] out output stream.
[in] v a 2-component vector.
Returns:
out.

const vec2d openvrml::make_vec2d (  )  throw ()

Create a vec2d.

Returns:
a zero-initialized vec2d.

const vec2d openvrml::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 vec2d openvrml::make_vec2d ( const double  x,
const 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 vec2d openvrml::operator * ( const vec2d &  lhs,
const 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 vec2d openvrml::operator * ( const 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 vec2d openvrml::operator/ ( const vec2d &  lhs,
const 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 vec2d openvrml::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 vec2d openvrml::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 openvrml::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 openvrml::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 & openvrml::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 & openvrml::operator<< ( std::ostream &  out,
const vec2d &  v 
)

Stream output.

Parameters:
[in,out] out output stream.
[in] v a 2-component vector.
Returns:
out.

const vec3f openvrml::make_vec3f (  )  throw ()

Create a vec3f.

Returns:
a zero-initialized vec3f.

const vec3f openvrml::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 vec3f openvrml::make_vec3f ( const float  x,
const float  y,
const 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 vec3f openvrml::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 vec3f openvrml::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 vec3f openvrml::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 vec3f openvrml::operator * ( const vec3f &  lhs,
const 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 vec3f openvrml::operator * ( const 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 vec3f openvrml::operator/ ( const vec3f &  lhs,
const 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 vec3f openvrml::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 vec3f openvrml::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 openvrml::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 openvrml::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 & openvrml::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 & openvrml::operator<< ( std::ostream &  out,
const vec3f &  v 
)

Stream output.

Parameters:
[in,out] out output stream.
[in] v a 3-component vector.
Returns:
out.

const vec3d openvrml::make_vec3d (  )  throw ()

Create a vec3d.

Returns:
a zero-initialized vec3d.

const vec3d openvrml::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 vec3d openvrml::make_vec3d ( const double  x,
const double  y,
const 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 vec3d openvrml::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 vec3d openvrml::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 vec3d openvrml::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 vec3d openvrml::operator * ( const vec3d &  lhs,
const 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 vec3d openvrml::operator * ( const 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 vec3d openvrml::operator/ ( const vec3d &  lhs,
const 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 vec3d openvrml::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 vec3d openvrml::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 openvrml::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 openvrml::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 & openvrml::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 & openvrml::operator<< ( std::ostream &  out,
const vec3d &  v 
)

Stream output.

Parameters:
[in,out] out output stream.
[in] v a 3-component vector.
Returns:
out.

const rotation openvrml::make_rotation (  )  throw ()

Create a default rotation.

Returns:
a default rotation.

const rotation openvrml::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 rotation openvrml::make_rotation ( const float  x,
const float  y,
const float  z,
const 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 rotation openvrml::make_rotation ( const vec3f &  axis,
const 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 rotation openvrml::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 rotation openvrml::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 rotation openvrml::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 openvrml::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 openvrml::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 & openvrml::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 & openvrml::operator<< ( std::ostream &  out,
const rotation &  r 
)

Stream output.

Parameters:
[in,out] out output stream.
[in] r a rotation.
Returns:
out.

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

Create a rotation matrix.

Parameters:
[in] rot a rotation.
Returns:
a matrix representation of rot.

const mat4f openvrml::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 mat4f openvrml::make_scale_mat4f ( const vec3f &  s  )  throw ()

Create a scale matrix.

Parameters:
[in] s a vector.
Returns:
a scale matrix.

const mat4f openvrml::make_scale_mat4f ( const 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 mat4f openvrml::make_translation_mat4f ( const vec3f &  t  )  throw ()

Create a translation matrix.

Parameters:
[in] t translation vector.
Returns:
a translation matrix.

const mat4f openvrml::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.

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

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

\[ \left[ \begin{array}{cccc} f_{11} & f_{12} & f_{13} & f_{14} \\ f_{21} & f_{22} & f_{23} & f_{24} \\ f_{31} & f_{32} & f_{33} & f_{34} \\ f_{41} & f_{42} & f_{43} & f_{44} \\ \end{array} \right] \]

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 mat4f openvrml::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 mat4f openvrml::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 mat4f openvrml::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 mat4f openvrml::operator * ( const mat4f &  mat,
const float  scalar 
) throw ()

Multiply a matrix by a scalar value.

Parameters:
[in] mat matrix.
[in] scalar scalar.
Returns:
the result matrix.

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

Multiply a scalar value by matrix.

Parameters:
[in] scalar scalar.
[in] mat matrix.
Returns:
the result matrix.

const mat4f openvrml::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.

std::istream & openvrml::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 & openvrml::operator<< ( std::ostream &  out,
const mat4f &  mat 
)

Stream output.

Parameters:
[in,out] out an output stream.
[in] mat a matrix.
Returns:
out.

bool openvrml::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 openvrml::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 quatf openvrml::make_quatf (  )  throw ()

Create a default quatf.

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

const quatf openvrml::make_quatf ( const float  x,
const float  y,
const float  z,
const 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 quatf openvrml::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 quatf openvrml::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 quatf openvrml::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 quatf openvrml::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 quatf openvrml::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 quatf openvrml::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 quatf openvrml::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 quatf openvrml::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 quatf openvrml::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.

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 & openvrml::operator<< ( std::ostream &  out,
const quatf &  quat 
)

Stream output.

Parameters:
[in,out] out an output stream.
[in] quat a quaternion.
Returns:
out.

bool openvrml::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 openvrml::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.

bool openvrml::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 openvrml::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 & openvrml::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 & openvrml::operator<< ( std::ostream &  out,
const image &  img 
)

Stream output.

Parameters:
[in,out] out output stream.
[in] img an image.

const node_path_t openvrml::get_path ( const std::vector< boost::intrusive_ptr< node > > &  root,
const node &  objective 
) throw ( std::bad_alloc )

Get the path to a node.

For internal use only.

Returns:
the path to a node.

node* openvrml::resolve_node_path ( const node_path_t &  path,
const std::vector< boost::intrusive_ptr< node > > &  root 
)

Resolve a node path against a node hierarchy.

For internal use only.

Returns:
a pointer to the objective node in the node hierarchy designated by root.

std::auto_ptr< 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,
const 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 & openvrml::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 & openvrml::operator<< ( std::ostream &  out,
const field_value::type_id  type_id 
)

Stream output.

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

Parameters:
[in,out] out output stream.
[in] type_id field_value type identifier.
Returns:
out.

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

Stream input.

Parameters:
[in,out] in input stream.
[out] type_id field_value type identifier.
Returns:
in.

bool openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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.

bool openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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 openvrml::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.

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

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

Stream inserter.

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

Parameters:
[in,out] out an output stream.
[in] type a node interface type.
Returns:
out.

std::istream & openvrml::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 openvrml::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 openvrml::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 & openvrml::operator<< ( std::ostream &  out,
const node_interface &  interface_ 
)

Stream output.

Parameters:
[in,out] out output stream.
[in] interface_ node_interface.
Returns:
out.

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

Stream input.

Parameters:
[in,out] in input stream.
[out] interface_ node_interface.
Returns:
in.

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

Stream output.

Parameters:
[in,out] out output stream.
[in] n a node.
Returns:
out.

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

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.

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.

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.

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

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

Initial value:

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

The PROFILE keyword was expected.

Initial value:

        vrml_parse_error(vrml_parse_error_end + 1)
The profile identifier was not recognized as a supported profile.

Initial value:

        vrml_parse_error(vrml_parse_error_end + 2)
The component identifier was unrecognized or the component level is unsupported.

Initial value:

        vrml_parse_error(vrml_parse_error_end + 3)
A “:” was expected.

Initial value:

        vrml_parse_error(vrml_parse_error_end + 4)
A boolean value (i.e., TRUE or FALSE) or “[” was expected.

Initial value:

        vrml_parse_error(vrml_parse_error_end + 5)
A boolean value (i.e., TRUE or FALSE) or “]” was expected.

Initial value:

        vrml_parse_error(vrml_parse_error_end + 6)
An RGBA color value was expected.

Initial value:

        vrml_parse_error(vrml_parse_error_end + 7)
An RGBA color value or “[” was expected.

Initial value:

        vrml_parse_error(vrml_parse_error_end + 8)
An RGBA color value or “]” was expected.

Initial value:

        vrml_parse_error(vrml_parse_error_end + 9)
The eventIn keyword is deprecated.

Initial value:

        vrml_parse_error(vrml_parse_error_end + 10)
The eventOut keyword is deprecated.

Initial value:

        vrml_parse_error(vrml_parse_error_end + 11)
The exposedField keyword is 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.