'All fields fully supported except shadows supported with at least Phong shading at level 3. All fields fully supported with at least Phong shading and Henyey-Greenstein phase function, shadows fully supported at level 4.'

'All instantiable nodes implement X3DNode, which corresponds to SFNode type in the X3D specification.'

'An HAnimMotion node supports discrete frame-by-frame playback for H-Anim motion data animation.'

'An HAnimSite node serves three purposes: (a) define an end effector location which can be used by an inverse kinematics system, (b) define an attachment point for accessories such as jewelry and clothing, and (c) define a location for a Viewpoint virtual camera in the reference frame of an HAnimSegment (such as a view through the eyes of the humanoid for use in multi-user worlds).'

'Analyser provides real-time frequency and time-domain analysis information, without any change to the input.'

'Anchor is a Grouping node that can contain most nodes.'

'Appearance specifies the visual properties of geometry by containing the Material, ImageTexture/MovieTexture/PixelTexture, FillProperties, LineProperties, programmable shader nodes (ComposedShader, PackagedShader, ProgramShader) and TextureTransform nodes.'

'Arc2D is a line-based geometry node that defines a linear circular arc with center (0,0) in X-Y plane, with angles measured starting at positive x-axis and sweeping towards positive y-axis.'

'ArcClose2D is a polygonal geometry node that defines a linear circular arc, closed by PIE or CHORD line segments, with center (0,0) in X-Y plane, with angles measured starting at positive x-axis and sweeping towards positive y-axis.'

'AudioClip provides audio data used by parent Sound nodes.'

'AudioDestination node represents the final audio destination and is what user ultimately hears, typically from the speakers of user device.'

'Background simulates ground and sky, using vertical arrays of wraparound color values.'

'BallJoint represents an unconstrained joint between two bodies that pivot about a common anchor point.'

'Base type for all Appearance nodes.'

'Base type for all coordinate node types in X3D.'

'Base type for all drag-style pointing device sensors.'

'Base type for all font style nodes.'

'Base type for all geometric property node types.'

'Base type for all geometry node types that are created parametrically and use control points to describe the final shape of the surface.'

'Base type for all Material nodes.'

'Base type for all node types that specify texture projector nodes, which provide a form of lighting.'

'Base type for all nodes that contain only information without visual semantics.'

'Base type for all nodes that provide control curve information in 2D space.'

'Base type for all nodes that specify 3D sources for texture images.'

'Base type for all nodes that specify a programmable shader.'

'Base type for all nodes that specify arbitrary fields for interfacing with per-object attribute values.'

'Base type for all nodes that specify cubic environment map sources for texture images.'

'Base type for all nodes that specify per-vertex attribute information to the shader.'

'Base type for all nodes which specify 2D sources for texture images.'

'Base type for all nodes which specify a transformation of texture coordinates.'

'Base type for all nodes which specify sources for texture images.'

'Base type for all nodes which specify texture coordinates.'

'Base type for all normal node types in X3D.'

'Base type for all pointing device sensors.'

'Base type for all prototype instances. Note that direct children nodes are disallowed, instead let fieldValue with type SFNode/MFNode contain them. Current practice is that, if desired, prototype authors must explicitly add the metadata SFNode field in the ProtoInterface.'

'Base type for all sensor node types that operate using key devices.'

'Base type for all sensors.'

'Base type for all Shape nodes.'

'Base type for all sound destination nodes, which represent the final destination of an audio signal and are what the user can ultimately hear.'

'Base type for all sound nodes.'

'Base type for all sound processing nodes, which are used to enhance audio with filtering, delaying, changing gain, etc.'

'Base type for all texture coordinate nodes which specify texture coordinates for a single texture.'

'Base type for all texture node types that define a single texture. A single texture can be used to influence a parameter of various material nodes in the Shape component, and it can be a child of MultiTexture.'

'Base type for all texture transform nodes which specify texture coordinate transformation for a single texture.'

'Base type for all touch-style pointing device sensors.'

'Base type for color specifications in X3D.'

'Base type for material nodes that describe how the shape looks like from one side. A different number of contanied texture nodes are allowed by each of the implementing nodes.'

'Base type for scripting nodes (but not shader nodes).'

'Base type for the environmental sensor nodes ProximitySensor, TransformSensor and VisibilitySensor.'

'Base type from which all Sequencers are derived.'

'Base type from which all time-dependent nodes are derived.'

'Base type from which all trigger nodes are derived.'

'Base type marking nodes that are valid product structure children for the CADGeometry component.'

'Base typefor all sensors that generate events based on network activity.'

'Billboard is a Grouping node that can contain most nodes.'

'Bindable nodes implement the binding stack, so that only one of each node type is active at a given time.'

'BiquadFilter node is an AudioNode processor implementing common low-order filters.'

'BlendedVolumeStyle combines rendering of two voxel data sets into one by blending voxel values.'

'BooleanFilter selectively passes true, false or negated events.'

'BooleanSequencer generates periodic discrete Boolean values.'

'BooleanToggle maintains state and negates output when a true input is provided.'

'BooleanTrigger converts time events to boolean true events.'

'BoundaryEnhancementVolumeStyle provides boundary enhancement for the volume rendering style.'

'BoundedPhysicsModel provides user-defined geometrical boundaries for particle motion.'

'Box is a geometry node specifying a rectangular cuboid.'

'BufferAudioSource node represents a memory-resident audio asset that can contain one or more channels.'

'CADAssembly holds a set of Computer-Aided Design (CAD) assemblies or parts grouped together.'

'CADFace holds geometry representing one face in a Computer-Aided Design (CAD) CADPart.'

'CADLayer nodes define a hierarchy that shows layer structure for a Computer-Aided Design (CAD) model.'

'CADPart is an atomic part that defines both coordinate-system location and the faces that constitute a part in a Computer-Aided Design (CAD) model.'

'CartoonVolumeStyle generates cartoon-style non-photorealistic rendering of associated volumetric data.'

'ChannelMerger unites different input channels into a single output channel.'

'ChannelSelector selects a single channel output from all input channels.'

'ChannelSplitter separates the different channels of a single audio source into a set of monophonic output channels.'

'Circle2D is a geometry node that defines a linear X-Y circle with center (0,0) in X-Y plane.'

'ClipPlane specifies a single plane equation used to clip (i.'

'CollidableOffset repositions geometry relative to center of owning body.'

'CollidableShape connects the collision detection system, the rigid body model, and the renderable scene graph.'

'Collision detects camera-to-object contact using current view and NavigationInfo avatarSize.'

'CollisionCollection holds a collection of objects that can be managed as a single entity for resolution of inter-object collisions.'

'CollisionSensor generates collision-detection events.'

'CollisionSpace holds collection of objects considered together for resolution of inter-object collisions.'

'Color node defines a set of RGB color values that apply either to a sibling Coordinate|CoordinateDouble node, or else to a parent ElevationGrid node.'

'ColorChaser generates a series of SFColor values that progressively change from initial value to destination value.'

'ColorDamper generates a series of RGB color values that progressively change from initial value to destination value.'

'ColorInterpolator generates a range of color values.'

'ColorRGBA node defines a set of RGBA color values that apply either to a sibling Coordinate|CoordinateDouble node, or else to a parent ElevationGrid node.'

'Composed geometry nodes produce renderable geometry, can contain Color Coordinate Normal TextureCoordinate, and are contained by a Shape node.'

'ComposedCubeMapTexture is a texture node that defines a cubic environment map source as an explicit set of images drawn from individual 2D texture nodes.'

'ComposedShader can contain field declarations, but no CDATA section of plain-text source code, since programs are composed from child ShaderPart nodes.'

'ComposedTexture3D defines a 3D image-based texture map as a collection of 2D texture sources at various depths.'

'ComposedVolumeStyle allows compositing multiple rendering styles into single rendering pass.'

'Cone is a geometry node.'

'ConeEmitter generates all available particles from a specific point in space.'

'Contact nodes are produced as output events when two collidable objects or spaces make contact.'

'Contour2D groups a set of curve segments into a composite contour.'

'ContourPolyline2D defines a linear curve segment as part of a trimming contour in the u-v domain of a NURBS surface.'

'Convolver performs a linear convolution on a given AudioBuffer, often used to achieve a reverberation effect.'

'Coordinate builds geometry by defining a set of 3D coordinate (triplet) point values.'

'CoordinateChaser generates a series of coordinate arrays that progressively change from initial value to destination value.'

'CoordinateDamper generates a series of coordinate arrays that progressively change from initial value to destination value.'

'CoordinateDouble builds geometry by defining a set of 3D coordinate (triplet) point values.'

'CoordinateInterpolator linearly interpolates among a list of 3-tuple MFVec3f arrays, producing a single MFVec3f array that is fractional average between two nearest arrays in the list.'

'CoordinateInterpolator2D generates a series of SFVec2f or MFVec2f 2-tuple float values.'

'Cylinder is a geometry node.'

'CylinderSensor converts pointer motion (for example, a mouse or wand) into rotation values using an invisible cylinder aligned with local Y-axis.'

'Delay causes a time delay between the arrival of input data and subsequent propagation to the output.'

'DirectionalLight might not be scoped by parent Group or Transform at levels 1 or 2.'

'DISEntityManager notifies a scene when new DIS ESPDU entities arrive or current entities leave.'

'DISEntityTypeMapping provides a best-match mapping from DIS ESPDU entity type information to a specific X3D model, thus providing a visual and behavioral representation that best matches the entity type.'

'Disk2D is a geometry node that defines a filled (or partially filled) planar circle with center (0,0).'

'DoubleAxisHingeJoint has two independent axes located around a common anchor point.'

'DynamicsCompressor node implements a dynamics compression effect, lowering volume of loudest parts of signal and raising volume of softest parts.'

'Each node inheriting the X3DMetadataObject interface contains a single array of strictly typed values: MFBool, MFInt32, MFFloat, MFDouble, MFString, or MFNode, the latter having children that are all Metadata nodes.'

'EaseInEaseOut enables gradual animation transitions by modifying TimeSensor fraction outputs.'

'EdgeEnhancementVolumeStyle specifies edge enhancement for the volume rendering style.'

'ElevationGrid is a geometry node defining a rectangular height field, with default values for a 1m by 1m square at height 0.'

'EspduTransform is a networked Transform node that can contain most nodes.'

'ExplosionEmitter generates all particles from a specific point in space at the initial time enabled.'

'ExternProtoDeclare refers to a ProtoDeclare node declaration provided in another file. ExternProtoDeclare interfaces are defined by field statements (and without IS/connect statements).'

'Extrusion is a geometry node that sequentially stretches a 2D cross section along a 3D-spine path in the local coordinate system, creating an outer hull.'

'FillProperties indicates whether appearance is filled or hatched for associated geometry nodes inside the same Shape.'

'FloatVertexAttribute defines a set of per-vertex single-precision floating-point attributes.'

'Fog simulates atmospheric effects by blending distant objects with fog color.'

'FogCoordinate defines a set of explicit fog depths on a per-vertex basis, overriding Fog visibilityRange.'

'FontStyle is an X3DFontStyleNode that defines the size, family, justification, and other styles used by Text nodes.'

'ForcePhysicsModel applies a constant force value to the particles.'

'Functional summary: a field statement defines an interface attribute or node. Each field statement can contain either attribute-value or node content.'

'Functional summary: a fieldValue statement re-initializes the default value of a field in a ProtoInstance. Each fieldValue statement can contain either attribute-value or node content.'

'Functional summary: connect statements define event-routing connections between node fields defined inside a ProtoBody declaration back to corresponding ProtoInterface fields.'

'Functional summary: each added component statement indicates needed scene functionality support above the given X3D profile.'

'Functional summary: each X3D scene includes a head statement that can contain component, unit and meta statements.'

'Functional summary: EXPORT exposes a local node for ROUTE passing of event values when the current Scene is included via Inline by a parent external world. These connections allow event values to be exchanged via ROUTE statements between a parent model and a child Inline model.'

'Functional summary: IMPORT provides ROUTE access to a node that has a corresponding EXPORT statement within an Inline scene. These connections allow event values to be exchanged via ROUTE statements between a parent model and a child Inline model.'

'Functional summary: the IS statement connects node fields defined inside a ProtoBody declaration back to corresponding ProtoInterface fields. IS/connect statements can be added if the parent node is within a ProtoBody and connect statements define correspondences between prototype fields and built-in node fields.'

'Functional summary: the meta statement provides metadata information about a scene, where name and content attributes provide attribute=value metadata pairs.'

'Functional summary: unit statement defines data-conversion factors for typed values defined in a scene.'

'GeneratedCubeMapTexture is a texture node that defines a cubic environment map that sources its data from internally generated images.'

'GeoCoordinate builds geometry as a set of geographic 3D coordinates.'

'GeoElevationGrid is a geometry node defining a rectangular height field, with default values for a 1m by 1m square at height 0.'

'GeoLocation positions a regular X3D model onto earth\'s surface.'

'GeoMetadata includes a generic subset of metadata about the geographic data.'

'Geometry nodes produce renderable geometry and are contained by a Shape node.'

'GeoOrigin is deprecated and discouraged (but nevertheless allowed) in X3D version 3.3. GeoOrigin is restored in X3D version 4.0 for special use on devices with limited floating-point resolution.'

'GeoPositionInterpolator animates objects within a geographic coordinate system.'

'GeoProximitySensor generates events when the viewer enters, exits and moves within a region of space (defined by a box).'

'GeoTouchSensor returns geographic coordinates for the object being selected.'

'GeoTransform is a Grouping node that can contain most nodes.'

'GeoViewpoint specifies viewpoints using geographic coordinates.'

'Group is a Grouping node that can contain most nodes.'

'Grouping nodes can contain other nodes as children, thus making up the backbone of a scene graph.'

'HAnimDisplacer nodes alter the shape of coordinate-based geometry within parent HAnimJoint or HAnimSegment nodes.'

'HAnimJoint node can represent each joint in a body.'

'HAnimSegment node contains Shape geometry for each body segment, providing a visual representation of the skeleton segment.'

'If a non-uniform scale is applied to the pick sensor, correct results may require level 3 support.'

'ImageCubeMapTexture is a texture node that defines a cubic environment map source as a single file format that contains multiple images, one for each side.'

'ImageTexture maps a 2D-image file onto a geometric shape.'

'ImageTexture3D defines a 3D image-based texture map by specifying a single image file that contains complete 3D data.'

'IndexedFaceSet defines polygons using index lists corresponding to vertex coordinates.'

'IndexedLineSet defines polyline segments using index lists corresponding to vertex coordinates.'

'IndexedQuadSet is a geometry node that defines quadrilaterals.'

'IndexedTriangleFanSet is a geometry node containing a Coordinate|CoordinateDouble node, and can also contain Color|ColorRGBA, Normal and TextureCoordinate nodes.'

'IndexedTriangleSet is a geometry node containing a Coordinate|CoordinateDouble node, and can also contain Color|ColorRGBA, Normal and TextureCoordinate nodes.'

'IndexedTriangleStripSet is a geometry node containing a Coordinate|CoordinateDouble node, and can also contain Color|ColorRGBA, Normal and TextureCoordinate nodes.'

'Inline can load another X3D or VRML model into the current scene via url.'

'IntegerSequencer generates periodic discrete integer values.'

'IntegerTrigger converts set_boolean true input events to an integer value (for example, useful when animating whichChoice in a Switch node).'

'Interpolator nodes are designed for linear keyframed animation. Interpolators are driven by an input key ranging [0..1] and produce corresponding piecewise-linear output functions.'

'IsoSurfaceVolumeData displays one or more surfaces extracted from a voxel dataset.'

'KeySensor generates events as the user presses keys on the keyboard.'

'Layer contains a list of children nodes that define the contents of the layer.'

'LayerSet defines a list of layers and a rendering order.'

'Layout node is used as layout field of LayoutLayer and LayoutGroup nodes.'

'LayoutGroup is a Grouping node that can contain most nodes, whose children are related by a common layout within a parent layout.'

'LayoutLayer is a Grouping node that can contain most nodes.'

'Light nodes provide illumination for rendering geometry in the scene. Implementing nodes must include a global field with type SFBool and accessType inputOutput.'

'Linear attenuation may occur at level 2, full support at level 3.'

'LinePickSensor uses one or more pickingGeometry line segments to compute intersections with pickTarget shapes.'

'LineProperties allows precise fine-grained control over the rendering style of lines and edges for associated geometry nodes inside the same Shape.'

'LineSet is a geometry node that can contain a Coordinate|CoordinateDouble node and optionally a Color|ColorRGBA node.'

'ListenerPointSource node represents position and orientation of a person listening to virtual sound in the audio scene, and provides single or multiple sound channels as output.'

'LoadSensor generates events as watchList child nodes are either loaded or fail to load.'

'LocalFog simulates atmospheric effects by blending distant objects with fog color.'

'LOD (Level Of Detail) uses camera-to-object distance to switch among contained child levels.'

'Material specifies surface rendering properties for associated geometry nodes.'

'Matrix3VertexAttribute defines a set of per-vertex 3x3 matrix attributes.'

'Matrix4VertexAttribute defines a set of per-vertex 4x4 matrix attributes.'

'MicrophoneSource captures input from a physical microphone in the real world.'

'MotorJoint drives relative angular velocities between body1 and body2 within a common reference frame.'

'MovieTexture applies a 2D movie image to surface geometry, or provides audio for a Sound node.'

'MultiTexture applies several individual textures to a single geometry node, enabling a variety of visual effects that include light mapping and environment mapping.'

'MultiTextureCoordinate contains multiple TextureCoordinate or TextureCoordinateGenerator nodes, for use by a parent polygonal geometry node such as IndexedFaceSet or a Triangle* node.'

'MultiTextureTransform contains multiple TextureTransform nodes, each provided for use by corresponding ImageTexture MovieTexture or PixelTexture nodes within a sibling MultiTexture node.'

'NavigationInfo describes the user\'s viewing model, user navigation-interaction modalities, and also dimensional characteristics of the user\'s (typically invisible) avatar.'

'Node type X3DViewpointNode defines a specific location in the local coordinate system from which the user may view the scene, and also defines a viewpoint binding stack.'

'Nodes implementing X3DSoundSourceNode provide signal inputs to the audio graph.'

'Nodes of this type can be used as child nodes for Appearance.'

'Normal defines a set of 3D surface-normal vectors that apply either to a sibling Coordinate|CoordinateDouble node, or else to a parent ElevationGrid node.'

'NormalInterpolator generates a series of normal (perpendicular) 3-tuple SFVec3f values.'

'Note that MFNode rootNode field can contain multiple nodes and has accessType inputOutput. Meanwhile MFNode children field is outputOnly, unlike other X3DGroupingNode exemplars.'

'NurbsCurve is a 3D curve analogous to NurbsPatchSurface.'

'NurbsCurve2D defines a trimming segment that is part of a trimming contour in the u-v domain of a surface.'

'NurbsOrientationInterpolator describes a 3D NURBS curve and outputs interpolated orientation values.'

'NurbsPatchSurface defines a contiguous 3D Non-Uniform Rational B-Spline (NURBS) surface.'

'NurbsPositionInterpolator describes a 3D NURBS curve and outputs interpolated position values.'

'NurbsSet collects a set of NurbsSurface nodes into a common group and treats NurbsSurface set as a unit during tessellation, thereby enforcing tessellation continuity along borders.'

'NurbsSurfaceInterpolator describes a 3D NURBS curve and outputs interpolated position and normal values.'

'NurbsSweptSurface uses a trajectoryCurve path to describe a generalized surface that is swept by a crossSectionCurve.'

'NurbsSwungSurface contains a profileCurve and a trajectoryCurve [X3DNurbsControlCurveNode].'

'NurbsTextureCoordinate describes a 3D NURBS surface in the parametric domain of its surface host, specifying mapping of texture onto the surface.'

'NurbsTrimmedSurface generates texture coordinates from a Non-Uniform Rational B-Spline (NURBS) surface.'

'OpacityMapVolumeStyle specifies that volumetric data is rendered using opacity mapped to a transfer function texture.'

'OrientationChaser generates a series of 4-tuple axis-angle SFRotation values that progressively change from initial value to destination value.'

'OrientationDamper generates a series of 4-tuple axis-angle SFRotation values that progressively change from initial value to destination value.'

'OrientationInterpolator generates a series of 4-tuple axis-angle SFRotation values.'

'OrthoViewpoint provides an orthographic perspective-free view of a scene from a specific location and direction.'

'OscillatorSource node represents an audio source generating a periodic waveform, providing a constant tone.'

'PackagedShader can contain field declarations, but no CDATA section of plain-text source code.'

'ParticleSystem specifies a complete particle system.'

'PeriodicWave defines a periodic waveform that can be used to shape the output of an Oscillator.'

'PhysicalMaterial specifies surface rendering properties for associated geometry nodes.'

'PickableGroup is a Grouping node that can contain most nodes.'

'PixelTexture creates a 2D-image texture map using a numeric array of pixel values.'

'PixelTexture3D defines a 3D image-based texture map as an explicit array of pixel values (image field).'

'PlaneSensor converts pointing device motion into 2D translation parallel to the local Z=0 plane.'

'PointEmitter generates particles from a specific point in space using the specified direction and speed.'

'PointPickSensor tests one or more pickingGeometry points in space as lying inside the provided pickTarget geometry.'

'PointProperties allows precise fine-grained control over the rendering style of PointSet node points inside the same Shape.'

'PointSet is a node that contains a set of colored 3D points, represented by contained Color|ColorRGBA and Coordinate|CoordinateDouble nodes.'

'Polyline2D is a geometry node that defines a connected set of vertices in a contiguous set of line segments in X-Y plane.'

'PolylineEmitter emits particles along a single polyline.'

'Polypoint2D is a geometry node that defines a set of 2D points in X-Y plane.'

'PositionChaser generates a series of position values that progressively change from initial value to destination value.'

'PositionChaser2D generates a series of 2D position values that progressively change from initial value to destination value.'

'PositionDamper generates a series of position values that progressively change from initial value to destination value.'

'PositionDamper2D generates a series of 2D floating-point values that progressively change from initial value to destination value.'

'PositionInterpolator generates a series of 3-tuple SFVec3f values.'

'PositionInterpolator2D generates a series of SFVec2f values.'

'ProgramShader contains no field declarations and no plain-text source code.'

'ProjectionVolumeStyle uses voxel data to directly generate output color.'

'ProtoBody contains the definition nodes for new Prototype nodes.'

'ProtoDeclare defines new Prototype nodes. Nested ProtoDeclares and ProtoInstances are allowed by the specification.'

'ProtoInstance can override field default values via fieldValue initializations. Non-recursive nested ProtoInstance and ProtoDeclare statements are allowed within a ProtoDeclare.'

'ProtoInterface defines fields for new Prototype nodes.'

'ProximitySensor generates events when the viewer enters, exits and moves within a region of space (defined by a box).'

'QuadSet is a geometry node that defines quadrilaterals.'

'ReceiverPdu is a networked Protocol Data Unit (PDU) information node that transmits the state of radio frequency (RF) receivers modeled in a simulation.'

'Rectangle2D is a geometry node that defines a 2D rectangle in X-Y plane.'

'RigidBody describes a collection of shapes with a mass distribution that is affected by the physics model.'

'RigidBodyCollection represents a system of bodies that interact within a single physics model.'

'ROUTE connects output fields of event-producing nodes to input fields of event-consuming nodes.'

'ScalarChaser generates a series of single floating-point values that progressively change from initial value to destination value.'

'ScalarDamper generates a series of floating-point values that progressively change from initial value to destination value.'

'ScalarInterpolator generates piecewise-linear SFFloat values.'

'Scene is the implicit root node of the X3D scene graph.'

'ScreenFontStyle is an X3DFontStyleNode defines the size, family, justification, and other styles used within a screen layout.'

'ScreenGroup is a Grouping node that can contain most nodes.'

'Script contains author-programmed event behaviors for a scene.'

'SegmentedVolumeData displays a segmented voxel dataset with different RenderStyle nodes.'

'ShaderPart can contain a CDATA section of plain-text source code.'

'ShaderProgram can contain field declarations and a CDATA section of plain-text source code.'

'Shape can appear under any grouping node.'

'SignalPdu is a networked Protocol Data Unit (PDU) information node that communicates the transmission of voice, audio or other data modeled in a simulation.'

'SilhouetteEnhancementVolumeStyle specifies that volumetric data is rendered with silhouette enhancement.'

'SingleAxisHingeJoint has single axis about which to rotate, similar to a traditional door hinge. Contains two RigidBody nodes (containerField values body1, body2).'

'SliderJoint constrains all movement between body1 and body2 along a single axis. Contains two RigidBody nodes (containerField values body1, body2).'

'Sphere is a geometry node, representing a perfectly round geometrical object that is the surface of a completely round ball.'

'SphereSensor converts pointing device motion into a spherical rotation about the origin of the local coordinate system.'

'SplinePositionInterpolator performs non-linear interpolation among paired lists of 3-tuple values and velocities to produce an SFVec3f value_changed output event.'

'SplinePositionInterpolator2D performs non-linear interpolation among paired lists of 2-tuple values and velocities to produce an SFVec2f value_changed output event.'

'SplineScalarInterpolator performs non-linear interpolation among paired lists of float values and velocities to produce an SFFloat value_changed output event.'

'SquadOrientationInterpolator performs non-linear interpolation among paired lists of rotation values to produce an SFRotation value_changed output event.'

'StaticGroup is similar to Group node but does not allow access to children after creation time.'

'StreamAudioDestination node represents the final audio destination via a media stream.'

'StreamAudioSource operates as an audio source whose media is received from a MediaStream obtained using the WebRTC or Media Capture and Streams APIs.'

'StringSensor generates events as the user presses keys on the keyboard.'

'SurfaceEmitter generates particles from the surface of an object.'

'Switch is a Grouping node that only renders one (or zero) child at a time.'

'TexCoordChaser2D generates a series of single floating-point values that progressively change from initial value to destination value.'

'TexCoordDamper2D generates a series of 2D floating-point arrays that progressively change from initial value to destination value.'

'Text is a 2D (flat) geometry node that can contain multiple lines of string values.'

'TextureBackground simulates ground and sky, using vertical arrays of wraparound color values, TextureBackground can also provide backdrop texture images on all six sides.'

'TextureCoordinate specifies 2D (s,t) texture-coordinate points, used by vertex-based geometry nodes (such as IndexedFaceSet or ElevationGrid) to map textures to vertices (and patches to NURBS surfaces).'

'TextureCoordinate3D specifies a set of 3D texture coordinates used by vertex-based geometry nodes (such as IndexedFaceSet or ElevationGrid) to map 3D textures to vertices.'

'TextureCoordinate4D specifies a set of 4D (homogeneous 3D) texture coordinates used by vertex-based geometry nodes (such as IndexedFaceSet or ElevationGrid) to map 3D textures to vertices.'

'TextureCoordinateGenerator computes 2D (s,t) texture-coordinate points, used by vertex-based geometry nodes (such as IndexedFaceSet or ElevationGrid) to map textures to vertices (and patches to NURBS surfaces).'

'TextureProjector is similar to a light that projects a texture into the scene, illuminating geometry that intersects the perspective projection volume.'

'TextureProjectorParallel is similar to a light that projects a texture into the scene, illuminating geometry that intersects the parallel projection volume.'

'TextureProperties allows precise fine-grained control over application of image textures to geometry.'

'TextureTransform shifts 2D texture coordinates for positioning, orienting and scaling image textures on geometry.'

'TextureTransform3D applies a 3D transformation to texture coordinates.'

'TextureTransformMatrix3D applies a 3D transformation to texture coordinates.'

'The Gain node amplifies or deamplifies the input signal.'

'The HAnimHumanoid node is used to: (a) store references to the joints, segments, sites, skeleton, optional skin, and fixed viewpoints, (b) serve as a container for the entire humanoid, (c) provide a convenient way of moving the humanoid through its environment, and (d) store human-readable metadata such as name, version, author, copyright, age, gender and other information.'

'The metadata provided by this node is contained in the Boolean values of the value field.'

'The metadata provided by this node is contained in the double-precision floating point numbers of the value field.'

'The metadata provided by this node is contained in the integer numbers of the value field.'

'The metadata provided by this node is contained in the metadata nodes of the value field.'

'The metadata provided by this node is contained in the single-precision floating point numbers of the value field.'

'The metadata provided by this node is contained in the strings of the value field.'

'The Sound node controls the 3D spatialization of sound playback by a child AudioClip or MovieTexture node.'

'The SpatialSound node controls the 3D spatialization of sound playback by a child AudioClip or MovieTexture node.'

'The X3DChaserNode abstract node type calculates the output on value_changed as a finite impulse response (FIR) based on the events received on set_destination field.'

'The X3DComposableVolumeRenderStyleNode abstract node type is the base type for all node types that allow rendering styles to be sequentially composed together to form a single renderable output.'

'The X3DDamperNode abstract node type creates an IIR response that approaches the destination value according to the shape of the e-function only asymptotically but very quickly.'

'The X3DLayerNode abstract node type is the base node type for layer nodes.'

'The X3DNBodyCollidableNode abstract node type represents objects that act as the interface between the rigid body physics, collision geometry proxy, and renderable objects in the scene graph hierarchy.'

'The X3DNBodyCollisionSpaceNode abstract node type represents objects that act as a self-contained spatial collection of objects that can interact through collision detection routines.'

'The X3DParticleEmitterNode abstract type represents any node that is an emitter of particles.'

'The X3DParticlePhysicsModelNode abstract type represents any node that applies a form of constraints on the particles after they have been generated.'

'The X3DPickableObject abstract interface marks a node as being capable of having customized picking performed on its contents or children.'

'The X3DPickSensorNode abstract node type is the base node type that represents the lowest common denominator of picking capabilities.'

'The X3DRigidJointNode abstract node type is the base type for all joint types.'

'The X3DViewportNode abstract node type is the base node type for viewport nodes.'

'The X3DVolumeDataNode abstract node type is the base type for all node types that describe volumetric data to be rendered.'

'The X3DVolumeRenderStyleNode abstract node type is the base type for all node types that specify a specific visual rendering style to be used when rendering volume data.'

'TimeSensor continuously generates events as time passes.'

'TimeTrigger converts boolean true events to time events.'

'ToneMappedVolumeStyle specifies that volumetric data is rendered with Gooch shading model of two-toned warm/cool coloring.'

'TouchSensor tracks location and state of the pointing device, detecting when a user points at or selects (activates) geometry.'

'Transform is a Grouping node that can contain most nodes.'

'TransformSensor generates output events when its targetObject enters, exits, and moves within a region in space (defined by a box).'

'TransmitterPdu is a networked Protocol Data Unit (PDU) information node that provides detailed information about a radio transmitter modeled in a simulation.'

'TriangleFanSet is a geometry node containing a Coordinate|CoordinateDouble node, and can also contain Color|ColorRGBA, Normal and TextureCoordinate nodes.'

'TriangleSet is a geometry node containing a Coordinate|CoordinateDouble node, and can also contain Color|ColorRGBA, Normal and TextureCoordinate nodes.'

'TriangleSet2D is a geometry node that defines a set of filled 2D triangles in X-Y plane.'

'TriangleStripSet is a geometry node containing a Coordinate|CoordinateDouble node, and can also contain Color|ColorRGBA, Normal and TextureCoordinate nodes.'

'TwoSidedMaterial specifies surface rendering properties for associated geometry nodes, for outer (front) and inner (back) sides of polygons.'

'UniversalJoint is like a BallJoint that constrains an extra degree of rotational freedom.'

'UnlitMaterial specifies surface rendering properties for associated geometry nodes.'

'Viewpoint provides a specific location and direction where the user may view the scene.'

'ViewpointGroup can contain Viewpoint, OrthoViewpoint, GeoViewpoint and other ViewpointGroup nodes for better user-navigation support with a shared description on the viewpoint list.'

'Viewport is a Grouping node that can contain most nodes.'

'VisibilitySensor detects when user can see a specific object or region as they navigate the world.'

'VolumeData displays a simple non-segmented voxel dataset with a single RenderStyle node.'

'VolumeEmitter emits particles from a random position confined within the given closed geometry volume.'

'VolumePickSensor tests picking intersections using the pickingGeometry against the pickTarget geometry volume.'

'WaveShaper node represents a nonlinear distorter that applies a wave-shaping distortion curve to the signal.'

'WindPhysicsModel applies a wind effect to the particles.'

'WorldInfo contains a title and simple persistent metadata information about an X3D scene. This node is strictly for documentation purposes and has no effect on the visual appearance or behaviour of the world.'

'X3D is the root node for an Extensible 3D (X3D) Graphics model.'

'X3DArrayField is the abstract field type from which all field types that can contain multiple values are derived, implementing the X3DField interface. All fields derived from X3DArrayField have names beginning with MF (multiple-valued field). MF fields may zero or more values, each of which shall be of the type indicated by the corresponding SF field type. It is illegal for any MF field to mix values of different SF field types.'

'X3DBoundedObject indicates that bounding box values can be provided (or computed) to encompass this node and any children.'

'X3DField is the abstract field type from which all single values field types are derived. All fields directly derived from X3DField have names beginning with SF (single-valued field). SF fields may only contain a single value of the type indicated by the name of the field type.'

'X3DFollowerNode is the abstract base class for all nodes in the Followers component.'

'X3DLayoutNode is the base node type for layout nodes.'

'X3DStatement is the abstract type from which all non-node statements are derived.'

'X3DUrlObject indicates that a node has content loaded from a Uniform Resource Locator (URL) and can be tracked via a LoadSensor. Such child nodes have containerField=\'children\' to indicate their relationship to the parent LoadSensor node.'

All Classes (399)