Direct Known Subclasses:

Scene
```
public class Graph
extends Object
```
A 2D or 3D scene-graph providing a (default) eye() node, input and timing handling to a raster or ray-tracing renderer.
1. Types and dimensions
The way the projection matrix is computed (see projection()), defines the type of the graph as: Graph.Type.PERSPECTIVE, Graph.Type.ORTHOGRAPHIC for 3d graphs and Graph.Type.TWO_D for a 2d graph.
To set up scene dimensions call setBoundingBall(Vector, float). The resulting ball is then used to:
1. optimally compute the zNear() and zFar() clipping planes
2. implement eye() motion interactions in methods such as turn(float, float, float), spin(int, int, int, int) or shift(float, float, float); and,
3. to interpolate the eye() when calling fit(float), among others
Use setZNear(Supplier) and setZFar(Supplier) to customized the z-near and z-far computations.
To only affect eye motions interactions and interpolations (while leaving the current z-near and z-far computations unaffected) call setCenter(Vector) and setRadius(float).
2. Scene-graph handling
A graph forms a tree of Nodes whose visual representations may be render(). To render a subtree call render(Node). Note that rendering routines should be called within your main-event loop.
The node collection belonging to the graph may be retrieved with nodes(). Nub provides other useful routines to handle the hierarchy, such as Node.setReference(Node), Node.detach(), Node.attach(), branch(Node), and clearTree().
The eye
Any Node (belonging or not to the graph hierarchy) may be set as the eye() (see setEye(Node)). Several functions handle the eye, such as lookAt(Vector), at(), setViewDirection(Vector), setUpVector(Vector), upVector(), fitFOV(), fov(), fit(), lookAround(float, float), cad(float, float), and moveForward(float).
2.1. Transformations
The graph acts as interface between screen space (a box of width() * height() * 1 dimensions), from where user gesture data is gathered, and the nodes. To transform points from/to screen space to/from node space use location(Vector, Node) and screenLocation(Vector, Node). To transform vectors from/to screen space to/from node space use displacement(Vector, Node) and screenDisplacement(Vector, Node).
3. Picking and interaction
Picking a node to interact with it is a two-step process:
1. Tag the node using an arbitrary name (which may be null) either with tag(String, Node)) or ray-casting: updateTag(String, int, int, Node[]), updateTag(String, int, int) or tag(String, int, int). While updateTag(String, int, int, Node[]) and updateTag(String, int, int) update the tagged node synchronously (i.e., they return the tagged node immediately), tag(String, int, int) updates it asynchronously (i.e., it optimally updates the tagged node during the next call to the render() or render(Node) algorithms); and,
2. Interact with your tagged nodes by calling any of the following methods: align(String), focus(String), shift(String, float, float, float, float), turn(String, float, float, float, float), zoom(String, float, float), or spin(String, int, int, int, int, float)).
Observations:
1. Refer to Node.bullsEyeSize() (and Node.setBullsEyeSize(float)) for the different ray-casting node picking policies.
2. To check if a given node would be picked with a ray casted at a given screen position, call tracks(Node, int, int).
3. To interact with the node that is referred with the null tag, call any of the following methods: align(), focus(), shift(float, float, float, float), turn(float, float, float, float), zoom(float, float) and spin(int, int, int, int, float)).
4. To directly interact with a given node, call any of the following methods: align(Node), focus(Node), shift(Node, float, float, float, float), turn(Node, float, float, float, float), zoom(Node, float, float) and spin(Node, int, int, int, int, float)).
5. To either interact with the node referred with a given tag or the eye, when that tag is not in use, call any of the following methods: align(Node), focus(String), shift(String, float, float, float, float), turn(String, float, float, float, float), zoom(String, float, float) and spin(String, int, int, int, int, float).
6. Set Graph.inertia in [0..1] (0 no inertia & 1 no friction) to change the default inertia value globally, instead of setting it on a per method call basis. Note that it is initially set to 0.8.
7. Customize node behaviors by overridden Node.interact(Object...) and then invoke them by either calling: interact(Object...), interact(String, Object...) or interact(Node, Object...).
4. Visibility and culling techniques
Geometry may be culled against the viewing volume by calling isPointVisible(Vector), ballVisibility(Vector, float) or boxVisibility(Vector, Vector).
5. Matrix handling
The graph performs matrix handling through a matrix-handler. Refer to the MatrixHandler documentation for details.
To define your geometry on the screen coordinate system (such as when drawing 2d controls on top of a 3d graph) issue your drawing code between beginHUD() and endHUD(). These methods are MatrixHandler wrapper functions with the same signatures provided for convenience.
See Also:

MatrixHandler

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`Graph.Type`	Enumerates the graph types.
`static class`	`Graph.Visibility`	Enumerates the different visibility states an object may have respect to the bounding volume.

Field Summary

Fields
Modifier and Type Field Description

static boolean _seeded

static float inertia

static boolean leftHanded

boolean picking

static Random random

Constructor Summary

Constructors
Constructor	Description
`Graph(Object context, int width, int height)`	Same as `this(context, width, height, Type.PERSPECTIVE)`.
`Graph(Object context, int width, int height, Node eye)`	Same as `this(context, width, height, eye, Type.PERSPECTIVE)`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addBehavior(Node node, BiConsumer<Graph,Node> behavior)`	Adds a custom node behavior to be executed for this scene `render()` algorithm.
`void`	`addBehavior(Node node, Consumer<Node> behavior)`	Same as `setBehavior(node, (g, n) -> behavior.accept(n))`.
`void`	`align()`	Same as `align((String)null)`.
`void`	`align(String tag)`	Same as `if (tag == null \|\| node(tag) != null) align(node(tag))`.
`void`	`align(Node node)`	Aligns the node (use null for the world) with the `eye()`.
`float`	`aspectRatio()`	Returns the `width()` to `height()` aspect ratio of the display window.
`Vector`	`at()`	2D eyes return the position.
`Graph.Visibility`	`ballVisibility(Vector center, float radius)`	Returns `Graph.Visibility.VISIBLE`, `Graph.Visibility.INVISIBLE`, or `Graph.Visibility.SEMIVISIBLE`, depending whether the ball (of radius `radius` and center `center`) is visible, invisible, or semi-visible, respectively.
`float`	`ballZFar()`	The far clipping plane is positioned at a distance equal to `zClippingCoefficient() * radius()` behind the `center()`:
`float`	`ballZNear()`	The clipping planes' positions depend on the `radius()` and `center()` rather than being fixed small-enough and large-enough values.
`void`	`beginHUD()`	Begin Heads Up Display (HUD) so that drawing can be done using 2D screen coordinates.
`float[][]`	`bounds()`	Returns the bounds plane equations.
`Graph.Visibility`	`boxVisibility(Vector corner1, Vector corner2)`	Returns `Graph.Visibility.VISIBLE`, `Graph.Visibility.INVISIBLE`, or `Graph.Visibility.SEMIVISIBLE`, depending whether the axis aligned box (defined by corners `p1` and `p2`) is visible, invisible, or semi-visible, respectively.
`static List<Node>`	`branch(Node node)`	Collects `node` and all its descendant nodes.
`void`	`cad(float roll, float pitch)`	Same as `rotateCAD(roll, pitch, new Vector(0, 1, 0), Graph.inertia)`.
`void`	`cad(float roll, float pitch, Vector upVector)`	Same as `rotateCAD(roll, pitch, upVector, Graph.inertia)`.
`void`	`cad(float roll, float pitch, Vector upVector, float inertia)`	Defines an axis which the eye rotates around.
`static Float`	`castToFloat(Object o)`	Cast `o` to a `Float`.
`static Integer`	`castToInt(Object o)`	Cast `o` to an `Integer`.
`Vector`	`center()`	Center of the ball (defined in world coordinates) used in eye motions interaction (e.g., `shift(float, float, float)`, `spin(int, int, int, int)`, `turn(float, float, float)`) and interpolation routines (e.g., `fit()`).
`void`	`clearTags()`	Removes all tags so that `node(String)` returns `null`.
`static void`	`clearTree()`	Same as `for(Node node : _leadingNodes()) detach(node)`.
`void`	`closeContext()`	Ends the rendering process (see `render(Node)`).
`Object`	`context()`	Returns the main renderer context.
`void`	`disableTagging(Node node)`	Disables tagging the node.
`Vector`	`displacement(Vector vector)`	Same as `return displacement(vector, null)`.
`Vector`	`displacement(Vector vector, Node node)`	Converts `vector` displacement given in screen space to the `node` coordinate system.
`float`	`distanceToBound(int index, Vector position)`	Returns the signed distance between point `position` and plane `index` in world units.
`void`	`draw()`	Paint method which is called just after your main event loop.
`void`	`endHUD()`	Ends Heads Up Display (HUD).
`Node`	`eye()`	Returns the associated eye.
`void`	`fit()`	Moves the eye so that the ball defined by `center()` and `radius()` is visible and fits the window.
`void`	`fit(float duration)`	Moves the eye during `duration` milliseconds so that the ball defined by `center()` and `radius()` is visible and fits the window.
`void`	`fit(int x, int y, int width, int height)`	Moves the eye so that the rectangular screen region defined by `x, y, width, height` (pixel units, with origin in the upper left corner) fits the screen.
`void`	`fit(int x, int y, int width, int height, float duration)`	Smoothly moves the eye during `duration` milliseconds so that the rectangular screen region defined by `rectangle` (pixel units, with origin in the upper left corner) fits the screen.
`void`	`fit(Node node)`	Convenience function that simply calls `fit(node, 0)`.
`void`	`fit(Node node, float duration)`	Smoothly interpolates the eye on a interpolator path so that it goes to `node`.
`void`	`fit(Vector corner1, Vector corner2)`	Moves the eye so that the world axis aligned box defined by `corner1` and `corner2` is entirely visible.
`void`	`fit(Vector corner1, Vector corner2, float duration)`	Smoothly moves the eye during `duration` milliseconds so that the world axis aligned box defined by `corner1` and `corner2` is entirely visible.
`void`	`fitFOV()`	Changes the `eye()` `fov()` so that the entire scene (defined by `center()` and `radius()`) is visible.
`void`	`fitFOV(float duration)`	Rescales the `fov()` `duration` milliseconds so that the ball defined by `center` and `radius` is visible and fits the window.
`void`	`focus()`	Same as `focus((String)null)`.
`void`	`focus(String tag)`	Same as `if (tag == null \|\| node(tag) != null) focus(node(tag))`.
`void`	`focus(Node node)`	Focuses the node (use null for the world) with the `eye()`.
`float`	`fov()`	Retrieves the scene field-of-view in radians.
`boolean`	`hasFocus(int pixelX, int pixelY)`	Returns whether or not the scene has focus or not under the given pixel.
`boolean`	`hasTag(String tag, Node node)`	Returns `true` if `node(tag)` (see `node(String)`) returns `node` and `false` otherwise.
`boolean`	`hasTag(Node node)`	Same as `return hasTag(null, node)`.
`int`	`height()`	Returns height of the screen window.
`float`	`hfov()`	Same as `return type() == Type.PERSPECTIVE ? radians(eye().magnitude() * aspectRatio()) : eye().magnitude()`.
`void`	`interact(Object... gesture)`	Same as `interact((String)null, gesture)`.
`void`	`interact(String tag, Object... gesture)`	Same as `if (tag == null \|\| node(tag) != null) interact(node(tag), gesture)`.
`void`	`interact(Node node, Object... gesture)`	Call the `node` (or the `eye()` if `node` is null) interact gesture parser function set either with `Node.setInteraction(Consumer)` or `Node.setInteraction(BiConsumer)`.
`boolean`	`is2D()`
`boolean`	`is3D()`
`boolean`	`isConeBackFacing(Vector vertex, ArrayList<Vector> normals)`	Returns `true` if the given cone is back-facing the eye and `false` otherwise.
`boolean`	`isConeBackFacing(Vector vertex, Vector[] normals)`	Returns `true` if the given cone is back-facing the eye and `false` otherwise.
`boolean`	`isConeBackFacing(Vector vertex, Vector axis, float angle)`	Returns `true` if the given cone is back-facing the eye and `false` otherwise.
`boolean`	`isConeFrontFacing(Vector vertex, ArrayList<Vector> normals)`	Same as `return !isConeBackFacing(vertex, normals)`.
`boolean`	`isConeFrontFacing(Vector vertex, Vector[] normals)`	Same as `!isConeBackFacing(vertex, normals)`.
`boolean`	`isConeFrontFacing(Vector vertex, Vector axis, float angle)`	Same as `return !isConeBackFacing(vertex, axis, angle)`.
`boolean`	`isEye(Node node)`	Checks whether or not the given node is the `eye()`.
`boolean`	`isFaceBackFacing(Vector vertex, Vector normal)`	Returns `true` if the given face is back-facing the camera.
`boolean`	`isFaceBackFacing(Vector a, Vector b, Vector c)`	Returns `true` if the given face is back-facing the eye.
`boolean`	`isFaceFrontFacing(Vector vertex, Vector normal)`	Same as `return !isFaceBackFacing(vertex, normal)`.
`boolean`	`isFaceFrontFacing(Vector a, Vector b, Vector c)`	Same as `return !isFaceBackFacing(a, b, c)`.
`static boolean`	`isNumInstance(Object o)`	Returns `true` if `o` is instance of `Integer`, `Float` or `Double`, and `false` otherwise.
`boolean`	`isOffscreen()`	Returns `true` if this scene is off-screen and `false` otherwise.
`boolean`	`isPointVisible(float x, float y, float z)`	Same as `return isPointVisible(new Vector(x, y, z))`.
`boolean`	`isPointVisible(Vector point)`	Returns `true` if `point` is visible (i.e, lies within the eye bounds) and `false` otherwise.
`boolean`	`isTagged(Node node)`	Returns `true` if the node is currently being tagged and `false` otherwise.
`boolean`	`isTagValid()`	Same as `isTagValid(null)`.
`boolean`	`isTagValid(String tag)`	Returns `true` if some node is tagged with `tag` (which may be {code null}) and `false` otherwise.
`long`	`lastUpdate()`	Max between `Node.lastUpdate()` and `_lastNonEyeUpdate()`.
`Vector`	`location(Vector pixel)`	Convenience function that simply returns `location(pixel, null)`.
`Vector`	`location(Vector pixel, Node node)`	Returns the `node` coordinates of `pixel`.
`void`	`lookAround(float deltaX, float deltaY)`	Same as `lookAround(deltaX, deltaY, Graph.inertia)`.
`void`	`lookAround(float deltaX, float deltaY, float inertia)`	Look around (without translating the eye) according to angular displacements `deltaX` and `deltaY` expressed in radians.
`void`	`lookAt(Vector target)`	2D eyes simply call `node().setPosition(target.x(), target.y())`.
`void`	`moveForward(float delta)`	Same as `moveForward(delta, Graph.inertia)`.
`void`	`moveForward(float delta, float inertia)`	Same as `translateEye(0, 0, delta / (zNear() - zFar()))`.
`Vector`	`ndcToScreenDisplacement(Vector vector)`	Converts `vector` displacement from normalized device coordinates (NDC) to screen space.
`Vector`	`ndcToScreenLocation(Vector vector)`	Converts `vector` location from normalized device coordinates (NDC) to screen space.
`Node`	`node()`	Same as `return node(null)`.
`Node`	`node(String tag)`	Returns the node tagged with `tag` (which may be `null`) which is usually set by ray casting (see `updateTag(String, int, int)`).
`static List<Node>`	`nodes()`	Returns a list of all the nodes that are reachable by the `render()` algorithm.
`void`	`openContext()`	Begins the rendering process (see `render(Node)`).
`void`	`pixelToLine(int pixelX, int pixelY, Vector origin, Vector direction)`	Gives the coefficients of a 3D half-line passing through the eye position and pixel (pixelX,pixelY).
`float`	`pixelToSceneRatio(Vector position)`	Returns the pixel to scene (units) ratio at `position`.
`void`	`pre()`	Paint method which is called just before your main event loop starts.
`Matrix`	`projection()`	Returns the cached projection matrix computed at `openContext()`.
`Matrix`	`projectionView()`	Returns the projection times view cached matrix computed at `openContext()`}.
`Matrix`	`projectionViewInverse()`	Returns the projection times view inverse matrix.
`float`	`radius()`	Radius of the ball (defined in world coordinates) used in eye motions interaction (e.g., `shift(float, float, float)`, `spin(int, int, int, int)`, `turn(float, float, float)`) and interpolation routines (e.g., `fit()`).
`void`	`randomize(Node node)`	Same as `node.randomize(center(), radius(), is3D())`.
`Node`	`randomNode()`	Same as `return Node.random(this)`.
`void`	`removeTag()`	Same as `removeTag(null)`.
`void`	`removeTag(String tag)`	Removes the `tag` so that a call to `isTagValid(String)` will return `false`.
`void`	`render()`	Renders the node tree onto the `context()` from the `eye()` viewpoint.
`void`	`render(Node subtree)`	Calls `openContext()`, then renders the node `subtree` (or the whole tree when `subtree` is `null`) onto the `context()` from the `eye()` viewpoint, and calls `closeContext()`.
`void`	`resetBehavior(Node node)`	Resets the node custom behavior which is set with `addBehavior(Node, BiConsumer)`.
`Vector`	`rightVector()`	Returns the normalized right vector of the eye, defined in the world coordinate system.
`float`	`sceneToPixelRatio(Vector position)`	Returns the ratio of scene (units) to pixel at `position`.
`Vector`	`screenDisplacement(Vector vector)`	Same as `return screenDisplacement(vector, null)`.
`Vector`	`screenDisplacement(Vector vector, Node node)`	Converts the `node` `vector` displacement to screen space.
`Vector`	`screenLocation(Node node)`	Converts the `node` origin location to screen space.
`Vector`	`screenLocation(Vector vector)`	Converts `vector` location from world to screen space.
`Vector`	`screenLocation(Vector vector, Node node)`	Converts `vector` location from `node` to screen.
`Vector`	`screenToNDCDisplacement(Vector vector)`	Converts `vector` displacement from screen space to normalized device coordinates (NDC).
`Vector`	`screenToNDCLocation(Vector vector)`	Converts `vector` location from screen space to normalized device coordinates (NDC).
`void`	`setBoundingBall(Vector center, float radius)`	Sets the ball for `zNear()` and `zFar()` computations within the `ballZNear()` and `ballZFar()` functions.
`void`	`setCenter(Vector center)`	Sets `center()`.
`void`	`setEye(Node eye)`	Replaces the current `eye()` with `eye`.
`void`	`setFOV(float fov)`	Sets the `eye()` `Node.worldMagnitude()`, according to `fov` (field-of-view) which is expressed in radians.
`void`	`setHeight(int height)`	Sets the graph `height()` in pixels.
`void`	`setHFOV(float hfov)`	Sets the `hfov()` of the `eye()` (in radians).
`void`	`setRadius(float radius)`	Sets `radius()`.
`void`	`setType(Graph.Type type)`	Defines the graph `_type` according to the projection of the scene.
`void`	`setUpVector(Vector up)`	Convenience function that simply calls `setUpVector(up, true)`.
`void`	`setUpVector(Vector up, boolean noMove)`	Rotates the eye so that its `upVector()` becomes `up` (defined in the world coordinate system).
`void`	`setViewDirection(Vector direction)`	Rotates the eye so that its `viewDirection()` is `direction` (defined in the world coordinate system).
`void`	`setWidth(int width)`	Sets the graph `width()` in pixels.
`void`	`setZFar(Supplier<Float> zFar)`	Sets the `zFar()` computation routine.
`void`	`setZNear(Supplier<Float> zNear)`	Sets the `zNear()` computation routine.
`void`	`shift(float dx, float dy, float dz)`	Same as `shift(dx, dy, dz, Graph.inertia)`.
`void`	`shift(float dx, float dy, float dz, float inertia)`	Same as `shift((String)null, dx, dy, dz, inertia)`.
`void`	`shift(String tag, float dx, float dy, float dz)`	Same as `shift(tag, dx, dy, dz, Graph.inertia)`.
`void`	`shift(String tag, float dx, float dy, float dz, float inertia)`	Same as `if (tag == null \|\| node(tag) != null) shift(node(tag), dx, dy, dz, inertia)`.
`void`	`shift(Node node, float dx, float dy, float dz)`	Same as `shift(node, dx, dy, dz, Graph.inertia)`.
`void`	`shift(Node node, float dx, float dy, float dz, float inertia)`	Translates the `node` (use null for the world) according to `(dx, dy, dz)` defined in screen-space ((a box of `width()` * `height()` * 1 dimensions), and `inertia` which should be in `[0..1]`, 0 no inertia & 1 no friction.
`void`	`spin(int pixel1X, int pixel1Y, int pixel2X, int pixel2Y)`	Same as `spin(pixel1X, pixel1Y, pixel2X, pixel2Y, Graph.inertia)`.
`void`	`spin(int pixel1X, int pixel1Y, int pixel2X, int pixel2Y, float inertia)`	Same as `spin((String)null, pixel1X, pixel1Y, pixel2X, pixel2Y, inertia)`.
`void`	`spin(String tag, int pixel1X, int pixel1Y, int pixel2X, int pixel2Y)`	Same as `spin(tag, pixel1X, pixel1Y, pixel2X, pixel2Y, Graph.inertia)`.
`void`	`spin(String tag, int pixel1X, int pixel1Y, int pixel2X, int pixel2Y, float inertia)`	Same as `if (tag == null \|\| node(tag) != null) spin(node(tag), pixel1X, pixel1Y, pixel2X, pixel2Y, inertia)`.
`void`	`spin(Node node, int pixel1X, int pixel1Y, int pixel2X, int pixel2Y)`	Same as `spin(node, pixel1X, pixel1Y, pixel2X, pixel2Y, Graph.inertia)`.
`void`	`spin(Node node, int pixel1X, int pixel1Y, int pixel2X, int pixel2Y, float inertia)`	Rotates the `node` (use null for the world) using an arcball interface, from points `(pixel1X, pixel1Y)` to `(pixel2X, pixel2Y)` pixel positions.
`void`	`tag(int pixelX, int pixelY)`	Same as `tag(null, pixelX, pixelY)`.
`void`	`tag(String tag, int pixelX, int pixelY)`	Same as `updateTag(String, int, int)` but doesn't return immediately the tagged node.
`void`	`tag(String tag, Node node)`	Tags the `node` (with `tag` which may be `null`) (see `node(String)`).
`void`	`tag(Node node)`	Same as `tag(null, node)`.
`void`	`togglePerspective()`	Shifts the graph `_type` between `Graph.Type.PERSPECTIVE` and `Graph.Type.ORTHOGRAPHIC` while trying to keep the `fov()`.
`boolean`	`tracks(Node node, int pixelX, int pixelY)`	Casts a ray at pixel position `(pixelX, pixelY)` and returns `true` if the ray picks the `node` and `false` otherwise.
`void`	`turn(float roll, float pitch, float yaw)`	Same as `turn(roll, pitch, yaw, Graph.inertia)`.
`void`	`turn(float roll, float pitch, float yaw, float inertia)`	Same as `turn((String)null, roll, pitch, yaw, inertia)`.
`void`	`turn(String tag, float roll, float pitch, float yaw)`	Same as `turn(tag, roll, pitch, yaw, Graph.inertia)`.
`void`	`turn(String tag, float roll, float pitch, float yaw, float inertia)`	Same as `if (tag == null \|\| node(tag) != null) turn(node(tag), roll, pitch, yaw, inertia)`.
`void`	`turn(Node node, float roll, float pitch, float yaw)`	Same as `turn(node, roll, pitch, yaw, Graph.inertia)`.
`void`	`turn(Node node, float roll, float pitch, float yaw, float inertia)`	Rotates the `node` (use null for the world) around the x-y-z screen axes according to `roll`, `pitch` and `yaw` radians, resp., and according to `inertia` which should be in `[0..1]`, 0 no inertia & 1 no friction.
`Graph.Type`	`type()`	Returns the graph type.
`void`	`untag(Node node)`	Removes all tags pointing to the `node`.
`Node`	`updateTag(int pixelX, int pixelY)`	Same as `return updateTag(null, null, pixelX, pixelY)`.
`Node`	`updateTag(int pixelX, int pixelY, List<Node> nodeList)`	Same as `return track(null, pixelX, pixelY, nodeList)`.
`Node`	`updateTag(int pixelX, int pixelY, Node[] nodeArray)`	Same as `return track(null, pixelX, pixelY, nodeArray)`.
`Node`	`updateTag(String tag, int pixelX, int pixelY)`	Tags (with `tag` which may be `null`) the node in `nodes()` picked with ray-casting at pixel `pixelX, pixelY` and returns it (see `node(String)`).
`Node`	`updateTag(String tag, int pixelX, int pixelY, List<Node> nodeList)`	Same as `updateTag(String, int, int, Node[])` but using a node list instead of an array.
`Node`	`updateTag(String tag, int pixelX, int pixelY, Node[] nodeArray)`	Tags (with `tag` which may be `null`) the node in `nodeArray` picked with ray-casting at pixel `pixelX, pixelY` and returns it (see `node(String)`).
`Node`	`updateTag(Node subtree, int pixelX, int pixelY)`	Same as `return return updateTag(subtree, null, pixelX, pixelY)`.
`Node`	`updateTag(Node subtree, String tag, int pixelX, int pixelY)`	Tags (with `tag` which may be `null`) the node in the `subtree` (or the whole tree when `subtree` is `null`) picked with ray-casting at pixel `pixelX, pixelY` and returns it (see `node(String)`).
`Vector`	`upVector()`	Returns the normalized up vector of the eye, defined in the world coordinate system.
`Matrix`	`view()`	Returns the cached view matrix computed at `_bind()`.
`Vector`	`viewDirection()`	Returns the normalized view direction of the eye, defined in the world coordinate system.
`int`	`width()`	Returns width of the screen window.
`float`	`zFar()`	Returns the far clipping plane distance used to compute the `projection()` matrix.
`Supplier<Float>`	`zFarSupplier()`	Retrieves the current `zFar()` computation routine.
`float`	`zNear()`	Returns the near clipping plane distance used to compute the `projection()` matrix.
`Supplier<Float>`	`zNearSupplier()`	Retrieves the current `zNear()` computation routine.
`void`	`zoom(float delta)`	Same as `zoom(delta, Graph.inertia)`.
`void`	`zoom(float delta, float inertia)`	Same as `zoom((String)null, delta, inertia)`.
`void`	`zoom(String tag, float delta)`	Same as `zoom(tag, delta, Graph.inertia)`.
`void`	`zoom(String tag, float delta, float inertia)`	Same as `if (tag == null \|\| node(tag) != null) zoom(node(tag), delta, inertia)`.
`void`	`zoom(Node node, float delta)`	Same as `zoom(node, delta, Graph.inertia)`.
`void`	`zoom(Node node, float delta, float inertia)`	Scales the `node` (use null for the world) according to `delta` and `inertia` which should be in `[0..1]`, 0 no inertia & 1 no friction.

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

- Field Detail
  - random
```
public static Random random
```
  - inertia
```
public static float inertia
```
  - leftHanded
```
public static boolean leftHanded
```
  - picking
```
public boolean picking
```
  - _seeded
```
public static boolean _seeded
```
- Constructor Detail
  - Graph
```
public Graph(Object context,
             int width,
             int height,
             Node eye)
```
    Same as this(context, width, height, eye, Type.PERSPECTIVE).
    
    See Also:
    
    Graph(Object, int, int, Node, Type)
  - Graph
```
public Graph(Object context,
             int width,
             int height)
```
    Same as this(context, width, height, Type.PERSPECTIVE).
    
    See Also:
    
    Graph(Object, int, int, Type)
- Method Detail
  - isNumInstance
```
public static boolean isNumInstance(Object o)
```
    Returns true if o is instance of Integer, Float or Double, and false otherwise.
  - castToFloat
```
public static Float castToFloat(Object o)
```
    Cast o to a Float. Returns null if o is not a num instance (See isNumInstance(Object)).
  - castToInt
```
public static Integer castToInt(Object o)
```
    Cast o to an Integer. Returns null if o is not a num instance (See isNumInstance(Object)).
  - randomNode
```
public Node randomNode()
```
    Same as return Node.random(this). Creates a random node.
    
    See Also:
    
    Node.random(Graph), randomize(Node)
  - randomize
```
public void randomize(Node node)
```
    Same as node.randomize(center(), radius(), is3D()).
    
    See Also:
    
    Node.randomize(Vector, float, boolean)
  - aspectRatio
```
public float aspectRatio()
```
    Returns the width() to height() aspect ratio of the display window.
  - width
```
public int width()
```
    Returns width of the screen window.
  - height
```
public int height()
```
    Returns height of the screen window.
  - setWidth
```
public void setWidth(int width)
```
    Sets the graph width() in pixels.
  - setHeight
```
public void setHeight(int height)
```
    Sets the graph height() in pixels.
  - type
```
public Graph.Type type()
```
    Returns the graph type. Set by setType(Type).
    
    See Also:
    
    setType(Type)
  - setType
```
public void setType(Graph.Type type)
```
    Defines the graph _type according to the projection of the scene. Either Graph.Type.PERSPECTIVE, Graph.Type.ORTHOGRAPHIC, Graph.Type.TWO_D or Graph.Type.CUSTOM.
    Graph.Type.PERSPECTIVE and Graph.Type.ORTHOGRAPHIC use the classical projection matrices and the node Node.worldMagnitude(). Both use zNear() and zFar() (to define their clipping planes) and width() and height() for frustum shape.
    A Graph.Type.TWO_D behaves like Graph.Type.ORTHOGRAPHIC, but instantiated graph nodes will be constrained so that they will remain at the x-y plane.
    
    See Also:
    
    Node.worldMagnitude()
  - togglePerspective
```
public void togglePerspective()
```
    Shifts the graph _type between Graph.Type.PERSPECTIVE and Graph.Type.ORTHOGRAPHIC while trying to keep the fov(). Only meaningful if graph is3D().
    
    See Also:
    
    setType(Type), setFOV(float), fov(), hfov(), setHFOV(float)
  - setFOV
```
public void setFOV(float fov)
```
    Sets the eye() Node.worldMagnitude(), according to fov (field-of-view) which is expressed in radians. Meaningless if the graph is2D(). If the graph _type is Graph.Type.ORTHOGRAPHIC it will match the perspective projection obtained using fov of an image centered at the world XY plane from the eye current position.
    Computed as as Math.tan(fov/2) if the graph type is Graph.Type.PERSPECTIVE and as Math.tan(fov / 2) * 2 * Math.abs(Vector.scalarProjection(Vector.subtract(eye().position(), center()), eye().zAxis())) / width() if the graph _type is Graph.Type.ORTHOGRAPHIC.
    
    See Also:
    
    fov(), hfov(), setHFOV(float), setType(Type)
  - fov
```
public float fov()
```
    Retrieves the scene field-of-view in radians. Meaningless if the scene is2D(). See setFOV(float) for details. The value is related to the eye() Node.worldMagnitude() as follows:
    
    It returns 2 * Math.atan(eye().magnitude()), when the graph type() is Graph.Type.PERSPECTIVE.
    
    It returns 2 * Math.atan(eye().magnitude() * width() / (2 * Math.abs(Vector.scalarProjection(Vector.subtract(eye().position(), center()), eye().zAxis())))), if the graph _type is Graph.Type.ORTHOGRAPHIC.
    
    Set this value with setFOV(float) or setHFOV(float).
    See Also:
    
    Node.worldMagnitude(), setType(Type), setHFOV(float), hfov(), setFOV(float)
  - setHFOV
```
public void setHFOV(float hfov)
```
    Sets the hfov() of the eye() (in radians).
    hfov() and fov() are linked by the aspectRatio(). This method actually calls: setFOV(2.0f * (float) Math.atan((float) Math.tan(hfov / 2.0f) / aspectRatio())) so that a call to hfov() returns the expected value.
    
    See Also:
    
    setFOV(float), fov(), hfov(), setFOV(float)
  - hfov
```
public float hfov()
```
    Same as return type() == Type.PERSPECTIVE ? radians(eye().magnitude() * aspectRatio()) : eye().magnitude().
    Returns the eye() horizontal field-of-view in radians.
    
    See Also:
    
    fov(), setHFOV(float), setFOV(float)
  - zNear
```
public float zNear()
```
    Returns the near clipping plane distance used to compute the projection() matrix.
    
    See Also:
    
    zFar()
  - zNearSupplier
```
public Supplier<Float> zNearSupplier()
```
    Retrieves the current zNear() computation routine.
    
    See Also:
    
    zNearSupplier()
  - setZNear
```
public void setZNear(Supplier<Float> zNear)
```
    Sets the zNear() computation routine.
    
    See Also:
    
    zNearSupplier(), setZFar(Supplier)
  - ballZNear
```
public float ballZNear()
```
    The clipping planes' positions depend on the radius() and center() rather than being fixed small-enough and large-enough values. A good approximation will hence result in an optimal precision of the z-buffer.
    The near clipping plane is positioned at a distance equal to zClippingCoefficient * radius() in front of the center(): Vector.scalarProjection( Vector.subtract(eye().position(), center()), eye().zAxis()) - zClippingCoefficient() * radius()
    In order to prevent negative or too small zNear() values (which would degrade the z precision), zNearCoefficient is used when the eye is inside the radius() ball:
    zMin = zNearCoefficient() * zClippingCoefficient() * radius();
    zNear = zMin;
    With an ORTHOGRAPHIC and TWO_D types, the value is simply clamped to 0
    
    See also the zFar() documentation. Attention: The value is always positive, although the clipping plane is positioned at a negative z value in the eye coordinate system.
    
    See Also:
    
    ballZFar()
  - zFar
```
public float zFar()
```
    Returns the far clipping plane distance used to compute the projection() matrix.
    
    See Also:
    
    zNear()
  - zFarSupplier
```
public Supplier<Float> zFarSupplier()
```
    Retrieves the current zFar() computation routine.
    
    See Also:
    
    zNearSupplier()
  - setZFar
```
public void setZFar(Supplier<Float> zFar)
```
    Sets the zFar() computation routine.
    
    See Also:
    
    zFarSupplier(), setZNear(Supplier)
  - ballZFar
```
public float ballZFar()
```
    The far clipping plane is positioned at a distance equal to zClippingCoefficient() * radius() behind the center():
    zFar = Vector.scalarProjection(Vector.subtract(eye().position(), center()), eye().zAxis()) + zClippingCoefficient() * radius().
    
    See Also:
    
    ballZNear()
  - clearTree
```
public static void clearTree()
```
    Same as for(Node node : _leadingNodes()) detach(node).
    
    See Also:
    
    Node.detach()
  - nodes
```
public static List<Node> nodes()
```
    Returns a list of all the nodes that are reachable by the render() algorithm.
    Note that node collections should be kept at user space for efficiency.
    
    See Also:
    
    isEye(Node)
  - branch
```
public static List<Node> branch(Node node)
```
    Collects node and all its descendant nodes.
  - beginHUD
```
public void beginHUD()
```
    Begin Heads Up Display (HUD) so that drawing can be done using 2D screen coordinates.
    All screen drawing should be enclosed between beginHUD() and endHUD(). Then you can just begin drawing your screen shapes. Attention: If you want your screen drawing to appear on top of your 3d graph then draw first all your 3d before doing any call to a beginHUD() and endHUD() pair.
    Warning: Offscreen scenes should call beginHUD() and endHUD() before closing the context (closeContext()).
    
    See Also:
    
    endHUD(), MatrixHandler.beginHUD(int, int)
  - endHUD
```
public void endHUD()
```
    Ends Heads Up Display (HUD). Throws an exception if beginHUD() wasn't properly called before.
    Wrapper for MatrixHandler.endHUD().
    
    See Also:
    
    beginHUD(), MatrixHandler.endHUD()
  - isEye
```
public boolean isEye(Node node)
```
    Checks whether or not the given node is the eye().
  - eye
```
public Node eye()
```
    Returns the associated eye. Never null.
    
    See Also:
    
    setEye(Node)
  - setEye
```
public void setEye(Node eye)
```
    Replaces the current eye() with eye.
    
    See Also:
    
    eye()
  - isPointVisible
```
public boolean isPointVisible(float x,
                              float y,
                              float z)
```
    Same as return isPointVisible(new Vector(x, y, z)).
    
    See Also:
    
    isPointVisible(Vector)
  - isPointVisible
```
public boolean isPointVisible(Vector point)
```
    Returns true if point is visible (i.e, lies within the eye bounds) and false otherwise.
    
    See Also:
    
    distanceToBound(int, Vector), ballVisibility(Vector, float), boxVisibility(Vector, Vector), bounds()
  - ballVisibility
```
public Graph.Visibility ballVisibility(Vector center,
                                       float radius)
```
    Returns Graph.Visibility.VISIBLE, Graph.Visibility.INVISIBLE, or Graph.Visibility.SEMIVISIBLE, depending whether the ball (of radius radius and center center) is visible, invisible, or semi-visible, respectively.
    
    See Also:
    
    distanceToBound(int, Vector), isPointVisible(Vector), boxVisibility(Vector, Vector), bounds(), _updateBounds()
  - boxVisibility
```
public Graph.Visibility boxVisibility(Vector corner1,
                                      Vector corner2)
```
    Returns Graph.Visibility.VISIBLE, Graph.Visibility.INVISIBLE, or Graph.Visibility.SEMIVISIBLE, depending whether the axis aligned box (defined by corners p1 and p2) is visible, invisible, or semi-visible, respectively.
    
    See Also:
    
    distanceToBound(int, Vector), isPointVisible(Vector), ballVisibility(Vector, float), bounds(), _updateBounds()
  - bounds
```
public float[][] bounds()
```
    Returns the bounds plane equations.
    In 2D the four 4-component vectors, respectively correspond to the left, right, top and bottom eye bounds lines. Each vector holds a plane equation of the form:
    a*x + b*y + c = 0 where a, b and c are the 3 components of each vector, in that order.
    In 3D the six 4-component vectors returned by this method, respectively correspond to the left, right, near, far, top and bottom eye bounding planes. Each vector holds a plane equation of the form:
    a*x + b*y + c*z + d = 0
    where a, b, c and d are the 4 components of each vector, in that order.
    
    See Also:
    
    distanceToBound(int, Vector), isPointVisible(Vector), ballVisibility(Vector, float), boxVisibility(Vector, Vector), _updateBounds()
  - distanceToBound
```
public float distanceToBound(int index,
                             Vector position)
```
    Returns the signed distance between point position and plane index in world units. The distance is negative if the point lies in the planes's bounding halfspace, and positive otherwise.
    In 2D index is a value between 0 and 3 which respectively correspond to the left, right, top and bottom eye bounding planes.
    In 3D index is a value between 0 and 5 which respectively correspond to the left, right, near, far, top and bottom eye bounding planes.
    
    See Also:
    
    isPointVisible(Vector), ballVisibility(Vector, float), boxVisibility(Vector, Vector), bounds()
  - pixelToSceneRatio
```
public float pixelToSceneRatio(Vector position)
```
    Returns the pixel to scene (units) ratio at position.
    Convenience function that simply returns 1 / sceneToPixelRatio(position).
    
    See Also:
    
    sceneToPixelRatio(Vector)
  - sceneToPixelRatio
```
public float sceneToPixelRatio(Vector position)
```
    Returns the ratio of scene (units) to pixel at position.
    A line of n * sceneToPixelRatio() graph units, located at position in the world coordinate system, will be projected with a length of n pixels on screen.
    Use this method to scale objects so that they have a constant pixel size on screen. The following code will draw a 20 pixel line, starting at center() and always directed along the screen vertical direction (upVector()):
    beginShape(LINES);
    vertex(scene.center().x(), scene.center().y(), scene.center().z());
    Vector v = Vector.add(scene.center(), Vector.multiply(scene.upVector(), 20 * scene.sceneToPixelRatio(scene.center())));
    vertex(v.x(), v.y(), v.z());
    endShape();
  - isFaceFrontFacing
```
public boolean isFaceFrontFacing(Vector a,
                                 Vector b,
                                 Vector c)
```
    Same as return !isFaceBackFacing(a, b, c).
    
    See Also:
    
    isFaceBackFacing(Vector, Vector, Vector)
  - isFaceBackFacing
```
public boolean isFaceBackFacing(Vector a,
                                Vector b,
                                Vector c)
```
    Returns true if the given face is back-facing the eye. Otherwise returns false.
    Vertices must given in clockwise order if graph is not leftHanded or in counter-clockwise order if leftHanded.
    
    Parameters:
    
    a - first face vertex
    
    b - second face vertex
    
    c - third face vertex
    
    See Also:
    
    isFaceBackFacing(Vector, Vector), isConeBackFacing(Vector, Vector, float)
  - isFaceFrontFacing
```
public boolean isFaceFrontFacing(Vector vertex,
                                 Vector normal)
```
    Same as return !isFaceBackFacing(vertex, normal).
    
    See Also:
    
    isFaceBackFacing(Vector, Vector)
  - isFaceBackFacing
```
public boolean isFaceBackFacing(Vector vertex,
                                Vector normal)
```
    Returns true if the given face is back-facing the camera. Otherwise returns false.
    
    Parameters:
    
    vertex - belonging to the face
    
    normal - face normal
    
    See Also:
    
    isFaceBackFacing(Vector, Vector, Vector), isConeBackFacing(Vector, Vector, float)
  - isConeFrontFacing
```
public boolean isConeFrontFacing(Vector vertex,
                                 ArrayList<Vector> normals)
```
    Same as return !isConeBackFacing(vertex, normals).
    
    See Also:
    
    isConeBackFacing(Vector, ArrayList)
  - isConeBackFacing
```
public boolean isConeBackFacing(Vector vertex,
                                ArrayList<Vector> normals)
```
    Returns true if the given cone is back-facing the eye and false otherwise.
    
    Parameters:
    
    vertex - Cone vertex
    
    normals - ArrayList of normals defining the cone.
    
    See Also:
    
    isConeBackFacing(Vector, Vector[]), isConeBackFacing(Vector, Vector, float)
  - isConeFrontFacing
```
public boolean isConeFrontFacing(Vector vertex,
                                 Vector[] normals)
```
    Same as !isConeBackFacing(vertex, normals).
    
    See Also:
    
    isConeBackFacing(Vector, Vector[])
  - isConeBackFacing
```
public boolean isConeBackFacing(Vector vertex,
                                Vector[] normals)
```
    Returns true if the given cone is back-facing the eye and false otherwise.
    
    Parameters:
    
    vertex - Cone vertex
    
    normals - Array of normals defining the cone.
    
    See Also:
    
    isConeBackFacing(Vector, ArrayList), isConeBackFacing(Vector, Vector, float)
  - isConeFrontFacing
```
public boolean isConeFrontFacing(Vector vertex,
                                 Vector axis,
                                 float angle)
```
    Same as return !isConeBackFacing(vertex, axis, angle).
    
    See Also:
    
    isConeBackFacing(Vector, Vector, float)
  - isConeBackFacing
```
public boolean isConeBackFacing(Vector vertex,
                                Vector axis,
                                float angle)
```
    Returns true if the given cone is back-facing the eye and false otherwise.
    
    Parameters:
    
    vertex - Cone vertex
    
    axis - Cone axis
    
    angle - Cone angle
  - setBoundingBall
```
public void setBoundingBall(Vector center,
                            float radius)
```
    Sets the ball for zNear() and zFar() computations within the ballZNear() and ballZFar() functions. Calls setCenter(Vector) setRadius(float).
    To only affect eye motions interactions and interpolations (while leaving the current z-near and z-far computations unaffected) call setCenter(Vector) and setRadius(float).
    
    See Also:
    
    setZNear(Supplier), setZFar(Supplier), setCenter(Vector), setRadius(float)
  - radius
```
public float radius()
```
    Radius of the ball (defined in world coordinates) used in eye motions interaction (e.g., shift(float, float, float), spin(int, int, int, int), turn(float, float, float)) and interpolation routines (e.g., fit()). This ball is different from the one used by the ballZNear() and ballZFar() algorithms ({see @link #setBoundingBall(Vector, float)}).
    Set it with setRadius(float).
    
    See Also:
    
    center(), setBoundingBall(Vector, float)
  - setRadius
```
public void setRadius(float radius)
```
    Sets radius(). To be used in conjuntion with setCenter(Vector).
    
    See Also:
    
    setCenter(Vector), setBoundingBall(Vector, float)
  - center
```
public Vector center()
```
    Center of the ball (defined in world coordinates) used in eye motions interaction (e.g., shift(float, float, float), spin(int, int, int, int), turn(float, float, float)) and interpolation routines (e.g., fit()). This ball is different from the one used by the ballZNear() and ballZFar() algorithms ({see @link #setBoundingBall(Vector, float)}).
    Set it with setCenter(Vector).
    
    See Also:
    
    radius(), setBoundingBall(Vector, float)
  - setCenter
```
public void setCenter(Vector center)
```
    Sets center(). To be used in conjuntion with setRadius(float).
    
    See Also:
    
    setRadius(float), setBoundingBall(Vector, float)
  - viewDirection
```
public Vector viewDirection()
```
    Returns the normalized view direction of the eye, defined in the world coordinate system. This corresponds to the negative Z axis of the eye() (node().worldDisplacement(new Vector(0.0f, 0.0f, -1.0f))). In 2D it always is (0,0,-1).
    Change this value using setViewDirection(Vector), lookAt(Vector) or Node.setWorldOrientation(Quaternion). It is orthogonal to upVector() and to rightVector().
  - setViewDirection
```
public void setViewDirection(Vector direction)
```
    Rotates the eye so that its viewDirection() is direction (defined in the world coordinate system).
    The eye Node.worldPosition() is not modified. The eye is rotated so that the horizon (defined by its upVector()) is preserved.
    
    See Also:
    
    lookAt(Vector), setUpVector(Vector)
  - setUpVector
```
public void setUpVector(Vector up)
```
    Convenience function that simply calls setUpVector(up, true).
    
    See Also:
    
    setUpVector(Vector, boolean)
  - setUpVector
```
public void setUpVector(Vector up,
                        boolean noMove)
```
    Rotates the eye so that its upVector() becomes up (defined in the world coordinate system).
    The eye is rotated around an axis orthogonal to up and to the current upVector() direction.
    Use this method in order to define the eye horizontal plane.
    When noMove is set to false, the orientation modification is compensated by a translation, so that the center() stays projected at the same position on screen. This is especially useful when the eye is an observer of the graph.
    When noMove is true, the Eye Node.worldPosition() is left unchanged, which is an intuitive behavior when the Eye is in first person mode.
    
    See Also:
    
    lookAt(Vector)
  - upVector
```
public Vector upVector()
```
    Returns the normalized up vector of the eye, defined in the world coordinate system.
    Set using setUpVector(Vector) or Node.setWorldOrientation(Quaternion). It is orthogonal to viewDirection() and to rightVector().
    It corresponds to the Y axis of the associated eye() (actually returns node().yAxis()
  - lookAt
```
public void lookAt(Vector target)
```
    2D eyes simply call node().setPosition(target.x(), target.y()). 3D eyes set Node.worldOrientation(), so that it looks at point target defined in the world coordinate system (The eye Node.worldPosition() is not modified. Simply setViewDirection(Vector)).
    
    See Also:
    
    at(), setUpVector(Vector), fit(), fit(Vector, Vector)
  - rightVector
```
public Vector rightVector()
```
    Returns the normalized right vector of the eye, defined in the world coordinate system.
    This vector lies in the eye horizontal plane, directed along the X axis (orthogonal to upVector() and to viewDirection(). Set using setUpVector(Vector), lookAt(Vector) or Node.setWorldOrientation(Quaternion).
    Simply returns node().xAxis().
  - at
```
public Vector at()
```
    2D eyes return the position. 3D eyes return a point defined in the world coordinate system where the eyes is pointing at (just in front of viewDirection()). Useful for setting the Processing camera() which uses a similar approach of that found in gluLookAt.
    
    See Also:
    
    lookAt(Vector)
  - fit
```
public void fit(Node node)
```
    Convenience function that simply calls fit(node, 0).
    
    See Also:
    
    fit(Node, float), fit(Vector, Vector), fit(int, int, int, int, float), fit(float), fit(int, int, int, int), fit(), fit(Vector, Vector, float), fitFOV(), fitFOV(float)
  - fit
```
public void fit(Node node,
                float duration)
```
    Smoothly interpolates the eye on a interpolator path so that it goes to node. The duration defines the interpolation speed.
    
    See Also:
    
    fit(Node), fit(Vector, Vector), fit(int, int, int, int, float), fit(float), fit(int, int, int, int), fit(), fit(Vector, Vector, float), fitFOV(), fitFOV(float)
  - fit
```
public void fit()
```
    Moves the eye so that the ball defined by center() and radius() is visible and fits the window.
    
    See Also:
    
    center(), radius(), fit(Node), fit(Node, float), fit(Vector, Vector), fit(int, int, int, int, float), fit(float), fit(int, int, int, int), fit(Vector, Vector, float), fitFOV(), fitFOV(float)
  - fit
```
public void fit(float duration)
```
    Moves the eye during duration milliseconds so that the ball defined by center() and radius() is visible and fits the window.
    In 3D the eye is simply translated along its viewDirection() so that the ball fits the screen. Its Node.worldOrientation() and its fov() are unchanged. You should therefore orientate the eye before you call this method.
    
    See Also:
    
    fit(float), fit(Node), fit(Node, float), fit(Vector, Vector), fit(int, int, int, int, float), fit(), fit(int, int, int, int), fit(Vector, Vector, float), fitFOV(), fitFOV(float)
  - fitFOV
```
public void fitFOV(float duration)
```
    Rescales the fov() duration milliseconds so that the ball defined by center and radius is visible and fits the window.
    The eye position and orientation are not modified and you first have to orientate the eye in order to actually see the scene (see lookAt(Vector) or fit()).
    Attention: The fov() is clamped to PI/2. This happens when the eye is at a distance lower than sqrt(2) * radius() from the center().
    
    See Also:
    
    fitFOV(), fit(float), fit(Node), fit(Node, float), fit(Vector, Vector), fit(int, int, int, int, float), fit(), fit(int, int, int, int), fit(Vector, Vector, float)
  - fitFOV
```
public void fitFOV()
```
    Changes the eye() fov() so that the entire scene (defined by center() and radius()) is visible.
    The eye position and orientation are not modified and you first have to orientate the eye in order to actually see the scene (see lookAt(Vector)).
    Attention: The fov() is clamped to PI/2. This happens when the eye is at a distance lower than sqrt(2) * radius() from the center().
    
    See Also:
    
    fitFOV(float), fit(float), fit(Node), fit(Node, float), fit(Vector, Vector), fit(int, int, int, int, float), fit(), fit(int, int, int, int), fit(Vector, Vector, float)
  - fit
```
public void fit(Vector corner1,
                Vector corner2,
                float duration)
```
    Smoothly moves the eye during duration milliseconds so that the world axis aligned box defined by corner1 and corner2 is entirely visible.
    
    See Also:
    
    fit(Vector, Vector), fit(float), fit(Node), fit(Node, float), fit(int, int, int, int, float), fit(), fit(int, int, int, int), fitFOV(), fitFOV(float)
  - fit
```
public void fit(Vector corner1,
                Vector corner2)
```
    Moves the eye so that the world axis aligned box defined by corner1 and corner2 is entirely visible.
    
    See Also:
    
    fit(Vector, Vector, float), fit(float), fit(Node), fit(Node, float), fit(int, int, int, int, float), fit(), fit(int, int, int, int), fitFOV(), fitFOV(float)
  - fit
```
public void fit(int x,
                int y,
                int width,
                int height,
                float duration)
```
    Smoothly moves the eye during duration milliseconds so that the rectangular screen region defined by rectangle (pixel units, with origin in the upper left corner) fits the screen.
    The eye is translated (its Node.worldOrientation() is unchanged) so that rectangle is entirely visible. Since the pixel coordinates only define bounds in 3D, it's the intersection of this bounds with a plane (orthogonal to the viewDirection() and passing through the center()) that is used to define the 3D rectangle that is eventually fitted.
    
    See Also:
    
    fit(int, int, int, int), fit(Vector, Vector, float), fit(Vector, Vector), fit(float), fit(Node), fit(Node, float), fit(), fitFOV(), fitFOV(float)
  - fit
```
public void fit(int x,
                int y,
                int width,
                int height)
```
    Moves the eye so that the rectangular screen region defined by x, y, width, height (pixel units, with origin in the upper left corner) fits the screen.
    In 3D the eye is translated (its Node.worldOrientation() is unchanged) so that rectangle is entirely visible. Since the pixel coordinates only define a frustum in 3D, it's the intersection of this frustum with a plane (orthogonal to the viewDirection() and passing through the center()) that is used to define the 3D rectangle that is eventually fitted.
    
    Parameters:
    
    x - coordinate of the rectangle
    
    y - coordinate of the rectangle
    
    width - width of the rectangle
    
    height - height of the rectangle
    
    See Also:
    
    fit(int, int, int, int, float), fit(Vector, Vector, float), fit(Vector, Vector), fit(float), fit(Node), fit(Node, float), fit(), fitFOV(), fitFOV(float)
  - pixelToLine
```
public void pixelToLine(int pixelX,
                        int pixelY,
                        Vector origin,
                        Vector direction)
```
    Gives the coefficients of a 3D half-line passing through the eye position and pixel (pixelX,pixelY). Origin in the upper left corner. Use height() - pixelY to locate the origin at the lower left corner.
    The origin of the half line (eye position) is stored in origin, while direction contains the properly oriented and normalized direction of the half line.
    This method is useful for analytical intersection in a selection method.
  - is2D
```
public boolean is2D()
```
    Returns:
    
    true if the graph is 2D.
  - is3D
```
public boolean is3D()
```
    Returns:
    
    true if the graph is 3D.
  - lastUpdate
```
public long lastUpdate()
```
    Max between Node.lastUpdate() and _lastNonEyeUpdate().
    
    Returns:
    
    last frame the eye was updated
    
    See Also:
    
    _lastNonEyeUpdate()
  - updateTag
```
public Node updateTag(int pixelX,
                      int pixelY,
                      Node[] nodeArray)
```
    Same as return track(null, pixelX, pixelY, nodeArray).
    
    See Also:
    
    updateTag(String, int, int, Node[])
  - updateTag
```
public Node updateTag(String tag,
                      int pixelX,
                      int pixelY,
                      Node[] nodeArray)
```
    Tags (with tag which may be null) the node in nodeArray picked with ray-casting at pixel pixelX, pixelY and returns it (see node(String)).
    
    See Also:
    
    updateTag(Node, String, int, int), updateTag(String, int, int), updateTag(String, int, int, List), render(), node(String), removeTag(String), tracks(Node, int, int), tag(String, Node), hasTag(String, Node), Node.tagging, Node.bullsEyeSize(), Node.setBullsEyeSize(float), tag(String, int, int), tag(String, int, int)
  - updateTag
```
public Node updateTag(int pixelX,
                      int pixelY,
                      List<Node> nodeList)
```
    Same as return track(null, pixelX, pixelY, nodeList).
    
    See Also:
    
    updateTag(String, int, int, List)
  - updateTag
```
public Node updateTag(String tag,
                      int pixelX,
                      int pixelY,
                      List<Node> nodeList)
```
    Same as updateTag(String, int, int, Node[]) but using a node list instead of an array.
    
    See Also:
    
    updateTag(String, int, int, Node[])
  - updateTag
```
public Node updateTag(int pixelX,
                      int pixelY)
```
    Same as return updateTag(null, null, pixelX, pixelY).
    
    See Also:
    
    updateTag(Node, String, int, int)
  - updateTag
```
public Node updateTag(Node subtree,
                      int pixelX,
                      int pixelY)
```
    Same as return return updateTag(subtree, null, pixelX, pixelY).
    
    See Also:
    
    updateTag(Node, String, int, int)
  - updateTag
```
public Node updateTag(String tag,
                      int pixelX,
                      int pixelY)
```
    Tags (with tag which may be null) the node in nodes() picked with ray-casting at pixel pixelX, pixelY and returns it (see node(String)). May return null if no node is intersected by the ray. Not that the eye() is never tagged. Same as return updateTag(null, tag, pixelX, pixelY).
    
    See Also:
    
    updateTag(Node, int, int), updateTag(String, int, int, Node[]), render(), node(String), removeTag(String), tracks(Node, int, int), tag(String, Node), hasTag(String, Node), Node.tagging, Node.bullsEyeSize(), Node.setBullsEyeSize(float), tag(String, int, int)
  - updateTag
```
public Node updateTag(Node subtree,
                      String tag,
                      int pixelX,
                      int pixelY)
```
    Tags (with tag which may be null) the node in the subtree (or the whole tree when subtree is null) picked with ray-casting at pixel pixelX, pixelY and returns it (see node(String)). May return null if no node is intersected by the ray. Not that the eye() is never tagged.
    
    See Also:
    
    updateTag(String, int, int), updateTag(String, int, int, Node[]), render(), node(String), removeTag(String), tracks(Node, int, int), tag(String, Node), hasTag(String, Node), Node.tagging, Node.bullsEyeSize(), Node.setBullsEyeSize(float), tag(String, int, int)
  - tracks
```
public boolean tracks(Node node,
                      int pixelX,
                      int pixelY)
```
    Casts a ray at pixel position (pixelX, pixelY) and returns true if the ray picks the node and false otherwise. The node is picked according to the Node.bullsEyeSize().
    
    See Also:
    
    node(String), removeTag(String), tag(String, Node), hasTag(String, Node), Node.tagging, Node.bullsEyeSize(), Node.setBullsEyeSize(float)
  - tag
```
public void tag(int pixelX,
                int pixelY)
```
    Same as tag(null, pixelX, pixelY).
    
    See Also:
    
    tag(String, int, int)
  - tag
```
public void tag(String tag,
                int pixelX,
                int pixelY)
```
    Same as updateTag(String, int, int) but doesn't return immediately the tagged node. The algorithm schedules an updated of the node to be tagged for the next traversal and hence should be always be used in conjunction with render().
    The tagged node (see node(String)) would be available after the next call to render(). It may be null if no node is intersected by the ray. Not that the eye() is never tagged.
    This method is optimal since it tags the nodes at traversal time. Prefer this method over updateTag(String, int, int) when dealing with several tags.
    
    See Also:
    
    render(), node(String), removeTag(String), tracks(Node, int, int), tag(String, Node), hasTag(String, Node), Node.tagging, Node.bullsEyeSize(), Node.setBullsEyeSize(float), tag(int, int)
  - hasFocus
```
public boolean hasFocus(int pixelX,
                        int pixelY)
```
    Returns whether or not the scene has focus or not under the given pixel.
  - isOffscreen
```
public boolean isOffscreen()
```
    Returns true if this scene is off-screen and false otherwise.
  - context
```
public Object context()
```
    Returns the main renderer context.
  - pre
```
public void pre()
```
    Paint method which is called just before your main event loop starts. Handles timing tasks, resize events, prepares caches, and opens the context if the scene is onscreen.
    This method should be registered at the PApplet (which requires it to be public and named as pre) and hence you don't need to call it.
    
    See Also:
    
    draw(), render(), isOffscreen()
  - draw
```
public void draw()
```
    Paint method which is called just after your main event loop. Closes the context if the scene is onscreen and renders when needed the back buffer (useful for picking).
    This method should be registered at the PApplet (which requires it to be pubic and be named as draw) and hence you don't need to call it.
    
    See Also:
    
    pre(), render(), isOffscreen()
  - projection
```
public Matrix projection()
```
    Returns the cached projection matrix computed at openContext().
  - view
```
public Matrix view()
```
    Returns the cached view matrix computed at _bind().
  - projectionView
```
public Matrix projectionView()
```
    Returns the projection times view cached matrix computed at openContext()}.
  - projectionViewInverse
```
public Matrix projectionViewInverse()
```
    Returns the projection times view inverse matrix.
  - openContext
```
public void openContext()
```
    Begins the rendering process (see render(Node)). Use it always before closeContext(). Binds the matrices to the renderer.
    This method is automatically called by render(Node). Call it explicitly when you need to customize that which is to be rendered, as follows:
    scene.openContext(); worldCustomRender() scene.closeContext();
    You may call render(Node) within openContext and closeContext, before openContext or after closeContext, or not even call it.
    See Also:
    
    render(Node), closeContext(), isOffscreen(), context()
  - closeContext
```
public void closeContext()
```
    Ends the rendering process (see render(Node)). Use it always after openContext(). Clears the picking cache. Displays the scene HUD.
    
    See Also:
    
    render(Node), openContext(), isOffscreen(), context()
  - render
```
public void render()
```
    Renders the node tree onto the context() from the eye() viewpoint. Calls addBehavior(Node, BiConsumer) on each visited node (refer to the Node documentation). Same as render(null).
    
    See Also:
    
    render(Node), addBehavior(Node, BiConsumer), Node.cull, Node.bypass(), Node.setShape(Consumer), Node.setShape(processing.core.PShape)
  - render
```
public void render(Node subtree)
```
    Calls openContext(), then renders the node subtree (or the whole tree when subtree is null) onto the context() from the eye() viewpoint, and calls closeContext(). All rendered nodes are marked as such (Node.rendered(Graph)). After issuing a render command you'll be left out at the world coordinate system. If the scene is offscreen this method should be called within openContext() and closeContext().
    Note that the rendering algorithm executes the custom behavior (set with addBehavior(Node, BiConsumer)) on each rendered node. (refer to the Node documentation).
    
    See Also:
    
    addBehavior(Node, BiConsumer), Node.cull, Node.bypass(), Node.setShape(Consumer), Node.setShape(processing.core.PShape)
  - addBehavior
```
public void addBehavior(Node node,
                        BiConsumer<Graph,Node> behavior)
```
    Adds a custom node behavior to be executed for this scene render() algorithm.
    Bypassing the node rendering and/or performing hierarchical culling, i.e., culling of the node and its children, should be done here.
    Graph scene = new Graph(context, width, height); Node space = new Node(); public void behavior(Graph graph, Node node) { if (graph.cullingCondition) { node.cull = true; } else if (bypassCondition) { node.bypass(); } } scene.addBehavior(space, behavior);
    Note that the graph culling condition may be set from ballVisibility(Vector, float) or boxVisibility(Vector, Vector).
    See Also:
    
    addBehavior(Node, Consumer), resetBehavior(Node), render(Node), Node.setBehavior(Graph, BiConsumer), Node.setBehavior(Graph, Consumer), Node.bypass(), Node.cull
  - addBehavior
```
public void addBehavior(Node node,
                        Consumer<Node> behavior)
```
    Same as setBehavior(node, (g, n) -> behavior.accept(n)).
    
    See Also:
    
    addBehavior(Node, BiConsumer), resetBehavior(Node), render(Node), Node.setBehavior(Graph, BiConsumer), Node.setBehavior(Graph, Consumer), Node.bypass(), Node.cull
  - resetBehavior
```
public void resetBehavior(Node node)
```
    Resets the node custom behavior which is set with addBehavior(Node, BiConsumer).
    
    See Also:
    
    addBehavior(Node, BiConsumer), render(Node), Node.bypass(), Node.cull
  - tag
```
public void tag(Node node)
```
    Same as tag(null, node).
    
    See Also:
    
    tag(String, Node)
  - tag
```
public void tag(String tag,
                Node node)
```
    Tags the node (with tag which may be null) (see node(String)). Tagging the eye() is not allowed. Call updateTag(String, int, int) or tag(String, int, int) to tag the node with ray casting.
    
    See Also:
    
    tracks(Node, int, int), updateTag(String, int, int), removeTag(String), hasTag(String, Node), Node.tagging
  - node
```
public Node node()
```
    Same as return node(null).
    
    See Also:
    
    node(String)
  - node
```
public Node node(String tag)
```
    Returns the node tagged with tag (which may be null) which is usually set by ray casting (see updateTag(String, int, int)). May return null. Reset it with removeTag(String).
    
    See Also:
    
    tracks(Node, int, int), updateTag(String, int, int), removeTag(String), hasTag(String, Node), tag(String, Node)
  - isTagValid
```
public boolean isTagValid()
```
    Same as isTagValid(null).
    
    See Also:
    
    isTagValid(String)
  - isTagValid
```
public boolean isTagValid(String tag)
```
    Returns true if some node is tagged with tag (which may be {code null}) and false otherwise.
  - isTagged
```
public boolean isTagged(Node node)
```
    Returns true if the node is currently being tagged and false otherwise.
  - hasTag
```
public boolean hasTag(Node node)
```
    Same as return hasTag(null, node).
    
    See Also:
    
    hasTag(String, Node)
  - hasTag
```
public boolean hasTag(String tag,
                      Node node)
```
    Returns true if node(tag) (see node(String)) returns node and false otherwise.
    
    See Also:
    
    tracks(Node, int, int), updateTag(String, int, int), removeTag(String), tag(String, Node), Node.isTagged(Graph)
  - clearTags
```
public void clearTags()
```
    Removes all tags so that node(String) returns null.
    
    See Also:
    
    node(String), tracks(Node, int, int), updateTag(String, int, int), tag(String, Node), hasTag(String, Node)
  - disableTagging
```
public void disableTagging(Node node)
```
    Disables tagging the node. Calls unTag(node) and then node.disableTagging().
    
    See Also:
    
    untag(Node), Node.tagging
  - untag
```
public void untag(Node node)
```
    Removes all tags pointing to the node.
  - removeTag
```
public void removeTag()
```
    Same as removeTag(null).
    
    See Also:
    
    removeTag(String)
  - removeTag
```
public void removeTag(String tag)
```
    Removes the tag so that a call to isTagValid(String) will return false.
    
    See Also:
    
    node(String), tracks(Node, int, int), updateTag(String, int, int), tag(String, Node), hasTag(String, Node)
  - ndcToScreenLocation
```
public Vector ndcToScreenLocation(Vector vector)
```
    Converts vector location from normalized device coordinates (NDC) to screen space. screenToNDCLocation(Vector) performs the inverse transformation. ndcToScreenDisplacement(Vector) transforms vector displacements instead of locations.
    
    See Also:
    
    screenToNDCLocation(Vector), ndcToScreenDisplacement(Vector)
  - screenToNDCLocation
```
public Vector screenToNDCLocation(Vector vector)
```
    Converts vector location from screen space to normalized device coordinates (NDC). ndcToScreenLocation(Vector) performs the inverse transformation. screenToNDCDisplacement(Vector) transforms vector displacements instead of locations.
    
    See Also:
    
    ndcToScreenLocation(Vector), screenToNDCDisplacement(Vector)
  - screenLocation
```
public Vector screenLocation(Node node)
```
    Converts the node origin location to screen space. Same as return screenLocation(new Vector(), node).
    
    See Also:
    
    screenLocation(Vector), screenLocation(Vector, Node)
  - screenLocation
```
public Vector screenLocation(Vector vector)
```
    Converts vector location from world to screen space. Same as return screenLocation(src, null).
    
    See Also:
    
    screenLocation(Node), screenLocation(Vector, Node)
  - screenLocation
```
public Vector screenLocation(Vector vector,
                             Node node)
```
    Converts vector location from node to screen. Use location(Vector, Node) to perform the inverse transformation.
    The x and y coordinates of the returned vector are expressed in screen coordinates, (0,0) being the upper left corner of the window. The z coordinate ranges between 0 (near plane) and 1 (excluded, far plane).
    
    See Also:
    
    screenLocation(Node), screenLocation(Vector), location(Vector, Node), location(Vector)
  - location
```
public Vector location(Vector pixel)
```
    Convenience function that simply returns location(pixel, null).
    
    See Also:
    
    location(Vector, Node)
  - location
```
public Vector location(Vector pixel,
                       Node node)
```
    Returns the node coordinates of pixel.
    The pixel (0,0) corresponds to the upper left corner of the window. The pixel.z() is a depth value ranging in [0..1] (near and far plane respectively). In 3D note that pixel.z is not a linear interpolation between zNear() and zFar(); pixel.z = zFar() / (zFar() - zNear()) * (1.0f - zNear() / z); where z is the distance from the point you project to the camera, along the viewDirection().
    The result is expressed in the node coordinate system. When node is null, the result is expressed in the world coordinates system. The possible node hierarchy (i.e., when Node.reference() is non-null) is taken into account.
    screenLocation(Vector, Node) performs the inverse transformation.
    screenDisplacement(Vector, Node) converts vector displacements instead of locations.
    This method only uses the intrinsic eye parameters (view and projection matrices), width() and height()). You can hence define a virtual eye and use this method to compute un-projections out of a classical rendering context.
    
    See Also:
    
    screenLocation(Vector, Node), screenDisplacement(Vector, Node), setWidth(int), setHeight(int)
  - ndcToScreenDisplacement
```
public Vector ndcToScreenDisplacement(Vector vector)
```
    Converts vector displacement from normalized device coordinates (NDC) to screen space. screenToNDCDisplacement(Vector) performs the inverse transformation. ndcToScreenLocation(Vector) transforms locations instead of vector displacements.
    
    See Also:
    
    screenToNDCDisplacement(Vector), ndcToScreenLocation(Vector)
  - screenToNDCDisplacement
```
public Vector screenToNDCDisplacement(Vector vector)
```
    Converts vector displacement from screen space to normalized device coordinates (NDC). ndcToScreenDisplacement(Vector) performs the inverse transformation. screenToNDCLocation(Vector) transforms locations instead of vector displacements.
    
    See Also:
    
    ndcToScreenDisplacement(Vector), screenToNDCLocation(Vector)
  - displacement
```
public Vector displacement(Vector vector)
```
    Same as return displacement(vector, null).
    
    See Also:
    
    displacement(Vector, Node), location(Vector, Node)
  - displacement
```
public Vector displacement(Vector vector,
                           Node node)
```
    Converts vector displacement given in screen space to the node coordinate system. The screen space coordinate system is centered at the bounding box of width() * height() * 1} dimensions. The screen space defines the place where user gestures takes place, e.g., shift(Node, float, float, float).
    screenDisplacement(Vector, Node) performs the inverse transformation. screenLocation(Vector, Node) converts pixel locations instead.
    
    See Also:
    
    displacement(Vector, Node), screenLocation(Vector, Node), shift(Node, float, float, float), shift(float, float, float)
  - screenDisplacement
```
public Vector screenDisplacement(Vector vector)
```
    Same as return screenDisplacement(vector, null).
    
    See Also:
    
    screenDisplacement(Vector, Node), screenLocation(Node)
  - screenDisplacement
```
public Vector screenDisplacement(Vector vector,
                                 Node node)
```
    Converts the node vector displacement to screen space. displacement(Vector, Node) performs the inverse transformation. screenLocation(Vector, Node) converts pixel locations instead.
    
    See Also:
    
    displacement(Vector, Node), screenLocation(Vector, Node)
  - interact
```
public void interact(Object... gesture)
```
    Same as interact((String)null, gesture).
    
    See Also:
    
    interact(String, Object...)
  - interact
```
public void interact(String tag,
                     Object... gesture)
```
    Same as if (tag == null || node(tag) != null) interact(node(tag), gesture).
    
    See Also:
    
    interact(Node, Object...)
  - interact
```
public void interact(Node node,
                     Object... gesture)
```
    Call the node (or the eye() if node is null) interact gesture parser function set either with Node.setInteraction(Consumer) or Node.setInteraction(BiConsumer).
    
    See Also:
    
    Node.setInteraction(BiConsumer), Node.setInteraction(Consumer)
  - align
```
public void align()
```
    Same as align((String)null).
    
    See Also:
    
    align(String), align(Node)
  - align
```
public void align(String tag)
```
    Same as if (tag == null || node(tag) != null) align(node(tag)).
    
    See Also:
    
    align(), align(Node), node(String)
  - align
```
public void align(Node node)
```
    Aligns the node (use null for the world) with the eye().
    
    See Also:
    
    align(), align(String tag)
  - focus
```
public void focus()
```
    Same as focus((String)null).
    
    See Also:
    
    focus(String), focus(Node)
  - focus
```
public void focus(String tag)
```
    Same as if (tag == null || node(tag) != null) focus(node(tag)).
    
    See Also:
    
    focus(), focus(Node), node(String)
  - focus
```
public void focus(Node node)
```
    Focuses the node (use null for the world) with the eye().
    Note that the ball center() is used as reference point when focusing the eye.
    
    See Also:
    
    focus(), focus(String tag)
  - zoom
```
public void zoom(float delta)
```
    Same as zoom(delta, Graph.inertia).
    
    See Also:
    
    zoom(float, float)
  - zoom
```
public void zoom(float delta,
                 float inertia)
```
    Same as zoom((String)null, delta, inertia).
    
    See Also:
    
    zoom(String, float, float)
  - zoom
```
public void zoom(String tag,
                 float delta)
```
    Same as zoom(tag, delta, Graph.inertia).
    
    See Also:
    
    zoom(String, float, float)
  - zoom
```
public void zoom(String tag,
                 float delta,
                 float inertia)
```
    Same as if (tag == null || node(tag) != null) zoom(node(tag), delta, inertia).
    
    See Also:
    
    zoom(Node, float, float)
  - zoom
```
public void zoom(Node node,
                 float delta)
```
    Same as zoom(node, delta, Graph.inertia).
    
    See Also:
    
    zoom(Node, float, float)
  - zoom
```
public void zoom(Node node,
                 float delta,
                 float inertia)
```
    Scales the node (use null for the world) according to delta and inertia which should be in [0..1], 0 no inertia & 1 no friction.
  - shift
```
public void shift(float dx,
                  float dy,
                  float dz)
```
    Same as shift(dx, dy, dz, Graph.inertia).
    
    See Also:
    
    shift(float, float, float, float)
  - shift
```
public void shift(float dx,
                  float dy,
                  float dz,
                  float inertia)
```
    Same as shift((String)null, dx, dy, dz, inertia).
    
    See Also:
    
    shift(String, float, float, float, float)
  - shift
```
public void shift(String tag,
                  float dx,
                  float dy,
                  float dz)
```
    Same as shift(tag, dx, dy, dz, Graph.inertia).
    
    See Also:
    
    shift(String, float, float, float, float)
  - shift
```
public void shift(String tag,
                  float dx,
                  float dy,
                  float dz,
                  float inertia)
```
    Same as if (tag == null || node(tag) != null) shift(node(tag), dx, dy, dz, inertia).
    
    See Also:
    
    shift(Node, float, float, float, float)
  - shift
```
public void shift(Node node,
                  float dx,
                  float dy,
                  float dz)
```
    Same as shift(node, dx, dy, dz, Graph.inertia).
    
    See Also:
    
    shift(Node, float, float, float, float)
  - shift
```
public void shift(Node node,
                  float dx,
                  float dy,
                  float dz,
                  float inertia)
```
    Translates the node (use null for the world) according to (dx, dy, dz) defined in screen-space ((a box of width() * height() * 1 dimensions), and inertia which should be in [0..1], 0 no inertia & 1 no friction.
    Note that the ball center() is used as reference point when shifting the eye.
  - turn
```
public void turn(float roll,
                 float pitch,
                 float yaw)
```
    Same as turn(roll, pitch, yaw, Graph.inertia).
    
    See Also:
    
    turn(float, float, float, float)
  - turn
```
public void turn(float roll,
                 float pitch,
                 float yaw,
                 float inertia)
```
    Same as turn((String)null, roll, pitch, yaw, inertia).
    
    See Also:
    
    turn(String, float, float, float, float)
  - turn
```
public void turn(String tag,
                 float roll,
                 float pitch,
                 float yaw)
```
    Same as turn(tag, roll, pitch, yaw, Graph.inertia).
    
    See Also:
    
    turn(String, float, float, float, float)
  - turn
```
public void turn(String tag,
                 float roll,
                 float pitch,
                 float yaw,
                 float inertia)
```
    Same as if (tag == null || node(tag) != null) turn(node(tag), roll, pitch, yaw, inertia).
    
    See Also:
    
    turn(Node, float, float, float, float)
  - turn
```
public void turn(Node node,
                 float roll,
                 float pitch,
                 float yaw)
```
    Same as turn(node, roll, pitch, yaw, Graph.inertia).
    
    See Also:
    
    turn(Node, float, float, float, float)
  - turn
```
public void turn(Node node,
                 float roll,
                 float pitch,
                 float yaw,
                 float inertia)
```
    Rotates the node (use null for the world) around the x-y-z screen axes according to roll, pitch and yaw radians, resp., and according to inertia which should be in [0..1], 0 no inertia & 1 no friction.
    Note that the ball center() is used as reference point when turning the eye.
  - spin
```
public void spin(int pixel1X,
                 int pixel1Y,
                 int pixel2X,
                 int pixel2Y)
```
    Same as spin(pixel1X, pixel1Y, pixel2X, pixel2Y, Graph.inertia).
    
    See Also:
    
    spin(int, int, int, int, float)
  - spin
```
public void spin(int pixel1X,
                 int pixel1Y,
                 int pixel2X,
                 int pixel2Y,
                 float inertia)
```
    Same as spin((String)null, pixel1X, pixel1Y, pixel2X, pixel2Y, inertia).
    
    See Also:
    
    spin(String, int, int, int, int, float)
  - spin
```
public void spin(String tag,
                 int pixel1X,
                 int pixel1Y,
                 int pixel2X,
                 int pixel2Y)
```
    Same as spin(tag, pixel1X, pixel1Y, pixel2X, pixel2Y, Graph.inertia).
    
    See Also:
    
    spin(String, int, int, int, int, float)
  - spin
```
public void spin(String tag,
                 int pixel1X,
                 int pixel1Y,
                 int pixel2X,
                 int pixel2Y,
                 float inertia)
```
    Same as if (tag == null || node(tag) != null) spin(node(tag), pixel1X, pixel1Y, pixel2X, pixel2Y, inertia).
    
    See Also:
    
    spin(Node, int, int, int, int, float)
  - spin
```
public void spin(Node node,
                 int pixel1X,
                 int pixel1Y,
                 int pixel2X,
                 int pixel2Y)
```
    Same as spin(node, pixel1X, pixel1Y, pixel2X, pixel2Y, Graph.inertia).
    
    See Also:
    
    spin(Node, int, int, int, int, float)
  - spin
```
public void spin(Node node,
                 int pixel1X,
                 int pixel1Y,
                 int pixel2X,
                 int pixel2Y,
                 float inertia)
```
    Rotates the node (use null for the world) using an arcball interface, from points (pixel1X, pixel1Y) to (pixel2X, pixel2Y) pixel positions. The inertia controls the gesture strength and it should be in [0..1], 0 no inertia & 1 no friction. The center of the rotation is the screen projected node origin (see Node.worldPosition()).
    For implementation details refer to Shoemake 92 paper: Arcball: a user interface for specifying three-dimensional orientation using a mouse.
    Note that the ball center() is used as pivot when spinning the eye.
  - moveForward
```
public void moveForward(float delta)
```
    Same as moveForward(delta, Graph.inertia).
    
    See Also:
    
    moveForward(float, float)
  - moveForward
```
public void moveForward(float delta,
                        float inertia)
```
    Same as translateEye(0, 0, delta / (zNear() - zFar())). The gesture strength is controlled with inertia which should be in [0..1], 0 no inertia & 1 no friction. Also rescales the eye() if the graph type is Graph.Type.ORTHOGRAPHIC so that nearby objects appear bigger when moving towards them.
    
    See Also:
    
    shift(float, float, float)
  - lookAround
```
public void lookAround(float deltaX,
                       float deltaY)
```
    Same as lookAround(deltaX, deltaY, Graph.inertia).
  - lookAround
```
public void lookAround(float deltaX,
                       float deltaY,
                       float inertia)
```
    Look around (without translating the eye) according to angular displacements deltaX and deltaY expressed in radians. The gesture strength is controlled with inertia which should be in [0..1], 0 no inertia & 1 no friction.
  - cad
```
public void cad(float roll,
                float pitch)
```
    Same as rotateCAD(roll, pitch, new Vector(0, 1, 0), Graph.inertia).
    
    See Also:
    
    cad(float, float, Vector, float)
  - cad
```
public void cad(float roll,
                float pitch,
                Vector upVector)
```
    Same as rotateCAD(roll, pitch, upVector, Graph.inertia).
    
    See Also:
    
    cad(float, float, Vector, float)
  - cad
```
public void cad(float roll,
                float pitch,
                Vector upVector,
                float inertia)
```
    Defines an axis which the eye rotates around. The eye can rotate left or right around this axis. It can also be moved up or down to show the 'top' and 'bottom' views of the scene. As a result, the upVector will always appear vertical in the scene, and the horizon is preserved and stays projected along the eye's horizontal axis. The gesture strength is controlled with inertia which should be in [0..1], 0 no inertia & 1 no friction.
    This method requires calling scene.eye().setYAxis(upVector) (see Node.setYAxis(Vector)) and fit() first.
    Note that the ball center() is used as reference point when rotating the eye.
    
    See Also:
    
    cad(float, float)

Modifier and Type	Field	Description
`static boolean`	`_seeded`
`static float`	`inertia`
`static boolean`	`leftHanded`
`boolean`	`picking`
`static Random`	`random`

Class Graph

1. Types and dimensions

2. Scene-graph handling

The eye

2.1. Transformations

3. Picking and interaction

4. Visibility and culling techniques

5. Matrix handling

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

random

inertia

leftHanded

picking

_seeded

Constructor Detail

Graph

Graph

Method Detail

isNumInstance

castToFloat

castToInt

randomNode

randomize

aspectRatio

width

height

setWidth

setHeight

type

setType

togglePerspective

setFOV

fov

setHFOV

hfov

zNear

zNearSupplier

setZNear

ballZNear

zFar

zFarSupplier

setZFar

ballZFar

clearTree

nodes

branch

beginHUD

endHUD

isEye

eye

setEye

isPointVisible

isPointVisible

ballVisibility

boxVisibility

bounds

distanceToBound

pixelToSceneRatio

sceneToPixelRatio

isFaceFrontFacing

isFaceBackFacing

isFaceFrontFacing

isFaceBackFacing

isConeFrontFacing

isConeBackFacing

isConeFrontFacing

isConeBackFacing

isConeFrontFacing

isConeBackFacing

setBoundingBall

radius

setRadius

center

setCenter

viewDirection