```
public class Node
extends Object
```
A node encapsulates a 2D or 3D coordinate system, represented by a position(), an orientation() and magnitude() defined respect to a reference() node. The order of these transformations is important: the node is first translated, then rotated around the new translated origin and then scaled.
Hierarchy of nodes
The default reference() node is the world coordinate system (represented by a null). If you setReference(Node) to a different node, you must then differentiate:
- The local position(), orientation() and magnitude(), defined with respect to the reference() which represents an angle preserving transformation of space.
- The global worldPosition(), worldOrientation() and worldMagnitude(), always defined with respect to the world coordinate system.
Geometry transformations
A node is useful to define the position, orientation and magnitude of an arbitrary object which may represent a point-of-view.
Use matrix() to access the node coordinate system, as when drawing an object locally:
// Builds a node at position (0.5,0,0) and oriented such that its Y axis is along the (1,1,1) direction
Node node = new Node(new Vector(0.5,0,0), new Quaternion(new Vector(0,1,0), new Vector(1,1,1)));
push();
applyMatrix(node.matrix());
// Draw your object here, in the local node coordinate system.
pop();

Use view() when rendering the scene from the node point-of-view. Note that this method is automatically called by the graph, see Graph.render(Node).
To transform a point from one node to another use location(Vector, Node) and worldLocation(Vector). To transform a vector (such as a normal) use displacement(Vector, Node) and worldDisplacement(Vector). To transform a quaternion use displacement(Quaternion, Node) and worldDisplacement(Quaternion). To transform a scalar use displacement(float, Node) and worldDisplacement(float).
The methods translate(Vector, float), rotate(Quaternion, float), orbit(Vector, float, Vector, float) and scale(float, float), locally apply differential geometry transformations damped with a given inertia. Note that when the inertial parameter is omitted its value is defaulted to 0.
Hierarchical traversals
Hierarchical traversals of the node hierarchy which automatically apply the local node transformations described above may be achieved with Graph.render() and Graph.render(Node). Customize the rendering traversal with Graph.addBehavior(Node, BiConsumer) (see also cull and bypass()).
Motion filters
One interesting feature of a node is that its displacements can be filtered. Setting a node filter allows to refine the input of translate(Vector), rotate(Quaternion), orbit(Vector, float) and scale(float) so that only the resulting filtered motion is applied to the node. The default filters are null resulting in no filtering. Use setTranslationFilter(BiFunction, Object[]), setRotationFilter(BiFunction, Object[]) and setScalingFilter(BiFunction, Object[]) to set different filters to a node.
Classical filters are provided for convenience (see translationAxisFilter, translationPlaneFilter and rotationAxisFilter) and new filters can very easily be implemented.
Visual hints
The node space visual representation may be configured using the following hints: CAMERA, AXES, HUD, BOUNDS,, SHAPE, BULLSEYE, and TORUS.
See hint(), configHint(int, Object...) enableHint(int), enableHint(int, Object...), disableHint(int), toggleHint(int) and resetHint().
Ray casting
Set the node picking ray-casting mode with enablePicking(int) (see also picking()).
Keyframe's based interpolated animations
Keyframes allow to define the position, orientation and magnitude a node (including the eye) should have at a particular moment in time. The node may then be animated through a Catmull-Rom spline, matching in space-time the key-frames which defines it. To define the keyframes comprising the path to be interpolated use code such as the following:
```
 
 Node shape = new Node(pshape);
 for (int i = 0; i < random(4, 10); i++) {
   scene.randomize(shape);
   // addKeyFrame(hint, elapsedTime) where elapsedTime is defined respect
   // to the previously added key-frame and expressed in milliseconds.
   shape.addKeyFrame(Node.AXES | Node.SHAPE, i % 2 == 1 ? 1000 : 4000);
 }
 
 
```
refer to addKeyFrame(), addKeyFrame(int, float), and addKeyFrame(Node, float) for the details.
To then interpolate the path at a given time (expressed in milliseconds) call interpolate(float). To play the path starting at that time, call animate() (see also toggleAnimation() and resetAnimation()). To disable/enable animationRecurrence() use setAnimationRecurrence(boolean) (it is disabled by default). Note that the animationTime() may set with setAnimationTime(float).
Custom behaviors
A custom node behavior to be executed during rendering Graph.render() may be set with setBehavior(Graph, Consumer). See Graph.addBehavior(Node, BiConsumer).
Custom user interactions
Implementing a custom user interaction for node is a two step process:
- Register a user gesture data parser, see setInteraction(BiConsumer) and setInteraction(Consumer).
- Send gesture data to the node by calling Graph.interact(Node, Object...), Graph.interact(String, Object...) or Graph.interact(Object...).

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class Node.BullsEyeShape

Field Summary

Fields
Modifier and Type	Field	Description
`static int`	`AXES`
`static int`	`BONE`
`static int`	`BOUNDS`
`static int`	`BULLSEYE`
`float`	`cacheMagnitude`
`Quaternion`	`cacheOrientation`
`Vector`	`cachePosition`
`Object[]`	`cacheRotationParams`
`Object[]`	`cacheScalingParams`
`float`	`cacheTargetMagnitude`
`Quaternion`	`cacheTargetOrientation`
`Vector`	`cacheTargetPosition`
`Quaternion`	`cacheTargetRotation`
`float`	`cacheTargetScaling`
`Vector`	`cacheTargetTranslation`
`Object[]`	`cacheTranslationParams`
`static int`	`CAMERA`
`boolean`	`cull`
`static int`	`FILTER`
`static BiFunction<Node,Object[],Quaternion>`	`forbidRotationFilter`	Filters rotation so that it gets nullified.
`static BiFunction<Node,Object[],Float>`	`forbidScalingFilter`	Filters scaling so that it gets nullified.
`static BiFunction<Node,Object[],Vector>`	`forbidTranslationFilter`	Filters translation so that it gets nullified.
`static int`	`HUD`
`static int`	`KEYFRAMES`
`static int`	`maxSteps`
`static BiFunction<Node,Object[],Float>`	`minMaxScalingFilter`	Filters scaling so that the node magnitude lies in `[min..max]`.
`static BiFunction<Node,Object[],Quaternion>`	`rotationAxisFilter`	Filters `quaternion` so that its `Quaternion.axis()` become `axis` (defined in this node coordinate system).
`static int`	`SHAPE`
`boolean`	`tagging`
`static int`	`TORUS`
`static BiFunction<Node,Object[],Vector>`	`translationAxisFilter`	Filters translation so that the node is translated along `axis` (defined in this node coordinate system).
`static BiFunction<Node,Object[],Vector>`	`translationPlaneFilter`	Filters translation so that the node is translated along the plane defined by `normal` (defined in this node coordinate system).

Constructor Summary

Constructors
Constructor	Description
`Node()`	Same as `this(null, new Vector(), new Quaternion(), 1)`.
`Node(boolean attach)`	Same as {this(null, new Vector(), new Quaternion(), 1, attach)}.
`Node(Consumer<PGraphics> shape)`	Same as `this(null, shape, new Vector(), new Quaternion(), 1)`.
`Node(Node reference)`	Same as `this(reference, new Vector(), new Quaternion(), 1)`.
`Node(Node reference, Consumer<PGraphics> shape)`	Same as `this(reference, shape, new Vector(), new Quaternion(), 1)`.
`Node(Node reference, Consumer<PGraphics> shape, Vector position, Quaternion orientation, float magnitude)`	Calls `Node(Node, Vector, Quaternion, float)` and then `setShape(Consumer)`.
`Node(Node reference, Vector position)`	Same as `this(reference, position, new Quaternion(), 1`.
`Node(Node reference, Vector position, Quaternion orientation)`	Same as `this(reference, position, orientation, 1`.
`Node(Node reference, Vector position, Quaternion orientation, float magnitude)`	Creates a node with `reference` as `reference()`, having `position`, `orientation` and `magnitude` as the `position()`, `orientation()` and `magnitude()`, respectively.
`Node(Node reference, PShape shape)`	Same as `this(reference, shape, new Vector(), new Quaternion(), 1)`.
`Node(Node reference, PShape shape, Vector position, Quaternion orientation, float magnitude)`	Creates a node with `reference` as `reference()` and `shape`, having `position`, `orientation` and `magnitude` as the `position()`, `orientation()` and `magnitude()`, respectively.
`Node(Vector position)`	Same as `this(null, position, new Quaternion(), 1)`.
`Node(Vector position, boolean attach)`	Same as `this(null, position, new Quaternion(), 1, attach)`.
`Node(Vector position, Quaternion orientation)`	Same as `this(null, position, orientation, 1)`.
`Node(Vector position, Quaternion orientation, boolean attach)`	Same as `this(null, position, orientation, 1, attach)`.
`Node(Vector position, Quaternion orientation, float magnitude)`	Same as `this(null, position, orientation, magnitude)`.
`Node(Vector position, Quaternion orientation, float magnitude, boolean attach)`	Same as `this(null, position, orientation, magnitude, attach)`.
`Node(PShape shape)`	Same as `this(null, shape, new Vector(), new Quaternion(), 1)`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addKeyFrame()`	Adds a node copy as keyframe at `0` time if there are no currently keyframes in the path.
`void`	`addKeyFrame(int hint, float time)`	Adds a node copy as a keyframe at `time` (in milliseconds) and a mask `hint`.
`void`	`addKeyFrame(Node node)`	Adds `node` (as is) as a keyframe.
`void`	`addKeyFrame(Node node, float time)`	Adds `node` (as is) as a keyframe at the given `time` (in milliseconds).
`void`	`align()`	Same as `align(null)`.
`void`	`align(boolean move)`	Same as `align(move, null)`.
`void`	`align(boolean move, float threshold)`	Same as `align(move, threshold, null)`.
`void`	`align(boolean move, float threshold, Node node)`	Aligns the node with `node`, so that two of their axis are parallel.
`void`	`align(boolean move, Node node)`	Convenience function that simply calls `align(move, 0.85f, node)`.
`void`	`align(float threshold)`	Same as `align(threshold, null)`.
`void`	`align(float threshold, Node node)`	Convenience function that simply calls `align(false, threshold, node)`.
`void`	`align(Node node)`	Convenience function that simply calls `align(false, 0.85f, node)`
`void`	`animate()`	Run the animation defined by the node keyframes.
`void`	`animate(float speed)`	Run the animation with the given `speed` defined by the node keyframes.
`boolean`	`animationRecurrence()`	Tells whether or not the keyframes animation is recurrent or not.
`float`	`animationTime()`	Returns the current interpolation time (in milliseconds) along the keyframes path.
`void`	`attach()`	Attaches the branch to which this node belongs to the tree so that this node (together with all nodes in the branch) is reached from the `Graph.render()` algorithm.
`static float`	`blueID(int id)`	Convert int `id` to blue.
`float`	`bullsEyeSize()`	Returns the node `BULLSEYE` `hint()` size.
`void`	`bypass()`	Bypass rendering the node for the current frame.
`List<Node>`	`children()`	Returns the list a child nodes of this node.
`int`	`colorID()`	Uniquely identifies the node.
`static int`	`colorID(int id)`	Convert int `id` to color.
`void`	`configHint(int hint, Object... params)`	Configures the hint using varargs as follows:
`Node`	`copy()`	Same as `return copy(true)`.
`Node`	`copy(boolean recursive)`	Performs a deep copy of this node, and its descendants iff `recursive` is `true`.
`void`	`detach()`	Detach node from the tree so that it's not reached from the `Graph.render()` algorithm and make all the nodes in the `node` branch eligible for garbage collection.
`void`	`disableHint(int hint)`	Disables all the single visual hints encoded in the bitwise-or `hint` mask.
`void`	`disablePicking(int hint)`	Disables all the single visual hints encoded in the bitwise-or `hint` mask.
`float`	`displacement(float scalar)`	Converts `scalar` displacement from world to this node.
`float`	`displacement(float scalar, Node node)`	Converts `scalar` displacement from `node` to this node.
`Quaternion`	`displacement(Quaternion quaternion)`	Converts `quaternion` displacement from world to this node.
`Quaternion`	`displacement(Quaternion quaternion, Node node)`	Converts `quaternion` displacement from `node` to this node.
`Vector`	`displacement(Vector vector)`	Converts `vector` displacement from world to this node.
`Vector`	`displacement(Vector vector, Node node)`	Converts `vector` displacement from `node` to this node.
`void`	`enableHint(int hint)`	Enables all single visual hints encoded in the bitwise-or `hint` mask.
`void`	`enableHint(int hint, Object... params)`	Calls `enableHint(int)` followed by `configHint(int, Object...)`.
`void`	`enablePicking(int picking)`	Enables all single visual hints encoded in the bitwise-or `pickingMode` mask.
`void`	`fromMatrix(Matrix matrix)`	Sets the node from a `matrix()` representation: orientation and magnitude in the upper left 3x3 matrix and position on the last column.
`void`	`fromWorldMatrix(Matrix matrix)`	Sets the node from `worldMatrix()` representation: orientation and magnitude in the upper left 3x3 matrix and position on the last column.
`static float`	`greenID(int id)`	Convert int `id` to green.
`float`	`highlight()`	Returns the highlighting magnitude use to scale the node when it's tagged.
`int`	`hint()`	Returns the current visual hint mask.
`int`	`id()`	Returns the unique sequential node id assigned at instantiation time.
`void`	`interact(Object[] gesture)`	Parse `gesture` params.
`void`	`interpolate(float time)`	Interpolate the node at the given time (in milliseconds) along the keyframes path.
`Node`	`inverse()`
`Node`	`inverse(boolean attach)`	Returns a node representing the inverse of this node space transformation.
`boolean`	`isAncestor(Node node)`	Returns `true` if `node` is ancestor of `this` node.
`static boolean`	`isAncestor(Node successor, Node ancestor)`	Same as `return successor.isAncestor(ancestor)`.
`boolean`	`isAttached()`	Returns whether or not the node is reachable by the rendering algorithm.
`boolean`	`isEye()`	Returns whether or not this node is some graph `Graph.eye()`.
`boolean`	`isEye(Graph graph)`	Returns whether or not this node is the given `graph` `Graph.eye()`.
`boolean`	`isHintEnabled(int hint)`	Returns whether or not all single visual hints encoded in the bitwise-or `hint` mask are enable or not.
`boolean`	`isPickingEnabled(int hint)`	Returns whether or not all hints encoded in the bitwise-or `hint` mask are enable for node picking with ray casting.
`boolean`	`isReference(Node node)`	Returns `true` if `node` is `reference()` `this` node.
`boolean`	`isTagged(Graph graph)`	Returns `true` if the `node` has been tagged by the `graph` at least once and `false` otherwise.
`long`	`lastUpdate()`
`float`	`localDisplacement(float scalar)`	Converts `scalar` displacement from `reference()` to this node.
`Quaternion`	`localDisplacement(Quaternion quaternion)`	Converts `quaternion` displacement from `reference()` to this node.
`Vector`	`localDisplacement(Vector vector)`	Converts `vector` displacement from `reference()` to this node.
`Vector`	`localLocation(Vector vector)`	Converts `vector` location from `reference()` to this node.
`Vector`	`location(Node node)`	Converts the `node` origin location to this node.
`Vector`	`location(Vector vector)`	Converts `vector` location from world to this node.
`Vector`	`location(Vector vector, Node node)`	Converts `vector` location from `node` to this node.
`float`	`magnitude()`	Returns the node magnitude, defined with respect to the `reference()`.
`boolean`	`matches(Node node)`	Returns whether this node matches other taking into account the `worldPosition()`, `worldOrientation()` and `worldMagnitude()` node parameters.
`Matrix`	`matrix()`	Returns the local transformation matrix represented by the node.
`void`	`orbit(Vector axis, float angle)`	Rotates the node around `axis` passing through the origin, both defined in the world coordinate system.
`void`	`orbit(Vector axis, float angle, float inertia)`	Same as `orbit(axis, angle, new Vector(), inertia)`.
`void`	`orbit(Vector axis, float angle, Vector center)`	Rotates the node around `axis` passing through `center`, both defined in the world coordinate system.
`void`	`orbit(Vector axis, float angle, Vector center, float inertia)`	Same as `orbit(new Quaternion(displacement(axis), angle), center, inertia)`.
`Quaternion`	`orientation()`	Returns the node orientation, defined with respect to the `reference()` (i.e, the current Quaternion orientation).
`static List<Node>`	`path(Node tail, Node tip)`	Returns an array containing a straight path of nodes from `tail` to `tip`.
`int`	`picking()`	Returns the current visual picking hint mask encoding the visual aspects that are to be taken into account for picking the node with ray casting.
`Vector`	`position()`	Returns the node position, defined with respect to the `reference()`.
`void`	`projectOnLine(Vector origin, Vector direction)`	Translates the node so that its `worldPosition()` lies on the line defined by `origin` and `direction` (defined in the world coordinate system).
`static Node`	`random(Graph graph)`	Returns a random node attached to `graph`.
`static Node`	`random(Vector center, float radius, boolean is3D)`	Returns a random node.
`void`	`randomize(Vector center, float radius, boolean is3D)`	Randomized this node.
`static float`	`redID(int id)`	Convert int `id` to red.
`Node`	`reference()`	Returns the reference node, in which this node is defined.
`float`	`referenceDisplacement(float scalar)`	Converts `scalar` displacement from this node to `reference()`.
`Quaternion`	`referenceDisplacement(Quaternion quaternion)`	Converts `quaternion` displacement from this node to `reference()`.
`Vector`	`referenceDisplacement(Vector vector)`	Converts `vector` displacement from this node to `reference()`.
`Vector`	`referenceLocation(Vector vector)`	Converts `vector` location from this node to `reference()`.
`Node`	`removeKeyFrame(float time)`	Remove the closest keyframe to `time` (in milliseconds) and returns it.
`void`	`removeKeyFrames()`	Removes all keyframes from the animation path.
`boolean`	`rendered(Graph graph)`	Tells whether the node was rendered in the last frame from `graph` after a call to `Graph.render(Node)` is issued.
`void`	`reset()`	Sets an identity node by resetting its `position()`, `orientation()` and `magnitude()`.
`void`	`resetAnimation()`	Resets the node animation.
`void`	`resetBehavior(Graph graph)`	Same as `graph.resetBehavior(this)`.
`void`	`resetHint()`	Resets the current `hint()`, i.e., disables all single visual hints available for the node.
`void`	`resetHUD()`	Same as calling `resetRMRHUD()` and `resetIMRHUD()`.
`void`	`resetIMRHUD()`	Same as `setIMRShape(null)`.
`void`	`resetIMRShape()`	Resets the immediate-mode rendering shape.
`void`	`resetInertia()`	Stops all node inertia's.
`void`	`resetPicking()`	Resets `picking()`, i.e., disables all single visual hints available for node picking with ray casting.
`void`	`resetReference()`	Sets `reference()` to the world and make this node reachable (see `isAttached()`).
`void`	`resetRMRHUD()`	Same as `setRMRShape(null)`.
`void`	`resetRMRShape()`	Resets the retained-mode rendering shape.
`void`	`resetRotationFilter()`	Nullifies the `rotationFilter()`.
`void`	`resetScalingFilter()`	Nullifies the `scalingFilter()`.
`void`	`resetShape()`	Calls `resetIMRShape()` and `resetRMRShape()`.
`void`	`resetTranslationFilter()`	Nullifies the `translationFilter()`.
`void`	`rotate(float x, float y, float z, float angle)`	Same as `rotate(new Vector(x,y,z), angle)`.
`void`	`rotate(float x, float y, float z, float angle, float inertia)`	Same as `rotate(new Vector(x, y, z), angle, inertia)`.
`void`	`rotate(Quaternion quaternion)`	Same as `orientation().compose((rotationfilter() != null) ? rotationfilter().apply(this, cacheRotationParams) : quaternion)`.
`void`	`rotate(Quaternion quaternion, float inertia)`	Rotates the node by `quaternion` (defined in the node coordinate system): `orientation().compose(quaternion)` and with an impulse defined with `inertia` which should be in `[0..1]`, 0 no inertia & 1 no friction.
`void`	`rotate(Vector axis, float angle)`	Same as `rotate(new Quaternion(axis, angle))`.
`void`	`rotate(Vector axis, float angle, float inertia)`	Same as `rotate(new Quaternion(axis, angle), inertia)`.
`BiFunction<Node,Object[],Quaternion>`	`rotationFilter()`	Returns the rotation filter used by `rotate(Quaternion)`.
`void`	`scale(float scaling)`	Same as `magnitude() = magnitude() * (scalingFilter() != null ? scalingFilter().apply(this, cacheScalingParams) : scaling)`.
`void`	`scale(float scaling, float inertia)`	Scales the node according to `scaling`, locally defined with respect to the `reference()` and with an impulse defined with `inertia` which should be in `[0..1]`, 0 no inertia & 1 no friction.
`BiFunction<Node,Object[],Float>`	`scalingFilter()`	Returns the scaling filter used by `scale(float)`.
`void`	`set(Node node)`	Sets `worldPosition()`, `worldOrientation()` and `worldMagnitude()` values from those of the `node`.
`void`	`setAnimationRecurrence(boolean enable)`	Enables (or disables) the recurrence of the keyframes animation.
`void`	`setAnimationTime(float time)`	Sets the animation time (in milliseconds) used for the next `animate()` call.
`void`	`setBehavior(Graph graph, BiConsumer<Graph,Node> behavior)`	Same as `graph.addBehavior(this, behavior)`.
`void`	`setBehavior(Graph graph, Consumer<Graph> behavior)`	Same as `graph.addBehavior(this, (g, n) -> behavior.accept(g))`.
`void`	`setBullsEyeSize(float size)`	Sets the `bullsEyeSize()` of the `BULLSEYE` `hint()`.
`void`	`setForbidRotationFilter()`	Same as `setRotationFilter(forbidRotationFilter, new Object[] {})`.
`void`	`setForbidScalingFilter()`	Same as `setScalingFilter(forbidScalingFilter, new Object[] {})`.
`void`	`setForbidTranslationFilter()`	Same as `setTranslationFilter(forbidTranslationFilter, new Object[] {})`.
`void`	`setHighlight(float highlight)`	Sets the node `highlight()` which should be a value in `[0..1]`.
`void`	`setHUD(Consumer<PGraphics> callback)`	Sets the node immediate mode rendering (imr) drawing procedure `HUD` hint (see `hint()`).
`void`	`setHUD(Node node)`	Sets this (H)eads (U)p (D)isplay from the `node` hud.
`void`	`setHUD(PShape shape)`	Sets the node retained mode rendering (rmr) shape `HUD` hint (see `hint()`).
`void`	`setInteraction(BiConsumer<Node,Object[]> callback)`	Sets the node interaction procedure `callback` which is a function that takes a node param (holding this node instance) and, optionally, a gesture encoded as an array of on Object params.
`void`	`setInteraction(Consumer<Object[]> callback)`	Sets the node interaction procedure `callback` which is a function implemented by a `Node` derived class and which takes no params, or a gesture encoded as an array of on Object params.
`void`	`setMagnitude(float magnitude)`	Sets the `magnitude()` of the node, locally defined with respect to the `reference()`.
`void`	`setMinMaxScalingFilter(float min, float max)`	Same as `setScalingFilter(Node.minMaxScalingFilter, new Object[] { min, max })`.
`void`	`setOrientation(float x, float y, float z, float w)`	Same as `setOrientation(Quaternion)` but with `float` Quaternion parameters.
`void`	`setOrientation(Quaternion orientation)`	Sets the node `orientation()`, locally defined with respect to the `reference()`.
`void`	`setPosition(float x, float y)`	Same as `setPosition(Vector)`, but with `float` parameters.
`void`	`setPosition(float x, float y, float z)`	Same as `setPosition(Vector)`, but with `float` parameters.
`void`	`setPosition(Vector position)`	Caches the `position()` of the node, locally defined with respect to the `reference()`.
`void`	`setReference(Node node)`	Sets the `reference()` of the node.
`void`	`setRotationAxisFilter(Vector axis)`	Same as `setRotationFilter(Node.rotationAxisFilter, new Object[] { axis })`.
`void`	`setRotationFilter(BiFunction<Node,Object[],Quaternion> filter, Object[] params)`	Sets the `rotationFilter()` and its `cacheRotationParams`.
`void`	`setScalingFilter(BiFunction<Node,Object[],Float> filter, Object[] params)`	Sets the `scalingFilter()` and its `cacheScalingParams`.
`void`	`setShape(Consumer<PGraphics> callback)`	Sets the node immediate mode rendering (imr) `SHAPE` procedure hint (see `hint()`).
`void`	`setShape(Node node)`	Sets this shape from the `node` shape.
`void`	`setShape(PShape shape)`	Sets the node retained mode rendering (rmr) `SHAPE` hint (see `hint()`).
`void`	`setTranslationAxisFilter(Vector axis)`	Same as `setTranslationFilter(translationAxisFilter, new Object[] { axis })`.
`void`	`setTranslationFilter(BiFunction<Node,Object[],Vector> filter, Object[] params)`	Sets the `translationFilter()` and its `cacheTranslationParams`.
`void`	`setTranslationFilter(Function<Object[],Vector> filter, Object[] params)`
`void`	`setTranslationPlaneFilter(Vector normal)`	Same as `setTranslationFilter(translationPlaneFilter, new Object[] { axis })`.
`void`	`setWorldMagnitude(float magnitude)`	Sets the `worldMagnitude()` of the node, defined in the world coordinate system.
`void`	`setWorldMagnitude(Node node)`	Sets the `worldMagnitude()` to that of `node`.
`void`	`setWorldOrientation(float x, float y, float z, float w)`	Same as `setWorldOrientation(Quaternion)`, but with `float` parameters.
`void`	`setWorldOrientation(Node node)`	Sets the `worldOrientation()` to that of `node`.
`void`	`setWorldOrientation(Quaternion quaternion)`	Sets the `worldOrientation()` of the node, defined in the world coordinate system.
`void`	`setWorldPosition(float x, float y)`	Same as `setWorldPosition(Vector)`, but with `float` parameters.
`void`	`setWorldPosition(float x, float y, float z)`	Same as `setWorldPosition(Vector)`, but with `float` parameters.
`void`	`setWorldPosition(Node node)`	Sets the `worldPosition()` to that of `node`.
`void`	`setWorldPosition(Vector position)`	Sets the node `worldPosition()`, defined in the world coordinate system.
`void`	`setXAxis(Vector axis)`	Rotates the node so that its `xAxis()` becomes `axis` defined in the world coordinate system.
`void`	`setYAxis(Vector axis)`	Rotates the node so that its `yAxis()` becomes `axis` defined in the world coordinate system.
`void`	`setZAxis(Vector axis)`	Rotates the node so that its `zAxis()` becomes `axis` defined in the world coordinate system.
`void`	`toggleAnimation()`	Toggles the node animation.
`void`	`toggleHint(int hint)`	Toggles all single visual hints encoded in the bitwise-or `hint` mask.
`void`	`togglePicking(int hint)`	Toggles all single visual hints encoded in the bitwise-or `hint` mask.
`String`	`toString()`	Return this node components as a String.
`void`	`translate(float x, float y, float z)`	Same as `translate(Vector)` but with `float` parameters.
`void`	`translate(float x, float y, float z, float inertia)`	Same as `translate(new Vector(x, y, z), inertia)`.
`void`	`translate(Vector vector)`	Same as `position().add((translationFilter() != null) ? translationFilter().apply(this, cacheTranslationParams) : vector)`.
`void`	`translate(Vector vector, float inertia)`	Translates the node according to `vector`, locally defined with respect to the `reference()` and with an impulse defined with `inertia` which should be in `[0..1]`, 0 no inertia & 1 no friction.
`BiFunction<Node,Object[],Vector>`	`translationFilter()`	Returns the translation filter used by `translate(Vector)`.
`Matrix`	`view()`	Returns the inverse of the matrix associated with the node position and orientation that is to be used when the node represents an eye.
`Matrix`	`viewInverse()`	Returns the inverse of the `view()` matrix.
`float`	`worldDisplacement(float scalar)`	Converts `scalar` displacement from this node to world.
`Quaternion`	`worldDisplacement(Quaternion quaternion)`	Converts `quaternion` displacement from this node to world.
`Vector`	`worldDisplacement(Vector vector)`	Converts `vector` displacement from this node to world.
`Node`	`worldInverse()`
`Node`	`worldInverse(boolean attach)`	Returns the `inverse()` of the node world transformation.
`Vector`	`worldLocation(Vector vector)`	Converts `vector` location from this node to world.
`float`	`worldMagnitude()`	Returns the magnitude of the node, defined in the world coordinate system.
`Matrix`	`worldMatrix()`	Returns the global transformation matrix represented by the node which grants direct access to it, without the need to traverse its ancestor hierarchy first (as it is the case with `matrix()`).
`Quaternion`	`worldOrientation()`	Returns the orientation of the node, defined in the world coordinate system.
`Vector`	`worldPosition()`	Returns the node position defined in the world coordinate system.
`Vector`	`xAxis()`	Same as `return xAxis(true)`
`Vector`	`xAxis(boolean positive)`	Returns the x-axis of the node, represented as a normalized vector defined in the world coordinate system.
`Vector`	`yAxis()`	Same as `return yAxis(true)`
`Vector`	`yAxis(boolean positive)`	Returns the y-axis of the node, represented as a normalized vector defined in the world coordinate system.
`Vector`	`zAxis()`	Same as `return zAxis(true)`
`Vector`	`zAxis(boolean positive)`	Returns the z-axis of the node, represented as a normalized vector defined in the world coordinate system.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - cull
```
public boolean cull
```
  - tagging
```
public boolean tagging
```
  - cacheTranslationParams
```
public Object[] cacheTranslationParams
```
  - cacheTargetPosition
```
public Vector cacheTargetPosition
```
  - cacheTargetTranslation
```
public Vector cacheTargetTranslation
```
  - cacheRotationParams
```
public Object[] cacheRotationParams
```
  - cacheTargetOrientation
```
public Quaternion cacheTargetOrientation
```
  - cacheTargetRotation
```
public Quaternion cacheTargetRotation
```
  - cacheScalingParams
```
public Object[] cacheScalingParams
```
  - cacheTargetMagnitude
```
public float cacheTargetMagnitude
```
  - cacheTargetScaling
```
public float cacheTargetScaling
```
  - cachePosition
```
public Vector cachePosition
```
  - cacheOrientation
```
public Quaternion cacheOrientation
```
  - cacheMagnitude
```
public float cacheMagnitude
```
  - CAMERA
```
public static final int CAMERA
```
    See Also:
    
    Constant Field Values
  - AXES
```
public static final int AXES
```
    See Also:
    
    Constant Field Values
  - HUD
```
public static final int HUD
```
    See Also:
    
    Constant Field Values
  - SHAPE
```
public static final int SHAPE
```
    See Also:
    
    Constant Field Values
  - BOUNDS
```
public static final int BOUNDS
```
    See Also:
    
    Constant Field Values
  - BULLSEYE
```
public static final int BULLSEYE
```
    See Also:
    
    Constant Field Values
  - TORUS
```
public static final int TORUS
```
    See Also:
    
    Constant Field Values
  - FILTER
```
public static final int FILTER
```
    See Also:
    
    Constant Field Values
  - BONE
```
public static final int BONE
```
    See Also:
    
    Constant Field Values
  - KEYFRAMES
```
public static final int KEYFRAMES
```
    See Also:
    
    Constant Field Values
  - maxSteps
```
public static int maxSteps
```
  - translationAxisFilter
```
public static BiFunction<Node,Object[],Vector> translationAxisFilter
```
    Filters translation so that the node is translated along axis (defined in this node coordinate system). Call it as: setTranslationFilter(Node.translationAxisFilter, new Object[] { axis }).
    
    See Also:
    
    translationPlaneFilter, translationPlaneFilter, rotationAxisFilter, minMaxScalingFilter
  - forbidTranslationFilter
```
public static BiFunction<Node,Object[],Vector> forbidTranslationFilter
```
    Filters translation so that it gets nullified. Call it as: setTranslationFilter(Node.forbidtranslationFilter, new Object[] { }).
    
    See Also:
    
    setForbidTranslationFilter()
  - translationPlaneFilter
```
public static BiFunction<Node,Object[],Vector> translationPlaneFilter
```
    Filters translation so that the node is translated along the plane defined by normal (defined in this node coordinate system). Call it as: setTranslationFilter(Node.vectorPlaneFilter, new Object[] { normal }).
    
    See Also:
    
    translationAxisFilter, rotationAxisFilter, minMaxScalingFilter
  - rotationAxisFilter
```
public static BiFunction<Node,Object[],Quaternion> rotationAxisFilter
```
    Filters quaternion so that its Quaternion.axis() become axis (defined in this node coordinate system). Call it as: setRotationFilter(Node.rotationAxisFilter, new Object[] { axis }).
    
    See Also:
    
    rotate(Quaternion), setRotationAxisFilter(Vector), translationAxisFilter, translationPlaneFilter, minMaxScalingFilter
  - forbidRotationFilter
```
public static BiFunction<Node,Object[],Quaternion> forbidRotationFilter
```
    Filters rotation so that it gets nullified. Call it as: setRotationFilter(Node.forbidRotationFilter, new Object[] { }).
    
    See Also:
    
    setForbidRotationFilter()
  - minMaxScalingFilter
```
public static BiFunction<Node,Object[],Float> minMaxScalingFilter
```
    Filters scaling so that the node magnitude lies in [min..max]. Call it as: setScalingFilter(Node.minMaxScalingFilter, new Object[] { min, max }).
    
    See Also:
    
    translationPlaneFilter, translationAxisFilter, rotationAxisFilter, setMinMaxScalingFilter(float, float)
  - forbidScalingFilter
```
public static BiFunction<Node,Object[],Float> forbidScalingFilter
```
    Filters scaling so that it gets nullified. Call it as: setScalingFilter(Node.forbidScalingilter, new Object[] { }).
    
    See Also:
    
    setForbidScalingFilter()
- Constructor Detail
  - Node
```
public Node()
```
    Same as this(null, new Vector(), new Quaternion(), 1).
    
    See Also:
    
    Node(Node, Vector, Quaternion, float)
  - Node
```
public Node(boolean attach)
```
    Same as {this(null, new Vector(), new Quaternion(), 1, attach)}. The attach var controls whether or not the node isAttached() by the Graph.render() algorithm.
    
    See Also:
    
    Node(Node, Vector, Quaternion, float, boolean)
  - Node
```
public Node(Vector position)
```
    Same as this(null, position, new Quaternion(), 1).
    
    See Also:
    
    Node(Node, Vector, Quaternion, float)
  - Node
```
public Node(Vector position,
            boolean attach)
```
    Same as this(null, position, new Quaternion(), 1, attach). The attach var controls whether or not the node isAttached() by the Graph.render() algorithm.
    
    See Also:
    
    Node(Node, Vector, Quaternion, float, boolean)
  - Node
```
public Node(Vector position,
            Quaternion orientation)
```
    Same as this(null, position, orientation, 1).
    
    See Also:
    
    Node(Node, Vector, Quaternion, float)
  - Node
```
public Node(Vector position,
            Quaternion orientation,
            boolean attach)
```
    Same as this(null, position, orientation, 1, attach). The attach var controls whether or not the node isAttached() by the Graph.render() algorithm.
    
    See Also:
    
    Node(Node, Vector, Quaternion, float, boolean)
  - Node
```
public Node(Node reference)
```
    Same as this(reference, new Vector(), new Quaternion(), 1).
    
    See Also:
    
    Node(Node, Vector, Quaternion, float)
  - Node
```
public Node(Node reference,
            Vector position)
```
    Same as this(reference, position, new Quaternion(), 1.
    
    See Also:
    
    Node(Node, Vector, Quaternion, float)
  - Node
```
public Node(Node reference,
            Vector position,
            Quaternion orientation)
```
    Same as this(reference, position, orientation, 1.
    
    See Also:
    
    Node(Node, Vector, Quaternion, float), isAttached()
  - Node
```
public Node(Vector position,
            Quaternion orientation,
            float magnitude)
```
    Same as this(null, position, orientation, magnitude).
    
    See Also:
    
    Node(Node, Vector, Quaternion, float)
  - Node
```
public Node(Vector position,
            Quaternion orientation,
            float magnitude,
            boolean attach)
```
    Same as this(null, position, orientation, magnitude, attach).
    
    See Also:
    
    Node(Node, Vector, Quaternion, float, boolean)
  - Node
```
public Node(Node reference,
            Vector position,
            Quaternion orientation,
            float magnitude)
```
    Creates a node with reference as reference(), having position, orientation and magnitude as the position(), orientation() and magnitude(), respectively. The bullsEyeSize() is set to 0.2 and the highlight() hint magnitude to 0.15. The node isAttached() by the Graph.render() algorithm iff the node reference happens to be.
    
    See Also:
    
    attach(), detach(), Node(Node, Vector, Quaternion, float, boolean)
  - Node
```
public Node(Consumer<PGraphics> shape)
```
    Same as this(null, shape, new Vector(), new Quaternion(), 1).
    
    See Also:
    
    Node(Node, Consumer, Vector, Quaternion, float)
  - Node
```
public Node(PShape shape)
```
    Same as this(null, shape, new Vector(), new Quaternion(), 1).
    
    See Also:
    
    Node(Node, processing.core.PShape, Vector, Quaternion, float)
  - Node
```
public Node(Node reference,
            Consumer<PGraphics> shape)
```
    Same as this(reference, shape, new Vector(), new Quaternion(), 1).
    
    See Also:
    
    Node(Node, Consumer, Vector, Quaternion, float)
  - Node
```
public Node(Node reference,
            PShape shape)
```
    Same as this(reference, shape, new Vector(), new Quaternion(), 1).
    
    See Also:
    
    Node(Node, processing.core.PShape, Vector, Quaternion, float)
  - Node
```
public Node(Node reference,
            Consumer<PGraphics> shape,
            Vector position,
            Quaternion orientation,
            float magnitude)
```
    Calls Node(Node, Vector, Quaternion, float) and then setShape(Consumer).
  - Node
```
public Node(Node reference,
            PShape shape,
            Vector position,
            Quaternion orientation,
            float magnitude)
```
    Creates a node with reference as reference() and shape, having position, orientation and magnitude as the position(), orientation() and magnitude(), respectively. The bullsEyeSize() is set to 0 and the highlight() hint to 0.15.
- Method Detail
  - matches
```
public boolean matches(Node node)
```
    Returns whether this node matches other taking into account the worldPosition(), worldOrientation() and worldMagnitude() node parameters.
    
    Parameters:
    
    node - node
  - toString
```
public String toString()
```
    Return this node components as a String.
    
    Overrides:
    
    toString in class Object
  - copy
```
public Node copy()
```
    Same as return copy(true).
    
    See Also:
    
    copy(boolean)
  - copy
```
public Node copy(boolean recursive)
```
    Performs a deep copy of this node, and its descendants iff recursive is true. Note that neither the keyframes nor the node filters get copied.
  - set
```
public void set(Node node)
```
    Sets worldPosition(), worldOrientation() and worldMagnitude() values from those of the node. The node reference() is not affected by this call.
    After calling set(node) a call to this.matches(node) should return true.
    
    See Also:
    
    reset(), worldMatrix(), setWorldPosition(Node), setWorldOrientation(Node), setWorldMagnitude(Node)
  - reset
```
public void reset()
```
    Sets an identity node by resetting its position(), orientation() and magnitude(). The node reference() is not affected by this call. Call set(null) if you want to reset the global worldPosition(), worldOrientation() and worldMagnitude() node parameters instead.
    
    See Also:
    
    set(Node)
  - id
```
public int id()
```
    Returns the unique sequential node id assigned at instantiation time. Used by colorID() and Graph._displayBackHint(Node).
  - colorID
```
public int colorID()
```
    Uniquely identifies the node. Also the color to be used for picking with a color buffer. See: http://stackoverflow.com/questions/2262100/rgb-int-to-rgb-python
  - redID
```
public static float redID(int id)
```
    Convert int id to red. Use it in conjunction with greenID(int) and blueID(int).
    
    See Also:
    
    colorID(int)
  - greenID
```
public static float greenID(int id)
```
    Convert int id to green. Use it in conjunction with redID(int) and blueID(int).
    
    See Also:
    
    colorID(int)
  - blueID
```
public static float blueID(int id)
```
    Convert int id to blue. Use it in conjunction with redID(int) and greenID(int).
    
    See Also:
    
    colorID(int)
  - colorID
```
public static int colorID(int id)
```
    Convert int id to color. See: http://stackoverflow.com/questions/2262100/rgb-int-to-rgb-python
  - lastUpdate
```
public long lastUpdate()
```
    Returns:
    
    the last frame this node affine transformation (worldPosition(), worldOrientation() or worldMagnitude()) or reference() was updated.
  - isReference
```
public boolean isReference(Node node)
```
    Returns true if node is reference() this node.
  - isAncestor
```
public boolean isAncestor(Node node)
```
    Returns true if node is ancestor of this node.
  - isAncestor
```
public static boolean isAncestor(Node successor,
                                 Node ancestor)
```
    Same as return successor.isAncestor(ancestor).
    
    See Also:
    
    isAncestor(Node), path(Node, Node)
  - path
```
public static List<Node> path(Node tail,
                              Node tip)
```
    Returns an array containing a straight path of nodes from tail to tip. Returns an empty list if tail is not ancestor of tip.
    
    See Also:
    
    isAncestor(Node, Node)
  - reference
```
public Node reference()
```
    Returns the reference node, in which this node is defined.
    The node position(), orientation() and magnitude() are defined with respect to the reference() coordinate system. A null reference node (default value) means that the node is defined in the world coordinate system.
    Use worldPosition(), worldOrientation() and worldMagnitude() to recursively convert values along the reference node chain and to get values expressed in the world coordinate system. The values match when the reference node is null.
    Use setReference(Node) to set this value and create a node hierarchy. Convenient functions allow you to convert coordinates and vectors from one node to another: see location(Vector, Node) and displacement(Vector, Node), respectively.
  - resetReference
```
public void resetReference()
```
    Sets reference() to the world and make this node reachable (see isAttached()).
    
    See Also:
    
    setReference(Node), detach()
  - setReference
```
public void setReference(Node node)
```
    Sets the reference() of the node. The node worldPosition(), worldOrientation() and worldMagnitude() are kept. Setting a detached reference of an attached node will make the node detached, while setting an attached reference of a detached node will keep it detached.
    The node position(), orientation() and magnitude() are then defined in the reference() coordinate system.
    Use worldPosition(), worldOrientation() and worldMagnitude() to express the node global transformation in the world coordinate system.
    Using this method, you can create a hierarchy of nodes. This hierarchy needs to be a tree, which root is the world coordinate system (i.e., null reference()). No action is performed if setting reference as the reference() would create a loop in the hierarchy.
    To make all the nodes in the node branch eligible for garbage collection call detach().
    
    See Also:
    
    detach()
  - resetInertia
```
public void resetInertia()
```
    Stops all node inertia's.
  - rendered
```
public boolean rendered(Graph graph)
```
    Tells whether the node was rendered in the last frame from graph after a call to Graph.render(Node) is issued. Ths method should be called from within the main event loop (after Graph.render(Node)).
  - attach
```
public void attach()
```
    Attaches the branch to which this node belongs to the tree so that this node (together with all nodes in the branch) is reached from the Graph.render() algorithm. A call to isAttached() will then return true.
    detach() performs the inverse operation.
    
    See Also:
    
    Graph.clearTree(), detach(), isAttached()
  - detach
```
public void detach()
```
    Detach node from the tree so that it's not reached from the Graph.render() algorithm and make all the nodes in the node branch eligible for garbage collection. A call to isAttached() (including the node descendants) will then return false.
    attach() performs the inverse operation.
    
    See Also:
    
    Graph.clearTree(), attach(), isAttached()
  - isAttached
```
public boolean isAttached()
```
    Returns whether or not the node is reachable by the rendering algorithm. Note that a detached child of an attached node is not listed in children(), even though they hold a reference() to the parent node.
    
    See Also:
    
    detach(), attach(), setReference(Node)
  - children
```
public List<Node> children()
```
    Returns the list a child nodes of this node. Note that detached children of an attached node are not listed, even though they hold a reference() to the node.
    
    See Also:
    
    isAttached(), attach(), detach()
  - randomize
```
public void randomize(Vector center,
                      float radius,
                      boolean is3D)
```
    Randomized this node. The node is randomly re-positioned inside the ball defined by center and radius, which in 2D is a circumference parallel to the x-y plane. The worldOrientation() is randomized by Quaternion.randomize(). The new magnitude is a random in old-magnitude * [0,5...2].
    
    See Also:
    
    Vector.randomize(), Quaternion.randomize(), random(Graph), random(Vector, float, boolean)
  - random
```
public static Node random(Graph graph)
```
    Returns a random node attached to graph. The node is randomly positioned inside the graph viewing volume which is defined by Graph.center() and Graph.radius() (see Vector.random()). The worldOrientation() is set by Quaternion.random(). The worldMagnitude() is a random in [0,5...2].
    
    See Also:
    
    random(Vector, float, boolean), Vector.random(), Quaternion.random(), randomize(Vector, float, boolean)
  - random
```
public static Node random(Vector center,
                          float radius,
                          boolean is3D)
```
    Returns a random node. The node is randomly positioned inside the ball defined by center and radius (see Vector.random()), which in 2D is a circumference parallel to the x-y plane. The worldOrientation() is set by Quaternion.random(). The worldMagnitude() is a random in [0,5...2].
    
    See Also:
    
    random(Graph), Vector.random(), Quaternion.random(), randomize(Vector, float, boolean)
  - setBullsEyeSize
```
public void setBullsEyeSize(float size)
```
    Sets the bullsEyeSize() of the BULLSEYE hint().
    Picking a node is done with ray casting against a screen-space bullseye shape (see configHint(int, Object...)) whose length is defined as follows:
    
    A percentage of the graph diameter (see Graph.radius()). Set it with size in [0..1].
    
    A fixed numbers of pixels. Set it with size > 1.
    See Also:
    
    bullsEyeSize()
  - setHighlight
```
public void setHighlight(float highlight)
```
    Sets the node highlight() which should be a value in [0..1]. Default value is 0.15.
    
    See Also:
    
    highlight()
  - highlight
```
public float highlight()
```
    Returns the highlighting magnitude use to scale the node when it's tagged.
    
    See Also:
    
    setHighlight(float)
  - bullsEyeSize
```
public float bullsEyeSize()
```
    Returns the node BULLSEYE hint() size. Set it with setBullsEyeSize(float).
    
    See Also:
    
    setBullsEyeSize(float)
  - position
```
public Vector position()
```
    Returns the node position, defined with respect to the reference().
    Use worldPosition() to get the result in world coordinates. These two values are identical when the reference() is null (default).
    
    See Also:
    
    setPosition(Vector)
  - setPosition
```
public void setPosition(Vector position)
```
    Caches the position() of the node, locally defined with respect to the reference(). If there's a translationFilter() it actually calls translate(Vector.subtract(position, this.position())).
    Use setWorldPosition(Vector) to define the world coordinates worldPosition().
    
    See Also:
    
    translate(Vector), setOrientation(Quaternion), setMagnitude(float)
  - setPosition
```
public void setPosition(float x,
                        float y)
```
    Same as setPosition(Vector), but with float parameters.
  - setPosition
```
public void setPosition(float x,
                        float y,
                        float z)
```
    Same as setPosition(Vector), but with float parameters.
  - translate
```
public void translate(float x,
                      float y,
                      float z,
                      float inertia)
```
    Same as translate(new Vector(x, y, z), inertia).
    
    See Also:
    
    translate(Vector, float)
  - translate
```
public void translate(float x,
                      float y,
                      float z)
```
    Same as translate(Vector) but with float parameters.
  - translate
```
public void translate(Vector vector,
                      float inertia)
```
    Translates the node according to vector, locally defined with respect to the reference() and with an impulse defined with inertia which should be in [0..1], 0 no inertia & 1 no friction.
    
    See Also:
    
    rotate(Quaternion, float), scale(float, float), orbit(Vector, float, Vector, float)
  - translate
```
public void translate(Vector vector)
```
    Same as position().add((translationFilter() != null) ? translationFilter().apply(this, cacheTranslationParams) : vector).
    
    See Also:
    
    translate(Vector, float), translationAxisFilter, translationPlaneFilter, translationFilter(), rotate(Quaternion), scale(float)
  - setTranslationFilter
```
public void setTranslationFilter(Function<Object[],Vector> filter,
                                 Object[] params)
```
  - setTranslationFilter
```
public void setTranslationFilter(BiFunction<Node,Object[],Vector> filter,
                                 Object[] params)
```
    Sets the translationFilter() and its cacheTranslationParams.
  - translationFilter
```
public BiFunction<Node,Object[],Vector> translationFilter()
```
    Returns the translation filter used by translate(Vector).
    
    See Also:
    
    setTranslationFilter(BiFunction, Object[])
  - resetTranslationFilter
```
public void resetTranslationFilter()
```
    Nullifies the translationFilter().
  - setTranslationAxisFilter
```
public void setTranslationAxisFilter(Vector axis)
```
    Same as setTranslationFilter(translationAxisFilter, new Object[] { axis }).
    
    See Also:
    
    setTranslationFilter(BiFunction, Object[]), translationAxisFilter, setTranslationPlaneFilter(Vector), setRotationAxisFilter(Vector), setMinMaxScalingFilter(float, float)
  - setForbidTranslationFilter
```
public void setForbidTranslationFilter()
```
    Same as setTranslationFilter(forbidTranslationFilter, new Object[] {}).
  - setTranslationPlaneFilter
```
public void setTranslationPlaneFilter(Vector normal)
```
    Same as setTranslationFilter(translationPlaneFilter, new Object[] { axis }).
    
    See Also:
    
    setTranslationFilter(BiFunction, Object[]), translationPlaneFilter, Filter(Vector), setRotationAxisFilter(Vector), setMinMaxScalingFilter(float, float)
  - worldPosition
```
public Vector worldPosition()
```
    Returns the node position defined in the world coordinate system.
    
    See Also:
    
    worldOrientation(), worldMagnitude(), setWorldPosition(Vector), position()
  - setWorldPosition
```
public void setWorldPosition(Node node)
```
    Sets the worldPosition() to that of node.
    
    See Also:
    
    setWorldPosition(Vector), set(Node)
  - setWorldPosition
```
public void setWorldPosition(Vector position)
```
    Sets the node worldPosition(), defined in the world coordinate system.
    Use setPosition(Vector) to define the local node position (with respect to the reference()).
  - setWorldPosition
```
public void setWorldPosition(float x,
                             float y)
```
    Same as setWorldPosition(Vector), but with float parameters.
  - setWorldPosition
```
public void setWorldPosition(float x,
                             float y,
                             float z)
```
    Same as setWorldPosition(Vector), but with float parameters.
  - orientation
```
public Quaternion orientation()
```
    Returns the node orientation, defined with respect to the reference() (i.e, the current Quaternion orientation).
    Use worldOrientation() to get the result in world coordinates. These two values are identical when the reference() is null (default).
    
    See Also:
    
    setOrientation(Quaternion)
  - setOrientation
```
public void setOrientation(float x,
                           float y,
                           float z,
                           float w)
```
    Same as setOrientation(Quaternion) but with float Quaternion parameters.
  - setOrientation
```
public void setOrientation(Quaternion orientation)
```
    Sets the node orientation(), locally defined with respect to the reference(). If there's a rotationFilter() it actually calls rotate(Quaternion.compose(orientation().inverse(), orientation)).
    Use setWorldOrientation(Quaternion) to define the world coordinates worldOrientation().
    
    See Also:
    
    orientation(), setPosition(Vector), setMagnitude(float)
  - rotate
```
public void rotate(Vector axis,
                   float angle,
                   float inertia)
```
    Same as rotate(new Quaternion(axis, angle), inertia).
    
    See Also:
    
    rotate(Quaternion, float)
  - rotate
```
public void rotate(Vector axis,
                   float angle)
```
    Same as rotate(new Quaternion(axis, angle)).
    
    See Also:
    
    rotate(Quaternion)
  - rotate
```
public void rotate(float x,
                   float y,
                   float z,
                   float angle,
                   float inertia)
```
    Same as rotate(new Vector(x, y, z), angle, inertia).
    
    See Also:
    
    rotate(Vector, float, float)
  - rotate
```
public void rotate(float x,
                   float y,
                   float z,
                   float angle)
```
    Same as rotate(new Vector(x,y,z), angle).
    
    See Also:
    
    rotate(Vector, float)
  - rotate
```
public void rotate(Quaternion quaternion,
                   float inertia)
```
    Rotates the node by quaternion (defined in the node coordinate system): orientation().compose(quaternion) and with an impulse defined with inertia which should be in [0..1], 0 no inertia & 1 no friction.
    
    See Also:
    
    translate(Vector, float), orbit(Vector, float, Vector, float), scale(float, float)
  - rotate
```
public void rotate(Quaternion quaternion)
```
    Same as orientation().compose((rotationfilter() != null) ? rotationfilter().apply(this, cacheRotationParams) : quaternion).
    
    See Also:
    
    rotate(Quaternion, float), rotationFilter(), rotationAxisFilter, translate(Vector), scale(float)
  - setRotationFilter
```
public void setRotationFilter(BiFunction<Node,Object[],Quaternion> filter,
                              Object[] params)
```
    Sets the rotationFilter() and its cacheRotationParams.
  - rotationFilter
```
public BiFunction<Node,Object[],Quaternion> rotationFilter()
```
    Returns the rotation filter used by rotate(Quaternion).
    
    See Also:
    
    setRotationFilter(BiFunction, Object[])
  - resetRotationFilter
```
public void resetRotationFilter()
```
    Nullifies the rotationFilter().
  - setRotationAxisFilter
```
public void setRotationAxisFilter(Vector axis)
```
    Same as setRotationFilter(Node.rotationAxisFilter, new Object[] { axis }).
    
    See Also:
    
    setRotationFilter(BiFunction, Object[]), rotationAxisFilter, setTranslationAxisFilter(Vector), setTranslationPlaneFilter(Vector), setMinMaxScalingFilter(float, float)
  - setForbidRotationFilter
```
public void setForbidRotationFilter()
```
    Same as setRotationFilter(forbidRotationFilter, new Object[] {}).
    
    See Also:
    
    setRotationFilter(BiFunction, Object[])
  - orbit
```
public void orbit(Vector axis,
                  float angle,
                  float inertia)
```
    Same as orbit(axis, angle, new Vector(), inertia).
    
    See Also:
    
    orbit(Vector, float), orbit(Vector, float, Vector, float)
  - orbit
```
public void orbit(Vector axis,
                  float angle)
```
    Rotates the node around axis passing through the origin, both defined in the world coordinate system. Same as orbit(axis, angle, new Vector()).
    
    See Also:
    
    orbit(Vector, float, Vector), orbit(Vector, float, Vector, float)
  - orbit
```
public void orbit(Vector axis,
                  float angle,
                  Vector center,
                  float inertia)
```
    Same as orbit(new Quaternion(displacement(axis), angle), center, inertia).
    
    See Also:
    
    orbit(Vector, float), orbit(Vector, float, float)
  - orbit
```
public void orbit(Vector axis,
                  float angle,
                  Vector center)
```
    Rotates the node around axis passing through center, both defined in the world coordinate system. Same as orbit(new Quaternion(displacement(axis), angle), center).
    
    See Also:
    
    _orbit(Quaternion, Vector), orbit(Vector, float)
  - worldOrientation
```
public Quaternion worldOrientation()
```
    Returns the orientation of the node, defined in the world coordinate system.
    
    See Also:
    
    worldPosition(), worldMagnitude(), setWorldOrientation(Quaternion), orientation()
  - setWorldOrientation
```
public void setWorldOrientation(Node node)
```
    Sets the worldOrientation() to that of node.
    
    See Also:
    
    setWorldOrientation(Quaternion), set(Node)
  - setWorldOrientation
```
public void setWorldOrientation(Quaternion quaternion)
```
    Sets the worldOrientation() of the node, defined in the world coordinate system.
    Use setOrientation(Quaternion) to define the local node orientation (with respect to the reference()).
  - setWorldOrientation
```
public void setWorldOrientation(float x,
                                float y,
                                float z,
                                float w)
```
    Same as setWorldOrientation(Quaternion), but with float parameters.
  - magnitude
```
public float magnitude()
```
    Returns the node magnitude, defined with respect to the reference().
    Use worldMagnitude() to get the result in world coordinates. These two values are identical when the reference() is null (default).
    
    See Also:
    
    setMagnitude(float)
  - setMagnitude
```
public void setMagnitude(float magnitude)
```
    Sets the magnitude() of the node, locally defined with respect to the reference(). If there's a scalingFilter() it actually calls scale(magnitude / magnitude()).
    Use setWorldMagnitude(float) to define the world coordinates worldMagnitude().
    
    See Also:
    
    scale(float)
  - scale
```
public void scale(float scaling,
                  float inertia)
```
    Scales the node according to scaling, locally defined with respect to the reference() and with an impulse defined with inertia which should be in [0..1], 0 no inertia & 1 no friction.
    
    See Also:
    
    translate(Vector, float), rotate(Quaternion, float), orbit(Vector, float)
  - scale
```
public void scale(float scaling)
```
    Same as magnitude() = magnitude() * (scalingFilter() != null ? scalingFilter().apply(this, cacheScalingParams) : scaling).
    
    See Also:
    
    scale(float, float), translate(Vector), rotate(Quaternion)
  - setScalingFilter
```
public void setScalingFilter(BiFunction<Node,Object[],Float> filter,
                             Object[] params)
```
    Sets the scalingFilter() and its cacheScalingParams.
  - scalingFilter
```
public BiFunction<Node,Object[],Float> scalingFilter()
```
    Returns the scaling filter used by scale(float).
    
    See Also:
    
    setScalingFilter(BiFunction, Object[])
  - resetScalingFilter
```
public void resetScalingFilter()
```
    Nullifies the scalingFilter().
  - setMinMaxScalingFilter
```
public void setMinMaxScalingFilter(float min,
                                   float max)
```
    Same as setScalingFilter(Node.minMaxScalingFilter, new Object[] { min, max }).
    
    See Also:
    
    setScalingFilter(BiFunction, Object[]), minMaxScalingFilter, setTranslationAxisFilter(Vector), setTranslationPlaneFilter(Vector), setRotationAxisFilter(Vector)
  - setForbidScalingFilter
```
public void setForbidScalingFilter()
```
    Same as setScalingFilter(forbidScalingFilter, new Object[] {}).
    
    See Also:
    
    setScalingFilter(BiFunction, Object[])
  - worldMagnitude
```
public float worldMagnitude()
```
    Returns the magnitude of the node, defined in the world coordinate system.
    Note that the magnitude is used to compute the node Graph.projection() matrix to render a scene from the node point-of-view.
    
    See Also:
    
    worldOrientation(), worldPosition(), setWorldPosition(Vector), position(), Graph.projection()
  - setWorldMagnitude
```
public void setWorldMagnitude(Node node)
```
    Sets the worldMagnitude() to that of node.
    
    See Also:
    
    setWorldMagnitude(float), set(Node)
  - setWorldMagnitude
```
public void setWorldMagnitude(float magnitude)
```
    Sets the worldMagnitude() of the node, defined in the world coordinate system.
    Use setMagnitude(float) to define the local node magnitude (with respect to the reference()).
  - align
```
public void align()
```
    Same as align(null).
    
    See Also:
    
    align(Node)
  - align
```
public void align(Node node)
```
    Convenience function that simply calls align(false, 0.85f, node)
    
    See Also:
    
    align(boolean, float, Node)
  - align
```
public void align(boolean move)
```
    Same as align(move, null).
    
    See Also:
    
    align(boolean, Node)
  - align
```
public void align(boolean move,
                  Node node)
```
    Convenience function that simply calls align(move, 0.85f, node).
    
    See Also:
    
    align(boolean, float, Node)
  - align
```
public void align(float threshold)
```
    Same as align(threshold, null).
    
    See Also:
    
    align(boolean, Node)
  - align
```
public void align(float threshold,
                  Node node)
```
    Convenience function that simply calls align(false, threshold, node).
    
    See Also:
    
    align(boolean, float, Node)
  - align
```
public void align(boolean move,
                  float threshold)
```
    Same as align(move, threshold, null).
    
    See Also:
    
    align(boolean, float, Node)
  - align
```
public void align(boolean move,
                  float threshold,
                  Node node)
```
    Aligns the node with node, so that two of their axis are parallel.
    If one of the X, Y and Z axis of the Node is almost parallel to any of the X, Y, or Z axis of node, the Node is rotated so that these two axis actually become parallel.
    If, after this first rotation, two other axis are also almost parallel, a second alignment is performed. The two nodes then have identical orientations, up to 90 degrees rotations.
    threshold measures how close two axis must be to be considered parallel. It is compared with the absolute values of the dot product of the normalized axis.
    When move is set to true, the Node worldPosition() is also affected by the alignment. The new Node worldPosition() is such that the node node position (computed with location(Vector), in the Node coordinates system) does not change.
    node may be null and then represents the world coordinate system (same convention than for the reference()).
  - projectOnLine
```
public void projectOnLine(Vector origin,
                          Vector direction)
```
    Translates the node so that its worldPosition() lies on the line defined by origin and direction (defined in the world coordinate system).
    Simply uses an orthogonal projection. direction does not need to be normalized.
  - setXAxis
```
public void setXAxis(Vector axis)
```
    Rotates the node so that its xAxis() becomes axis defined in the world coordinate system. Attention: this rotation is not uniquely defined. See Quaternion.fromTo(Vector, Vector).
    
    See Also:
    
    xAxis(), setYAxis(Vector), setZAxis(Vector)
  - setYAxis
```
public void setYAxis(Vector axis)
```
    Rotates the node so that its yAxis() becomes axis defined in the world coordinate system. Attention: this rotation is not uniquely defined. See Quaternion.fromTo(Vector, Vector).
    
    See Also:
    
    yAxis(), setYAxis(Vector), setZAxis(Vector)
  - setZAxis
```
public void setZAxis(Vector axis)
```
    Rotates the node so that its zAxis() becomes axis defined in the world coordinate system. Attention: this rotation is not uniquely defined. See Quaternion.fromTo(Vector, Vector).
    
    See Also:
    
    zAxis(), setYAxis(Vector), setZAxis(Vector)
  - xAxis
```
public Vector xAxis()
```
    Same as return xAxis(true)
    
    See Also:
    
    xAxis(boolean)
  - xAxis
```
public Vector xAxis(boolean positive)
```
    Returns the x-axis of the node, represented as a normalized vector defined in the world coordinate system.
    
    See Also:
    
    setXAxis(Vector), yAxis(), zAxis()
  - yAxis
```
public Vector yAxis()
```
    Same as return yAxis(true)
    
    See Also:
    
    yAxis(boolean)
  - yAxis
```
public Vector yAxis(boolean positive)
```
    Returns the y-axis of the node, represented as a normalized vector defined in the world coordinate system.
    
    See Also:
    
    setYAxis(Vector), xAxis(), zAxis()
  - zAxis
```
public Vector zAxis()
```
    Same as return zAxis(true)
    
    See Also:
    
    zAxis(boolean)
  - zAxis
```
public Vector zAxis(boolean positive)
```
    Returns the z-axis of the node, represented as a normalized vector defined in the world coordinate system.
    
    See Also:
    
    setZAxis(Vector), xAxis(), yAxis()
  - matrix
```
public Matrix matrix()
```
    Returns the local transformation matrix represented by the node.
    This matrix only represents the local node transformation (i.e., with respect to the reference()). Use worldMatrix() to get the full Node transformation matrix (i.e., from the world to the Node coordinate system). These two match when the reference() is null.
    Use this method to manually traverse the node tree hierarchy:
    push();
    applyMatrix(node.matrix());
    // You are in the local node coordinate system.
    pop();
    
    See Also:
    
    set(Node), worldMatrix(), view(), viewInverse()
  - worldMatrix
```
public Matrix worldMatrix()
```
    Returns the global transformation matrix represented by the node which grants direct access to it, without the need to traverse its ancestor hierarchy first (as it is the case with matrix()).
    This matrix represents the global node transformation: the entire reference() hierarchy is taken into account to define the node transformation from the world coordinate system. Use matrix() to get the local node transformation matrix (i.e. defined with respect to the reference()). These two match when the reference() is null.
    
    See Also:
    
    set(Node), matrix(), view(), viewInverse()
  - view
```
public Matrix view()
```
    Returns the inverse of the matrix associated with the node position and orientation that is to be used when the node represents an eye. This matrix matches the inverted of the worldMatrix() when magnitude() is 1.
    The view matrix converts from the world coordinates system to the eye coordinates system, so that coordinates can then be projected on screen using a projection matrix.
    
    See Also:
    
    Matrix.view(Vector, Quaternion), viewInverse(), matrix(), worldMatrix(), set(Node), set(Node)
  - viewInverse
```
public Matrix viewInverse()
```
    Returns the inverse of the view() matrix. This matrix matches the worldMatrix() when worldMagnitude() is 1.
    This matrix converts from the eye to world space.
    
    See Also:
    
    view(), matrix(), worldMatrix(), set(Node)
  - fromMatrix
```
public void fromMatrix(Matrix matrix)
```
    Sets the node from a matrix() representation: orientation and magnitude in the upper left 3x3 matrix and position on the last column.
    
    See Also:
    
    fromWorldMatrix(Matrix), matrix()
  - fromWorldMatrix
```
public void fromWorldMatrix(Matrix matrix)
```
    Sets the node from worldMatrix() representation: orientation and magnitude in the upper left 3x3 matrix and position on the last column.
    Hence, if your openGL code fragment looks like:
    float [] m = new float [16]; m[0]=...;
    gl.glMultMatrixf(m);
    
    It is equivalent to write:
    Node node = new Node();
    node.fromWorldMatrix(m);
    graph.applyWorldTransformation(node);
    // You are in the local node coordinate system.
    
    Which allows to apply local transformations to the node while using geometry data from other node instances when necessary (see location(Vector, Node) and displacement(Vector, Node)).
    
    See Also:
    
    fromMatrix(Matrix), worldMatrix()
  - inverse
```
public Node inverse()
```
  - inverse
```
public Node inverse(boolean attach)
```
    Returns a node representing the inverse of this node space transformation.
    The new node orientation() is the Quaternion.inverse() of the original orientation. Its position() is the negated inverse rotated image of the original position. Its magnitude() is 1 / original magnitude.
    If a node is considered as a space rigid transformation, i.e., position and orientation, but no magnitude (magnitude=1), the inverse() node performs the inverse transformation.
    Only the local node transformation (i.e., defined with respect to the reference()) is inverted. Use worldInverse() for a global inverse.
    The resulting node has the same reference() as the this node.
    
    See Also:
    
    worldInverse()
  - worldInverse
```
public Node worldInverse()
```
  - worldInverse
```
public Node worldInverse(boolean attach)
```
    Returns the inverse() of the node world transformation.
    The worldOrientation() of the new node is the Quaternion.inverse() of the original orientation. Its worldPosition() is the negated and inverse rotated image of the original position. The worldMagnitude() is the original magnitude multiplicative inverse.
    Use inverse() for a local (i.e., with respect to reference()) transformation inverse.
    
    See Also:
    
    inverse()
  - displacement
```
public float displacement(float scalar)
```
    Converts scalar displacement from world to this node. Same as return displacement(scalar, null). displacement(Vector) converts vector displacements instead of scalar displacements. displacement(Quaternion) converts quaternion displacements instead of scalar displacements. location(Vector) converts locations instead of displacements.
    
    See Also:
    
    displacement(float, Node), displacement(Vector), displacement(Quaternion), location(Vector)
  - displacement
```
public float displacement(float scalar,
                          Node node)
```
    Converts scalar displacement from node to this node. Use node.displacement(scalar, this) to perform the inverse transformation. displacement(Vector, Node) converts vector displacements instead of scalar displacements. displacement(Quaternion, Node) converts quaternion displacements instead of scalar displacements. location(Vector, Node) converts locations instead of displacements.
    
    See Also:
    
    displacement(float), displacement(Quaternion), displacement(Vector), worldDisplacement(Vector)
  - worldDisplacement
```
public float worldDisplacement(float scalar)
```
    Converts scalar displacement from this node to world. displacement(float) performs the inverse transformation. worldDisplacement(Vector) converts vector displacements instead of scalar displacements. worldDisplacement(Quaternion) converts quaternion displacements instead of scalar displacements. worldLocation(Vector) converts locations instead of displacements.
    
    See Also:
    
    location(Vector), worldDisplacement(Vector), worldDisplacement(Quaternion), displacement(float, Node)
  - localDisplacement
```
public float localDisplacement(float scalar)
```
    Converts scalar displacement from reference() to this node.
    referenceDisplacement(float) performs the inverse transformation.
    
    See Also:
    
    displacement(Quaternion), displacement(Vector)
  - referenceDisplacement
```
public float referenceDisplacement(float scalar)
```
    Converts scalar displacement from this node to reference().
    localDisplacement(float) performs the inverse transformation.
    
    See Also:
    
    worldDisplacement(Quaternion), worldDisplacement(Vector)
  - displacement
```
public Quaternion displacement(Quaternion quaternion)
```
    Converts quaternion displacement from world to this node. Same as return displacement(quaternion, null). displacement(Vector) converts vector displacements instead of quaternion displacements. displacement(float) converts scalar displacements instead of quaternion displacements. location(Vector) converts locations instead of displacements.
    
    See Also:
    
    displacement(Quaternion, Node), displacement(Vector), displacement(float), location(Vector)
  - displacement
```
public Quaternion displacement(Quaternion quaternion,
                               Node node)
```
    Converts quaternion displacement from node to this node. Use node.displacement(quaternion, this) to perform the inverse transformation. displacement(Vector, Node) converts vector displacements instead of quaternion displacements. displacement(float, Node) converts scalar displacements instead of quaternion displacements. location(Vector, Node) converts locations instead of displacements.
    
    See Also:
    
    displacement(Quaternion), displacement(Vector), displacement(float), worldDisplacement(Vector)
  - worldDisplacement
```
public Quaternion worldDisplacement(Quaternion quaternion)
```
    Converts quaternion displacement from this node to world. displacement(Vector) performs the inverse transformation. worldDisplacement(Vector) converts vector displacements instead of quaternion displacements. worldDisplacement(float) converts scalar displacements instead of quaternion displacements. worldLocation(Vector) converts locations instead of displacements.
    
    See Also:
    
    location(Vector), worldDisplacement(Vector), worldDisplacement(float), displacement(Quaternion, Node)
  - localDisplacement
```
public Quaternion localDisplacement(Quaternion quaternion)
```
    Converts quaternion displacement from reference() to this node.
    referenceDisplacement(Quaternion) performs the inverse transformation. localLocation(Vector) converts locations instead of displacements.
    
    See Also:
    
    displacement(Quaternion), displacement(Vector)
  - referenceDisplacement
```
public Quaternion referenceDisplacement(Quaternion quaternion)
```
    Converts quaternion displacement from this node to reference().
    localDisplacement(Quaternion) performs the inverse transformation. referenceLocation(Vector) converts locations instead of displacements.
    
    See Also:
    
    worldDisplacement(Quaternion), worldDisplacement(Vector)
  - displacement
```
public Vector displacement(Vector vector)
```
    Converts vector displacement from world to this node. Same as return displacement(vector, null). displacement(Quaternion) converts quaternion displacements instead of vector displacements. location(Vector) converts locations instead of displacements.
    
    See Also:
    
    displacement(Vector, Node), displacement(Quaternion), location(Vector)
  - displacement
```
public Vector displacement(Vector vector,
                           Node node)
```
    Converts vector displacement from node to this node. Use node.displacement(vector, this) to perform the inverse transformation. displacement(Quaternion, Node) converts quaternion displacements instead of vector displacements. location(Vector, Node) converts locations instead of displacements.
    
    See Also:
    
    displacement(Vector), displacement(Quaternion), worldDisplacement(Vector)
  - worldDisplacement
```
public Vector worldDisplacement(Vector vector)
```
    Converts vector displacement from this node to world. displacement(Vector) performs the inverse transformation. worldDisplacement(Quaternion) converts quaternion displacements instead of vector displacements. worldLocation(Vector) converts locations instead of displacements.
    
    See Also:
    
    location(Vector), worldDisplacement(Quaternion), displacement(Vector, Node)
  - localDisplacement
```
public Vector localDisplacement(Vector vector)
```
    Converts vector displacement from reference() to this node.
    referenceDisplacement(Vector) performs the inverse transformation. localLocation(Vector) converts locations instead of displacements.
    
    See Also:
    
    displacement(Vector)
  - referenceDisplacement
```
public Vector referenceDisplacement(Vector vector)
```
    Converts vector displacement from this node to reference().
    localDisplacement(Vector) performs the inverse transformation. referenceLocation(Vector) converts locations instead of displacements.
    
    See Also:
    
    worldDisplacement(Vector)
  - location
```
public Vector location(Node node)
```
    Converts the node origin location to this node. Same as return location(new Vector(), node). displacement(Vector, Node) converts vector displacements instead of locations. displacement(Quaternion, Node) converts quaternion displacements instead of locations.
    
    See Also:
    
    location(Vector), location(Vector, Node), displacement(Vector, Node), displacement(Quaternion, Node)
  - location
```
public Vector location(Vector vector)
```
    Converts vector location from world to this node. Same as return location(vector, null). displacement(Vector) converts vector displacements instead of locations. displacement(Quaternion) converts quaternion displacements instead of locations.
    
    See Also:
    
    location(Node), location(Vector, Node), displacement(Vector), displacement(Quaternion)
  - location
```
public Vector location(Vector vector,
                       Node node)
```
    Converts vector location from node to this node. Use node.location(vector, this) to perform the inverse transformation. displacement(Vector, Node) converts vector displacements instead of locations. displacement(Quaternion, Node) converts quaternion displacements instead of locations.
    
    See Also:
    
    location(Node), location(Vector), worldLocation(Vector)
  - worldLocation
```
public Vector worldLocation(Vector vector)
```
    Converts vector location from this node to world. location(Vector) performs the inverse transformation. worldDisplacement(Vector) converts vector displacements instead of locations. worldDisplacement(Quaternion) converts quaternion displacements instead of locations.
    
    See Also:
    
    displacement(Vector), displacement(Quaternion), location(Vector, Node)
  - localLocation
```
public Vector localLocation(Vector vector)
```
    Converts vector location from reference() to this node.
    referenceLocation(Vector) performs the inverse transformation. localDisplacement(Vector) converts displacements instead of locations.
    
    See Also:
    
    location(Vector)
  - referenceLocation
```
public Vector referenceLocation(Vector vector)
```
    Converts vector location from this node to reference().
    localLocation(Vector) performs the inverse transformation. referenceDisplacement(Vector) converts displacements instead of locations.
    
    See Also:
    
    worldLocation(Vector)
  - isTagged
```
public boolean isTagged(Graph graph)
```
    Returns true if the node has been tagged by the graph at least once and false otherwise.
    
    See Also:
    
    Graph.hasTag(String, Node), Graph.hasTag(Node)
  - setBehavior
```
public void setBehavior(Graph graph,
                        BiConsumer<Graph,Node> behavior)
```
    Same as graph.addBehavior(this, behavior).
    
    See Also:
    
    setBehavior(Graph, Consumer), Graph.addBehavior(Node, BiConsumer), Graph.addBehavior(Node, Consumer)
  - setBehavior
```
public void setBehavior(Graph graph,
                        Consumer<Graph> behavior)
```
    Same as graph.addBehavior(this, (g, n) -> behavior.accept(g)).
    
    See Also:
    
    setBehavior(Graph, BiConsumer), Graph.addBehavior(Node, BiConsumer), Graph.addBehavior(Node, Consumer)
  - resetBehavior
```
public void resetBehavior(Graph graph)
```
    Same as graph.resetBehavior(this).
    
    See Also:
    
    Graph.resetBehavior(Node)
  - bypass
```
public void bypass()
```
    Bypass rendering the node for the current frame. Set it before calling Graph.render() or any rendering algorithm. Note that the node nor its children get culled.
  - resetShape
```
public void resetShape()
```
    Calls resetIMRShape() and resetRMRShape().
    
    See Also:
    
    setShape(processing.core.PShape), setShape(Consumer)
  - resetRMRShape
```
public void resetRMRShape()
```
    Resets the retained-mode rendering shape.
    
    See Also:
    
    setShape(Consumer)
  - resetIMRShape
```
public void resetIMRShape()
```
    Resets the immediate-mode rendering shape.
    
    See Also:
    
    setShape(processing.core.PShape)
  - setShape
```
public void setShape(Node node)
```
    Sets this shape from the node shape.
  - setShape
```
public void setShape(PShape shape)
```
    Sets the node retained mode rendering (rmr) SHAPE hint (see hint()). Use enableHint(Node.SHAPE), disableHint(Node.SHAPE) and toggleHint(Node.SHAPE) to (dis)enable the hint.
    
    See Also:
    
    setShape(Consumer), resetShape(), resetIMRShape(), resetRMRShape()
  - setShape
```
public void setShape(Consumer<PGraphics> callback)
```
    Sets the node immediate mode rendering (imr) SHAPE procedure hint (see hint()). Use enableHint(Node.SHAPE), disableHint(Node.SHAPE) and toggleHint(Node.SHAPE) to (dis)enable the hint.
    
    See Also:
    
    setShape(processing.core.PShape), resetShape(), resetIMRShape(), resetRMRShape()
  - setInteraction
```
public void setInteraction(Consumer<Object[]> callback)
```
    Sets the node interaction procedure callback which is a function implemented by a Node derived class and which takes no params, or a gesture encoded as an array of on Object params.
    The interaction is performed either after calling the Graph.interact(String, Object...), Graph.interact(Object...) or Graph.interact(Node, Object...) scene procedures.
    Same as setInteraction((n, o) -> callback.accept(o)).
    
    See Also:
    
    setInteraction(BiConsumer)
  - setInteraction
```
public void setInteraction(BiConsumer<Node,Object[]> callback)
```
    Sets the node interaction procedure callback which is a function that takes a node param (holding this node instance) and, optionally, a gesture encoded as an array of on Object params.
    The interaction is performed either after calling the Graph.interact(String, Object...), Graph.interact(Object...) or Graph.interact(Node, Object...) scene procedures.
    
    See Also:
    
    setInteraction(Consumer)
  - interact
```
public void interact(Object[] gesture)
```
    Parse gesture params. Useful to customize the node behavior. Default implementation is empty. , i.e., it is meant to be implemented by derived classes.
    
    See Also:
    
    setInteraction(BiConsumer), setInteraction(Consumer)
  - resetHUD
```
public void resetHUD()
```
    Same as calling resetRMRHUD() and resetIMRHUD().
  - resetRMRHUD
```
public void resetRMRHUD()
```
    Same as setRMRShape(null).
    
    See Also:
    
    setShape(processing.core.PShape)
  - resetIMRHUD
```
public void resetIMRHUD()
```
    Same as setIMRShape(null).
    
    See Also:
    
    setShape(Consumer)
  - setHUD
```
public void setHUD(Node node)
```
    Sets this (H)eads (U)p (D)isplay from the node hud.
  - setHUD
```
public void setHUD(PShape shape)
```
    Sets the node retained mode rendering (rmr) shape HUD hint (see hint()). The 2D shape screen coordinates are interpreted relative to the node worldPosition() screen projection when the hint is rendered (Graph.render(Node)). Use enableHint(Node.HUD), disableHint(Node.HUD) and toggleHint(Node.HUD) to (dis)enable the hint.
    
    See Also:
    
    setHUD(Consumer), resetHUD(), resetIMRHUD(), resetRMRHUD()
  - setHUD
```
public void setHUD(Consumer<PGraphics> callback)
```
    Sets the node immediate mode rendering (imr) drawing procedure HUD hint (see hint()). The 2D shape screen coordinates are interpreted relative to the node worldPosition() screen projection when the hint is rendered (Graph.render(Node)). Use enableHint(Node.HUD), disableHint(Node.HUD) and toggleHint(Node.HUD) to (dis)enable the hint.
    
    See Also:
    
    setShape(processing.core.PShape), resetHUD(), resetIMRHUD(), resetRMRHUD()
  - isPickingEnabled
```
public boolean isPickingEnabled(int hint)
```
    Returns whether or not all hints encoded in the bitwise-or hint mask are enable for node picking with ray casting.
    
    See Also:
    
    picking(), resetPicking(), resetPicking(), disablePicking(int), enablePicking(int), togglePicking(int), hint(), isHintEnabled(int)
  - picking
```
public int picking()
```
    Returns the current visual picking hint mask encoding the visual aspects that are to be taken into account for picking the node with ray casting. Refer to hint() to learn how to configure the mask.
    Note that picking a node from one of its visual aspects requires both the hint() and this mask to have enabled the same aspects.
    
    See Also:
    
    picking(), resetPicking(), disablePicking(int), enablePicking(int), togglePicking(int), isPickingEnabled(int), hint(), isHintEnabled(int), resetHint(), disableHint(int), enableHint(int), toggleHint(int)
  - resetPicking
```
public void resetPicking()
```
    Resets picking(), i.e., disables all single visual hints available for node picking with ray casting.
    
    See Also:
    
    picking(), resetPicking(), disablePicking(int), enablePicking(int), togglePicking(int), isPickingEnabled(int), hint(), isHintEnabled(int), resetHint(), disableHint(int), enableHint(int), toggleHint(int)
  - disablePicking
```
public void disablePicking(int hint)
```
    Disables all the single visual hints encoded in the bitwise-or hint mask.
    
    See Also:
    
    picking(), resetPicking(), resetPicking(), disablePicking(int), enablePicking(int), togglePicking(int), isPickingEnabled(int), hint(), isHintEnabled(int), resetHint(), disableHint(int), enableHint(int), toggleHint(int)
  - enablePicking
```
public void enablePicking(int picking)
```
    Enables all single visual hints encoded in the bitwise-or pickingMode mask.
    
    See Also:
    
    picking(), resetPicking(), disablePicking(int), enablePicking(int), togglePicking(int), isPickingEnabled(int), hint(), isHintEnabled(int), resetHint(), disableHint(int), enableHint(int), toggleHint(int)
  - togglePicking
```
public void togglePicking(int hint)
```
    Toggles all single visual hints encoded in the bitwise-or hint mask.
    
    See Also:
    
    resetPicking(), resetPicking(), disablePicking(int), enablePicking(int), togglePicking(int), isPickingEnabled(int), hint(), isHintEnabled(int), resetHint(), disableHint(int), enableHint(int), toggleHint(int)
  - isHintEnabled
```
public boolean isHintEnabled(int hint)
```
    Returns whether or not all single visual hints encoded in the bitwise-or hint mask are enable or not.
    
    See Also:
    
    hint(), enableHint(int), configHint(int, Object...), enableHint(int, Object...), disableHint(int), toggleHint(int), resetHint(), picking(), enablePicking(int), disablePicking(int), togglePicking(int), isPickingEnabled(int), resetPicking()
  - hint
```
public int hint()
```
    Returns the current visual hint mask. The mask is a bitwise-or of the following single visual hints available for the node:
    
    CAMERA which displays a camera hint centered at the node screen projection.
    
    AXES which displays an axes hint centered at the node worldPosition() an oriented according to the node worldOrientation().
    
    HUD which displays the node Heads-Up-Display set with setHUD(processing.core.PShape) or setHUD(Consumer).
    
    BOUNDS which displays the bounding volume of each graph for which this node is the eye. Only meaningful if there's a second scene perspective to look at this eye node from.
    
    SHAPE which displays the node shape set with setShape(processing.core.PShape) or setShape(Consumer).
    
    BULLSEYE which displays a bullseye centered at the node worldPosition() screen projection. Call setBullsEyeSize(float) to set the size of the hint
    
    TORUS which displays a torus solenoid.
    
    Displaying the hint requires first to enabling it (see enableHint(int)) and then calling a Graph rendering algorithm.
    See Also:
    
    enableHint(int), configHint(int, Object...), enableHint(int, Object...), disableHint(int), toggleHint(int), isHintEnabled(int), resetHint(), picking(), enablePicking(int), disablePicking(int), togglePicking(int), isPickingEnabled(int), resetPicking()
  - resetHint
```
public void resetHint()
```
    Resets the current hint(), i.e., disables all single visual hints available for the node.
    
    See Also:
    
    hint(), enableHint(int), configHint(int, Object...), enableHint(int, Object...), disableHint(int), toggleHint(int), isHintEnabled(int), picking(), enablePicking(int), disablePicking(int), togglePicking(int), isPickingEnabled(int), resetPicking()
  - disableHint
```
public void disableHint(int hint)
```
    Disables all the single visual hints encoded in the bitwise-or hint mask.
    
    See Also:
    
    hint(), enableHint(int), configHint(int, Object...), enableHint(int, Object...), resetHint(), toggleHint(int), isHintEnabled(int), picking(), enablePicking(int), disablePicking(int), togglePicking(int), isPickingEnabled(int), resetPicking()
  - enableHint
```
public void enableHint(int hint,
                       Object... params)
```
    Calls enableHint(int) followed by configHint(int, Object...).
    
    See Also:
    
    hint(), enableHint(int), configHint(int, Object...), disableHint(int), resetHint(), toggleHint(int), isHintEnabled(int), picking(), enablePicking(int), disablePicking(int), togglePicking(int), isPickingEnabled(int), resetPicking()
  - enableHint
```
public void enableHint(int hint)
```
    Enables all single visual hints encoded in the bitwise-or hint mask.
    
    See Also:
    
    hint(), disableHint(int), configHint(int, Object...), enableHint(int, Object...), resetHint(), toggleHint(int), isHintEnabled(int), picking(), enablePicking(int), disablePicking(int), togglePicking(int), isPickingEnabled(int), resetPicking()
  - toggleHint
```
public void toggleHint(int hint)
```
    Toggles all single visual hints encoded in the bitwise-or hint mask.
    
    See Also:
    
    hint(), disableHint(int), configHint(int, Object...), enableHint(int, Object...), resetHint(), enableHint(int), isHintEnabled(int), picking(), enablePicking(int), disablePicking(int), togglePicking(int), isPickingEnabled(int), resetPicking()
  - configHint
```
public void configHint(int hint,
                       Object... params)
```
    Configures the hint using varargs as follows:
    
    CAMERA hint: configHint(Node.CAMERA, cameraStroke) or configHint(Node.CAMERA, cameraStroke, cameraLength).
    
    AXES hint: configHint(Node.AXES, axesLength).
    
    BULLSEYE hint: configHint(Node.BULLSEYE, bullseyeStroke), configHint(Node.BULLSEYE, bullseyeShape), or configHint(Node.BULLSEYE, bullseyeStroke, bullseyeShape).
    
    TORUS hint: configHint(Node.TORUS, torusStroke), or configHint(Node.TORUS, torusStroke, torusFaces).
    
    BOUNDS hint: configHint(Node.BOUNDS, boundsWeight).
    
    KEYFRAMES hint: configHint(Node.KEYFRAMES, keyframesMask) or configHint(Node.KEYFRAMES, keyframesMask, steps) or configHint(Node.KEYFRAMES, keyframesMask, steps, splineStroke), or configHint(Node.KEYFRAMES, keyframesMask, steps, splineStroke, splineWeight).
    
    Note that the cameraStroke, splineStroke, bullseyeStroke and torusStroke are color int vars; cameraLength and exesLength are world magnitude numerical values; highlight is a numerical value in [0..1] which represents the scale factor to be applied to the node when it gets tagged (see Graph.tag(String, Node)); bullseyeShape is either of type Node.BullsEyeShape.SQUARE or Node.BullsEyeShape.CIRCLE; graph is of type Graph; graph may be of type PGraphics; and, boundsWeight is an int defining the bounds stroke and splineWeight is an int defining the spline stroke.
    See Also:
    
    hint(), enableHint(int), enableHint(int, Object...), disableHint(int), toggleHint(int), isHintEnabled(int), resetHint(), picking(), enablePicking(int), disablePicking(int), togglePicking(int), isPickingEnabled(int), resetPicking()
  - isEye
```
public boolean isEye()
```
    Returns whether or not this node is some graph Graph.eye().
  - isEye
```
public boolean isEye(Graph graph)
```
    Returns whether or not this node is the given graph Graph.eye().
  - animate
```
public void animate()
```
    Run the animation defined by the node keyframes.
  - animate
```
public void animate(float speed)
```
    Run the animation with the given speed defined by the node keyframes.
  - toggleAnimation
```
public void toggleAnimation()
```
    Toggles the node animation.
  - resetAnimation
```
public void resetAnimation()
```
    Resets the node animation.
  - animationTime
```
public float animationTime()
```
    Returns the current interpolation time (in milliseconds) along the keyframes path.
  - setAnimationTime
```
public void setAnimationTime(float time)
```
    Sets the animation time (in milliseconds) used for the next animate() call.
  - addKeyFrame
```
public void addKeyFrame()
```
    Adds a node copy as keyframe at 0 time if there are no currently keyframes in the path. Otherwise the keyframe is added 1000 milliseconds after the previously added one.
    
    See Also:
    
    addKeyFrame(Node, float), addKeyFrame(int, float), addKeyFrame(Node)
  - addKeyFrame
```
public void addKeyFrame(int hint,
                        float time)
```
    Adds a node copy as a keyframe at time (in milliseconds) and a mask hint.
  - addKeyFrame
```
public void addKeyFrame(Node node)
```
    Adds node (as is) as a keyframe.
  - addKeyFrame
```
public void addKeyFrame(Node node,
                        float time)
```
    Adds node (as is) as a keyframe at the given time (in milliseconds).
  - removeKeyFrame
```
public Node removeKeyFrame(float time)
```
    Remove the closest keyframe to time (in milliseconds) and returns it. May return null if the interpolator is empty.
  - removeKeyFrames
```
public void removeKeyFrames()
```
    Removes all keyframes from the animation path.
  - interpolate
```
public void interpolate(float time)
```
    Interpolate the node at the given time (in milliseconds) along the keyframes path.
  - animationRecurrence
```
public boolean animationRecurrence()
```
    Tells whether or not the keyframes animation is recurrent or not.
  - setAnimationRecurrence
```
public void setAnimationRecurrence(boolean enable)
```
    Enables (or disables) the recurrence of the keyframes animation.

Class Node

Hierarchy of nodes

Geometry transformations

Hierarchical traversals

Motion filters

Visual hints

Ray casting

Keyframe's based interpolated animations

Custom behaviors

Custom user interactions

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

cull

tagging

cacheTranslationParams

cacheTargetPosition

cacheTargetTranslation

cacheRotationParams

cacheTargetOrientation

cacheTargetRotation

cacheScalingParams

cacheTargetMagnitude

cacheTargetScaling

cachePosition

cacheOrientation

cacheMagnitude

CAMERA

AXES

HUD

SHAPE

BOUNDS

BULLSEYE

TORUS

FILTER

BONE

KEYFRAMES

maxSteps

translationAxisFilter

forbidTranslationFilter

translationPlaneFilter

rotationAxisFilter

forbidRotationFilter

minMaxScalingFilter

forbidScalingFilter

Constructor Detail

Node

Node

Node

Node

Node

Node

Node

Node

Node

Node

Node

Node

Node

Node

Node

Node

Node

Node

Method Detail

matches

toString

copy

copy

set

reset

id

colorID

redID

greenID

blueID

colorID