GLViewer (Artisynth API documentation)

java.lang.Object
- maspack.render.GL.GLViewer

All Implemented Interfaces:

com.jogamp.opengl.GLEventListener, java.util.EventListener, HasProperties, GLRenderer, Renderer, Viewer

Direct Known Subclasses:

GL2Viewer, GL3Viewer
```
public abstract class GLViewer
extends java.lang.Object
implements com.jogamp.opengl.GLEventListener, GLRenderer, HasProperties, Viewer
```
Author:

John E Lloyd and ArtiSynth team members

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class GLViewer.BlendFactor

static class GLViewer.GLVersion

static class GLViewer.RotationMode
- Nested classes/interfaces inherited from interface maspack.render.Renderer
  Renderer.ColorInterpolation, Renderer.ColorMixing, Renderer.DrawMode, Renderer.FaceStyle, Renderer.HighlightStyle, Renderer.LineStyle, Renderer.PointStyle, Renderer.Shading

Nested Classes
Modifier and Type	Class and Description
`static class`	`GLViewer.BlendFactor`
`static class`	`GLViewer.GLVersion`
`static class`	`GLViewer.RotationMode`

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`AUTO_FIT`
`static GLViewer.BlendFactor`	`DEFAULT_DST_BLENDING`
`static boolean`	`DEFAULT_ELLIPTIC_CURSOR_ACTIVE`
`static Vector2d`	`DEFAULT_ELLIPTIC_CURSOR_SIZE`
`static GLViewer.RotationMode`	`DEFAULT_ROTATION_MODE`
`static GLViewer.BlendFactor`	`DEFAULT_SRC_BLENDING`
`static PropertyList`	`myProps`
`static boolean`	`useGLJPanel` Whether to use a GLJPanel or GLCanvas

Fields inherited from interface maspack.render.Renderer
HIGHLIGHT, SORT_FACES

Constructor Summary

Constructors
Constructor and Description

GLViewer()

Constructors
Constructor and Description
`GLViewer()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`GLClipPlane`	`addClipPlane()`
`boolean`	`addClipPlane(GLClipPlane clipPlane)`
`GLClipPlane`	`addClipPlane(RigidTransform3d X, double size)`
`void`	`addDragger(Dragger3d d)`
`void`	`addKeyListener(java.awt.event.KeyListener l)`
`Light`	`addLight(float[] position, float[] ambient, float[] diffuse, float[] specular)`
`int`	`addLight(Light light)` Adds a specified light to this viewer and enables it.
`void`	`addMouseInputListener(javax.swing.event.MouseInputListener l)`
`void`	`addMouseWheelListener(java.awt.event.MouseWheelListener l)`
`void`	`addRenderable(IsRenderable d)` Adds a renderable to this viewer.
`void`	`addRenderListener(RenderListener l)` Adds a render listener to this viewer.
`void`	`addSelectionListener(ViewerSelectionListener l)` Adds a selection listener to this viewer that will fire whenever objects are selected.
`void`	`addVertex(double px, double py, double pz)` Adds a vertex to a primitive being drawn while in draw mode.
`void`	`addVertex(float[] pnt)` Adds a vertex to a primitive being drawn while in draw mode.
`void`	`addVertex(float px, float py, float pz)` Adds a vertex to a primitive being drawn while in draw mode.
`void`	`addVertex(Vector3d pnt)` Adds a vertex to a primitive being drawn while in draw mode.
`void`	`autoFit()` Calls either `Viewer.autoFitOrtho()` or `Viewer.autoFitPerspective()`, depending on whether the current view is orthogonal or perspective.
`void`	`autoFitOrtho()` Auto computes the eye and center positions and an orthogonal viewing frustum to fit the current scence.
`void`	`autoFitPerspective()` Auto computes the eye and center positions and an perpective viewing frustum to fit the current scence.
`abstract void`	`awaitScreenShotCompletion()`
`boolean`	`begin2DRendering()` Puts this Renderer into 2D rendering mode, or returns `false` if 2D rendering is not supported.
`boolean`	`begin2DRendering(double w, double h)` Puts this Renderer into 2D rendering mode, or returns `false` if 2D rendering is not supported.
`void`	`begin2DRendering(double left, double right, double bottom, double top)`
`void`	`beginDraw(Renderer.DrawMode mode)` Begins draw mode.
`com.jogamp.opengl.GL`	`beginGL()` Begin application-defined GL rendering, using GL primitives based on handles returned by `getGL()`, etc.
`void`	`beginSelectionQuery(int idx)` Begins a selection query with the {\it query identifier} `qid`.
`void`	`beginSubSelection(IsSelectable s, int idx)` Begins selection for a `IsSelectable` `s`that manages its own selection; this call should be used in place of `Renderer.beginSelectionQuery(int)` for such objects.
`double`	`centerDistancePerPixel()` Computes the distance per pixel at the viewpoint center.
`abstract void`	`cleanupScreenShots()`
`void`	`clearClipPlanes()`
`void`	`clearDraggers()`
`void`	`clearPickMatrix()`
`void`	`clearRenderables()` Removes all renderables from this viewer.
`void`	`display(com.jogamp.opengl.GLAutoDrawable drawable)`
`abstract void`	`display(com.jogamp.opengl.GLAutoDrawable drawable, int flags)`
`void`	`dispose()` MUST BE CALLED by whatever frame when it is going down, will notify any shared resources that they can be cleared.
`void`	`dispose(com.jogamp.opengl.GLAutoDrawable drawable)` Called any time GL context is switched! e.g.
`double`	`distancePerPixel(Vector3d pnt)` Computes the distance per pixel for a point specified with respect to world coordinates.
`void`	`draw(RenderObject robj)` Draws all the primitives in the first point, line and triangles groups.
`void`	`drawArrow(Vector3d pnt0, Vector3d pnt1, double rad, boolean capped)` Draws a solid arrow between two points in model coordinates, using the current shading and material.
`void`	`drawAxes(RigidTransform3d X, double len, int width, boolean highlight)` Draws a set of coordinate axes representing a rigid coordinate frame `X`.
`void`	`drawBox(Vector3d pnt, Vector3d widths)` Draws an axis-aligned box in model coordinates, using the current shading and material.
`void`	`drawCone(Vector3d pnt0, Vector3d pnt1, double rad0, double rad1, boolean capped)` Draws a cone between two points in model coordinates, using the current shading and material.
`void`	`drawCube(Vector3d pnt, double w)` Draws an axis-aligned cube with a specified width centered at a point in model coordinates, using the current shading and material.
`void`	`drawCylinder(Vector3d pnt0, Vector3d pnt1, double rad, boolean capped)` Draws a cylinder between two points in model coordinates, using the current shading and material.
`void`	`drawLine(double px0, double py0, double pz0, double px1, double py1, double pz1)` Draws a single line between two points in model coordinates, using the current line width, material, and shading.
`void`	`drawLine(RenderProps props, float[] pnt0, float[] pnt1, boolean highlight)` Draws a single line between two points in model coordinates, using the line style, radius, line color, and shading specified by the render properties argument `props`.
`void`	`drawLine(RenderProps props, float[] pnt0, float[] pnt1, boolean capped, boolean highlight)` Draws a single line between two points in model coordinates, using the line style, radius, line color, and shading specified by the render properties argument `props`.
`void`	`drawLine(Vector3d pnt0, Vector3d pnt1)` Draws a single line between two points in model coordinates, using the current line width, material, and shading.
`void`	`drawLines(RenderObject robj)` Draws all the lines in the first line group of the specified render object, using the current material and shading.
`void`	`drawLines(RenderObject robj, int gidx, Renderer.LineStyle style, double rad)` Draws all the lines in the specified line group of the supplied render object, using the current material and shading.
`void`	`drawLines(RenderObject robj, Renderer.LineStyle style, double rad)` Draws all the lines in the first line group of the specified render object, using the current material and shading.
`void`	`drawPoint(double px, double py, double pz)` Draws a single point located at `px`, `py` and `pz` in model coordinates, using the current point size, material, and shading.
`void`	`drawPoint(Vector3d pnt)` Draws a single point located at `pnt` in model coordinates, using the current point size, material, and shading.
`void`	`drawPoints(RenderObject robj)` Draws all the points in the first point group of the specified render object, using the current material and shading.
`void`	`drawPoints(RenderObject robj, int gidx, Renderer.PointStyle style, double rad)` Draws all the points in the specified point group of the supplied render object, using the current material and shading.
`void`	`drawPoints(RenderObject robj, Renderer.PointStyle style, double rad)` Draws all the points in the first point group of the specified render object, using the current material and shading.
`void`	`drawSolidAxes(RigidTransform3d X, double[] lens, double rad, boolean highlight)` Draws a solid set of coordinate axes representing a rigid coordinate frame `X`.
`void`	`drawSolidAxes(RigidTransform3d X, double len, double rad, boolean highlight)` Draws a solid set of coordinate axes representing a rigid coordinate frame `X`.
`void`	`drawSphere(Vector3d pnt, double rad)` Draws a sphere with a specified radius centered at a point in model coordinates, using the current shading and material.
`void`	`drawSpindle(Vector3d pnt0, Vector3d pnt1, double rad)` Draws a spindle between two points in model coordinates, using the current shading and material.
`double`	`drawText(java.awt.Font font, java.lang.String str, Vector3d pos, double emSize)` Draws text in the x-y plane in model coordinates.
`double`	`drawText(java.lang.String str, float[] pos, double emSize)` Draws text in the x-y plane in model coordinates.
`double`	`drawText(java.lang.String str, Vector3d pos, double emSize)` Draws text in the x-y plane in model coordinates.
`void`	`drawTriangle(Vector3d pnt0, Vector3d pnt1, Vector3d pnt2)` Draws a single triangular face specified by three points, using the current shading, lighting and material.
`void`	`drawTriangles(RenderObject robj)` Draws all the triangles in the first triangle group of the specified render object, using the current material and shading.
`void`	`drawTriangles(RenderObject robj, int gidx)` Draws all the triangles in the specified triangle group of the render object, using the current material and shading.
`void`	`drawVertices(RenderObject robj, VertexIndexArray idxs, Renderer.DrawMode mode)` Draws a selection of vertices associated with the specified RenderObject, using a specified drawing mode and the current material and shading.
`void`	`end2DRendering()` Take this Renderer out of 2D rendering mode, by reenabling the depth buffer and restoring the model and projection matrices to the values they had when 2D rendering mode was first entered.
`void`	`endDraw()` Ends draw mode.
`void`	`endGL()` Ends application-defined GL rendering.
`void`	`endSelectionQuery()` Ends a selection query that was initiated with a call to `Renderer.beginSelectionQuery(int)`.
`void`	`endSubSelection()` Ends object sub-selection that was initiated with a call to `Renderer.beginSubSelection(maspack.render.IsSelectable, int)`.
`double`	`estimateRadiusAndCenter(Point3d center)` Size is the diameter of the bounding box.
`void`	`finish2DRendering()`
`PropertyList`	`getAllPropertyInfo()` Returns a list giving static information about all properties exported by this object.
`boolean`	`getAutoSwapBufferMode()` Check whether or not the GL canvas is set to auto swap buffers
`AxisAlignedRotation`	`getAxialView()` Returns the current axis-aligned view.
`double`	`getAxisLength()`
`float[]`	`getBackColor(float[] rgba)` Returns the RGB or RGBA values for the back color as a float array, or `null` if no back color is set.
`java.awt.Color`	`getBackgroundColor()` Returns the background color for this viewer.
`float[]`	`getBackgroundColor(float[] rgba)` Returns the background color for this viewer.
`GLViewer.BlendFactor`	`getBlendDestFactor()`
`GLViewer.BlendFactor`	`getBlendSourceFactor()`
`boolean`	`getBounds(Point3d pmin, Point3d pmax)`
`BumpMapProps`	`getBumpMap()` Returns the most recently set bump mapping properties, or `null` if no bump mapping has been set or bump mapping is not supported.
`GLDrawableComponent`	`getCanvas()`
`int`	`getCellDivisions()`
`double`	`getCellSize()`
`Point3d`	`getCenter()` Returns the current center point
`RigidTransform3d`	`getCenterToWorld()` Returns a transform from world coordinates to center coordinates, with the axes aligned to match the current eyeToWorld transform.
`GLClipPlane`	`getClipPlane(int idx)`
`GLClipPlane[]`	`getClipPlanes()`
`float[]`	`getColor(float[] rgba)` Gets a copy of the current diffuse "color"
`Renderer.ColorInterpolation`	`getColorInterpolation()` Returns the color interpolation currently being used by this Renderer.
`ColorMapProps`	`getColorMap()` Returns the properties for the most recently set color map, or `null` if no color map is currently set or color mapping is not supported.
`com.jogamp.opengl.GLContext`	`getContext()` Gets the "currently active" context.
`AxisAlignedRotation`	`getDefaultAxialView()`
`java.awt.Font`	`getDefaultFont()` Retrieves the default font.
`int`	`getDepthOffset()` The current depth offset level.
`java.util.LinkedList<Dragger3d>`	`getDraggers()`
`boolean`	`getEllipticCursorActive()`
`Vector2d`	`getEllipticCursorSize()`
`boolean`	`getEllipticSelection()`
`float[]`	`getEmission(float[] rgb)` Returns the RGB values for the emission color as a float array.
`RenderList`	`getExternalRenderList()` Returns the external render list for this viewer, or `null` if the viewer does not have an external render list.
`Point3d`	`getEye()` Returns the eye position.
`void`	`getEyeToWorld(RigidTransform3d X)` Gets the eye-to-world transform for this viewer.
`Vector3d`	`getEyeZDirection()` Gives the direction, in world coordinates, of a vector that is perpendicular to the screen and points towards the viewer.
`Renderer.FaceStyle`	`getFaceStyle()` Returns the current mode for rendering faces.
`double`	`getFarPlaneDistance()` Returns the distance, in model coordinates, from the eye to the far clip plane.
`float[]`	`getFrontColor(float[] rgba)` Returns the RGB or RGBA values for the front color as a float array.
`void`	`getFrustum(double[] bounds)` Returns the bounds for the current frustum.
`com.jogamp.opengl.GL`	`getGL()`
`GLGridPlane`	`getGrid()`
`boolean`	`getGridVisible()`
`void`	`getHighlightColor(float[] rgba)` Returns the color that is used to highlight objects when the highlighting method is `Renderer.HighlightStyle.COLOR`.
`boolean`	`getHighlighting()` Queries whether or not highlighting is enabled.
`Renderer.HighlightStyle`	`getHighlightStyle()` Returns the highlight style used by this renderer.
`int`	`getIndexOfLight(Light light)` Get the index of a specified light in this viewer.
`java.awt.event.KeyListener[]`	`getKeyListeners()`
`Light`	`getLight(int i)` Get a specified light by index in this viewer.
`float`	`getLineWidth()` Returns the current width for rendering lines, in pixels.
`int`	`getMaxGLClipPlanes()`
`AffineTransform3dBase`	`getModelMatrix()` Gets the current model matrix.
`void`	`getModelMatrix(AffineTransform3d m)` Gets the current model matrix.
`void`	`getModelMatrix(Matrix4d X)`
`GLMouseListener`	`getMouseHandler()`
`javax.swing.event.MouseInputListener[]`	`getMouseInputListeners()`
`java.awt.event.MouseWheelListener[]`	`getMouseWheelListeners()`
`NormalMapProps`	`getNormalMap()` Returns the most recently set normal mapping properties, or `null` if no normal mapping has been set or normal mapping is not supported.
`int`	`getNumClipPlanes()`
`float`	`getPointSize()` Returns the current size for rendering points, in pixels.
`boolean`	`getProfiling()`
`Matrix4d`	`getProjectionMatrix()`
`void`	`getProjectionMatrix(Matrix4d X)`
`Property`	`getProperty(java.lang.String name)` Returns a property associated with a specified path name.
`int`	`getRenderFlags()`
`RenderListener[]`	`getRenderListeners()` Returns an array of all render listeners held by this viewer.
`GLViewer.RotationMode`	`getRotationMode()`
`boolean`	`getRoundedPoints()`
`int`	`getScreenHeight()` Returns the screen height, in pixels
`int`	`getScreenWidth()` Returns the screen width, in pixels
`int`	`getScreenX()`
`int`	`getScreenY()`
`void`	`getSelectingColor(float[] rgba)`
`ViewerSelectionEvent`	`getSelectionEvent()`
`ViewerSelectionFilter`	`getSelectionFilter()` Returns the current selection filter for the viewer, if any.
`ViewerSelectionListener[]`	`getSelectionListeners()` Returns a list of all the selection listener in this viewer.
`boolean`	`getSelectOnPress()`
`Renderer.Shading`	`getShading()` Returns the current shading model used by this renderer.
`float`	`getShininess()` Returns the current shininess parameter.
`boolean`	`getSolidAxes()`
`float[]`	`getSpecular(float[] rgb)` Returns the RGB values for the specular color as a float array.
`int`	`getSurfaceResolution()` Returns the resolution used for creating mesh representations of curved solids.
`java.awt.geom.Rectangle2D`	`getTextBounds(java.awt.Font font, java.lang.String str, double emSize)` Computes and returns the logical bounding box of the supplied text.
`abstract GLTextRenderer`	`getTextRenderer()`
`AffineTransform2dBase`	`getTextureMatrix()` Gets the current texture matrix.
`void`	`getTextureMatrix(AffineTransform2d X)` Gets the current texture matrix.
`boolean`	`getTransparencyFaceCulling()`
`Vector3d`	`getUpVector()` Returns the ``up'' vector which this viewer uses in some instances to determine the direction of the y axis of the eye coordinate system.
`Renderer.ColorMixing`	`getVertexColorMixing()` Returns the method used for combining vertex coloring and material coloring.
`double`	`getVerticalFieldOfView()` Returns the default vertical field of view in degrees.
`RigidTransform3d`	`getViewMatrix()` Gets the current view matrix.
`void`	`getViewMatrix(Matrix4d X)`
`void`	`getViewMatrix(RigidTransform3d TWE)` Gets the current view matrix.
`double`	`getViewPlaneDistance()` Returns the distance, in model coordinates, from the eye to view plane (which corresponds to the far clip plane).
`double`	`getViewPlaneHeight()` Returns the height of the view plane, in model coordinates.
`double`	`getViewPlaneWidth()` Returns the width of the view plane, in model coordinates.
`abstract boolean`	`grabPending()`
`boolean`	`has2DRendering()` Returns `true` if this Renderer supports 2D rendering mode.
`abstract boolean`	`hasColorMapMixing(Renderer.ColorMixing cmix)` Queries whether or not a specified method for combining color map and material coloring is supported by this Renderer.
`boolean`	`hasHighlightStyle(Renderer.HighlightStyle style)` Returns `true` if this viewer supports the indicated highlighting style.
`boolean`	`hasSelection()` Queries whether or not this Renderer supports selection.
`boolean`	`hasTextRendering()` Queries whether or not this renderer supports text rendering.
`boolean`	`hasVertexColoring()`
`abstract boolean`	`hasVertexColorMixing(Renderer.ColorMixing cmix)` Queries whether or not a specified method for combining vertex coloring and material coloring is supported by this Renderer.
`void`	`init(com.jogamp.opengl.GLAutoDrawable drawable)` Called any time GL context is switched! e.g.
`boolean`	`is2DRendering()` Check whether the Renderer is currently in 2D rendering mode.
`boolean`	`isAutoResizeEnabled()`
`boolean`	`isAutoViewportEnabled()`
`boolean`	`isBlendingEnabled()`
`boolean`	`isDepthEnabled()`
`boolean`	`isDepthWriteEnabled()`
`boolean`	`isLightingEnabled()`
`boolean`	`isMultiSampleEnabled()`
`boolean`	`isOrthogonal()` Returns true if the current viewing projection is orthogonal.
`boolean`	`isSelectable(IsSelectable s)` Returns true if `s` is selectable in the current selection context.
`boolean`	`isSelecting()` Returns true if the renderer is currently performing a selection render.
`boolean`	`isSelectionEnabled()` Returns `true` if viewer-based selection is enabled.
`boolean`	`isSpecialRenderFlagsSet()` Used to see if rendering with special flags has been performed yet.
`boolean`	`isTextureMappingEnabled()`
`boolean`	`isTransparencyEnabled()`
`boolean`	`isVertexColoringEnabled()`
`abstract void`	`maybeUpdateMaterials()`
`void`	`mulModelMatrix(AffineTransform3dBase trans)` Post-multiplies the model matrix by the specified transform X, which may be either a `RigidTransform3d` or an `AffineTransform3d`.
`int`	`numFreeClipPlanes()`
`int`	`numLights()` Returns the number of lights in this viewer.
`int`	`numMultiSamples()`
`int`	`numSelectionQueriesNeeded()`
`void`	`paint()`
`boolean`	`popModelMatrix()` Restores the model matrix by popping it off the model matrix stack
`boolean`	`popProjectionMatrix()`
`boolean`	`popTextureMatrix()`
`boolean`	`popViewMatrix()`
`void`	`pushModelMatrix()` Saves the model matrix by pushing it onto the model matrix stack.
`void`	`pushProjectionMatrix()`
`void`	`pushTextureMatrix()`
`void`	`pushViewMatrix()`
`boolean`	`removeClipPlane(GLClipPlane clipPlane)`
`void`	`removeDragger(Dragger3d d)`
`void`	`removeKeyListener(java.awt.event.KeyListener l)`
`void`	`removeLight(int i)` Removes the light with the specified index from this viewer.
`boolean`	`removeLight(Light light)` Removes the indicated light from this viewer.
`void`	`removeMouseInputListener(javax.swing.event.MouseInputListener l)`
`void`	`removeMouseWheelListener(java.awt.event.MouseWheelListener l)`
`boolean`	`removeRenderable(IsRenderable d)` Removes a renderable from this viewer.
`boolean`	`removeRenderListener(RenderListener l)` Removes a render listener from this viewer.
`boolean`	`removeSelectionListener(ViewerSelectionListener l)` Removes a selection listener from this viewer.
`void`	`repaint()` Request a repaint operation for this viewer.
`void`	`rerender()` Convenience methods that calls `Viewer.rerender(int)` with `flags` = 0.
`void`	`rerender(int flags)` Request a render with special flags that will be used only for the duration of that render.
`void`	`resetEllipticCursorSize()`
`void`	`reshape(com.jogamp.opengl.GLAutoDrawable drawable, int x, int y, int w, int h)`
`void`	`restoreDefaultState(boolean strictChecking)` Restores the renderer to its default state.
`void`	`rotate(double xang, double yang)` Rotate the eye coordinate frame about the center point
`void`	`rotateModelMatrix(double zdeg, double ydeg, double xdeg)` Rotates the model frame.
`void`	`scaleModelMatrix(double s)` Scales the current model matrix.
`void`	`scaleModelMatrix(double sx, double sy, double sz)`
`boolean`	`setAutoResizeEnabled(boolean enabled)` Allows you to explicitly enable or disable resizing of viewer (may want to disable while recording video or while selecting)
`void`	`setAutoSwapBufferMode(boolean enable)` Enable or disable the GL Canvas auto-swap mode
`boolean`	`setAutoViewportEnabled(boolean enabled)` Allows you to explicitly enable or disable automatic viewport adjustment based on screen width/height (may want to disable while recording video or while selecting)
`void`	`setAxialView(AxisAlignedRotation REW)` Sets an axial (or axis-aligned) view.
`void`	`setAxisLength(double len)`
`void`	`setBackColor(float[] rgba)` Optionally sets the diffuse and ambient colors used for the subsequent rendering of the back faces of triangles.
`void`	`setBackgroundColor(java.awt.Color color)` Sets the background color for this viewer.
`void`	`setBackgroundColor(float[] rgba)` Sets the background color for this viewer.
`void`	`setBackgroundColor(float r, float g, float b)`
`void`	`setBlendDestFactor(GLViewer.BlendFactor factor)`
`void`	`setBlendingEnabled(boolean set)`
`void`	`setBlendSourceFactor(GLViewer.BlendFactor factor)`
`BumpMapProps`	`setBumpMap(BumpMapProps props)` If bump mapping is supported, sets up bump mapping according to the properties specified by `props`, or removes bump mapping if `props` is `null`.
`void`	`setCenter(Point3d c)` Sets the center point for the viewer, and adjusts the eye coordinates so that the eye's -z axis is directed at the center point.
`void`	`setColor(java.awt.Color color)` Sets the diffuse and ambient colors to be used for subsequent rendering of primitives.
`void`	`setColor(float[] rgba)` Sets the diffuse and ambient colors to the value specified by `rgba`.
`void`	`setColor(float[] rgba, boolean highlight)` Sets the diffuse and ambient colors to the value specified by `rgba`, and enables or disables highlighting according to the value of `highlight`.
`void`	`setColor(float r, float g, float b)` Sets the diffuse and ambient colors to be used for subsequent rendering of primitives.
`void`	`setColor(float r, float g, float b, float a)` Sets the diffuse and ambient colors to be used for subsequent rendering of primitives.
`Renderer.ColorInterpolation`	`setColorInterpolation(Renderer.ColorInterpolation interp)` Sets the color interpolation method to be used
`ColorMapProps`	`setColorMap(ColorMapProps props)` If color mapping is supported, sets up a color map according to the properties specified by `props`, or removes any color map if `props` is `null`.
`void`	`setDefaultAxialView(AxisAlignedRotation view)`
`void`	`setDefaultFont(java.awt.Font font)` Sets default font for text rendering
`void`	`setDefaultLights()`
`boolean`	`setDepthEnabled(boolean set)`
`void`	`setDepthOffset(int offset)` Set a depth offset for the projection matrix.
`boolean`	`setDepthWriteEnabled(boolean set)`
`void`	`setDrawTool(Dragger3d d)`
`void`	`setEdgeColoring(RenderProps props, boolean highlight)` Sets the diffuse and ambient colors to the edge color in `props`, and enables or disables highlighting according to the value of `highlight`.
`void`	`setEllipticCursorActive(boolean active)`
`void`	`setEllipticCursorSize(Vector2d size)`
`void`	`setEllipticSelection(boolean enable)`
`void`	`setEmission(float[] rgb)` Sets the emission color to be used for subsequent rendering of primitives.
`void`	`setExternalRenderList(RenderList list)` Sets the external render list for this viewer.
`void`	`setEye(Point3d eye)` Moves the eye coordinates to a specifed location in world coordinates, and adjusts the orientation so that the eye's -z axis is directed at the center point.
`void`	`setEyeToWorld(Point3d eye, Point3d center, Vector3d up)` Sets the eyeToWorld transform for this viewer, using the canonical parameters used by the GL `lookat` method.
`void`	`setEyeToWorld(RigidTransform3d X)` Directly sets the eye coordinate frame.
`void`	`setFaceColoring(RenderProps props, boolean highlight)` Sets the diffuse and ambient colors to the face color in `props`, and enables or disables highlighting according to the value of `highlight`.
`void`	`setFaceColoring(RenderProps props, float[] rgba, boolean highlight)` Sets the diffuse and ambient colors to `rgba`, and enables or disables highlighting according to the value of `highlight`.
`Renderer.FaceStyle`	`setFaceStyle(Renderer.FaceStyle style)` Sets the style for rendering faces.
`void`	`setFrontAlpha(float a)` Sets the alpha value for the front material.
`void`	`setFrontColor(float[] rgba)` Sets the diffuse and ambient colors to be used for subsequent rendering of primitives.
`void`	`setGlobalRenderFlags(int flags)`
`void`	`setGridVisible(boolean visible)`
`void`	`setHighlightColor(java.awt.Color color)`
`boolean`	`setHighlighting(boolean enable)` Enables or disables highlighting.
`boolean`	`setHighlightStyle(Renderer.HighlightStyle style)` Sets the highlighting style for this viewer.
`boolean`	`setLightingEnabled(boolean enable)`
`void`	`setLineColoring(RenderProps props, boolean highlight)` Sets the diffuse and ambient colors to the line color in `props`, and enables or disables highlighting according to the value of `highlight`.
`Renderer.Shading`	`setLineShading(RenderProps props)` Sets the shading appropriate to the line style specified in `props`.
`void`	`setLineWidth(float w)` Sets the width for rendering lines, in pixels.
`void`	`setMaterial(float[] frontRgba, float[] backRgba, float shininess, boolean selected)`
`void`	`setModelMatrix(AffineTransform3dBase m)` Sets the model matrix to the specified transform.
`void`	`setModelMatrix2d(double left, double right, double bottom, double top)` Sets the model matrix to perform scaling and translation in the x-y plane so that the model coordinates (left,bottom) and (right,top) map onto (-1,1) and (1,1) in world coordinates.
`void`	`setMouseHandler(GLMouseListener handler)`
`void`	`setMultiSampleEnabled(boolean set)`
`void`	`setNormal(double nx, double ny, double nz)` Sets the normal to be associated with the next vertex to be added while in draw mode.
`void`	`setNormal(float nx, float ny, float nz)` Sets the normal to be associated with the next vertex to be added while in draw mode.
`void`	`setNormal(Vector3d nrm)` Sets the normal to be associated with the next vertex to be added while in draw mode.
`NormalMapProps`	`setNormalMap(NormalMapProps props)` If normal mapping is supported, sets up a normal map according to the properties specified by `props`, or removes normal mapping if `props` is `null`.
`void`	`setOrthogonal(double fieldHeight, double near, double far)` Sets the viewing frustum to an orthogonal projection centered about the -z axis.
`void`	`setOrthogonal(double left, double right, double bottom, double top, double near, double far)` Sets the viewing frustum to a general orthogonal projection.
`void`	`setOrthographicView(boolean enable)`
`void`	`setPerspective(double fieldOfView, double near, double far)` Sets the viewing frustum to a perspective projection centered about the -z axis.
`void`	`setPerspective(double left, double right, double bottom, double top, double near, double far)` Sets the viewing frustum to a general perspective projection.
`void`	`setPerspective(double left, double right, double bottom, double top, double near, double far, boolean setExplicit)`
`void`	`setPointColoring(RenderProps props, boolean highlight)` Sets the diffuse and ambient colors to the point color in `props`, and enables or disables highlighting according to the value of `highlight`.
`Renderer.Shading`	`setPointShading(RenderProps props)` Sets the shading appropriate to the point style specified in `props`.
`void`	`setPointSize(float s)` Sets the size for rendering points, in pixels.
`void`	`setProfiling(boolean enable)`
`void`	`setPropsColoring(RenderProps props, float[] rgba, boolean highlight)` Sets the diffuse and ambient colors to `rgba`, and enables or disables highlighting according to the value of `highlight`.
`Renderer.Shading`	`setPropsShading(RenderProps props)` Sets the shading to that shading specified by `props.getShading()`.
`void`	`setRotationMode(GLViewer.RotationMode mode)`
`boolean`	`setRoundedPoints(boolean enable)`
`void`	`setSelectingColor(java.awt.Color color)` Special color used for selection (primarily for color-based selection, although since the renderbuffers are typically not drawn, can be used for any selection method).
`void`	`setSelectingColor(float r, float g, float b, float a)` The material color to use if the renderer is currently performing a selection render.
`void`	`setSelectionEnabled(boolean selection)` Enables or disables viewer-based selection.
`void`	`setSelectionFilter(ViewerSelectionFilter filter)` Sets a selection filter for the viewer.
`void`	`setSelectOnPress(boolean enable)`
`Renderer.Shading`	`setShading(Renderer.Shading shading)` Sets the shading model used by this renderer.
`void`	`setShininess(float s)` Sets the shininess parameter to be used for subsequent rendering of primitives (see `Renderer.getShininess()`.
`void`	`setSolidAxes(boolean enable)`
`void`	`setSpecular(float[] rgb)` Sets the specular color to be used for subsequent rendering of primitives.
`int`	`setSurfaceResolution(int nres)` Sets the resolution used for creating mesh representations of curved solids.
`void`	`setTextureCoord(double tx, double ty)` Sets the texture coordinate to be associated with the next vertex to be added while in draw mode.
`void`	`setTextureCoord(float x, float y)` Sets the texture coordinate to be associated with the next vertex to be added while in draw mode.
`void`	`setTextureCoord(Vector2d tex)` Sets the texture coordinate to be associated with the next vertex to be added while in draw mode.
`boolean`	`setTextureMappingEnabled(boolean enable)`
`void`	`setTextureMatrix(AffineTransform2dBase T)` Sets the texture coordinate transformation matrix to the specified transform.
`void`	`setTransparencyEnabled(boolean enable)`
`boolean`	`setTransparencyFaceCulling(boolean enable)`
`abstract void`	`setupScreenShot(int w, int h, java.io.File file, java.lang.String format)`
`abstract void`	`setupScreenShot(int w, int h, int samples, java.io.File file, java.lang.String format)` Setup for a screenshot during the next render cycle
`void`	`setUpVector(Vector3d upVector)` Sets the ``up'' vector for this viewer to a specified value, and adjusts the eye-to-world transform to account for this new vertical direction, while the eye's -z axis is directed at the center point.
`boolean`	`setVertexColoringEnabled(boolean enable)`
`Renderer.ColorMixing`	`setVertexColorMixing(Renderer.ColorMixing cmix)` Sets the method used for combining vertex coloring and material coloring.
`void`	`setVerticalFieldOfView(double fov)` Sets the default vertical field of view in degrees.
`void`	`setViewMatrix(RigidTransform3d v)` Sets the view matrix for this viewer.
`void`	`setViewport(com.jogamp.opengl.GL gl, int x, int y, int width, int height)` Sets the viewer's viewport.
`void`	`setViewVolume(double near, double far)`
`void`	`translateModelMatrix(double tx, double ty, double tz)` Translates the model frame.
`void`	`translateModelMatrix(Vector3d t)`
`void`	`zoom(double s)` Zoom in or out by a specified scale factor.

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

Methods inherited from interface maspack.render.Renderer
drawArrow, drawArrow, drawAxes, drawBox, drawBox, drawCone, drawCube, drawCylinder, drawLine, drawLine, drawLines, drawLines, drawLines, drawLineStrip, drawPoint, drawPoint, drawPoints, drawPoints, drawPoints, drawSphere, drawSpindle, drawText, drawTriangle, drawTriangles, drawTriangles, drawVertices, drawVertices, hasBumpMapping, hasColorMapping, hasNormalMapping

- Field Detail
  - useGLJPanel
```
public static boolean useGLJPanel
```
    Whether to use a GLJPanel or GLCanvas
  - DEFAULT_SRC_BLENDING
```
public static GLViewer.BlendFactor DEFAULT_SRC_BLENDING
```
  - DEFAULT_DST_BLENDING
```
public static GLViewer.BlendFactor DEFAULT_DST_BLENDING
```
  - AUTO_FIT
```
public static final double AUTO_FIT
```
    See Also:
    
    Constant Field Values
  - DEFAULT_ROTATION_MODE
```
public static GLViewer.RotationMode DEFAULT_ROTATION_MODE
```
  - DEFAULT_ELLIPTIC_CURSOR_SIZE
```
public static Vector2d DEFAULT_ELLIPTIC_CURSOR_SIZE
```
  - DEFAULT_ELLIPTIC_CURSOR_ACTIVE
```
public static boolean DEFAULT_ELLIPTIC_CURSOR_ACTIVE
```
  - myProps
```
public static PropertyList myProps
```
- Constructor Detail
  - GLViewer
```
public GLViewer()
```
- Method Detail
  - getAllPropertyInfo
```
public PropertyList getAllPropertyInfo()
```
    Description copied from interface: HasProperties
    
    Returns a list giving static information about all properties exported by this object.
    
    Specified by:
    
    getAllPropertyInfo in interface HasProperties
    
    Returns:
    
    static information for all exported properties
  - getProperty
```
public Property getProperty(java.lang.String name)
```
    Returns a property associated with a specified path name. All properties exported by this object must have a name which is a valid Java identifier. Specifying one of these names causes the corresponding Property to be returned. Handles to sub-properties can also be obtained by delimiting the sub-property name(s) by '.' characters. A sub-property exists if the value of a property is itself an object which exports properties. It is only possible to obtain a sub-property handle if each of its ancestor properties exports their values by reference.
    
    Specified by:
    
    getProperty in interface HasProperties
    
    Parameters:
    
    name - name of the desired property or sub-property
    
    Returns:
    
    handle to the property
  - setProfiling
```
public void setProfiling(boolean enable)
```
  - getProfiling
```
public boolean getProfiling()
```
  - getEllipticCursorSize
```
public Vector2d getEllipticCursorSize()
```
  - setEllipticCursorSize
```
public void setEllipticCursorSize(Vector2d size)
```
  - resetEllipticCursorSize
```
public void resetEllipticCursorSize()
```
  - getEllipticCursorActive
```
public boolean getEllipticCursorActive()
```
  - setEllipticCursorActive
```
public void setEllipticCursorActive(boolean active)
```
  - getSurfaceResolution
```
public int getSurfaceResolution()
```
    Description copied from interface: Renderer
    
    Returns the resolution used for creating mesh representations of curved solids.
    
    Specified by:
    
    getSurfaceResolution in interface Renderer
    
    Returns:
    
    resolution for approximating curved surfaces
    
    See Also:
    
    Renderer.setSurfaceResolution(int)
  - setSurfaceResolution
```
public int setSurfaceResolution(int nres)
```
    Description copied from interface: Renderer
    
    Sets the resolution used for creating mesh representations of curved solids. The number represents the number of line segments that would be used to approximate a circle. This level of resolution is then employed to create the mesh.
    
    Specified by:
    
    setSurfaceResolution in interface Renderer
    
    Parameters:
    
    nres - resolution for curved surfaces
    
    Returns:
    
    previous resolution
  - setAxisLength
```
public void setAxisLength(double len)
```
  - getAxisLength
```
public double getAxisLength()
```
  - setSolidAxes
```
public void setSolidAxes(boolean enable)
```
  - getSolidAxes
```
public boolean getSolidAxes()
```
  - setGridVisible
```
public void setGridVisible(boolean visible)
```
  - getGridVisible
```
public boolean getGridVisible()
```
  - getKeyListeners
```
public java.awt.event.KeyListener[] getKeyListeners()
```
  - addKeyListener
```
public void addKeyListener(java.awt.event.KeyListener l)
```
  - removeKeyListener
```
public void removeKeyListener(java.awt.event.KeyListener l)
```
  - getDraggers
```
public java.util.LinkedList<Dragger3d> getDraggers()
```
  - addSelectionListener
```
public void addSelectionListener(ViewerSelectionListener l)
```
    Description copied from interface: Viewer
    
    Adds a selection listener to this viewer that will fire whenever objects are selected.
    
    Specified by:
    
    addSelectionListener in interface Viewer
    
    Parameters:
    
    l - selection listener to add
    
    See Also:
    
    Viewer.removeSelectionListener(maspack.render.ViewerSelectionListener)
  - removeSelectionListener
```
public boolean removeSelectionListener(ViewerSelectionListener l)
```
    Description copied from interface: Viewer
    
    Removes a selection listener from this viewer.
    
    Specified by:
    
    removeSelectionListener in interface Viewer
    
    Parameters:
    
    l - selection listener to remove
    
    See Also:
    
    Viewer.addSelectionListener(maspack.render.ViewerSelectionListener)
  - getSelectionListeners
```
public ViewerSelectionListener[] getSelectionListeners()
```
    Description copied from interface: Viewer
    
    Returns a list of all the selection listener in this viewer.
    
    Specified by:
    
    getSelectionListeners in interface Viewer
    
    Returns:
    
    selection listeners in this viewer
    
    See Also:
    
    Viewer.addSelectionListener(maspack.render.ViewerSelectionListener), Viewer.removeSelectionListener(maspack.render.ViewerSelectionListener)
  - getSelectionEvent
```
public ViewerSelectionEvent getSelectionEvent()
```
  - addRenderListener
```
public void addRenderListener(RenderListener l)
```
    Description copied from interface: Viewer
    
    Adds a render listener to this viewer. Render listeners are fired every time the viewer performs a repaint.
    
    Specified by:
    
    addRenderListener in interface Viewer
    
    Parameters:
    
    l - render listener to add.
  - removeRenderListener
```
public boolean removeRenderListener(RenderListener l)
```
    Description copied from interface: Viewer
    
    Removes a render listener from this viewer.
    
    Specified by:
    
    removeRenderListener in interface Viewer
    
    Parameters:
    
    l - render listener to remove
    
    Returns:
    
    true if l was present and removed.
  - getRenderListeners
```
public RenderListener[] getRenderListeners()
```
    Description copied from interface: Viewer
    
    Returns an array of all render listeners held by this viewer.
    
    Specified by:
    
    getRenderListeners in interface Viewer
    
    Returns:
    
    all render listeners
  - addRenderable
```
public void addRenderable(IsRenderable d)
```
    Description copied from interface: Viewer
    
    Adds a renderable to this viewer.
    
    Specified by:
    
    addRenderable in interface Viewer
    
    Parameters:
    
    d - renderable to add
  - addDragger
```
public void addDragger(Dragger3d d)
```
  - setDrawTool
```
public void setDrawTool(Dragger3d d)
```
  - removeRenderable
```
public boolean removeRenderable(IsRenderable d)
```
    Description copied from interface: Viewer
    
    Removes a renderable from this viewer.
    
    Specified by:
    
    removeRenderable in interface Viewer
    
    Parameters:
    
    d - renderable to remove
    
    Returns:
    
    true if r was present and removed
  - removeDragger
```
public void removeDragger(Dragger3d d)
```
  - clearDraggers
```
public void clearDraggers()
```
  - clearRenderables
```
public void clearRenderables()
```
    Description copied from interface: Viewer
    
    Removes all renderables from this viewer.
    
    Specified by:
    
    clearRenderables in interface Viewer
  - getViewPlaneDistance
```
public double getViewPlaneDistance()
```
    Description copied from interface: Renderer
    
    Returns the distance, in model coordinates, from the eye to view plane (which corresponds to the far clip plane). This is a positive number.
    
    Specified by:
    
    getViewPlaneDistance in interface Renderer
    
    Returns:
    
    distance to the near clip plane
    
    See Also:
    
    Renderer.getFarPlaneDistance()
  - getFarPlaneDistance
```
public double getFarPlaneDistance()
```
    Description copied from interface: Renderer
    
    Returns the distance, in model coordinates, from the eye to the far clip plane. This is a positive number.
    
    Specified by:
    
    getFarPlaneDistance in interface Renderer
    
    Returns:
    
    distance to the far clip plane
    
    See Also:
    
    Renderer.getViewPlaneDistance()
  - getVerticalFieldOfView
```
public double getVerticalFieldOfView()
```
    Returns the default vertical field of view in degrees. This is used by autoFitOrtho.
    
    Specified by:
    
    getVerticalFieldOfView in interface Viewer
    
    Returns:
    
    default vertical field of view.
  - setVerticalFieldOfView
```
public void setVerticalFieldOfView(double fov)
```
    Sets the default vertical field of view in degrees. This is used by autoFitOrtho.
    
    Specified by:
    
    setVerticalFieldOfView in interface Viewer
    
    Parameters:
    
    fov - vertical field of view (degrees).
  - repaint
```
public void repaint()
```
    Description copied from interface: Viewer
    
    Request a repaint operation for this viewer.
    
    Specified by:
    
    repaint in interface Viewer
  - paint
```
public void paint()
```
  - setExternalRenderList
```
public void setExternalRenderList(RenderList list)
```
    Description copied from interface: Viewer
    Sets the external render list for this viewer. This is a list of renderables that is maintained independently of the set of renderables maintained by Viewer.addRenderable(maspack.render.IsRenderable), Viewer.removeRenderable(maspack.render.IsRenderable), etc.
    Generally, if an application specifies an external render list, it should rebuild that list prior to each invocation of this viewer's Viewer.rerender(int) method. This is typically dones as follows:
```
    RenderList extList;
    ...
    extList.clear();
    for (every external renderable r) {
       extList.addIfVisible (r);
    }
 
```
    The call to addIfVisible() will place r onto the render list (if it is visible) and also call its prerender() method. Note in particular that prerender() will not be called by the viewer.
    External render lists are designed for situations where a set of renderables is being rendered simultaneously by multiple viewers, and consequently we don't want prerender() to be called multiple times by different viewers.
    Specified by:
    
    setExternalRenderList in interface Viewer
    
    Parameters:
    
    list - new external render list, or null to clear the external list
  - getExternalRenderList
```
public RenderList getExternalRenderList()
```
    Description copied from interface: Viewer
    
    Returns the external render list for this viewer, or null if the viewer does not have an external render list.
    
    Specified by:
    
    getExternalRenderList in interface Viewer
    
    Returns:
    
    external render list
  - rerender
```
public void rerender(int flags)
```
    Request a render with special flags that will be used only for the duration of that render.
    
    Specified by:
    
    rerender in interface Viewer
    
    Parameters:
    
    flags - rendering flags
  - isSpecialRenderFlagsSet
```
public boolean isSpecialRenderFlagsSet()
```
    Used to see if rendering with special flags has been performed yet.
  - rerender
```
public void rerender()
```
    Description copied from interface: Viewer
    
    Convenience methods that calls Viewer.rerender(int) with flags = 0.
    
    Specified by:
    
    rerender in interface Viewer
  - getFrustum
```
public void getFrustum(double[] bounds)
```
    Returns the bounds for the current frustum. These consist of the quantities left, right, bottom, and top that describe the edge locations of the near clipping plane (in eye coordinates), and near and far, which describe the positions of the near and far clipping planes along the -z axis (again in eye coordinates).
    
    Parameters:
    
    bounds - returns the values of left, right, bottom, top, near and far (in that order)
  - setPerspective
```
public void setPerspective(double left,
                           double right,
                           double bottom,
                           double top,
                           double near,
                           double far)
```
    Sets the viewing frustum to a general perspective projection.
    
    Specified by:
    
    setPerspective in interface Viewer
    
    Parameters:
    
    left - left edge position of the near clipping plane
    
    right - right edge position of the near clipping plane
    
    bottom - bottom edge position of the near clipping plane
    
    top - top position of the near clipping plane
    
    near - near clipping plane position (along the -z axis; must be a positive number)
    
    far - far clipping plane position (along the -z axis; must be a positive number)
  - setPerspective
```
public void setPerspective(double left,
                           double right,
                           double bottom,
                           double top,
                           double near,
                           double far,
                           boolean setExplicit)
```
  - setPerspective
```
public void setPerspective(double fieldOfView,
                           double near,
                           double far)
```
    Sets the viewing frustum to a perspective projection centered about the -z axis. Also sets the default field of view returned by getVerticalFieldOfView.
    
    Specified by:
    
    setPerspective in interface Viewer
    
    Parameters:
    
    fieldOfView - vertial field of view (in degrees)
    
    near - near clipping plane position (along the -z axis; must be a positive number)
    
    far - far clipping plane position (along the -z axis; must be a positive number)
  - setOrthogonal
```
public void setOrthogonal(double fieldHeight,
                          double near,
                          double far)
```
    Sets the viewing frustum to an orthogonal projection centered about the -z axis.
    
    Specified by:
    
    setOrthogonal in interface Viewer
    
    Parameters:
    
    fieldHeight - vertical height of the field of view
    
    near - near clipping plane position (along the -z axis; must be a positive number)
    
    far - far clipping plane position (along the -z axis; must be a positive number)
  - setOrthogonal
```
public void setOrthogonal(double left,
                          double right,
                          double bottom,
                          double top,
                          double near,
                          double far)
```
    Description copied from interface: Viewer
    
    Sets the viewing frustum to a general orthogonal projection. This is done by specifying the edges locations of the view plane (i.e., the near clipping plane) with respect to the x-y plane of the eye coordinates, while also specifying the distances of the view plane and far clipping plane along the -z axis.
    
    Specified by:
    
    setOrthogonal in interface Viewer
    
    Parameters:
    
    left - left edge position of the near clipping plane
    
    right - right edge position of the near clipping plane
    
    bottom - bottom edge position of the near clipping plane
    
    top - top position of the near clipping plane
    
    near - near clipping plane position (along the -z axis; must be a positive number)
    
    far - far clipping plane position (along the -z axis; must be a positive number)
  - isOrthogonal
```
public boolean isOrthogonal()
```
    Returns true if the current viewing projection is orthogonal.
    
    Specified by:
    
    isOrthogonal in interface Renderer
    
    Returns:
    
    true if viewing projection is orthogonal
  - setOrthographicView
```
public void setOrthographicView(boolean enable)
```
  - getBounds
```
public boolean getBounds(Point3d pmin,
                         Point3d pmax)
```
  - estimateRadiusAndCenter
```
public double estimateRadiusAndCenter(Point3d center)
```
    Size is the diameter of the bounding box.
  - autoFit
```
public void autoFit()
```
    Description copied from interface: Viewer
    
    Calls either Viewer.autoFitOrtho() or Viewer.autoFitPerspective(), depending on whether the current view is orthogonal or perspective.
    
    Specified by:
    
    autoFit in interface Viewer
  - autoFitPerspective
```
public void autoFitPerspective()
```
    Auto computes the eye and center positions and an perpective viewing frustum to fit the current scence. This makes use of the IsRenderable.updateBounds(maspack.matrix.Vector3d, maspack.matrix.Vector3d) method of all the renderables to estimate the scene center and an approximate radius r. It then computes a distance d from the center to the eye using r = d tan(fov/2), where fov is the field of view returned by Viewer.getVerticalFieldOfView() and converted to radians. This field of view also used to used to compute the perspective frustum. The eye frame orientation is adjusted so that its $y$ axis is parallel to the current value of the ``up'' vector.
    
    Specified by:
    
    autoFitPerspective in interface Viewer
    
    See Also:
    
    Viewer.setUpVector(maspack.matrix.Vector3d), Viewer.getUpVector()
  - autoFitOrtho
```
public void autoFitOrtho()
```
    Description copied from interface: Viewer
    
    Auto computes the eye and center positions and an orthogonal viewing frustum to fit the current scence. This makes use of the IsRenderable.updateBounds(maspack.matrix.Vector3d, maspack.matrix.Vector3d) method of all the renderables to estimate the scene center and an approximate radius r. It then computes a distance d from the center to the eye using r = d tan(fov/2), where fov is the field of view returned by Viewer.getVerticalFieldOfView() and converted to radians. The eye frame orientation is adjusted so that its $y$ axis is parallel to the current value of the ``up'' vector.
    
    Specified by:
    
    autoFitOrtho in interface Viewer
    
    See Also:
    
    Viewer.setUpVector(maspack.matrix.Vector3d), Viewer.getUpVector()
  - getScreenWidth
```
public int getScreenWidth()
```
    Description copied from interface: Renderer
    
    Returns the screen width, in pixels
    
    Specified by:
    
    getScreenWidth in interface Renderer
    
    Returns:
    
    screen width
  - getScreenHeight
```
public int getScreenHeight()
```
    Description copied from interface: Renderer
    
    Returns the screen height, in pixels
    
    Specified by:
    
    getScreenHeight in interface Renderer
    
    Returns:
    
    screen height
  - getScreenX
```
public int getScreenX()
```
  - getScreenY
```
public int getScreenY()
```
  - getGL
```
public com.jogamp.opengl.GL getGL()
```
    Specified by:
    
    getGL in interface GLRenderer
  - setAutoSwapBufferMode
```
public void setAutoSwapBufferMode(boolean enable)
```
    Enable or disable the GL Canvas auto-swap mode
  - getAutoSwapBufferMode
```
public boolean getAutoSwapBufferMode()
```
    Check whether or not the GL canvas is set to auto swap buffers
  - getContext
```
public com.jogamp.opengl.GLContext getContext()
```
    Gets the "currently active" context. If not currently rendering, this will return null;
    
    Returns:
    
    active context
  - rotate
```
public void rotate(double xang,
                   double yang)
```
    Rotate the eye coordinate frame about the center point
    
    Parameters:
    
    xang - amount of horizontal rotation (in radians)
    
    yang - amount of vertical rotation (in radians)
  - zoom
```
public void zoom(double s)
```
    Zoom in or out by a specified scale factor. A factor larger than one zooms out, while a factor less than one zooms in. In orthographic projection, zoom is accomplished changing the frustum size. In perspective projection, it is accomplished by moving the eye position along the z axis of the eye frame.
    
    Parameters:
    
    s - scale factor
  - distancePerPixel
```
public double distancePerPixel(Vector3d pnt)
```
    Computes the distance per pixel for a point specified with respect to world coordinates.
    
    Specified by:
    
    distancePerPixel in interface Renderer
    
    Parameters:
    
    pnt - point undergoing the displacement
    
    Returns:
    
    displacement distance corresponding to one pixel
  - centerDistancePerPixel
```
public double centerDistancePerPixel()
```
    Computes the distance per pixel at the viewpoint center.
    
    Specified by:
    
    centerDistancePerPixel in interface Renderer
    
    Returns:
    
    displacement distance corresponding to one pixel
  - setDefaultAxialView
```
public void setDefaultAxialView(AxisAlignedRotation view)
```
  - getDefaultAxialView
```
public AxisAlignedRotation getDefaultAxialView()
```
  - setAxialView
```
public void setAxialView(AxisAlignedRotation REW)
```
    Sets an axial (or axis-aligned) view. This is done by setting the rotational part of the eye-to-world transform to the axis-aligned rotation REW, and then moving the eye position so that the center position lies along the new -z axis of the eye frame, while maintaining the current distance between the eye and the center.
    The method also sets this viewer's `up'' vector to the y axis of REW, and saves REW itself as the current axis-aligned view, which can be retrieved using getAxialView(). The viewer's grid is also adjusted to align with the nearest set of aligned axes.
    
    Specified by:
    
    setAxialView in interface Viewer
    
    Parameters:
    
    REW - axis-aligned rotational component for the eye-to-world transform
    
    See Also:
    
    getAxialView(), setUpVector(maspack.matrix.Vector3d), getUpVector()
  - getAxialView
```
public AxisAlignedRotation getAxialView()
```
    Returns the current axis-aligned view. This is either the one with which the viewer was initialized, or that most recently set by Viewer.setAxialView(maspack.matrix.AxisAlignedRotation).
    
    Specified by:
    
    getAxialView in interface Viewer
    
    Returns:
    
    current axis-aligned view.
    
    See Also:
    
    Viewer.setAxialView(maspack.matrix.AxisAlignedRotation)
  - getCanvas
```
public GLDrawableComponent getCanvas()
```
  - init
```
public void init(com.jogamp.opengl.GLAutoDrawable drawable)
```
    Called any time GL context is switched! e.g. moving window to new display
    
    Specified by:
    
    init in interface com.jogamp.opengl.GLEventListener
  - isMultiSampleEnabled
```
public boolean isMultiSampleEnabled()
```
  - numMultiSamples
```
public int numMultiSamples()
```
  - setMultiSampleEnabled
```
public void setMultiSampleEnabled(boolean set)
```
  - dispose
```
public void dispose(com.jogamp.opengl.GLAutoDrawable drawable)
```
    Called any time GL context is switched! e.g. moving window to new display
    
    Specified by:
    
    dispose in interface com.jogamp.opengl.GLEventListener
  - addMouseInputListener
```
public void addMouseInputListener(javax.swing.event.MouseInputListener l)
```
  - removeMouseInputListener
```
public void removeMouseInputListener(javax.swing.event.MouseInputListener l)
```
  - getMouseInputListeners
```
public javax.swing.event.MouseInputListener[] getMouseInputListeners()
```
  - addMouseWheelListener
```
public void addMouseWheelListener(java.awt.event.MouseWheelListener l)
```
  - removeMouseWheelListener
```
public void removeMouseWheelListener(java.awt.event.MouseWheelListener l)
```
  - getMouseWheelListeners
```
public java.awt.event.MouseWheelListener[] getMouseWheelListeners()
```
  - reshape
```
public void reshape(com.jogamp.opengl.GLAutoDrawable drawable,
                    int x,
                    int y,
                    int w,
                    int h)
```
    Specified by:
    
    reshape in interface com.jogamp.opengl.GLEventListener
  - getViewPlaneHeight
```
public double getViewPlaneHeight()
```
    Description copied from interface: Renderer
    
    Returns the height of the view plane, in model coordinates. The view plane corresponds to the clipping plane nearest the viewer.
    
    Specified by:
    
    getViewPlaneHeight in interface Renderer
    
    Returns:
    
    view plane height
  - getViewPlaneWidth
```
public double getViewPlaneWidth()
```
    Description copied from interface: Renderer
    
    Returns the width of the view plane, in model coordinates. The view plane corresponds to the clipping plane nearest the viewer.
    
    Specified by:
    
    getViewPlaneWidth in interface Renderer
    
    Returns:
    
    view plane width
  - setPointSize
```
public void setPointSize(float s)
```
    Description copied from interface: Renderer
    
    Sets the size for rendering points, in pixels. The default size is 1.
    
    Specified by:
    
    setPointSize in interface Renderer
    
    Parameters:
    
    s - new point size (in pixels).
    
    See Also:
    
    Renderer.getPointSize()
  - getPointSize
```
public float getPointSize()
```
    Description copied from interface: Renderer
    
    Returns the current size for rendering points, in pixels.
    
    Specified by:
    
    getPointSize in interface Renderer
    
    Returns:
    
    current point size (in pixels).
    
    See Also:
    
    Renderer.setPointSize(float)
  - setLineWidth
```
public void setLineWidth(float w)
```
    Description copied from interface: Renderer
    
    Sets the width for rendering lines, in pixels. The default size is 1.
    
    Specified by:
    
    setLineWidth in interface Renderer
    
    Parameters:
    
    w - new line width (in pixels).
    
    See Also:
    
    Renderer.getLineWidth()
  - getLineWidth
```
public float getLineWidth()
```
    Description copied from interface: Renderer
    
    Returns the current width for rendering lines, in pixels.
    
    Specified by:
    
    getLineWidth in interface Renderer
    
    Returns:
    
    current line width (in pixels).
    
    See Also:
    
    Renderer.setLineWidth(float)
  - setViewport
```
public void setViewport(com.jogamp.opengl.GL gl,
                        int x,
                        int y,
                        int width,
                        int height)
```
    Sets the viewer's viewport.
  - setViewVolume
```
public void setViewVolume(double near,
                          double far)
```
  - getViewMatrix
```
public void getViewMatrix(RigidTransform3d TWE)
```
    Description copied from interface: Renderer
    
    Gets the current view matrix. The view matrix is the transformation from world coordinates to eye coordinates.
    
    Specified by:
    
    getViewMatrix in interface Renderer
    
    Parameters:
    
    TWE - returns the current transform from world to eye coordinates
  - getViewMatrix
```
public RigidTransform3d getViewMatrix()
```
    Description copied from interface: Renderer
    
    Gets the current view matrix. The view matrix is the transformation from world coordinates to eye coordinates.
    
    Specified by:
    
    getViewMatrix in interface Renderer
    
    Returns:
    
    view matrix value (may be modified by the user)
  - getEyeToWorld
```
public void getEyeToWorld(RigidTransform3d X)
```
    Description copied from interface: Viewer
    
    Gets the eye-to-world transform for this viewer. This is the inverse of the view matrix.
    
    Specified by:
    
    getEyeToWorld in interface Viewer
    
    Parameters:
    
    X - returns the eye-to-world transform
  - setEyeToWorld
```
public void setEyeToWorld(RigidTransform3d X)
```
    Directly sets the eye coordinate frame.
    
    Specified by:
    
    setEyeToWorld in interface Viewer
    
    Parameters:
    
    X - new EyeToWorld transformation
  - setEyeToWorld
```
public void setEyeToWorld(Point3d eye,
                          Point3d center,
                          Vector3d up)
```
    Sets the eyeToWorld transform for this viewer, using the canonical parameters used by the GL lookat method.
    
    Specified by:
    
    setEyeToWorld in interface Viewer
    
    Parameters:
    
    eye - position of the eye, in world coordinates
    
    center - point that the eye is looking at, in world coordinates
    
    up - up direction, in world coordinates
  - setModelMatrix2d
```
public void setModelMatrix2d(double left,
                             double right,
                             double bottom,
                             double top)
```
    Sets the model matrix to perform scaling and translation in the x-y plane so that the model coordinates (left,bottom) and (right,top) map onto (-1,1) and (1,1) in world coordinates. When in 2d rendering mode, this means that (left,bottom) and (right,top) will correspond to the lower left and top right of the screen.
    
    Specified by:
    
    setModelMatrix2d in interface Renderer
    
    Parameters:
    
    left - x value corresponding to -1 in world coordinates
    
    right - x value corresponding to 1 in world coordinates
    
    bottom - y value corresponding to -1 in world coordinates
    
    top - y value corresponding to 1 in world coordinates
    
    See Also:
    
    Renderer.is2DRendering()
  - setDepthOffset
```
public void setDepthOffset(int offset)
```
    Set a depth offset for the projection matrix. Each unit represents enough depth to account for one bin in the depth buffer. Positive values bring following objects closer to the screen, while negative values send them father away. The default value is 0.
    Depth offsets are used to help resolve z-fighting, in which overlapping primitives drawn in the same plane compete for visibility. If the plane has a considerable tilt with respect to the viewer, then an offset larger than one may be needed to resolve the issue.
    
    Specified by:
    
    setDepthOffset in interface Renderer
    
    Parameters:
    
    offset - new depth offset value
  - getDepthOffset
```
public int getDepthOffset()
```
    The current depth offset level. See Renderer.setDepthOffset(int) for a description. The default value is 0.
    
    Specified by:
    
    getDepthOffset in interface Renderer
    
    Returns:
    
    the current depth offset (in depth bins)
  - display
```
public void display(com.jogamp.opengl.GLAutoDrawable drawable)
```
    Specified by:
    
    display in interface com.jogamp.opengl.GLEventListener
  - display
```
public abstract void display(com.jogamp.opengl.GLAutoDrawable drawable,
                             int flags)
```
  - setBackgroundColor
```
public void setBackgroundColor(float r,
                               float g,
                               float b)
```
  - setBackgroundColor
```
public void setBackgroundColor(float[] rgba)
```
    Description copied from interface: Viewer
    
    Sets the background color for this viewer.
    
    Specified by:
    
    setBackgroundColor in interface Viewer
    
    Parameters:
    
    rgba - RGB (if length 3) or RGBA values (if length 4) for the background color
  - setBackgroundColor
```
public void setBackgroundColor(java.awt.Color color)
```
    Description copied from interface: Viewer
    
    Sets the background color for this viewer.
    
    Specified by:
    
    setBackgroundColor in interface Viewer
    
    Parameters:
    
    color - new background color
  - getBackgroundColor
```
public java.awt.Color getBackgroundColor()
```
    Description copied from interface: Viewer
    
    Returns the background color for this viewer.
    
    Specified by:
    
    getBackgroundColor in interface Viewer
    
    Returns:
    
    background color
  - getBackgroundColor
```
public float[] getBackgroundColor(float[] rgba)
```
    Description copied from interface: Viewer
    
    Returns the background color for this viewer. The color is returned as a float array describing the color's RGBA values in the range [0,1]. The returned array can be provided through the argument rgba. Otherwise, if this argument is null, an array is allocated internally.
    
    Specified by:
    
    getBackgroundColor in interface Viewer
    
    Parameters:
    
    rgba - optional array for returning the values
    
    Returns:
    
    rgba array describing the background color
  - setDefaultLights
```
public void setDefaultLights()
```
  - setLightingEnabled
```
public boolean setLightingEnabled(boolean enable)
```
  - isLightingEnabled
```
public boolean isLightingEnabled()
```
  - setVertexColoringEnabled
```
public boolean setVertexColoringEnabled(boolean enable)
```
  - isVertexColoringEnabled
```
public boolean isVertexColoringEnabled()
```
  - hasVertexColoring
```
public boolean hasVertexColoring()
```
  - getColorInterpolation
```
public Renderer.ColorInterpolation getColorInterpolation()
```
    Description copied from interface: Renderer
    
    Returns the color interpolation currently being used by this Renderer.
    
    Specified by:
    
    getColorInterpolation in interface Renderer
    
    Returns:
    
    current color interpolation
  - setColorInterpolation
```
public Renderer.ColorInterpolation setColorInterpolation(Renderer.ColorInterpolation interp)
```
    Sets the color interpolation method to be used
    
    Specified by:
    
    setColorInterpolation in interface Renderer
    
    Parameters:
    
    interp - new color interpolation
    
    Returns:
    
    the previous value so it can be reset
  - setTextureMappingEnabled
```
public boolean setTextureMappingEnabled(boolean enable)
```
  - isTextureMappingEnabled
```
public boolean isTextureMappingEnabled()
```
  - hasVertexColorMixing
```
public abstract boolean hasVertexColorMixing(Renderer.ColorMixing cmix)
```
    Description copied from interface: Renderer
    
    Queries whether or not a specified method for combining vertex coloring and material coloring is supported by this Renderer.
    
    Specified by:
    
    hasVertexColorMixing in interface Renderer
    
    Returns:
    
    true if the color mixing method is supported
  - setVertexColorMixing
```
public Renderer.ColorMixing setVertexColorMixing(Renderer.ColorMixing cmix)
```
    Description copied from interface: Renderer
    
    Sets the method used for combining vertex coloring and material coloring. This Renderer may not support all methods. If a method is not supported, then the color mixing method will remain unchanged. Applications can use Renderer.hasVertexColorMixing(maspack.render.Renderer.ColorMixing) to test whether a method is suuported.
    
    Specified by:
    
    setVertexColorMixing in interface Renderer
    
    Parameters:
    
    cmix - new color mixing method
    
    Returns:
    
    previous color mixing method
  - getVertexColorMixing
```
public Renderer.ColorMixing getVertexColorMixing()
```
    Description copied from interface: Renderer
    
    Returns the method used for combining vertex coloring and material coloring.
    
    Specified by:
    
    getVertexColorMixing in interface Renderer
    
    Returns:
    
    current color mixing method
  - hasColorMapMixing
```
public abstract boolean hasColorMapMixing(Renderer.ColorMixing cmix)
```
    Description copied from interface: Renderer
    
    Queries whether or not a specified method for combining color map and material coloring is supported by this Renderer.
    
    Specified by:
    
    hasColorMapMixing in interface Renderer
    
    Returns:
    
    true if the color mixing method is supported
  - setColorMap
```
public ColorMapProps setColorMap(ColorMapProps props)
```
    Description copied from interface: Renderer
    
    If color mapping is supported, sets up a color map according to the properties specified by props, or removes any color map if props is null. Once a color map is set, it will be applied to any subsequent draw operation for which the vertices contain texture coordinates.
    
    Specified by:
    
    setColorMap in interface Renderer
    
    Parameters:
    
    props - properties for the color map, or null to disable
    
    Returns:
    
    the previous color map properties
  - getColorMap
```
public ColorMapProps getColorMap()
```
    Description copied from interface: Renderer
    
    Returns the properties for the most recently set color map, or null if no color map is currently set or color mapping is not supported.
    
    Specified by:
    
    getColorMap in interface Renderer
    
    Returns:
    
    current color map properties.
    
    See Also:
    
    Renderer.setColorMap(maspack.render.ColorMapProps)
  - setNormalMap
```
public NormalMapProps setNormalMap(NormalMapProps props)
```
    Description copied from interface: Renderer
    
    If normal mapping is supported, sets up a normal map according to the properties specified by props, or removes normal mapping if props is null. Once normal mapping is set, it will be applied to any subsequent draw operation for which the vertices contain texture coordinates. At present, texture coordinates can only be specified for draw operations involving a RenderObject.
    For normal mapping to work, shading must not be set to Renderer.Shading.NONE or Renderer.Shading.FLAT.
    
    Specified by:
    
    setNormalMap in interface Renderer
    
    Parameters:
    
    props - properties for the normal mapping, or null to disable
    
    Returns:
    
    the previous normal map properties
  - getNormalMap
```
public NormalMapProps getNormalMap()
```
    Description copied from interface: Renderer
    
    Returns the most recently set normal mapping properties, or null if no normal mapping has been set or normal mapping is not supported.
    
    Specified by:
    
    getNormalMap in interface Renderer
    
    Returns:
    
    current normal mapping properties.
    
    See Also:
    
    Renderer.setNormalMap(maspack.render.NormalMapProps)
  - setBumpMap
```
public BumpMapProps setBumpMap(BumpMapProps props)
```
    Description copied from interface: Renderer
    
    If bump mapping is supported, sets up bump mapping according to the properties specified by props, or removes bump mapping if props is null. Once bump mapping is set, it will be applied to any subsequent draw operation for which the vertices contain texture coordinates. At present, texture coordinates can only be specified for draw operations involving a RenderObject.
    For bump mapping to work, shading must not be set to Renderer.Shading.NONE or Renderer.Shading.FLAT.
    
    Specified by:
    
    setBumpMap in interface Renderer
    
    Parameters:
    
    props - properties for the bump mapping, or null to disable
    
    Returns:
    
    the previous bump map properties
  - getBumpMap
```
public BumpMapProps getBumpMap()
```
    Description copied from interface: Renderer
    
    Returns the most recently set bump mapping properties, or null if no bump mapping has been set or bump mapping is not supported.
    
    Specified by:
    
    getBumpMap in interface Renderer
    
    Returns:
    
    current bump mapping properties.
    
    See Also:
    
    Renderer.setBumpMap(maspack.render.BumpMapProps)
  - setDepthEnabled
```
public boolean setDepthEnabled(boolean set)
```
  - isDepthEnabled
```
public boolean isDepthEnabled()
```
  - setDepthWriteEnabled
```
public boolean setDepthWriteEnabled(boolean set)
```
  - isDepthWriteEnabled
```
public boolean isDepthWriteEnabled()
```
  - setShading
```
public Renderer.Shading setShading(Renderer.Shading shading)
```
    Description copied from interface: Renderer
    
    Sets the shading model used by this renderer. The default value is Renderer.Shading.FLAT, in which one normal is used per primitive. A shading model of Renderer.Shading.NONE turns off lighting and causes primitives to be rendered in solid colors, using the current diffuse color.
    
    Specified by:
    
    setShading in interface Renderer
    
    Parameters:
    
    shading - new shading model to be used
    
    Returns:
    
    previous shading model
  - getShading
```
public Renderer.Shading getShading()
```
    Description copied from interface: Renderer
    
    Returns the current shading model used by this renderer. A shading model of Renderer.Shading.NONE turns off lighting and causes primitives to be rendered in solid colors, using the current diffuse color.
    
    Specified by:
    
    getShading in interface Renderer
    
    Returns:
    
    current shading model
  - setRoundedPoints
```
public boolean setRoundedPoints(boolean enable)
```
  - getRoundedPoints
```
public boolean getRoundedPoints()
```
  - isTransparencyEnabled
```
public boolean isTransparencyEnabled()
```
  - setTransparencyEnabled
```
public void setTransparencyEnabled(boolean enable)
```
  - isBlendingEnabled
```
public boolean isBlendingEnabled()
```
  - setBlendingEnabled
```
public void setBlendingEnabled(boolean set)
```
  - getBlendSourceFactor
```
public GLViewer.BlendFactor getBlendSourceFactor()
```
  - setBlendSourceFactor
```
public void setBlendSourceFactor(GLViewer.BlendFactor factor)
```
  - getBlendDestFactor
```
public GLViewer.BlendFactor getBlendDestFactor()
```
  - setBlendDestFactor
```
public void setBlendDestFactor(GLViewer.BlendFactor factor)
```
  - setUpVector
```
public void setUpVector(Vector3d upVector)
```
    Description copied from interface: Viewer
    Sets the ``up'' vector for this viewer to a specified value, and adjusts the eye-to-world transform to account for this new vertical direction, while the eye's -z axis is directed at the center point. This is equivalent to
```
 setEyeToWorld (getEye(), getCenter(), up);
 
```
    Specified by:
    
    setUpVector in interface Viewer
    
    Parameters:
    
    upVector - new up vector, in world coordinates
    
    See Also:
    
    Viewer.getEye(), Renderer.getCenter()
  - getUpVector
```
public Vector3d getUpVector()
```
    Description copied from interface: Viewer
    
    Returns the ``up'' vector which this viewer uses in some instances to determine the direction of the y axis of the eye coordinate system.
    
    Specified by:
    
    getUpVector in interface Viewer
    
    Returns:
    
    up vector, in world coordinates
    
    See Also:
    
    Viewer.setUpVector(maspack.matrix.Vector3d), Viewer.setCenter(maspack.matrix.Point3d), Viewer.setEye(maspack.matrix.Point3d)
  - hasSelection
```
public boolean hasSelection()
```
    Queries whether or not this Renderer supports selection.
    
    Specified by:
    
    hasSelection in interface Renderer
    
    Returns:
    
    true if selection is supported.
  - isSelecting
```
public boolean isSelecting()
```
    Returns true if the renderer is currently performing a selection render. When this is the case, the application should avoid calls affecting color and lighting.
    
    Specified by:
    
    isSelecting in interface Renderer
    
    Returns:
    
    true if the renderer is in selection mode.
  - setHighlightStyle
```
public boolean setHighlightStyle(Renderer.HighlightStyle style)
```
    Description copied from interface: Viewer
    
    Sets the highlighting style for this viewer. If the style is specified as Renderer.HighlightStyle.NONE, then highlighting is deactivated. Not all highlighting styles may be supported; if the specified style is not supported this method does nothing and returns false.
    
    Specified by:
    
    setHighlightStyle in interface Viewer
    
    Parameters:
    
    style - highlighting style to be set
    
    Returns:
    
    true if the highlighting style is supported.
    
    See Also:
    
    Viewer.hasHighlightStyle(maspack.render.Renderer.HighlightStyle)
  - hasHighlightStyle
```
public boolean hasHighlightStyle(Renderer.HighlightStyle style)
```
    Description copied from interface: Viewer
    
    Returns true if this viewer supports the indicated highlighting style.
    
    Specified by:
    
    hasHighlightStyle in interface Viewer
    
    Returns:
    
    true if style is supported
  - getHighlightStyle
```
public Renderer.HighlightStyle getHighlightStyle()
```
    Description copied from interface: Renderer
    
    Returns the highlight style used by this renderer. This specifies how rendered objects are highlighted when highlighting is enabled. A value of Renderer.HighlightStyle.NONE indicates that highlighting is deactivated.
    
    Specified by:
    
    getHighlightStyle in interface Renderer
    
    Returns:
    
    current highlighting method.
  - setHighlightColor
```
public void setHighlightColor(java.awt.Color color)
```
  - getHighlightColor
```
public void getHighlightColor(float[] rgba)
```
    Description copied from interface: Renderer
    
    Returns the color that is used to highlight objects when the highlighting method is Renderer.HighlightStyle.COLOR.
    
    Specified by:
    
    getHighlightColor in interface Renderer
    
    Parameters:
    
    rgba - array of length 3 or 4 in which the RGB or RGBA components of the highlight color are returned.
  - setSelectingColor
```
public void setSelectingColor(java.awt.Color color)
```
    Special color used for selection (primarily for color-based selection, although since the renderbuffers are typically not drawn, can be used for any selection method).
  - setSelectingColor
```
public void setSelectingColor(float r,
                              float g,
                              float b,
                              float a)
```
    The material color to use if the renderer is currently performing a selection render. This is mainly used for color-based selection.
    
    Parameters:
    
    r - red
    
    g - green
    
    b - blue
    
    a - alpha
  - getSelectingColor
```
public void getSelectingColor(float[] rgba)
```
  - setFaceStyle
```
public Renderer.FaceStyle setFaceStyle(Renderer.FaceStyle style)
```
    Description copied from interface: Renderer
    
    Sets the style for rendering faces. This determines whether the front and/or back of each face is rendered. The default value is Renderer.FaceStyle.FRONT.
    
    Specified by:
    
    setFaceStyle in interface Renderer
    
    Parameters:
    
    style - new face style
    
    Returns:
    
    previous face style
    
    See Also:
    
    Renderer.getFaceStyle()
  - getFaceStyle
```
public Renderer.FaceStyle getFaceStyle()
```
    Description copied from interface: Renderer
    
    Returns the current mode for rendering faces.
    
    Specified by:
    
    getFaceStyle in interface Renderer
    
    Returns:
    
    current face rendering mode
    
    See Also:
    
    Renderer.setFaceStyle(maspack.render.Renderer.FaceStyle)
  - setSelectionEnabled
```
public void setSelectionEnabled(boolean selection)
```
    Description copied from interface: Viewer
    
    Enables or disables viewer-based selection. If this viewer does not support selection (i.e., if Renderer.hasSelection() returns false, then this method does nothing.
    
    Specified by:
    
    setSelectionEnabled in interface Viewer
    
    Parameters:
    
    selection - if true, enables selection
  - isSelectionEnabled
```
public boolean isSelectionEnabled()
```
    Description copied from interface: Viewer
    
    Returns true if viewer-based selection is enabled.
    
    Specified by:
    
    isSelectionEnabled in interface Viewer
    
    Returns:
    
    false if selection is disabled or not supported.
  - setSelectOnPress
```
public void setSelectOnPress(boolean enable)
```
  - getSelectOnPress
```
public boolean getSelectOnPress()
```
  - setEllipticSelection
```
public void setEllipticSelection(boolean enable)
```
  - getEllipticSelection
```
public boolean getEllipticSelection()
```
  - getCenter
```
public Point3d getCenter()
```
    Description copied from interface: Renderer
    
    Returns the current center point
    
    Specified by:
    
    getCenter in interface Renderer
    
    Returns:
    
    center point, in world coordinates
  - setCenter
```
public void setCenter(Point3d c)
```
    Sets the center point for the viewer, and adjusts the eye coordinates so that the eye's -z axis is directed at the center point. The vertical direction is specified by the current up vector.
    
    Specified by:
    
    setCenter in interface Viewer
    
    Parameters:
    
    c - new center location, in world coordinates
    
    See Also:
    
    getUpVector()
  - getEye
```
public Point3d getEye()
```
    Description copied from interface: Viewer
    
    Returns the eye position. This corresponds to the translational component of the eye-to-world transform.
    
    Specified by:
    
    getEye in interface Viewer
    
    Returns:
    
    eye position, in world coordinates
  - setEye
```
public void setEye(Point3d eye)
```
    Moves the eye coordinates to a specifed location in world coordinates, and adjusts the orientation so that the eye's -z axis is directed at the center point. The vertical direction is specified by the current up vector.
    
    Specified by:
    
    setEye in interface Viewer
    
    Parameters:
    
    eye - new eye location, in world coordinates
    
    See Also:
    
    getCenter(), getUpVector()
  - getCenterToWorld
```
public RigidTransform3d getCenterToWorld()
```
    Returns a transform from world coordinates to center coordinates, with the axes aligned to match the current eyeToWorld transform. Seen through the viewer, this will appear centered on the view frame with z pointing toward the view, y pointing up, and x pointing to the right.
  - getCellDivisions
```
public int getCellDivisions()
```
  - getCellSize
```
public double getCellSize()
```
  - getGrid
```
public GLGridPlane getGrid()
```
  - addLight
```
public Light addLight(float[] position,
                      float[] ambient,
                      float[] diffuse,
                      float[] specular)
```
  - addLight
```
public int addLight(Light light)
```
    Description copied from interface: Viewer
    
    Adds a specified light to this viewer and enables it. In some cases, the added light may exceed the number of lights supported by the renderer. In that case, the light will still be added but will not be enabled.
    Changes to the lighting caused by adding or removing lights, or by changing the properties of existing lights, will take effect at the beginning of the next repaint step.
    
    Specified by:
    
    addLight in interface Viewer
    
    Parameters:
    
    light - light to add to the viewer
    
    Returns:
    
    index of the added light
  - removeLight
```
public void removeLight(int i)
```
    Description copied from interface: Viewer
    
    Removes the light with the specified index from this viewer.
    Changes to the lighting caused by adding or removing lights, or by changing the properties of existing lights, will take effect at the beginning of the next repaint step.
    
    Specified by:
    
    removeLight in interface Viewer
    
    Parameters:
    
    i - index of the light to be removed
  - removeLight
```
public boolean removeLight(Light light)
```
    Description copied from interface: Viewer
    
    Removes the indicated light from this viewer.
    Changes to the lighting caused by adding or removing lights, or by changing the properties of existing lights, will take effect at the beginning of the next repaint step.
    
    Specified by:
    
    removeLight in interface Viewer
    
    Parameters:
    
    light - light to be removed
    
    Returns:
    
    true if the viewer contained the light and it was removed
  - getLight
```
public Light getLight(int i)
```
    Description copied from interface: Viewer
    
    Get a specified light by index in this viewer. Lights will include both predefined lights as well as those specifically defined by the application.
    
    Specified by:
    
    getLight in interface Viewer
    
    Parameters:
    
    i - index of the light
  - getIndexOfLight
```
public int getIndexOfLight(Light light)
```
    Description copied from interface: Viewer
    
    Get the index of a specified light in this viewer.
    
    Specified by:
    
    getIndexOfLight in interface Viewer
    
    Parameters:
    
    light - light for which an index is sought
    
    Returns:
    
    Index of the light, or -1 if the viewer does not contain the light.
  - numLights
```
public int numLights()
```
    Description copied from interface: Viewer
    
    Returns the number of lights in this viewer. This number will include both predefined lights as well as those specifically defined by the application.
    
    Specified by:
    
    numLights in interface Viewer
  - setupScreenShot
```
public abstract void setupScreenShot(int w,
                                     int h,
                                     int samples,
                                     java.io.File file,
                                     java.lang.String format)
```
    Setup for a screenshot during the next render cycle
    
    Parameters:
    
    w - width of shot
    
    h - height of shot
    
    samples - number of samples to use for the multisample FBO (does antialiasing)
    
    file - file to which the screen shot should be written
    
    format - format string
  - awaitScreenShotCompletion
```
public abstract void awaitScreenShotCompletion()
```
  - setAutoResizeEnabled
```
public boolean setAutoResizeEnabled(boolean enabled)
```
    Allows you to explicitly enable or disable resizing of viewer (may want to disable while recording video or while selecting)
    
    Returns:
    
    old value
  - isAutoResizeEnabled
```
public boolean isAutoResizeEnabled()
```
  - setAutoViewportEnabled
```
public boolean setAutoViewportEnabled(boolean enabled)
```
    Allows you to explicitly enable or disable automatic viewport adjustment based on screen width/height (may want to disable while recording video or while selecting)
    
    Returns:
    
    old value
  - isAutoViewportEnabled
```
public boolean isAutoViewportEnabled()
```
  - setupScreenShot
```
public abstract void setupScreenShot(int w,
                                     int h,
                                     java.io.File file,
                                     java.lang.String format)
```
  - grabPending
```
public abstract boolean grabPending()
```
  - setRotationMode
```
public void setRotationMode(GLViewer.RotationMode mode)
```
  - getRotationMode
```
public GLViewer.RotationMode getRotationMode()
```
  - setTransparencyFaceCulling
```
public boolean setTransparencyFaceCulling(boolean enable)
```
  - getTransparencyFaceCulling
```
public boolean getTransparencyFaceCulling()
```
  - getEyeZDirection
```
public Vector3d getEyeZDirection()
```
    Description copied from interface: Renderer
    
    Gives the direction, in world coordinates, of a vector that is perpendicular to the screen and points towards the viewer. The corresponds to the Z direction in eye coordinates.
    
    Specified by:
    
    getEyeZDirection in interface Renderer
    
    Returns:
    
    current z direction of the eye frame
  - setGlobalRenderFlags
```
public void setGlobalRenderFlags(int flags)
```
  - getRenderFlags
```
public int getRenderFlags()
```
  - begin2DRendering
```
public boolean begin2DRendering()
```
    Description copied from interface: Renderer
    
    Puts this Renderer into 2D rendering mode, or returns false if 2D rendering is not supported. This method behaves identically to Renderer.begin2DRendering(double,double), only with the existing screen width and height used for w and h.
    
    Specified by:
    
    begin2DRendering in interface Renderer
    
    Returns:
    
    true if 2D rendering is supported
    
    See Also:
    
    Renderer.getScreenWidth(), Renderer.getScreenHeight(), Renderer.has2DRendering()
  - has2DRendering
```
public boolean has2DRendering()
```
    Description copied from interface: Renderer
    
    Returns true if this Renderer supports 2D rendering mode.
    
    Specified by:
    
    has2DRendering in interface Renderer
    
    Returns:
    
    true if 2D rendering is supported
    
    See Also:
    
    Renderer.is2DRendering()
  - begin2DRendering
```
public void begin2DRendering(double left,
                             double right,
                             double bottom,
                             double top)
```
  - finish2DRendering
```
public void finish2DRendering()
```
  - begin2DRendering
```
public boolean begin2DRendering(double w,
                                double h)
```
    Description copied from interface: Renderer
    
    Puts this Renderer into 2D rendering mode, or returns false if 2D rendering is not supported. If 2D rendering is supported, then the depth buffer is disabled, the model and view matrices are set to the identity, and the projection matrix is redefined to provide an orthographic projection with the world frame located at the bottom left corner of the screen with the x axis horizontal and pointing to the right, and the y axis vertical. The scaling is set so that the width and height of the screen map to the ranges (0, w) and (0, h), respectively. If 2D rendering is not supported, then no changes are made to any of the matrices and this method will have no effect.
    
    Specified by:
    
    begin2DRendering in interface Renderer
    
    Parameters:
    
    w - width of the screen coordinates
    
    h - height of the screen coordinates
    
    Returns:
    
    true if 2D rendering is supported
    
    See Also:
    
    Renderer.has2DRendering()
  - end2DRendering
```
public void end2DRendering()
```
    Description copied from interface: Renderer
    
    Take this Renderer out of 2D rendering mode, by reenabling the depth buffer and restoring the model and projection matrices to the values they had when 2D rendering mode was first entered.
    
    Specified by:
    
    end2DRendering in interface Renderer
  - is2DRendering
```
public boolean is2DRendering()
```
    Description copied from interface: Renderer
    
    Check whether the Renderer is currently in 2D rendering mode.
    
    Specified by:
    
    is2DRendering in interface Renderer
    
    Returns:
    
    true if in 2D rendering mode.
  - numSelectionQueriesNeeded
```
public int numSelectionQueriesNeeded()
```
  - beginSelectionQuery
```
public void beginSelectionQuery(int idx)
```
    Description copied from interface: Renderer
    
    Begins a selection query with the {\it query identifier} qid. If the rendering that occurs between this call and the subsequent call to Renderer.endSelectionQuery() results in anything being rendered within the selection window, a {\it selection hit} will be generated for qid. If called within the render method for a IsSelectable, then qid must lie in the range 0 to numq-1, where numq is the value returned by IsSelectable.numSelectionQueriesNeeded(). Selection queries cannot be nested. If a query identifier is used more than once, it is assumed as part of the same query.
    
    Specified by:
    
    beginSelectionQuery in interface Renderer
    
    Parameters:
    
    idx - identifier for the selection query
    
    See Also:
    
    Renderer.endSelectionQuery()
  - endSelectionQuery
```
public void endSelectionQuery()
```
    Description copied from interface: Renderer
    
    Ends a selection query that was initiated with a call to Renderer.beginSelectionQuery(int).
    
    Specified by:
    
    endSelectionQuery in interface Renderer
    
    See Also:
    
    Renderer.beginSelectionQuery(int)
  - beginSubSelection
```
public void beginSubSelection(IsSelectable s,
                              int idx)
```
    Description copied from interface: Renderer
    
    Begins selection for a IsSelectable sthat manages its own selection; this call should be used in place of Renderer.beginSelectionQuery(int) for such objects. Selectables that manage their own selection are identified by having a value numq >= 0, where numq is the value returned by IsSelectable.numSelectionQueriesNeeded() IsSelectable#numSelectionQueriesNeeded{}}. The argument qid is the current selection query identifier, which after the call should be increased by numq.
    
    Specified by:
    
    beginSubSelection in interface Renderer
    
    Parameters:
    
    s - Selectable that is managing its own sub-selection
    
    idx - current selection query identifier
  - endSubSelection
```
public void endSubSelection()
```
    Description copied from interface: Renderer
    
    Ends object sub-selection that was initiated with a call to Renderer.beginSubSelection(maspack.render.IsSelectable, int).
    
    Specified by:
    
    endSubSelection in interface Renderer
    
    See Also:
    
    Renderer.endSubSelection()
  - setSelectionFilter
```
public void setSelectionFilter(ViewerSelectionFilter filter)
```
    Description copied from interface: Viewer
    
    Sets a selection filter for the viewer. This restricts which objects are actually rendered when a selection render is performed, and therefore restricts which objects can actually be selected. This allows selection of objects that might otherwise be occluded within a scene.
    
    Specified by:
    
    setSelectionFilter in interface Viewer
    
    Parameters:
    
    filter - Selection filter to be applied
  - getSelectionFilter
```
public ViewerSelectionFilter getSelectionFilter()
```
    Description copied from interface: Viewer
    
    Returns the current selection filter for the viewer, if any.
    
    Specified by:
    
    getSelectionFilter in interface Viewer
    
    Returns:
    
    current selection filter, or null if there is none.
  - isSelectable
```
public boolean isSelectable(IsSelectable s)
```
    Description copied from interface: Renderer
    
    Returns true if s is selectable in the current selection context. This will be the case if s.isSelectable() returns true, and s also passes whatever selection filter might currently be set in the renderer.
    
    Specified by:
    
    isSelectable in interface Renderer
  - getMouseHandler
```
public GLMouseListener getMouseHandler()
```
  - setMouseHandler
```
public void setMouseHandler(GLMouseListener handler)
```
  - cleanupScreenShots
```
public abstract void cleanupScreenShots()
```
  - clearPickMatrix
```
public void clearPickMatrix()
```
  - setModelMatrix
```
public void setModelMatrix(AffineTransform3dBase m)
```
    Description copied from interface: Renderer
    
    Sets the model matrix to the specified transform. The model matrix is the transformation from model coordinates to world coordinates.
    
    Specified by:
    
    setModelMatrix in interface Renderer
    
    Parameters:
    
    m - new model matrix value
  - setViewMatrix
```
public void setViewMatrix(RigidTransform3d v)
```
    Description copied from interface: Viewer
    
    Sets the view matrix for this viewer. This is the transform from world to eye coordinates.
    
    Specified by:
    
    setViewMatrix in interface Viewer
    
    Parameters:
    
    v - transform from world to eye coordinates.
  - getModelMatrix
```
public void getModelMatrix(AffineTransform3d m)
```
    Description copied from interface: Renderer
    
    Gets the current model matrix. The model matrix is the transformation from model coordinates to world coordinates.
    
    Specified by:
    
    getModelMatrix in interface Renderer
    
    Parameters:
    
    m - returns the current model matrix value
  - getModelMatrix
```
public AffineTransform3dBase getModelMatrix()
```
    Description copied from interface: Renderer
    
    Gets the current model matrix. The model matrix is the transformation from model coordinates to world coordinates. If the matrix is a rigid transformation, the returned value is a RigidTransform3d; otherwise, it is a more general AffineTransform3d.
    
    Specified by:
    
    getModelMatrix in interface Renderer
    
    Returns:
    
    model matrix value (may be modified by the user)
  - translateModelMatrix
```
public void translateModelMatrix(Vector3d t)
```
  - translateModelMatrix
```
public void translateModelMatrix(double tx,
                                 double ty,
                                 double tz)
```
    Description copied from interface: Renderer
    Translates the model frame. This is done post-multiplying the current model matrix by a translation matrix. If the model matrix is described by the affine transform
```
  [  M   p  ]
  [         ]
  [  0   1  ]
 
```
    where M is a 3 X 3 matrix and p is a 3 X 1 translation vector, and if t is the translation vector, then this method sets the model matrix to
```
  [  M   M t + p ]
  [              ]
  [  0      1    ]
 
```
    Specified by:
    
    translateModelMatrix in interface Renderer
    
    Parameters:
    
    tx - translation along x
    
    ty - translation along y
    
    tz - translation along z
  - rotateModelMatrix
```
public void rotateModelMatrix(double zdeg,
                              double ydeg,
                              double xdeg)
```
    Description copied from interface: Renderer
    Rotates the model frame. This is done post-multiplying the current model matrix by a rotation matrix formed from three successive rotations: a rotation of zdeg degrees about the z axis, followed by a rotation of ydeg degrees about the new y axis, and finally a rotation of xdeg degrees about the new x axis. If the model matrix is described by the affine transform
```
  [  M   p  ]
  [         ]
  [  0   1  ]
 
```
    where M is a 3 X 3 matrix and p is a 3 X 1 translation vector, and if R is the rotation matrix, then this method sets the model matrix to
```
  [  M R   p ]
  [          ]
  [   0    1 ]
 
```
    Specified by:
    
    rotateModelMatrix in interface Renderer
    
    Parameters:
    
    zdeg - rotation about z axis (degrees)
    
    ydeg - rotation about new y axis (degrees)
    
    xdeg - rotation about new x axis (degrees)
  - scaleModelMatrix
```
public void scaleModelMatrix(double s)
```
    Description copied from interface: Renderer
    Scales the current model matrix. If the model matrix is described by the affine transform
```
  [  M   p  ]
  [         ]
  [  0   1  ]
 
```
    where M is a 3 X 3 matrix and p is a 3 X 1 translation vector, and s is the scale factor, then this method sets the model matrix to
```
  [ s M  p  ]
  [         ]
  [  0   1  ]
 
```
    Specified by:
    
    scaleModelMatrix in interface Renderer
    
    Parameters:
    
    s - scale factor
  - scaleModelMatrix
```
public void scaleModelMatrix(double sx,
                             double sy,
                             double sz)
```
  - mulModelMatrix
```
public void mulModelMatrix(AffineTransform3dBase trans)
```
    Description copied from interface: Renderer
    Post-multiplies the model matrix by the specified transform X, which may be either a RigidTransform3d or an AffineTransform3d. If the model matrix is described by the affine transform
```
  [  M   p  ]
  [         ]
  [  0   1  ]
 
```
    where M is a 3 X 3 matrix and p is a 3 X 1 translation vector, and the transform X is described by
```
  [  A   b  ]
  [         ]
  [  0   1  ]
 
```
    then this method sets the model matrix to
```
  [ M A   M b + p ]
  [               ]
  [  0       1    ]
 
```
    Specified by:
    
    mulModelMatrix in interface Renderer
    
    Parameters:
    
    trans - transform to multiply the model matrix by
  - getModelMatrix
```
public void getModelMatrix(Matrix4d X)
```
  - getViewMatrix
```
public void getViewMatrix(Matrix4d X)
```
  - getProjectionMatrix
```
public void getProjectionMatrix(Matrix4d X)
```
  - getProjectionMatrix
```
public Matrix4d getProjectionMatrix()
```
  - setTextureMatrix
```
public void setTextureMatrix(AffineTransform2dBase T)
```
    Description copied from interface: Renderer
    
    Sets the texture coordinate transformation matrix to the specified transform. The texture matrix is applied to texture coordinates, useful for tiling, or when compacting multiple texture sources into a single large texture.
    
    Specified by:
    
    setTextureMatrix in interface Renderer
    
    Parameters:
    
    T - new texture transform matrix
  - getTextureMatrix
```
public AffineTransform2dBase getTextureMatrix()
```
    Description copied from interface: Renderer
    
    Gets the current texture matrix. The texture matrix is the transformation applied to any texture coordinates. If the matrix is a rigid transformation, the returned value is a RigidTransform2d; otherwise, it is a more general AffineTransform2d.
    
    Specified by:
    
    getTextureMatrix in interface Renderer
    
    Returns:
    
    texture matrix value (may be modified by the user)
  - getTextureMatrix
```
public void getTextureMatrix(AffineTransform2d X)
```
    Description copied from interface: Renderer
    
    Gets the current texture matrix. The texture matrix is the transformation applied to texture coordinates.
    
    Specified by:
    
    getTextureMatrix in interface Renderer
    
    Parameters:
    
    X - returns the current texture matrix value
    
    See Also:
    
    Renderer.setTextureMatrix(AffineTransform2dBase)
  - pushViewMatrix
```
public void pushViewMatrix()
```
  - popViewMatrix
```
public boolean popViewMatrix()
```
  - pushModelMatrix
```
public void pushModelMatrix()
```
    Description copied from interface: Renderer
    
    Saves the model matrix by pushing it onto the model matrix stack.
    
    Specified by:
    
    pushModelMatrix in interface Renderer
  - popModelMatrix
```
public boolean popModelMatrix()
```
    Description copied from interface: Renderer
    
    Restores the model matrix by popping it off the model matrix stack
    
    Specified by:
    
    popModelMatrix in interface Renderer
    
    Returns:
    
    false if the model matrix stack is empty
  - pushProjectionMatrix
```
public void pushProjectionMatrix()
```
  - popProjectionMatrix
```
public boolean popProjectionMatrix()
```
  - pushTextureMatrix
```
public void pushTextureMatrix()
```
  - popTextureMatrix
```
public boolean popTextureMatrix()
```
  - numFreeClipPlanes
```
public int numFreeClipPlanes()
```
  - getMaxGLClipPlanes
```
public int getMaxGLClipPlanes()
```
  - addClipPlane
```
public GLClipPlane addClipPlane()
```
  - addClipPlane
```
public GLClipPlane addClipPlane(RigidTransform3d X,
                                double size)
```
  - addClipPlane
```
public boolean addClipPlane(GLClipPlane clipPlane)
```
  - getClipPlane
```
public GLClipPlane getClipPlane(int idx)
```
  - getNumClipPlanes
```
public int getNumClipPlanes()
```
  - getClipPlanes
```
public GLClipPlane[] getClipPlanes()
```
  - removeClipPlane
```
public boolean removeClipPlane(GLClipPlane clipPlane)
```
  - clearClipPlanes
```
public void clearClipPlanes()
```
  - drawSphere
```
public void drawSphere(Vector3d pnt,
                       double rad)
```
    Description copied from interface: Renderer
    
    Draws a sphere with a specified radius centered at a point in model coordinates, using the current shading and material. The point is located in model coordinates. The resolution of the sphere is specified by Renderer.getSurfaceResolution().
    
    Specified by:
    
    drawSphere in interface Renderer
    
    Parameters:
    
    pnt - center of the sphere
    
    rad - radius of the sphere
  - drawCube
```
public void drawCube(Vector3d pnt,
                     double w)
```
    Description copied from interface: Renderer
    
    Draws an axis-aligned cube with a specified width centered at a point in model coordinates, using the current shading and material.
    
    Specified by:
    
    drawCube in interface Renderer
    
    Parameters:
    
    pnt - center of the cube
    
    w - width of the cube
  - drawBox
```
public void drawBox(Vector3d pnt,
                    Vector3d widths)
```
    Description copied from interface: Renderer
    
    Draws an axis-aligned box in model coordinates, using the current shading and material.
    
    Specified by:
    
    drawBox in interface Renderer
    
    Parameters:
    
    pnt - center of the box
    
    widths - x,y,z widths of the box
  - drawCylinder
```
public void drawCylinder(Vector3d pnt0,
                         Vector3d pnt1,
                         double rad,
                         boolean capped)
```
    Description copied from interface: Renderer
    
    Draws a cylinder between two points in model coordinates, using the current shading and material. The resolution is specified by Renderer.getSurfaceResolution().
    
    Specified by:
    
    drawCylinder in interface Renderer
    
    Parameters:
    
    pnt0 - first end point
    
    pnt1 - second end point
    
    rad - radius of the cylinder
    
    capped - if true, indicates that the cylinder should have a solid cap on each end
  - drawSpindle
```
public void drawSpindle(Vector3d pnt0,
                        Vector3d pnt1,
                        double rad)
```
    Description copied from interface: Renderer
    
    Draws a spindle between two points in model coordinates, using the current shading and material. The resolution is specified by Renderer.getSurfaceResolution().
    
    Specified by:
    
    drawSpindle in interface Renderer
    
    Parameters:
    
    pnt0 - first end point
    
    pnt1 - second end point
    
    rad - radius of the spindle
  - drawCone
```
public void drawCone(Vector3d pnt0,
                     Vector3d pnt1,
                     double rad0,
                     double rad1,
                     boolean capped)
```
    Description copied from interface: Renderer
    
    Draws a cone between two points in model coordinates, using the current shading and material. A cone is like a cylinder, except that it can have different radii at the end points. The resolution is specified by Renderer.getSurfaceResolution().
    
    Specified by:
    
    drawCone in interface Renderer
    
    Parameters:
    
    pnt0 - first end point
    
    pnt1 - second end point
    
    rad0 - radius at first end point
    
    rad1 - radius at second end point
    
    capped - if true, indicates that the cone should have a solid cap on each end
  - drawArrow
```
public void drawArrow(Vector3d pnt0,
                      Vector3d pnt1,
                      double rad,
                      boolean capped)
```
    Description copied from interface: Renderer
    
    Draws a solid arrow between two points in model coordinates, using the current shading and material. The arrow is rendered as a cylinder with radius rad, topped with a conical arrow head pointing towards the second end point. The arrow head has a base radius of 3*rad and length given by
    min (6*rad, len/2)
    where len is the distance between the two end points. The resolution is specified by Renderer.getSurfaceResolution().
    
    Specified by:
    
    drawArrow in interface Renderer
    
    Parameters:
    
    pnt0 - first end point
    
    pnt1 - second end point
    
    rad - radius of the cylinder
    
    capped - if true, indicates that the arrow should have a solid cap on the bottom
  - drawLine
```
public void drawLine(RenderProps props,
                     float[] pnt0,
                     float[] pnt1,
                     boolean highlight)
```
    Description copied from interface: Renderer
    
    Draws a single line between two points in model coordinates, using the line style, radius, line color, and shading specified by the render properties argument props.
    If props.getLineStyle() specifies a line style of Renderer.LineStyle.LINE, then the line is drawn as a pixel-based line with a width given by props.getLineWidth(). For other line styles, the line is drawn as a solid with a nominal radius given by props.getLineRadius(). If highlight is true and the highlight style is Renderer.HighlightStyle.COLOR, then the line will be drawn using the highlight color rather than the line color specified in props.
    
    Specified by:
    
    drawLine in interface Renderer
    
    Parameters:
    
    props - render properties used for drawing the line
    
    pnt0 - first point
    
    pnt1 - second point
    
    highlight - if true, indicates that highlighting, if enabled, should be applied to the line
  - drawLine
```
public void drawLine(RenderProps props,
                     float[] pnt0,
                     float[] pnt1,
                     boolean capped,
                     boolean highlight)
```
    Description copied from interface: Renderer
    
    Draws a single line between two points in model coordinates, using the line style, radius, line color, and shading specified by the render properties argument props. This method is functionally equivalent to Renderer.drawLine(RenderProps,float[],float[],boolean), except for the additional control provided by the argument capped.
    
    Specified by:
    
    drawLine in interface Renderer
    
    Parameters:
    
    props - render properties used for drawing the line
    
    pnt0 - first point
    
    pnt1 - second point
    
    capped - if true, specifies that the line should have a solid cap on its ends for styles such as Renderer.LineStyle.CYLINDER and @link LineStyle#ARROW}
    
    highlight - if true, indicates that highlighting, if enabled, should be applied to the line
  - drawPoint
```
public void drawPoint(Vector3d pnt)
```
    Description copied from interface: Renderer
    
    Draws a single point located at pnt in model coordinates, using the current point size, material, and shading. Since no normal is specified, this method should generally be called with either lighting disabled or with shading set to Renderer.Shading.NONE.
    
    Specified by:
    
    drawPoint in interface Renderer
    
    Parameters:
    
    pnt - location of the point
  - drawPoint
```
public void drawPoint(double px,
                      double py,
                      double pz)
```
    Description copied from interface: Renderer
    
    Draws a single point located at px, py and pz in model coordinates, using the current point size, material, and shading. This method is functionally equivalent to Renderer.drawPoint(Vector3d).
    
    Specified by:
    
    drawPoint in interface Renderer
    
    Parameters:
    
    px - x coordinate of the point
    
    py - y coordinate of the point
    
    pz - z coordinate of the point
  - drawLine
```
public void drawLine(Vector3d pnt0,
                     Vector3d pnt1)
```
    Description copied from interface: Renderer
    
    Draws a single line between two points in model coordinates, using the current line width, material, and shading. Since no normal are specified, this method should generally be called with either lighting disabled or with shading set to Renderer.Shading.NONE.
    
    Specified by:
    
    drawLine in interface Renderer
    
    Parameters:
    
    pnt0 - first point
    
    pnt1 - second point
  - drawLine
```
public void drawLine(double px0,
                     double py0,
                     double pz0,
                     double px1,
                     double py1,
                     double pz1)
```
    Description copied from interface: Renderer
    
    Draws a single line between two points in model coordinates, using the current line width, material, and shading. This method is functionally equivalent to Renderer.drawLine(Vector3d,Vector3d).
    
    Specified by:
    
    drawLine in interface Renderer
    
    Parameters:
    
    px0 - x coordinate of first point
    
    py0 - y coordinate of first point
    
    pz0 - z coordinate of first point
    
    px1 - x coordinate of second point
    
    py1 - y coordinate of second point
    
    pz1 - z coordinate of second point
  - drawTriangle
```
public void drawTriangle(Vector3d pnt0,
                         Vector3d pnt1,
                         Vector3d pnt2)
```
    Description copied from interface: Renderer
    
    Draws a single triangular face specified by three points, using the current shading, lighting and material. The triangle's normal is computed and used for all three vertices, so that unless shading is set to Renderer.Shading.NONE, the shading will be effectively flat.
    
    Specified by:
    
    drawTriangle in interface Renderer
    
    Parameters:
    
    pnt0 - first point
    
    pnt1 - second point
    
    pnt2 - third point
  - drawAxes
```
public void drawAxes(RigidTransform3d X,
                     double len,
                     int width,
                     boolean highlight)
```
    Description copied from interface: Renderer
    
    Draws a set of coordinate axes representing a rigid coordinate frame X. The origin point for the axes is X.p, and the directions for each axis are given by the three columns of X.R. Each axis is drawn as a pixel-based line with a length len and a width width. By default, the x, y, and z axes are drawn using the colors red, green, and blue, unless highlight is true and the highlight style is Renderer.HighlightStyle.COLOR, in which case all axes are drawn using the renderer's highlight color.
    
    Specified by:
    
    drawAxes in interface Renderer
    
    Parameters:
    
    X - coordinate frame defining the axes
    
    len - axis length
    
    width - width of each axis (in pixels)
    
    highlight - if true, indicates that the axes should be highlighted.
  - drawSolidAxes
```
public void drawSolidAxes(RigidTransform3d X,
                          double[] lens,
                          double rad,
                          boolean highlight)
```
    Description copied from interface: Renderer
    
    Draws a solid set of coordinate axes representing a rigid coordinate frame X. This method is functionally equivalent to Renderer.drawSolidAxes(RigidTransform3d,double,double,boolean), except that the lengths for each axis are individually specified. Axes with a a specified length of 0 will not be drawn.
    
    Specified by:
    
    drawSolidAxes in interface Renderer
    
    Parameters:
    
    X - coordinate frame defining the axes
    
    lens - lengths for each axis
    
    rad - axis cylinder radius
    
    highlight - if true, indicates that the axes should be highlighted.
  - drawSolidAxes
```
public void drawSolidAxes(RigidTransform3d X,
                          double len,
                          double rad,
                          boolean highlight)
```
    Description copied from interface: Renderer
    
    Draws a solid set of coordinate axes representing a rigid coordinate frame X. The origin point for the axes is X.p, and the directions for each axis are given by the three columns of X.R. Each axis is drawn an arrow-tipped cylinder with a length len and cylinder radius rad. By default, the x, y, and z axes are drawn using the colors red, green, and blue, unless highlight is true and the highlight style is Renderer.HighlightStyle.COLOR, in which case all axes are drawn using the renderer's highlight color.
    
    Specified by:
    
    drawSolidAxes in interface Renderer
    
    Parameters:
    
    X - coordinate frame defining the axes
    
    len - axis length
    
    rad - axis cylinder radius
    
    highlight - if true, indicates that the axes should be highlighted.
  - getTextRenderer
```
public abstract GLTextRenderer getTextRenderer()
```
  - setDefaultFont
```
public void setDefaultFont(java.awt.Font font)
```
    Description copied from interface: Renderer
    
    Sets default font for text rendering
    
    Specified by:
    
    setDefaultFont in interface Renderer
    
    Parameters:
    
    font - default font. The font size largely impacts the resolution of the renderer characters. A value of at least 32pt is recommended.
  - getDefaultFont
```
public java.awt.Font getDefaultFont()
```
    Description copied from interface: Renderer
    
    Retrieves the default font.
    
    Specified by:
    
    getDefaultFont in interface Renderer
    
    Returns:
    
    default font.
  - hasTextRendering
```
public boolean hasTextRendering()
```
    Description copied from interface: Renderer
    
    Queries whether or not this renderer supports text rendering.
    
    Specified by:
    
    hasTextRendering in interface Renderer
    
    Returns:
    
    true if text rendering is supported.
  - getTextBounds
```
public java.awt.geom.Rectangle2D getTextBounds(java.awt.Font font,
                                               java.lang.String str,
                                               double emSize)
```
    Description copied from interface: Renderer
    
    Computes and returns the logical bounding box of the supplied text. The width is the total advance, from baseline of the first character, to the advance after the last character. The height is the line height (ascent + descent + leading). The origin is placed at the baseline, with the position specifying the bottom-left corner. Note that in some fonts, some characters may extend outside of these bounds. This method is mainly used for manual alignment of text.
    
    Specified by:
    
    getTextBounds in interface Renderer
    
    Parameters:
    
    font - font to use for sizing
    
    str - String of which to compute the bounding box
    
    emSize - size of the 'em' unit
    
    Returns:
    
    rectangular bounds
  - drawText
```
public double drawText(java.lang.String str,
                       float[] pos,
                       double emSize)
```
    Description copied from interface: Renderer
    
    Draws text in the x-y plane in model coordinates. Uses a default font.
    
    Specified by:
    
    drawText in interface Renderer
    
    Parameters:
    
    str - string to render
    
    pos - position of the lower left of the text box (model coordinates)
    
    emSize - size of an `em' unit in model coordinates
    
    Returns:
    
    the advance distance in the x-direction (width of text)
  - drawText
```
public double drawText(java.awt.Font font,
                       java.lang.String str,
                       Vector3d pos,
                       double emSize)
```
    Description copied from interface: Renderer
    
    Draws text in the x-y plane in model coordinates.
    
    Specified by:
    
    drawText in interface Renderer
    
    Parameters:
    
    font - the font to use. The font size largely impacts the resolution of the renderer characters. A value of at least 32pt is recommended.
    
    str - string to render
    
    pos - position of the lower left of the text box (model coordinates)
    
    emSize - size of an `em' unit in model coordinates
    
    Returns:
    
    the advance distance in the x-direction (width of text)
  - drawText
```
public double drawText(java.lang.String str,
                       Vector3d pos,
                       double emSize)
```
    Description copied from interface: Renderer
    
    Draws text in the x-y plane in model coordinates. Uses a default font.
    
    Specified by:
    
    drawText in interface Renderer
    
    Parameters:
    
    str - string to render
    
    pos - position of the lower left of the text box (model coordinates)
    
    emSize - size of an `em' unit in model coordinates
    
    Returns:
    
    the advance distance in the x-direction (width of text)
  - dispose
```
public void dispose()
```
    MUST BE CALLED by whatever frame when it is going down, will notify any shared resources that they can be cleared. It is best to add it as a WindowListener
  - setHighlighting
```
public boolean setHighlighting(boolean enable)
```
    Enables or disables highlighting. If highlighting is enabled, subsequent primitives will be rendered in a highlighted fashion using the style indicated by Renderer.HighlightStyle. If the style is Renderer.HighlightStyle.COLOR, highlighting is done by setting the effective color to the highlight color.
    
    Specified by:
    
    setHighlighting in interface Renderer
    
    Parameters:
    
    enable - if true, enable highlighting.
    
    Returns:
    
    previous highlighting value
    
    See Also:
    
    Renderer.getHighlightColor(float[])
  - getHighlighting
```
public boolean getHighlighting()
```
    Description copied from interface: Renderer
    
    Queries whether or not highlighting is enabled.
    
    Specified by:
    
    getHighlighting in interface Renderer
    
    Returns:
    
    true if highlighting is enabled
  - setFrontColor
```
public void setFrontColor(float[] rgba)
```
    Description copied from interface: Renderer
    
    Sets the diffuse and ambient colors to be used for subsequent rendering of primitives. This is also the color that is used for solid color rendering if lighting is disabled or shading is set to Renderer.Shading.NONE. By default, this color is used for both the front and back faces of triangles, but an alternative color can be specified for back faces using Renderer.setBackColor(float[]).
    
    Specified by:
    
    setFrontColor in interface Renderer
    
    Parameters:
    
    rgba - array of length 3 or 4 specifying RGB or RGBA values in the range [0,1]. Alpha is only applied to the diffuse color and is assumed to be 1.0 if not specified.
  - getColor
```
public float[] getColor(float[] rgba)
```
    Gets a copy of the current diffuse "color"
    
    Parameters:
    
    rgba - array to fill, or null to create new array
    
    Returns:
    
    filled array
  - getFrontColor
```
public float[] getFrontColor(float[] rgba)
```
    Description copied from interface: Renderer
    
    Returns the RGB or RGBA values for the front color as a float array. The application may supply the array via the argument rgba. Otherwise, Otherwise, if rgba is null, an array of length 4 will be allocated for returning the RGBA values. The default RGBA values for the front color are (1, 1, 1, 1).
    
    Specified by:
    
    getFrontColor in interface Renderer
    
    Parameters:
    
    rgba - optional storage of length 3 or 4 for returning either the RGB or RGBA values.
    
    Returns:
    
    RGB or RGBA values for the front color
  - setBackColor
```
public void setBackColor(float[] rgba)
```
    Description copied from interface: Renderer
    
    Optionally sets the diffuse and ambient colors used for the subsequent rendering of the back faces of triangles. If rgba is set to null, then the back color is cleared and back faces will be rendered using the front color. By default, the back color is null.
    
    Specified by:
    
    setBackColor in interface Renderer
    
    Parameters:
    
    rgba - null to clear back coloring, or an array of length 3 or 4 specifying RGB or RGBA values in the range [0,1]. Alpha is only applied to the diffuse color and is assumed to be 1.0 if not specified.
  - getBackColor
```
public float[] getBackColor(float[] rgba)
```
    Description copied from interface: Renderer
    
    Returns the RGB or RGBA values for the back color as a float array, or null if no back color is set. The application may supply the array via the argument rgba. Otherwise, Otherwise, if rgba is null and the back color is set, an array of length 4 will be allocated for returning the RGBA values.
    
    Specified by:
    
    getBackColor in interface Renderer
    
    Parameters:
    
    rgba - optional storage of length 3 or 4 for returning either the RGB or RGBA values.
    
    Returns:
    
    RGB or RGBA values for the back color, or null if no back color is set.
  - setEmission
```
public void setEmission(float[] rgb)
```
    Description copied from interface: Renderer
    
    Sets the emission color to be used for subsequent rendering of primitives. The default emission color has a value of (0, 0, 0).
    
    Specified by:
    
    setEmission in interface Renderer
    
    Parameters:
    
    rgb - array of length 3 specifying RGB values in the range [0,1].
  - getEmission
```
public float[] getEmission(float[] rgb)
```
    Description copied from interface: Renderer
    
    Returns the RGB values for the emission color as a float array. The application may supply the array via the argument rgb. Otherwise, if rgb is null, an array will be allocated for returning the RGB values.
    
    Specified by:
    
    getEmission in interface Renderer
    
    Parameters:
    
    rgb - optional storage for returning the RGB values.
    
    Returns:
    
    RGB values for the emission color
  - setSpecular
```
public void setSpecular(float[] rgb)
```
    Description copied from interface: Renderer
    
    Sets the specular color to be used for subsequent rendering of primitives. The default specular color has a value of (0.1, 0.1, 0.1).
    
    Specified by:
    
    setSpecular in interface Renderer
    
    Parameters:
    
    rgb - array of length 3 specifying RGB values in the range [0,1].
  - getSpecular
```
public float[] getSpecular(float[] rgb)
```
    Description copied from interface: Renderer
    
    Returns the RGB values for the specular color as a float array. The application may supply the array via the argument rgb. Otherwise, if rgb is null, an array will be allocated for returning the RGB values.
    
    Specified by:
    
    getSpecular in interface Renderer
    
    Parameters:
    
    rgb - optional storage for returning the RGB values.
    
    Returns:
    
    RGB values for the specular color
  - setShininess
```
public void setShininess(float s)
```
    Description copied from interface: Renderer
    
    Sets the shininess parameter to be used for subsequent rendering of primitives (see Renderer.getShininess(). This should be in the range [0,128], and the default value is 32.
    
    Specified by:
    
    setShininess in interface Renderer
    
    Parameters:
    
    s - shininess parameter
  - getShininess
```
public float getShininess()
```
    Description copied from interface: Renderer
    
    Returns the current shininess parameter. This is the specular exponent of the lighting equation, and is in the range [0,128],
    
    Specified by:
    
    getShininess in interface Renderer
    
    Returns:
    
    shininess parameter
  - setFrontAlpha
```
public void setFrontAlpha(float a)
```
    Description copied from interface: Renderer
    
    Sets the alpha value for the front material.
    
    Specified by:
    
    setFrontAlpha in interface Renderer
    
    Parameters:
    
    a - alpha value, in the range [0,1].
  - setColor
```
public void setColor(float[] rgba,
                     boolean highlight)
```
    Description copied from interface: Renderer
    Sets the diffuse and ambient colors to the value specified by rgba, and enables or disables highlighting according to the value of highlight. If highlighting is requested and the highlight style is Renderer.HighlightStyle.COLOR, the highlight color will override the diffuse/ambient color settings. This method also clears any back color that may be present. It is therefore equivalent to calling
```
    setFrontColor (rgba);
    setBackColor (null);
    setHighlighting (highlight);
 
```
    Specified by:
    
    setColor in interface Renderer
    
    Parameters:
    
    rgba - array of length 3 or 4 specifying RGB or RGBA values in the range [0,1]. Alpha is only applied to the diffuse color and is assumed to be 1.0 if not specified.
    
    highlight - if true, enables highlighting rgba
  - setColor
```
public void setColor(float[] rgba)
```
    Description copied from interface: Renderer
    Sets the diffuse and ambient colors to the value specified by rgba. This method also clears any back color that may be present, and is therefore equivalent to calling
```
    setFrontColor (rgba);
    setBackColor (null);
 
```
    Specified by:
    
    setColor in interface Renderer
    
    Parameters:
    
    rgba - array of length 3 or 4 specifying RGB or RGBA values in the range [0,1]. Alpha is only applied to the diffuse color and is assumed to be 1.0 if not specified.
  - setColor
```
public void setColor(float r,
                     float g,
                     float b)
```
    Description copied from interface: Renderer
    
    Sets the diffuse and ambient colors to be used for subsequent rendering of primitives. The method is functionally equivalent to Renderer.setColor(float[]), only with alpha assumed to be 1.
    
    Specified by:
    
    setColor in interface Renderer
    
    Parameters:
    
    r - red value
    
    g - green value
    
    b - blue value
  - setColor
```
public void setColor(float r,
                     float g,
                     float b,
                     float a)
```
    Description copied from interface: Renderer
    
    Sets the diffuse and ambient colors to be used for subsequent rendering of primitives. The method is functionally equivalent to Renderer.setColor(float[]).
    
    Specified by:
    
    setColor in interface Renderer
    
    Parameters:
    
    r - red value
    
    g - green value
    
    b - blue value
    
    a - alpha value
  - setColor
```
public void setColor(java.awt.Color color)
```
    Description copied from interface: Renderer
    
    Sets the diffuse and ambient colors to be used for subsequent rendering of primitives. The method is functionally equivalent to Renderer.setColor(float[]), with the RGBA values being obtained from the color components of color.
    
    Specified by:
    
    setColor in interface Renderer
    
    Parameters:
    
    color - specifies RGBA color values.
  - setMaterial
```
public void setMaterial(float[] frontRgba,
                        float[] backRgba,
                        float shininess,
                        boolean selected)
```
  - setPropsColoring
```
public void setPropsColoring(RenderProps props,
                             float[] rgba,
                             boolean highlight)
```
    Description copied from interface: Renderer
    Sets the diffuse and ambient colors to rgba, and enables or disables highlighting according to the value of highlight. If rgba only has a length of 3 then the front alpha value is supplied by props.getAlpha(). The shininess is set to props.getShininess(), while the back color is set to null, the emission color is set to its default value, and the specular color is set to either props.getSpecular(), or to its default value if the former is null. This behavior is equivalent to the following:
```
   setFrontColor (rgba);
   if (rgba.length == 3) {
      setFrontAlpha (props.getAlpha());
   }
   setBackColor (null);
   setShininess (props.getShininess());
   setEmission (DEFAULT_EMISSION_VALUE);
   specular = props.getSpecular();
   setSpecular (specular != null ? specular : DEFAULT_SPECULAR_VALUE);
   setHighlighting (highlight)
 
```
    If highlighting is requested and the highlight method equals Renderer.HighlightStyle.COLOR, the highlight color will override the diffuse/ambient color settings.
    Specified by:
    
    setPropsColoring in interface Renderer
    
    Parameters:
    
    props - supplies the shininess value
    
    rgba - an array of length 3 or 4 specifying RGB or RGBA values for the color the range [0,1]. Alpha is only applied to the diffuse color and is set to props.getAlpha() if not specified.
    
    highlight - if true, enables highlighting
  - setLineColoring
```
public void setLineColoring(RenderProps props,
                            boolean highlight)
```
    Description copied from interface: Renderer
    
    Sets the diffuse and ambient colors to the line color in props, and enables or disables highlighting according to the value of highlight. The back color is set to null, and the emission, shininess, and specular values are set either from props or from default values.
    The resulting behavior is equivalent to Renderer.setPropsColoring(maspack.render.RenderProps, float[], boolean) with props.getLineColor() supplying the rgba value. If highlighting is requested and the highlight method equals Renderer.HighlightStyle.COLOR, the highlight color will override the diffuse/ambient color settings.
    
    Specified by:
    
    setLineColoring in interface Renderer
    
    Parameters:
    
    props - supplies the shininess and line color values
    
    highlight - if true, enables highlighting
  - setPointColoring
```
public void setPointColoring(RenderProps props,
                             boolean highlight)
```
    Description copied from interface: Renderer
    
    Sets the diffuse and ambient colors to the point color in props, and enables or disables highlighting according to the value of highlight. The back color is set to null, and the emission, shininess, and specular values are set either from props or from default values.
    The resulting behavior is equivalent to Renderer.setPropsColoring(maspack.render.RenderProps, float[], boolean) with props.getPointColor() supplying the rgba value. If highlighting is requested and the highlight method equals Renderer.HighlightStyle.COLOR, the highlight color will override the diffuse/ambient color settings.
    
    Specified by:
    
    setPointColoring in interface Renderer
    
    Parameters:
    
    props - supplies the shininess and point color values
    
    highlight - if true, enables highlighting
  - setEdgeColoring
```
public void setEdgeColoring(RenderProps props,
                            boolean highlight)
```
    Description copied from interface: Renderer
    
    Sets the diffuse and ambient colors to the edge color in props, and enables or disables highlighting according to the value of highlight. If the edge color is null then the line color in props is used instead. The back color is set to null, and the emission, shininess, and specular values are set either from props or from default values.
    The resulting behavior is equivalent to Renderer.setPropsColoring(maspack.render.RenderProps, float[], boolean) with props.getEdgeColor() or props.getLineColor() supplying the rgba value. If highlighting is requested and the highlight method equals Renderer.HighlightStyle.COLOR, the highlight color will override the diffuse/ambient color settings.
    
    Specified by:
    
    setEdgeColoring in interface Renderer
    
    Parameters:
    
    props - supplies the shininess and edge (or line) color values
    
    highlight - if true, enables highlighting
  - setFaceColoring
```
public void setFaceColoring(RenderProps props,
                            boolean highlight)
```
    Description copied from interface: Renderer
    
    Sets the diffuse and ambient colors to the face color in props, and enables or disables highlighting according to the value of highlight. The back color will also be set to the (possibly null) value of the back color in props. If the back color is not null, then this will be used to provide the coloring for back faces when they are visible. The emission, shininess, and specular values are set either from props or from default values.
    The resulting behavior is equivalent to Renderer.setPropsColoring(maspack.render.RenderProps, float[], boolean) with props.getFaceColor() supplying the rgba value, except that the back color is set from props.getBackColor() instead of being set to null. If highlighting is requested and the highlight method equals Renderer.HighlightStyle.COLOR, the highlight color will override the diffuse/ambient color settings.
    
    Specified by:
    
    setFaceColoring in interface Renderer
    
    Parameters:
    
    props - supplies the shininess and front and back color values
    
    highlight - if true, enables highlighting
  - setFaceColoring
```
public void setFaceColoring(RenderProps props,
                            float[] rgba,
                            boolean highlight)
```
    Description copied from interface: Renderer
    
    Sets the diffuse and ambient colors to rgba, and enables or disables highlighting according to the value of highlight. The back color will also be set to the (possibly null) value of the back color in props. If the back color is not null, then this will be used to provide the coloring for back faces when they are visible. The emission, shininess, and specular values are set either from props or from default values.
    The resulting behavior is equivalent to Renderer.setPropsColoring(maspack.render.RenderProps, float[], boolean), except that the back color is set from props.getBackColor() instead of being set to null. If highlighting is requested and the highlight method equals Renderer.HighlightStyle.COLOR, the highlight color will override the diffuse/ambient color settings.
    
    Specified by:
    
    setFaceColoring in interface Renderer
    
    Parameters:
    
    props - supplies the shininess and back color values
    
    rgba - an array of length 3 or 4 specifying RGB or RGBA values for the color the range [0,1]. Alpha is only applied to the diffuse color and is set to props.getAlpha() if not specified.
    
    highlight - if true, enables highlighting
  - setPointShading
```
public Renderer.Shading setPointShading(RenderProps props)
```
    Sets the shading appropriate to the point style specified in props. If props.getPointStyle() is Renderer.PointStyle.POINT, then shading is set to Renderer.Shading.NONE; otherwise, it is set to props.getShading().
    
    Specified by:
    
    setPointShading in interface Renderer
    
    Parameters:
    
    props - properties giving the shading and point style
    
    Returns:
    
    the previous shading setting
  - setLineShading
```
public Renderer.Shading setLineShading(RenderProps props)
```
    Sets the shading appropriate to the line style specified in props. If props.getLineStyle() is Renderer.LineStyle.LINE, then shading is set to Renderer.Shading.NONE; otherwise, it is set to props.getShading().
    
    Specified by:
    
    setLineShading in interface Renderer
    
    Parameters:
    
    props - properties giving the shading and line style
    
    Returns:
    
    the previous shading setting
  - setPropsShading
```
public Renderer.Shading setPropsShading(RenderProps props)
```
    Sets the shading to that shading specified by props.getShading().
    
    Specified by:
    
    setPropsShading in interface Renderer
    
    Parameters:
    
    props - properties giving the shading
    
    Returns:
    
    the previous shading setting
  - drawPoints
```
public void drawPoints(RenderObject robj)
```
    Description copied from interface: Renderer
    
    Draws all the points in the first point group of the specified render object, using the current material and shading.
    
    Specified by:
    
    drawPoints in interface Renderer
    
    Parameters:
    
    robj - render object
  - drawPoints
```
public void drawPoints(RenderObject robj,
                       Renderer.PointStyle style,
                       double rad)
```
    Description copied from interface: Renderer
    
    Draws all the points in the first point group of the specified render object, using the current material and shading. The points are drawn either as pixel-based points or as solids, according to the specified points style. For points drawn using the style Renderer.PointStyle.POINT, the argument rad gives the point size, whereas for Renderer.PointStyle.CUBE it gives the cube half-width, and for Renderer.PointStyle.SPHERE it gives the sphere radius.
    
    Specified by:
    
    drawPoints in interface Renderer
    
    Parameters:
    
    robj - render object
    
    style - point style to use for drawing
    
    rad - radius for spheres or width for pixel-based points
  - drawPoints
```
public void drawPoints(RenderObject robj,
                       int gidx,
                       Renderer.PointStyle style,
                       double rad)
```
    Description copied from interface: Renderer
    
    Draws all the points in the specified point group of the supplied render object, using the current material and shading. The points are drawn either as pixel-based points or as solids, according to the specified points style. For points drawn using the style Renderer.PointStyle.POINT, the argument rad gives the point size, whereas for Renderer.PointStyle.CUBE it gives the cube half-width, and for Renderer.PointStyle.SPHERE it gives the sphere radius.
    
    Specified by:
    
    drawPoints in interface Renderer
    
    Parameters:
    
    robj - render object
    
    gidx - point group index
    
    style - point style to use for drawing
    
    rad - radius for spheres or width for pixel-based points
  - drawLines
```
public void drawLines(RenderObject robj)
```
    Description copied from interface: Renderer
    
    Draws all the lines in the first line group of the specified render object, using the current material and shading.
    
    Specified by:
    
    drawLines in interface Renderer
    
    Parameters:
    
    robj - render object
  - drawLines
```
public void drawLines(RenderObject robj,
                      Renderer.LineStyle style,
                      double rad)
```
    Description copied from interface: Renderer
    
    Draws all the lines in the first line group of the specified render object, using the current material and shading. The lines are drawn either as pixel-based lines or as solid primitives, according to the specified line style. For lines drawn using the style Renderer.LineStyle.LINE, the argument rad gives the line width, whereas for solid primitives (Renderer.LineStyle.CYLINDER, Renderer.LineStyle.SOLID_ARROW, Renderer.LineStyle.SPINDLE), it gives the nominal radius.
    
    Specified by:
    
    drawLines in interface Renderer
    
    Parameters:
    
    robj - render object
    
    style - line style to use for drawing
    
    rad - radius for solid lines or width for pixel-based lines
  - drawLines
```
public void drawLines(RenderObject robj,
                      int gidx,
                      Renderer.LineStyle style,
                      double rad)
```
    Description copied from interface: Renderer
    
    Draws all the lines in the specified line group of the supplied render object, using the current material and shading. The lines are drawn either as pixel-based lines or as solid primitives, according to the specified line style. For lines drawn using the style Renderer.LineStyle.LINE, the argument rad gives the line width, whereas for solid primitives (Renderer.LineStyle.CYLINDER, Renderer.LineStyle.SOLID_ARROW, Renderer.LineStyle.SPINDLE), it gives the nominal radius.
    
    Specified by:
    
    drawLines in interface Renderer
    
    Parameters:
    
    robj - render object
    
    gidx - line group index
    
    style - line style to use for drawing
    
    rad - radius for solid lines or width for pixel-based lines
  - drawTriangles
```
public void drawTriangles(RenderObject robj)
```
    Description copied from interface: Renderer
    
    Draws all the triangles in the first triangle group of the specified render object, using the current material and shading.
    
    Specified by:
    
    drawTriangles in interface Renderer
    
    Parameters:
    
    robj - render object
  - drawTriangles
```
public void drawTriangles(RenderObject robj,
                          int gidx)
```
    Description copied from interface: Renderer
    
    Draws all the triangles in the specified triangle group of the render object, using the current material and shading.
    
    Specified by:
    
    drawTriangles in interface Renderer
    
    Parameters:
    
    robj - render object
    
    gidx - triangle group index
  - draw
```
public void draw(RenderObject robj)
```
    Description copied from interface: Renderer
    
    Draws all the primitives in the first point, line and triangles groups.
    
    Specified by:
    
    draw in interface Renderer
    
    Parameters:
    
    robj - render object
  - drawVertices
```
public void drawVertices(RenderObject robj,
                         VertexIndexArray idxs,
                         Renderer.DrawMode mode)
```
    Description copied from interface: Renderer
    
    Draws a selection of vertices associated with the specified RenderObject, using a specified drawing mode and the current material and shading. This version of the method should be favoured for persistent index lists, since the VertexIndexArray can detect whether or not it has been modified, which allows for caching.
    
    Specified by:
    
    drawVertices in interface Renderer
    
    Parameters:
    
    robj - render object
    
    idxs - vertex indices
    
    mode - drawing mode to be used for drawing the vertices
  - beginDraw
```
public void beginDraw(Renderer.DrawMode mode)
```
    Description copied from interface: Renderer
    
    Begins draw mode. This is analogous to glBegin() in the old GL specification. Once in draw mode, the application can specify the vertices (and if necessary, normals) that are used to draw the primitive that is specified by the mode parameter.
    
    Specified by:
    
    beginDraw in interface Renderer
    
    Parameters:
    
    mode - specifies the primitive to be built while in draw mode.
  - addVertex
```
public void addVertex(float px,
                      float py,
                      float pz)
```
    Description copied from interface: Renderer
    
    Adds a vertex to a primitive being drawn while in draw mode.
    
    Specified by:
    
    addVertex in interface Renderer
    
    Parameters:
    
    px - vertex x coordinate
    
    py - vertex y coordinate
    
    pz - vertex z coordinate
    
    See Also:
    
    Renderer.beginDraw(maspack.render.Renderer.DrawMode)
  - setNormal
```
public void setNormal(float nx,
                      float ny,
                      float nz)
```
    Description copied from interface: Renderer
    
    Sets the normal to be associated with the next vertex to be added while in draw mode. This normal will remain in effect until a subsequent setNormal call. The normal does not need to be normalized.
    
    Specified by:
    
    setNormal in interface Renderer
    
    Parameters:
    
    nx - normal x coordinate
    
    ny - normal y coordinate
    
    nz - normal z coordinate
    
    See Also:
    
    Renderer.beginDraw(maspack.render.Renderer.DrawMode)
  - setTextureCoord
```
public void setTextureCoord(float x,
                            float y)
```
    Description copied from interface: Renderer
    
    Sets the texture coordinate to be associated with the next vertex to be added while in draw mode. This texture coordinate will remain in effect until a subsequent setTexcoord call. The coordinate should be within the range [0, 1]
    
    Specified by:
    
    setTextureCoord in interface Renderer
    
    Parameters:
    
    x - texture x coordinate
    
    y - texture y coordinate
    
    See Also:
    
    Renderer.beginDraw(maspack.render.Renderer.DrawMode)
  - addVertex
```
public void addVertex(double px,
                      double py,
                      double pz)
```
    Description copied from interface: Renderer
    
    Adds a vertex to a primitive being drawn while in draw mode.
    
    Specified by:
    
    addVertex in interface Renderer
    
    Parameters:
    
    px - vertex x coordinate
    
    py - vertex y coordinate
    
    pz - vertex z coordinate
    
    See Also:
    
    Renderer.beginDraw(maspack.render.Renderer.DrawMode)
  - addVertex
```
public void addVertex(Vector3d pnt)
```
    Description copied from interface: Renderer
    
    Adds a vertex to a primitive being drawn while in draw mode.
    
    Specified by:
    
    addVertex in interface Renderer
    
    Parameters:
    
    pnt - coordinates for the vertex
    
    See Also:
    
    Renderer.beginDraw(maspack.render.Renderer.DrawMode)
  - addVertex
```
public void addVertex(float[] pnt)
```
    Description copied from interface: Renderer
    
    Adds a vertex to a primitive being drawn while in draw mode.
    
    Specified by:
    
    addVertex in interface Renderer
    
    Parameters:
    
    pnt - coordinates for the vertex
    
    See Also:
    
    Renderer.beginDraw(maspack.render.Renderer.DrawMode)
  - setNormal
```
public void setNormal(double nx,
                      double ny,
                      double nz)
```
    Description copied from interface: Renderer
    
    Sets the normal to be associated with the next vertex to be added while in draw mode. This method is functionally equivalent to Renderer.setNormal(float,float,float).
    
    Specified by:
    
    setNormal in interface Renderer
    
    Parameters:
    
    nx - normal x coordinate
    
    ny - normal y coordinate
    
    nz - normal z coordinate
    
    See Also:
    
    Renderer.beginDraw(maspack.render.Renderer.DrawMode)
  - setNormal
```
public void setNormal(Vector3d nrm)
```
    Description copied from interface: Renderer
    
    Sets the normal to be associated with the next vertex to be added while in draw mode. This method is functionally equivalent to to Renderer.setNormal(float,float,float).
    
    Specified by:
    
    setNormal in interface Renderer
    
    Parameters:
    
    nrm - normal coordinates
    
    See Also:
    
    Renderer.beginDraw(maspack.render.Renderer.DrawMode)
  - setTextureCoord
```
public void setTextureCoord(double tx,
                            double ty)
```
    Description copied from interface: Renderer
    
    Sets the texture coordinate to be associated with the next vertex to be added while in draw mode. This method is functionally equivalent to Renderer.setTextureCoord(float,float).
    
    Specified by:
    
    setTextureCoord in interface Renderer
    
    Parameters:
    
    tx - texture x coordinate
    
    ty - texture y coordinate
    
    See Also:
    
    Renderer.beginDraw(maspack.render.Renderer.DrawMode)
  - setTextureCoord
```
public void setTextureCoord(Vector2d tex)
```
    Description copied from interface: Renderer
    
    Sets the texture coordinate to be associated with the next vertex to be added while in draw mode. This method is functionally equivalent to to Renderer.setTextureCoord(float,float).
    
    Specified by:
    
    setTextureCoord in interface Renderer
    
    Parameters:
    
    tex - texture coordinates
    
    See Also:
    
    Renderer.beginDraw(maspack.render.Renderer.DrawMode)
  - endDraw
```
public void endDraw()
```
    Description copied from interface: Renderer
    
    Ends draw mode. This is analogous to glEnd() in the old GL specification.
    
    Specified by:
    
    endDraw in interface Renderer
  - maybeUpdateMaterials
```
public abstract void maybeUpdateMaterials()
```
  - restoreDefaultState
```
public void restoreDefaultState(boolean strictChecking)
```
    Description copied from interface: Renderer
    
    Restores the renderer to its default state. If strict checking is enabled, then this method will throw an exception if the graphics state is currently inside a draw block, or the model matrix stack is not empty.
    
    Specified by:
    
    restoreDefaultState in interface Renderer
    
    Parameters:
    
    strictChecking - if true, enables strict checking.
  - beginGL
```
public com.jogamp.opengl.GL beginGL()
```
    Begin application-defined GL rendering, using GL primitives based on handles returned by getGL(), etc. Save the current graphics state.
  - endGL
```
public void endGL()
```
    Ends application-defined GL rendering. Restores the graphics state to what it was when beginGL() was called.

Class GLViewer

Nested Class Summary

Nested classes/interfaces inherited from interface maspack.render.Renderer

Field Summary

Fields inherited from interface maspack.render.Renderer

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface maspack.render.Renderer

Field Detail

useGLJPanel

DEFAULT_SRC_BLENDING

DEFAULT_DST_BLENDING

AUTO_FIT

DEFAULT_ROTATION_MODE

DEFAULT_ELLIPTIC_CURSOR_SIZE

DEFAULT_ELLIPTIC_CURSOR_ACTIVE

myProps

Constructor Detail

GLViewer

Method Detail

getAllPropertyInfo

getProperty

setProfiling

getProfiling

getEllipticCursorSize

setEllipticCursorSize

resetEllipticCursorSize

getEllipticCursorActive

setEllipticCursorActive

getSurfaceResolution

setSurfaceResolution

setAxisLength

getAxisLength

setSolidAxes

getSolidAxes

setGridVisible

getGridVisible

getKeyListeners

addKeyListener

removeKeyListener

getDraggers

addSelectionListener

removeSelectionListener

getSelectionListeners

getSelectionEvent

addRenderListener

removeRenderListener

getRenderListeners

addRenderable

addDragger

setDrawTool

removeRenderable

removeDragger

clearDraggers

clearRenderables

getViewPlaneDistance

getFarPlaneDistance

getVerticalFieldOfView

setVerticalFieldOfView

repaint

paint

setExternalRenderList

getExternalRenderList

rerender

isSpecialRenderFlagsSet

rerender

getFrustum

setPerspective

setPerspective

setPerspective

setOrthogonal

setOrthogonal

isOrthogonal

setOrthographicView

getBounds

estimateRadiusAndCenter

autoFit

autoFitPerspective

autoFitOrtho