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

openvrml Namespace Reference


Detailed Description

The OpenVRML Runtime Library.


Classes

class  color
 A color. More...
class  vec2f
 Two-component single precision vector. More...
class  vec3f
 Three-component single precision vector. More...
class  rotation
 A rotation. More...
class  mat4f
 A class for all matrix operations. More...
class  quatf
 A quaternion. More...
class  image
 Pixmap data. More...
class  bounding_volume
 A bounding volume. More...
class  bounding_sphere
 A bounding sphere. More...
class  axis_aligned_bounding_box
 An axis-aligned bounding box. More...
class  invalid_vrml
 Exception thrown when the parser fails due to errors in the VRML input. More...
class  viewer_in_use
 Exception thrown when attempting to associate a viewer with a browser when the viewer is already associated with a browser. More...
class  browser
 Encapsulates a VRML browser. More...
class  bad_url
 Thrown when there is a problem resolving a URI. More...
class  invalid_url
 Thrown when parsing a URI fails. More...
class  unreachable_url
 Thrown when a URI cannot be reached. More...
class  no_alternative_url
 Exception thrown when no URI in an alternative URI list can be resolved. More...
class  scene
 A scene in the VRML world. More...
class  doc
 A class to contain document references. More...
class  doc2
 A class to contain document references. More...
class  event_listener
 Abstract base class of event listeners. More...
class  field_value_listener
 Concrete event listener template. More...
class  event_emitter
 Abstract base class of event emitters. More...
class  field_value_emitter
 Concrete event emitter template. More...
class  exposedfield
 Class template to simplify implementation of exposedFields. More...
class  field_value
 Abstract base class for the VRML field types. More...
struct  FieldValueConcept
 Concept checking class to validate that a template parameter is a model of the FieldValue concept. More...
class  sfbool
 A boolean node field value. More...
class  sfcolor
 A color node field value. More...
class  sffloat
 A single precision floating point node field value. More...
class  sfimage
 A pixmap. More...
class  sfint32
 A 32-bit integer node field value. More...
class  sfnode
 A node field value to hold a single node reference. More...
class  sfrotation
 A rotation node field value. More...
class  sfstring
 A string node field value. More...
class  sftime
 A double precision floating point node field value. More...
class  sfvec2f
 A 2-component vector node field value. More...
class  sfvec3f
 A 3-component vector node field value. More...
class  mfcolor
 A color array node field value. More...
class  mffloat
 A float array node field value. More...
class  mfint32
 An integer array node field value. More...
class  mfnode
 A node reference array node field value. More...
class  mfrotation
 A rotation array node field value. More...
class  mfstring
 A string array node field value. More...
class  mftime
 A double array node field value. More...
class  mfvec2f
 A 2-component vector array node field value. More...
class  mfvec3f
 A 3-component vector array node field value. More...
class  frustum
 A view frustum. More...
class  img
 Image data. More...
class  node_interface
 Type information for an interface of a node. More...
class  unsupported_interface
 Exception to indicate that a node interface is not supported. More...
struct  node_interface_matches_eventin
 Determine if a node_interface matches an eventIn identifier. More...
struct  node_interface_matches_eventout
 Determine if a node_interface matches an eventOut identifier. More...
struct  node_interface_matches_exposedfield
 Determine if a node_interface matches an exposedField identifier. More...
struct  node_interface_matches_field
 Determine if a node_interface matches an field identifier. More...
struct  node_interface_compare
 Function object to compare two node_interfaces based on their id. More...
class  node_class
 A class object for node instances. More...
class  node_type
 Type information object for nodes. More...
class  field_value_type_mismatch
 Thrown when field value types do not match, generally in a ROUTE or IS. More...
class  node
 A node in the scene graph. More...
class  appearance_node
 Abstract base class for appearance nodes. More...
class  child_node
 Abstract base class for child nodes. More...
class  color_node
 Abstract base class for color nodes. More...
class  coordinate_node
 Abstract base class for coordinate nodes. More...
class  font_style_node
 Abstract base class for font style nodes. More...
class  geometry_node
 Abstract base class for geometry nodes. More...
class  grouping_node
 Abstract base class for grouping nodes. More...
class  material_node
 Abstract base class for material nodes. More...
class  normal_node
 Abstract base class for normal nodes. More...
class  sound_source_node
 Abstract base class for sound source nodes. More...
class  texture_node
 Abstract base class for texture nodes. More...
class  texture_coordinate_node
 Abstract base class for texture coordinate nodes. More...
class  texture_transform_node
 Abstract base class for texture transform nodes. More...
class  transform_node
 Abstract base class for texture transform nodes. More...
class  viewpoint_node
 Abstract base class for texture transform nodes. More...
class  node_traverser
 Traverse the children of each node in a node hierarchy only once. More...
class  node_ptr
 A reference-counted smart pointer for nodes. More...
class  rendering_context
 Information needed during a render traversal. More...
class  scope
 The scope class keeps track of defined nodes and prototypes. More...
class  script
 Abstract class implemented by scripting language bindings. More...
class  script_node_class
 Class object for script_nodes. More...
class  script_node
 Represents a VRML Script node. More...
class  viewer
 Map the scene graph to the underlying graphics library. More...

Namespaces

namespace  vrml97_node
 Implementations of the VRML97 nodes.
namespace  gl
 OpenGL geometry renderer.

Typedefs

typedef int32_t int32
 32-bit signed integer.
typedef field_value_listener<
sfbool
sfbool_listener
 sfbool event listener.
typedef field_value_listener<
sfcolor
sfcolor_listener
 sfcolor event listener.
typedef field_value_listener<
sffloat
sffloat_listener
 sffloat event listener.
typedef field_value_listener<
sfimage
sfimage_listener
 sfimage event listener.
typedef field_value_listener<
sfint32
sfint32_listener
 sfint32 event listener.
typedef field_value_listener<
sfnode
sfnode_listener
 sfnode event listener.
typedef field_value_listener<
sfrotation
sfrotation_listener
 sfrotation event listener.
typedef field_value_listener<
sfstring
sfstring_listener
 sfstring event listener.
typedef field_value_listener<
sftime
sftime_listener
 sftime event listener.
typedef field_value_listener<
sfvec2f
sfvec2f_listener
 sfvec2f event listener.
typedef field_value_listener<
sfvec3f
sfvec3f_listener
 sfvec3f event listener.
typedef field_value_listener<
mfcolor
mfcolor_listener
 mfcolor event listener.
typedef field_value_listener<
mffloat
mffloat_listener
 mffloat event listener.
typedef field_value_listener<
mfint32
mfint32_listener
 mfint32 event listener.
typedef field_value_listener<
mfnode
mfnode_listener
 mfnode event listener.
typedef field_value_listener<
mfrotation
mfrotation_listener
 mfrotation event listener.
typedef field_value_listener<
mfstring
mfstring_listener
 mfstring event listener.
typedef field_value_listener<
mftime
mftime_listener
 mftime event listener.
typedef field_value_listener<
mfvec2f
mfvec2f_listener
 mfvec2f event listener.
typedef field_value_listener<
mfvec3f
mfvec3f_listener
 mfvec3f event listener.
typedef field_value_emitter<
sfbool
sfbool_emitter
 sfbool event emitter.
typedef field_value_emitter<
sfcolor
sfcolor_emitter
 sfcolor event emitter.
typedef field_value_emitter<
sffloat
sffloat_emitter
 sffloat event emitter.
typedef field_value_emitter<
sfimage
sfimage_emitter
 sfimage event emitter.
typedef field_value_emitter<
sfint32
sfint32_emitter
 sfint32 event emitter.
typedef field_value_emitter<
sfnode
sfnode_emitter
 sfnode event emitter.
typedef field_value_emitter<
sfrotation
sfrotation_emitter
 sfrotation event emitter.
typedef field_value_emitter<
sfstring
sfstring_emitter
 sfstring event emitter.
typedef field_value_emitter<
sftime
sftime_emitter
 sftime event emitter.
typedef field_value_emitter<
sfvec2f
sfvec2f_emitter
 sfvec2f event emitter.
typedef field_value_emitter<
sfvec3f
sfvec3f_emitter
 sfvec3f event emitter.
typedef field_value_emitter<
mfcolor
mfcolor_emitter
 mfcolor event emitter.
typedef field_value_emitter<
mffloat
mffloat_emitter
 mffloat event emitter.
typedef field_value_emitter<
mfint32
mfint32_emitter
 mfint32 event emitter.
typedef field_value_emitter<
mfnode
mfnode_emitter
 mfnode event emitter.
typedef field_value_emitter<
mfrotation
mfrotation_emitter
 mfrotation event emitter.
typedef field_value_emitter<
mfstring
mfstring_emitter
 mfstring event emitter.
typedef field_value_emitter<
mftime
mftime_emitter
 mftime event emitter.
typedef field_value_emitter<
mfvec2f
mfvec2f_emitter
 mfvec2f event emitter.
typedef field_value_emitter<
mfvec3f
mfvec3f_emitter
 mfvec3f event emitter.
typedef boost::shared_ptr<
field_value
field_value_ptr
 A boost::shared_ptr to a field_value.
typedef std::set< node_interface,
node_interface_compare
node_interface_set
 A group of unique node_interfaces.
typedef boost::shared_ptr<
node_type
node_type_ptr
 A boost::shared_ptr to a node_type.
typedef boost::shared_ptr<
node_class
node_class_ptr
 A boost::shared_ptr to a node_class.
typedef std::map< std::string,
boost::shared_ptr< field_value > > 
initial_value_map
 A map of the initial values with which a node is instantiated.
typedef std::deque< node * > node_path
 A path to a node in the scene starting with one of the scene root nodes and ending with the objective node.

Functions

bool operator== (const color &lhs, const color &rhs) throw ()
 Compare for equality.
bool operator!= (const color &lhs, const color &rhs) throw ()
 Compare for inequality.
std::ostream & operator<< (std::ostream &out, const color &c)
 Stream output.
const vec2f operator * (const vec2f &lhs, const float rhs) throw ()
 Multiply a vector by a scalar.
const vec2f operator * (const float lhs, const vec2f &rhs) throw ()
 Multiply a vector by a scalar.
const vec2f operator/ (const vec2f &lhs, const float rhs) throw ()
 Divide a vector by a scalar.
const vec2f operator+ (const vec2f &lhs, const vec2f &rhs) throw ()
 Add two vectors.
const vec2f operator- (const vec2f &lhs, const vec2f &rhs) throw ()
 Subtract two vectors.
bool operator== (const vec2f &lhs, const vec2f &rhs) throw ()
 Compare for equality.
bool operator!= (const vec2f &lhs, const vec2f &rhs) throw ()
 Compare for inequality.
std::ostream & operator<< (std::ostream &out, const vec2f &v)
 Stream output.
const vec3f operator * (const vec3f &lhs, const vec3f &rhs) throw ()
 Cross multiply two vectors.
const vec3f operator * (const vec3f &vec, const mat4f &mat) throw ()
 Multiply a vector by a matrix.
const vec3f operator * (const mat4f &mat, const vec3f &vec) throw ()
 Multiply a matrix by a vector.
const vec3f operator * (const vec3f &lhs, const float rhs) throw ()
 Multiply a vector by a scalar.
const vec3f operator * (const float lhs, const vec3f &rhs) throw ()
 Multiply a vector by a scalar.
const vec3f operator/ (const vec3f &lhs, const float rhs) throw ()
 Divide a vector by a scalar.
const vec3f operator+ (const vec3f &lhs, const vec3f &rhs) throw ()
 Add two vectors.
const vec3f operator- (const vec3f &lhs, const vec3f &rhs) throw ()
 Subtract two vectors.
bool operator== (const vec3f &lhs, const vec3f &rhs) throw ()
 Compare for equality.
bool operator!= (const vec3f &lhs, const vec3f &rhs) throw ()
 Compare for inequality.
std::ostream & operator<< (std::ostream &out, const vec3f &v)
 Stream output.
const rotation operator * (const rotation &lhs, const rotation &rhs) throw ()
 Multiply rotations.
bool operator== (const rotation &lhs, const rotation &rhs) throw ()
 Compare for equality.
bool operator!= (const rotation &lhs, const rotation &rhs) throw ()
 Compare for inequality.
std::ostream & operator<< (std::ostream &out, const rotation &r)
 Stream output.
const mat4f operator * (const mat4f &mat, const float scalar) throw ()
 Multiply a matrix by a scalar value.
const mat4f operator * (const float scalar, const mat4f &mat) throw ()
 Multiply a scalar value by matrix.
const mat4f operator * (const mat4f &lhs, const mat4f &rhs) throw ()
 Multiply two matrices.
std::ostream & operator<< (std::ostream &out, const mat4f &mat)
 Stream output.
bool operator== (const mat4f &lhs, const mat4f &rhs) throw ()
 Equality comparison operator.
bool operator!= (const mat4f &lhs, const mat4f &rhs) throw ()
 Inequality comparison operator.
const quatf operator * (const quatf &lhs, const quatf &rhs) throw ()
 Multiply two quaternions.
const quatf operator * (const quatf &quat, const float scalar) throw ()
 Multiply a quaternion by a scalar.
const quatf operator * (const float scalar, const quatf &quat) throw ()
 Multiply a scalar by a quaternion.
const quatf operator/ (const quatf &quat, const float scalar) throw ()
 Divide a quaternion by a scalar.
const quatf operator+ (const quatf &lhs, const quatf &rhs) throw ()
 Add two quaternions.
const quatf operator- (const quatf &lhs, const quatf &rhs) throw ()
 Take the difference between two quaternions.
std::ostream & operator<< (std::ostream &out, const quatf &quat)
 Stream output.
bool operator== (const quatf &lhs, const quatf &rhs) throw ()
 Compare for equality.
bool operator!= (const quatf &lhs, const quatf &rhs) throw ()
 Compare for inequality.
bool operator== (const image &lhs, const image &rhs) throw ()
 Compare for equality.
bool operator!= (const image &lhs, const image &rhs) throw ()
 Compare for inequality.
std::ostream & operator<< (std::ostream &out, const image &img)
 Stream output.
 float (&mat4f::operator[](size_t index) throw())[4]
 Row access.
const float (&mat4f::operator[](size_t index) const throw())[4]
 Row access.
std::ostream & operator<< (std::ostream &out, const field_value &value)
 Stream output.
std::ostream & operator<< (std::ostream &out, const field_value::type_id type_id)
 Stream output.
std::istream & operator>> (std::istream &in, field_value::type_id &type_id)
 Stream input.
bool operator== (const sfbool &lhs, const sfbool &rhs) throw ()
 Compare for equality.
bool operator!= (const sfbool &lhs, const sfbool &rhs) throw ()
 Compare for inequality.
bool operator== (const sfcolor &lhs, const sfcolor &rhs) throw ()
 Compare for equality.
bool operator!= (const sfcolor &lhs, const sfcolor &rhs) throw ()
 Compare for inequality.
bool operator== (const sffloat &lhs, const sffloat &rhs) throw ()
 Compare for equality.
bool operator!= (const sffloat &lhs, const sffloat &rhs) throw ()
 Compare for inequality.
bool operator== (const sfimage &lhs, const sfimage &rhs) throw ()
 Compare for equality.
bool operator!= (const sfimage &lhs, const sfimage &rhs) throw ()
 Compare for inequality.
bool operator== (const sfint32 &lhs, const sfint32 &rhs) throw ()
 Compare for equality.
bool operator!= (const sfint32 &lhs, const sfint32 &rhs) throw ()
 Compare for inequality.
bool operator== (const sfnode &lhs, const sfnode &rhs) throw ()
 Compare for equality.
bool operator!= (const sfnode &lhs, const sfnode &rhs) throw ()
 Compare for inequality.
bool operator== (const sfrotation &lhs, const sfrotation &rhs) throw ()
 Compare for equality.
bool operator!= (const sfrotation &lhs, const sfrotation &rhs) throw ()
 Compare for inequality.
bool operator== (const sfstring &lhs, const sfstring &rhs) throw ()
 Compare for equality.
bool operator!= (const sfstring &lhs, const sfstring &rhs) throw ()
 Compare for inequality.
bool operator== (const sftime &lhs, const sftime &rhs) throw ()
 Compare for equality.
bool operator!= (const sftime &lhs, const sftime &rhs) throw ()
 Compare for inequality.
bool operator== (const sfvec2f &lhs, const sfvec2f &rhs) throw ()
 Compare for equality.
bool operator!= (const sfvec2f &lhs, const sfvec2f &rhs) throw ()
 Compare for inequality.
bool operator== (const sfvec3f &lhs, const sfvec3f &rhs) throw ()
 Compare for equality.
bool operator!= (const sfvec3f &lhs, const sfvec3f &rhs) throw ()
 Compare for inequality.
bool operator== (const mfcolor &lhs, const mfcolor &rhs) throw ()
 Compare for equality.
bool operator!= (const mfcolor &lhs, const mfcolor &rhs) throw ()
 Compare for inequality.
bool operator== (const mffloat &lhs, const mffloat &rhs) throw ()
 Compare for equality.
bool operator!= (const mffloat &lhs, const mffloat &rhs) throw ()
 Compare for inequality.
bool operator== (const mfint32 &lhs, const mfint32 &rhs) throw ()
 Compare for equality.
bool operator!= (const mfint32 &lhs, const mfint32 &rhs) throw ()
 Compare for inequality.
bool operator== (const mfnode &lhs, const mfnode &rhs) throw ()
 Compare for equality.
bool operator!= (const mfnode &lhs, const mfnode &rhs) throw ()
 Compare for inequality.
bool operator== (const mfrotation &lhs, const mfrotation &rhs) throw ()
 Compare for equality.
bool operator!= (const mfrotation &lhs, const mfrotation &rhs) throw ()
 Compare for inequality.
bool operator== (const mfstring &lhs, const mfstring &rhs) throw ()
 Compare for equality.
bool operator!= (const mfstring &lhs, const mfstring &rhs) throw ()
 Compare for inequality.
bool operator== (const mftime &lhs, const mftime &rhs) throw ()
 Compare for equality.
bool operator!= (const mftime &lhs, const mftime &rhs) throw ()
 Compare for inequality.
bool operator== (const mfvec2f &lhs, const mfvec2f &rhs) throw ()
 Compare for equality.
bool operator!= (const mfvec2f &lhs, const mfvec2f &rhs) throw ()
 Compare for inequality.
bool operator== (const mfvec3f &lhs, const mfvec3f &rhs) throw ()
 Compare for equality.
bool operator!= (const mfvec3f &lhs, const mfvec3f &rhs) throw ()
 Compare for inequality.
std::ostream & operator<< (std::ostream &out, const node_interface::type_id type)
 Stream inserter.
std::istream & operator>> (std::istream &in, node_interface::type_id &type)
 Stream extractor.
bool operator== (const node_interface &lhs, const node_interface &rhs) throw ()
 Compare for equality.
bool operator!= (const node_interface &lhs, const node_interface &rhs) throw ()
 Compare for openvrml::inequality.
std::ostream & operator<< (std::ostream &out, const node_interface &interface)
 Stream output.
std::istream & operator>> (std::istream &in, node_interface &interface)
 Stream input.
const node_interface_set::const_iterator find_interface (const node_interface_set &interfaces, const std::string &id) throw ()
 Find an interface matching id.
std::ostream & operator<< (std::ostream &out, const node &n)
 Stream output.
bool add_route (node &from_node, const std::string &from_eventout, node &to_node, const std::string &to_eventin) throw (std::bad_alloc, unsupported_interface, field_value_type_mismatch)
 Add a route from an eventOut of this node to an eventIn of another node.
bool delete_route (node &from, const std::string &eventout, node &to, const std::string &eventin) throw (unsupported_interface)
 Remove a route from an eventOut of this node to an eventIn of another node.
template<typename To>
To node_cast (node *n) throw ()
 Downcast a node to one of the abstract node types.
template<>
script_nodenode_cast< script_node * > (node *n) throw ()
 Cast to a script_node.
template<>
appearance_nodenode_cast< appearance_node * > (node *n) throw ()
 Cast to an appearance_node.
template<>
child_nodenode_cast< child_node * > (node *n) throw ()
 Cast to a child_node.
template<>
color_nodenode_cast< color_node * > (node *n) throw ()
 Cast to a color_node.
template<>
coordinate_nodenode_cast< coordinate_node * > (node *n) throw ()
 Cast to a coordinate_node.
template<>
font_style_nodenode_cast< font_style_node * > (node *n) throw ()
 Cast to a font_style_node.
template<>
geometry_nodenode_cast< geometry_node * > (node *n) throw ()
 Cast to a geometry_node.
template<>
grouping_nodenode_cast< grouping_node * > (node *n) throw ()
 Cast to a grouping_node.
template<>
material_nodenode_cast< material_node * > (node *n) throw ()
 Cast to a material_node.
template<>
normal_nodenode_cast< normal_node * > (node *n) throw ()
 Cast to a normal_node.
template<>
sound_source_nodenode_cast< sound_source_node * > (node *n) throw ()
 Cast to a sound_source_node.
template<>
texture_nodenode_cast< texture_node * > (node *n) throw ()
 Cast to a texture_node.
template<>
texture_coordinate_nodenode_cast< texture_coordinate_node * > (node *n) throw ()
 Cast to a texture_coordinate_node.
template<>
texture_transform_nodenode_cast< texture_transform_node * > (node *n) throw ()
 Cast to a texture_transform_node.
template<>
transform_nodenode_cast< transform_node * > (node *n) throw ()
 Cast to a transform_node.
template<>
viewpoint_nodenode_cast< viewpoint_node * > (node *n) throw ()
 Cast to a viewpoint_node.
bool operator== (const node_ptr &lhs, const node_ptr &rhs) throw ()
 Compare for equality.
bool operator!= (const node_ptr &lhs, const node_ptr &rhs) throw ()
 Compare for inequality.

Variables

const double pi = 3.14159265358979323846
 pi
const double pi_2 = 1.57079632679489661923
 pi/2
const double pi_4 = 0.78539816339744830962
 pi/4
const double inv_pi = 0.31830988618379067154
 1/pi
system * the_system = &defaultSystem
 The global system object.

Typedef Documentation

openvrml::sfbool_listener
 

sfbool event listener.

openvrml::sfcolor_listener
 

sfcolor event listener.

openvrml::sffloat_listener
 

sffloat event listener.

openvrml::sfimage_listener
 

sfimage event listener.

openvrml::sfint32_listener
 

sfint32 event listener.

openvrml::sfnode_listener
 

sfnode event listener.

openvrml::sfrotation_listener
 

sfrotation event listener.

openvrml::sfstring_listener
 

sfstring event listener.

openvrml::sftime_listener
 

sftime event listener.

openvrml::sfvec2f_listener
 

sfvec2f event listener.

openvrml::sfvec3f_listener
 

sfvec3f event listener.

openvrml::mfcolor_listener
 

mfcolor event listener.

openvrml::mffloat_listener
 

mffloat event listener.

openvrml::mfint32_listener
 

mfint32 event listener.

openvrml::mfnode_listener
 

mfnode event listener.

openvrml::mfrotation_listener
 

mfrotation event listener.

openvrml::mfstring_listener
 

mfstring event listener.

openvrml::mftime_listener
 

mftime event listener.

openvrml::mfvec2f_listener
 

mfvec2f event listener.

openvrml::mfvec3f_listener
 

mfvec3f event listener.

openvrml::sfbool_emitter
 

sfbool event emitter.

openvrml::sfcolor_emitter
 

sfcolor event emitter.

openvrml::sffloat_emitter
 

sffloat event emitter.

openvrml::sfimage_emitter
 

sfimage event emitter.

openvrml::sfint32_emitter
 

sfint32 event emitter.

openvrml::sfnode_emitter
 

sfnode event emitter.

openvrml::sfrotation_emitter
 

sfrotation event emitter.

openvrml::sfstring_emitter
 

sfstring event emitter.

openvrml::sftime_emitter
 

sftime event emitter.

openvrml::sfvec2f_emitter
 

sfvec2f event emitter.

openvrml::sfvec3f_emitter
 

sfvec3f event emitter.

openvrml::mfcolor_emitter
 

mfcolor event emitter.

openvrml::mffloat_emitter
 

mffloat event emitter.

openvrml::mfint32_emitter
 

mfint32 event emitter.

openvrml::mfnode_emitter
 

mfnode event emitter.

openvrml::mfrotation_emitter
 

mfrotation event emitter.

openvrml::mfstring_emitter
 

mfstring event emitter.

openvrml::mftime_emitter
 

mftime event emitter.

openvrml::mfvec2f_emitter
 

mfvec2f event emitter.

openvrml::mfvec3f_emitter
 

mfvec3f event emitter.

openvrml::field_value_ptr
 

A boost::shared_ptr to a field_value.

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

A boost::shared_ptr to a node_type.

openvrml::node_class_ptr
 

A boost::shared_ptr to a node_class.

openvrml::initial_value_map
 

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


Function Documentation

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

Compare for equality.

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

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

Compare for inequality.

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

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

Stream output.

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

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

Multiply a vector by a scalar.

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

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

Multiply a vector by a scalar.

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

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

Divide a vector by a scalar.

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

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

Add two vectors.

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

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

Subtract two vectors.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Stream output.

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

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

Cross multiply two vectors.

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

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

Multiply a vector by a matrix.

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

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

Multiply a matrix by a vector.

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

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

Multiply a vector by a scalar.

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

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

Multiply a vector by a scalar.

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

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

Divide a vector by a scalar.

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

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

Add two vectors.

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

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

Subtract two vectors.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Stream output.

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

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

Multiply rotations.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Stream output.

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

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

Multiply a matrix by a scalar value.

Parameters:
mat matrix.
scalar scalar.
Returns:
the result matrix.

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

Multiply a scalar value by matrix.

Parameters:
scalar scalar.
mat matrix.
Returns:
the result matrix.

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

Multiply two matrices.

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

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

Stream output.

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

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

Equality comparison operator.

All componenents must match exactly.

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

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

Inequality comparison operator.

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

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

Multiply two quaternions.

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

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

Multiply a quaternion by a scalar.

Parameters:
quat quaternion.
scalar scalar.
Returns:
the product of quat and scalar.

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

Multiply a scalar by a quaternion.

Parameters:
scalar scalar.
quat quaternion.
Returns:
the product of scalar and quat.

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

Divide a quaternion by a scalar.

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

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

Add two quaternions.

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

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

Take the difference between two quaternions.

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

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

Stream output.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Stream output.

Parameters:
out output stream.
img image.

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

Row access.

Parameters:
index row index.
Returns:
row index.

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

Row access.

Parameters:
index row index.
Returns:
row index.

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

Stream output.

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

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

Stream output.

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

Parameters:
out output stream.
type_id field_value type identifier.
Returns:
out.

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

Stream input.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Compare for equality.

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

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

Compare for inequality.

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

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

Stream inserter.

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

Parameters:
out an output stream.
type a node interface type.
Returns:
out.

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

Stream extractor.

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

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

Compare for equality.

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

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

Compare for openvrml::inequality.

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

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

Stream output.

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

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

Stream input.

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

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

Stream output.

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

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

Cast to a script_node.

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

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

Cast to an appearance_node.

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

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

Cast to a child_node.

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

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

Cast to a color_node.

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

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

Cast to a coordinate_node.

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

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

Cast to a font_style_node.

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

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

Cast to a geometry_node.

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

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

Cast to a grouping_node.

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

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

Cast to a material_node.

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

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

Cast to a normal_node.

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

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

Cast to a sound_source_node.

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

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

Cast to a texture_node.

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

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

Cast to a texture_coordinate_node.

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

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

Cast to a texture_transform_node.

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

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

Cast to a transform_node.

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

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

Cast to a viewpoint_node.

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

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

Compare for equality.

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

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

Compare for inequality.

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

Variable Documentation

const double openvrml::pi = 3.14159265358979323846
 

pi

const double openvrml::pi_2 = 1.57079632679489661923
 

pi/2

const double openvrml::pi_4 = 0.78539816339744830962
 

pi/4

const double openvrml::inv_pi = 0.31830988618379067154
 

1/pi

system * openvrml::the_system = &defaultSystem
 

The global system object.