StlRenderer (Artisynth API documentation)

java.lang.Object
- maspack.render.StlRenderer

All Implemented Interfaces:: Renderer

public class StlRenderer
extends java.lang.Object
implements Renderer

"Renders" a scene by writing it to an STL file. Sequence of events should be:

      stlRenderer.begin(fileName, true);  // open as binary
      //... render scene
      stlRenderer.end()                   // close file

Author:: C Antonio Sanchez and ArtiSynth team members

Nested Class Summary
- Nested classes/interfaces inherited from interface maspack.render.Renderer
  Renderer.AxisDrawStyle, Renderer.ColorInterpolation, Renderer.ColorMixing, Renderer.DrawMode, Renderer.FaceStyle, Renderer.HighlightStyle, Renderer.LineStyle, Renderer.PointStyle, Renderer.Shading

Field Summary

Fields
Modifier and Type Field and Description

static double DEFAULT_AXIS_RADIUS_RATIO
- Fields inherited from interface maspack.render.Renderer
  HIGHLIGHT, SORT_FACES

Fields
Modifier and Type	Field and Description
`static double`	`DEFAULT_AXIS_RADIUS_RATIO`

Constructor Summary

Constructors
Constructor and Description

StlRenderer()

Constructors
Constructor and Description
`StlRenderer()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`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`	`begin(java.lang.String fileName)` Starts writing an STL file with the given filename, in binary mode
`void`	`begin(java.lang.String fileName, boolean binary)` Starts writing an STL file
`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`	`beginDraw(Renderer.DrawMode mode)` Begins draw mode.
`void`	`beginSelectionQuery(int qid)` Begins a selection query with the {\it query identifier} `qid`.
`void`	`beginSubSelection(IsSelectable s, int qid)` 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()` Returns the displacement distance of the center point, in a plane parallel to the view plane, that corresponds to a screen displacement of one pixel.
`double`	`distancePerPixel(Vector3d pnt)` Returns the displacement distance of a point `p`, in a plane parallel to the view plane, that corresponds to a screen displacement of one pixel.
`void`	`draw(RenderObject robj)` Draws all the primitives in the first point, line and triangles groups.
`void`	`drawArrow(float[] pnt0, float[] pnt1, double rad, boolean capped)` Draws a solid arrow between two points in model coordinates, using the current shading and material.
`void`	`drawArrow(RenderProps props, float[] pnt0, float[] pnt1, boolean capped, boolean highlight)` Draws an arrow between two points in model coordinates, using the radius, line color, and shading specified by the render properties argument `props`.
`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`	`drawArrow(Vector3d pnt, Vector3d dir, double scale, double rad, boolean capped)` Draws a solid arrow in model coordinates, starting at `pnt` and extending along `dir`, with a length given by the length of `dir` times `scale`, using the current shading and material.
`void`	`drawAxes(RigidTransform3d X, double[] lens, int width, boolean highlight)` Draws a set of coordinate axes representing a rigid coordinate frame `X`.
`void`	`drawAxes(RigidTransform3d X, double len, int width, boolean highlight)` Draws a set of coordinate axes representing a rigid coordinate frame `X`.
`void`	`drawAxes(RigidTransform3d X, Renderer.AxisDrawStyle style, double[] lens, int width, double rad, boolean highlight)` Draws a solid set of coordinate axes representing a rigid coordinate frame `X`.
`void`	`drawAxes(RigidTransform3d X, Renderer.AxisDrawStyle style, double len, int width, double rad, boolean highlight)` Draws a solid set of coordinate axes representing a rigid coordinate frame `X`.
`void`	`drawBox(float[] pnt, double wx, double wy, double wz)` Draws an axis-aligned box in model coordinates, using the current shading and material.
`void`	`drawBox(RigidTransform3d TBM, Vector3d widths)` Draws a box centered on the specified transform in model coordinates, using the current shading and material.
`void`	`drawBox(Vector3d pnt, Vector3d widths)` Draws an axis-aligned box in model coordinates, using the current shading and material.
`void`	`drawCone(float[] pnt0, float[] pnt1, double rad0, double rad1, boolean capped)` Draws a cone between two points 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(float[] 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`	`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(float[] pnt0, float[] pnt1, double rad, boolean capped)` Draws a cylinder between two points 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(float[] pnt0, float[] pnt1)` 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(RenderProps props, float[] pnt0, float[] pnt1, float[] color, 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(RenderProps props, Vector3d pnt0, Vector3d 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(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)` Draws all the lines in the specified line group of the render object, using the current material and shading.
`void`	`drawLines(RenderObject robj, int gidx, int offset, int count, Renderer.LineStyle style, double rad)` Draws a selection of lines in the specified line group of the supplied 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, int gidx, RenderInstances rinst)` Draws the specified group of lines, repeated for each instance in rinst.
`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`	`drawLineStrip(RenderProps props, java.lang.Iterable<float[]> pnts, Renderer.LineStyle style, boolean highlight)` Draws a line strip between a series of points in model coordinates, using the radius, line color, and shading specified by the render properties argument `props`, and the line style specified by `style`.
`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(float[] pnt)` Draws a single point located at `pnt` in model coordinates, using the current point size, material, and shading.
`void`	`drawPoint(RenderProps props, float[] pnt, boolean highlight)` Draws a single point located at `pnt` in model coordinates, using the point style, size, point color, and shading specified by the render properties argument `props`.
`void`	`drawPoint(RenderProps props, Vector3d pnt, boolean highlight)` Draws a single point located at `pnt` in model coordinates, using the point style, size, point color, and shading specified by the render properties argument `props`.
`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)` Draws all the points in the specified point group of the supplied render object, using the current material and shading.
`void`	`drawPoints(RenderObject robj, int gidx, int offset, int count, Renderer.PointStyle style, double rad)` Draws a selection of points in the specified point group of the supplied 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, int gidx, RenderInstances rinst)` Draws the specified group of points, repeated for each instance in rinst.
`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`	`drawRay(RenderProps props, Vector3d pnt, Vector3d dir, double scale, boolean highlight)` Draws a ray from an origin point along a specified direction, in model coordinates, using the line style, radius, line color, and shading specified by the render properties argument `props`.
`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(float[] pnt, double rad)` Draws a sphere with a specified radius centered at a point in model coordinates, using the current shading and material.
`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(float[] pnt0, float[] pnt1, double rad)` Draws a spindle between two points 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, float[] pos, double emSize)` Draws text in the x-y plane in model coordinates.
`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(float[] pnt0, float[] pnt1, float[] pnt2)` Draws a single triangular face specified by three points, using the current shading, lighting and material.
`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`	`drawTriangles(RenderObject robj, int gidx, int offset, int count)` Draws a selection of triangles in the specified triangle group of the render object, using the current material and shading.
`void`	`drawTriangles(RenderObject robj, int gidx, RenderInstances rinst)` Draws the specified group of triangles, repeated for each instance in rinst.
`void`	`drawVertices(RenderObject robj, Renderer.DrawMode mode)` Draws all the vertices associated with the specified RenderObject, using a specified drawing mode and the current material and shading.
`void`	`drawVertices(RenderObject robj, VertexIndexArray idxs, int offset, int count, 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`	`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`	`end()` Closes the STL rendering file
`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`	`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`	`getAxisRadiusRatio()` Returns the axis radius ratio.
`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.
`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.
`Point3d`	`getCenter()` Returns the current center point
`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.
`java.awt.Font`	`getDefaultFont()` Retrieves the default font.
`int`	`getDepthOffset()` The current depth offset level.
`float[]`	`getEmission(float[] rgb)` Returns the RGB values for the emission color as a float array.
`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`	`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.
`float`	`getLineWidth()` Returns the current width for rendering lines, in pixels.
`AffineTransform3dBase`	`getModelMatrix()` Gets the current model matrix.
`void`	`getModelMatrix(AffineTransform3d X)` Gets the current model matrix.
`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.
`float`	`getPointSize()` Returns the current size for rendering points, in pixels.
`int`	`getScreenHeight()` Returns the screen height, in pixels
`int`	`getScreenWidth()` Returns the screen width, in pixels
`Renderer.Shading`	`getShading()` Returns the current shading model used by this renderer.
`float`	`getShininess()` Returns the current shininess parameter.
`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.
`AffineTransform2dBase`	`getTextureMatrix()` Gets the current texture matrix.
`void`	`getTextureMatrix(AffineTransform2d X)` Gets the current texture matrix.
`Renderer.ColorMixing`	`getVertexColorMixing()` Returns the method used for combining vertex coloring and material coloring.
`RigidTransform3d`	`getViewMatrix()` Gets the current view matrix.
`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.
`boolean`	`has2DRendering()` Returns `true` if this Renderer supports 2D rendering mode.
`boolean`	`hasBumpMapping()` Queries whether or not this renderer supports bump mapping.
`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`	`hasColorMapping()` Queries whether or not this renderer supports color mapping.
`boolean`	`hasNormalMapping()` Queries whether or not this renderer supports normal mapping.
`boolean`	`hasSelection()` Queries whether or not this Renderer supports selection.
`boolean`	`hasTextRendering()` Queries whether or not this renderer supports text rendering.
`boolean`	`hasVertexColorMixing(Renderer.ColorMixing cmix)` Queries whether or not a specified method for combining vertex coloring and material coloring is supported by this Renderer.
`boolean`	`is2DRendering()` Check whether the Renderer is currently in 2D rendering mode.
`boolean`	`isOrthogonal()` Returns `true` if this renderer is currently configured for orthogonal projection.
`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.
`void`	`mulModelMatrix(AffineTransform3dBase trans)` Post-multiplies the model matrix by the specified transform X, which may be either a `RigidTransform3d` or an `AffineTransform3d`.
`boolean`	`popModelMatrix()` Restores the model matrix by popping it off the model matrix stack
`void`	`pushModelMatrix()` Saves the model matrix by pushing it onto the model matrix stack.
`void`	`restoreDefaultState(boolean strictChecking)` Restores the renderer to its default state.
`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)`
`void`	`setAxisRadiusRatio(double ratio)` Sets a ratio which can be used to determine the radius for an axis when the radius is not explicitly specified.
`void`	`setBackColor(float[] rgba)` Optionally sets the diffuse and ambient colors used for the subsequent rendering of the back faces of triangles.
`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`	`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 to be used by this renderer.
`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`	`setDefaultFont(java.awt.Font font)` Sets default font for text rendering
`void`	`setDepthOffset(int offset)` Set a depth offset for the projection matrix.
`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`	`setEmission(float[] rgb)` Sets the emission color to be used for subsequent rendering of primitives.
`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.
`boolean`	`setHighlighting(boolean enable)` Enables or disables highlighting.
`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 width)` Sets the width for rendering lines, in pixels.
`void`	`setModelMatrix(AffineTransform3dBase X)` 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`	`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`	`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 size)` Sets the size for rendering points, in pixels.
`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()`.
`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`	`setSpecular(float[] rgb)` Sets the specular color to be used for subsequent rendering of primitives.
`int`	`setSurfaceResolution(int nsegs)` 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 tx, float ty)` 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.
`void`	`setTextureMatrix(AffineTransform2dBase T)` Sets the texture coordinate transformation matrix to the specified transform.
`Renderer.ColorMixing`	`setVertexColorMixing(Renderer.ColorMixing cmix)` Sets the method used for combining vertex coloring and material coloring.
`void`	`translateModelMatrix(double tx, double ty, double tz)` Translates the model frame.

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

- Field Detail
  - DEFAULT_AXIS_RADIUS_RATIO
```
public static double DEFAULT_AXIS_RADIUS_RATIO
```
- Constructor Detail
  - StlRenderer
```
public StlRenderer()
```
- Method Detail
  - begin
```
public void begin(java.lang.String fileName)
```
    Starts writing an STL file with the given filename, in binary mode
    
    Parameters:
    
    fileName - STL file name
  - begin
```
public void begin(java.lang.String fileName,
                  boolean binary)
```
    Starts writing an STL file
    
    Parameters:
    
    fileName - STL file name
    
    binary - if true, writes in binary file format, otherwise in ASCII
  - end
```
public void end()
```
    Closes the STL rendering file
  - getScreenHeight
```
public int getScreenHeight()
```
    Description copied from interface: Renderer
    
    Returns the screen height, in pixels
    
    Specified by:
    
    getScreenHeight in interface Renderer
    
    Returns:
    
    screen height
  - getScreenWidth
```
public int getScreenWidth()
```
    Description copied from interface: Renderer
    
    Returns the screen width, in pixels
    
    Specified by:
    
    getScreenWidth in interface Renderer
    
    Returns:
    
    screen width
  - 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
  - distancePerPixel
```
public double distancePerPixel(Vector3d pnt)
```
    Description copied from interface: Renderer
    
    Returns the displacement distance of a point p, in a plane parallel to the view plane, that corresponds to a screen displacement of one pixel. Both p and the displacement are given with respect to model coordinates.
    
    Specified by:
    
    distancePerPixel in interface Renderer
    
    Parameters:
    
    pnt - point undergoing the displacement
    
    Returns:
    
    displacement distance corresponding to one pixel
  - centerDistancePerPixel
```
public double centerDistancePerPixel()
```
    Description copied from interface: Renderer
    
    Returns the displacement distance of the center point, in a plane parallel to the view plane, that corresponds to a screen displacement of one pixel. The displacement is given with respect to model coordinates.
    
    Specified by:
    
    centerDistancePerPixel in interface Renderer
    
    Returns:
    
    displacement distance corresponding to one pixel
  - 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
  - isOrthogonal
```
public boolean isOrthogonal()
```
    Description copied from interface: Renderer
    
    Returns true if this renderer is currently configured for orthogonal projection.
    
    Specified by:
    
    isOrthogonal in interface Renderer
    
    Returns:
    
    true if projection is orthogonal
  - 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()
  - 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)
  - setPointSize
```
public void setPointSize(float size)
```
    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:
    
    size - new point size (in pixels).
    
    See Also:
    
    Renderer.getPointSize()
  - 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)
  - setLineWidth
```
public void setLineWidth(float width)
```
    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:
    
    width - new line width (in pixels).
    
    See Also:
    
    Renderer.getLineWidth()
  - 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)
  - 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()
  - 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)
```
    Description copied from interface: Renderer
    
    Sets the color interpolation to be used by this renderer. The default value is Renderer.ColorInterpolation.RGB, but Renderer.ColorInterpolation.HSV is often more appropriate for displaying information that is purely color-based.
    
    Specified by:
    
    setColorInterpolation in interface Renderer
    
    Parameters:
    
    interp - new color interpolation mode
    
    Returns:
    
    previous color interpolation mode
  - hasVertexColorMixing
```
public 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
  - 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
  - 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
  - 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
  - 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
  - getAxisRadiusRatio
```
public double getAxisRadiusRatio()
```
    Returns the axis radius ratio. See Renderer.setAxisRadiusRatio(double) for more information.
    
    Specified by:
    
    getAxisRadiusRatio in interface Renderer
    
    Returns:
    
    axis render ratio
  - setAxisRadiusRatio
```
public void setAxisRadiusRatio(double ratio)
```
    Sets a ratio which can be used to determine the radius for an axis when the radius is not explicitly specified. The radius is computed by multiplying the ratio by the axis length. This is typically used when rendering coordinate axes as solid arrows and has a default value is 0.016.
    
    Specified by:
    
    setAxisRadiusRatio in interface Renderer
    
    Parameters:
    
    ratio - new axis render ratio
  - 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
  - drawPoint
```
public void drawPoint(float[] pnt)
```
    Description copied from interface: Renderer
    
    Draws a single point located at pnt 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:
    
    pnt - array (of length 3) giving the point to draw
  - 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
  - drawLine
```
public void drawLine(float[] pnt0,
                     float[] pnt1)
```
    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:
    
    pnt0 - array (of length 3) giving the first point
    
    pnt1 - array (of length 3) giving the 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
  - drawTriangle
```
public void drawTriangle(float[] pnt0,
                         float[] pnt1,
                         float[] pnt2)
```
    Description copied from interface: Renderer
    
    Draws a single triangular face specified by three points, using the current shading, lighting and material. This method is functionally equivalent to is functionally equivalent to Renderer.drawTriangle(Vector3d,Vector3d,Vector3d).
    
    Specified by:
    
    drawTriangle in interface Renderer
    
    Parameters:
    
    pnt0 - first point
    
    pnt1 - second point
    
    pnt2 - third point
  - 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 nsegs)
```
    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:
    
    nsegs - resolution for curved surfaces
    
    Returns:
    
    previous resolution
  - 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
  - drawSphere
```
public void drawSphere(float[] 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. This method is functionally equivalent to Renderer.drawSphere(Vector3d,double).
    
    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
  - drawCube
```
public void drawCube(float[] 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(float[] pnt,
                    double wx,
                    double wy,
                    double wz)
```
    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
    
    wx - width in x
    
    wy - width in y
    
    wz - width in z
  - 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
  - drawBox
```
public void drawBox(RigidTransform3d TBM,
                    Vector3d widths)
```
    Description copied from interface: Renderer
    
    Draws a box centered on the specified transform in model coordinates, using the current shading and material.
    
    Specified by:
    
    drawBox in interface Renderer
    
    Parameters:
    
    TBM - transform from box to model coordinates on which the box is centered
    
    widths - x,y,z widths of the box
  - 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
  - drawSpindle
```
public void drawSpindle(float[] pnt0,
                        float[] 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
  - 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
  - drawCylinder
```
public void drawCylinder(float[] pnt0,
                         float[] 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
  - 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
  - drawCone
```
public void drawCone(float[] pnt0,
                     float[] 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
  - drawArrow
```
public void drawArrow(float[] pnt0,
                      float[] 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. This method is functionally equivalent to Renderer.drawArrow(Vector3d,Vector3d,double,boolean) except that the points are specified using float[].
    
    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
  - drawArrow
```
public void drawArrow(Vector3d pnt,
                      Vector3d dir,
                      double scale,
                      double rad,
                      boolean capped)
```
    Description copied from interface: Renderer
    
    Draws a solid arrow in model coordinates, starting at pnt and extending along dir, with a length given by the length of dir times scale, using the current shading and material. The arrow is rendered as described for Renderer.drawArrow(Vector3d,Vector3d,double,boolean).
    
    Specified by:
    
    drawArrow in interface Renderer
    
    Parameters:
    
    pnt - starting point
    
    dir - direction
    
    scale - scale factor for dir
    
    rad - radius of the cylinder
    
    capped - if true, indicates that the arrow should have a solid cap on the bottom
  - drawAxes
```
public void drawAxes(RigidTransform3d X,
                     Renderer.AxisDrawStyle style,
                     double len,
                     int width,
                     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. The manner in which the axes are rendered is specified by style, which is an instance of Renderer.AxisDrawStyle. 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
    
    style - manner in which the axes should be rendered (e.g., pixel-based lines or solid arrows)
    
    len - length of the axes
    
    width - for pixel-based rendering, specifies the line width in pixels
    
    rad - if > 0, specifies the radius of each axis when using solid rendering. Otherwise, the radius is determined by multiplying the axis length by the ratio returned by Renderer.getAxisRadiusRatio().
    
    highlight - if true, indicates that the axes should be highlighted.
  - drawAxes
```
public void drawAxes(RigidTransform3d X,
                     Renderer.AxisDrawStyle style,
                     double[] lens,
                     int width,
                     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 identical to Renderer.drawAxes(RigidTransform3d,AxisDrawStyle,double,int,double,boolean), except that the length of each axis can be specified separately.
    
    Specified by:
    
    drawAxes in interface Renderer
    
    Parameters:
    
    X - coordinate frame defining the axes
    
    style - manner in which the axes should be rendered (e.g., pixel-based lines or solid arrows)
    
    lens - lengths of each axis
    
    width - for pixel-based rendering, specifies the line width in pixels
    
    rad - if > 0, specifies the radius of each axis when using solid rendering. Otherwise, the radius is determined by multiplying the maximum axis length by the ratio returned by Renderer.getAxisRadiusRatio().
    
    highlight - if true, indicates that the axes should be highlighted.
  - 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. If , the radius is determined automatically using the value returned by Renderer.getAxisRadiusRatio().
    
    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. If , the radius is determined automatically using the value returned by Renderer.getAxisRadiusRatio().
    
    highlight - if true, indicates that the axes should be highlighted.
  - drawAxes
```
public void drawAxes(RigidTransform3d X,
                     double[] lens,
                     int width,
                     boolean highlight)
```
    Description copied from interface: Renderer
    
    Draws a set of coordinate axes representing a rigid coordinate frame X. This method is functionally equivalent to Renderer.drawAxes(RigidTransform3d,double,int,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:
    
    drawAxes in interface Renderer
    
    Parameters:
    
    X - coordinate frame defining the axes
    
    lens - lengths for each axis
    
    width - width of each axis (in pixels)
    
    highlight - if true, indicates that the axes should be highlighted.
  - drawPoint
```
public void drawPoint(RenderProps props,
                      float[] pnt,
                      boolean highlight)
```
    Description copied from interface: Renderer
    
    Draws a single point located at pnt in model coordinates, using the point style, size, point color, and shading specified by the render properties argument props. This method is functionally equivalent to Renderer.drawPoint(RenderProps,Vector3d,boolean) except that the point is specified using float[].
    
    Specified by:
    
    drawPoint in interface Renderer
    
    Parameters:
    
    props - render properties used for drawing the point
    
    pnt - location of the point
    
    highlight - if true, indicates that highlighting, if enabled, should be applied to the point
  - drawPoint
```
public void drawPoint(RenderProps props,
                      Vector3d pnt,
                      boolean highlight)
```
    Description copied from interface: Renderer
    
    Draws a single point located at pnt in model coordinates, using the point style, size, point color, and shading specified by the render properties argument props.
    If props.getPointStyle() specifies a point style of Renderer.PointStyle.POINT, then the point is drawn as a pixel-based point with a size given by props.getPointSize(). Otherwise, if the point style is Renderer.PointStyle.CUBE or Renderer.PointStyle.SPHERE, then the point is drawn as a solid with a radius given by props.getPointRadius(). If highlight is true and the highlight style is Renderer.HighlightStyle.COLOR, then the point will be drawn using the highlight color rather than the point color specified in props.
    
    Specified by:
    
    drawPoint in interface Renderer
    
    Parameters:
    
    props - render properties used for drawing the point
    
    pnt - location of the point
    
    highlight - if true, indicates that highlighting, if enabled, should be applied to the point
  - 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. This method is functionally equivalent to Renderer.drawLine(RenderProps,Vector3d,Vector3d,boolean) except that the points are specified using float[].
    
    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,
                     Vector3d pnt0,
                     Vector3d 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
  - drawRay
```
public void drawRay(RenderProps props,
                    Vector3d pnt,
                    Vector3d dir,
                    double scale,
                    boolean highlight)
```
    Description copied from interface: Renderer
    
    Draws a ray from an origin point along a specified direction, in model coordinates, using the line style, radius, line color, and shading specified by the render properties argument props. The length of the ray is given by the length of dir, scaled by scale.
    If props.getLineStyle() specifies a line style of Renderer.LineStyle.LINE, then the ray is drawn as a pixel-based line with a width given by props.getLineWidth(). For other line styles, the ray 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 ray will be drawn using the highlight color rather than the line color specified in props.
    
    Specified by:
    
    drawRay in interface Renderer
    
    Parameters:
    
    props - render properties used for drawing the ray
    
    pnt - origin of the ray
    
    dir - direction of the ray
    
    scale - second point
    
    highlight - if true, indicates that highlighting, if enabled, should be applied to the ray
  - drawLine
```
public void drawLine(RenderProps props,
                     float[] pnt0,
                     float[] pnt1,
                     float[] color,
                     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 arguments color and capped.
    
    Specified by:
    
    drawLine in interface Renderer
    
    Parameters:
    
    props - render properties used for drawing the line
    
    pnt0 - first point
    
    pnt1 - second point
    
    color - if not null, specifies an alternate color that should be used in place of the line color specified in props
    
    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
  - 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
  - drawArrow
```
public void drawArrow(RenderProps props,
                      float[] pnt0,
                      float[] pnt1,
                      boolean capped,
                      boolean highlight)
```
    Description copied from interface: Renderer
    
    Draws an arrow between two points in model coordinates, using the radius, line color, and shading specified by the render properties argument props. The method behaves similarly to Renderer.drawArrow(float[],float[],double,boolean), with the cylinder radius determine instead by props.getLineRadius().
    
    Specified by:
    
    drawArrow in interface Renderer
    
    Parameters:
    
    props - render properties used for drawing the arrow
    
    pnt0 - first point
    
    pnt1 - second point
    
    capped - if true, specifies that the arrow should have a solid cap on the bottom
    
    highlight - if true, indicates that highlighting, if enabled, should be applied to the arrow
  - drawLineStrip
```
public void drawLineStrip(RenderProps props,
                          java.lang.Iterable<float[]> pnts,
                          Renderer.LineStyle style,
                          boolean highlight)
```
    Description copied from interface: Renderer
    
    Draws a line strip between a series of points in model coordinates, using the radius, line color, and shading specified by the render properties argument props, and the line style specified by style.
    If the line style is Renderer.LineStyle.LINE, then the strip is drawn using pixel-based lines with a width given by props.getLineWidth(). For other line styles, the strip is drawn as solids with a nominal radius given by props.getLineRadius(). If highlight is true and the highlight style is Renderer.HighlightStyle.COLOR, then the strip will be drawn using the highlight color rather than the line color specified in props.
    
    Specified by:
    
    drawLineStrip in interface Renderer
    
    Parameters:
    
    props - render properties used for drawing the strip
    
    pnts - list of points used for drawing the strip
    
    style - line style to be used for the strip
    
    highlight - if true, indicates that highlighting, if enabled, should be applied to the strip
  - 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
  - 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.
  - 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,
                       float[] 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)
  - 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)
  - 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
  - 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()
  - 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()
  - 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()
  - 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.
  - 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(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.
  - 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
  - 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.
  - 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].
  - 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
  - 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
  - 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
  - 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
  - setPointShading
```
public Renderer.Shading setPointShading(RenderProps props)
```
    Description copied from interface: Renderer
    
    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)
```
    Description copied from interface: Renderer
    
    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)
```
    Description copied from interface: Renderer
    
    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
  - hasColorMapping
```
public boolean hasColorMapping()
```
    Description copied from interface: Renderer
    
    Queries whether or not this renderer supports color mapping.
    
    Specified by:
    
    hasColorMapping in interface Renderer
    
    Returns:
    
    true if color mapping is supported.
  - hasColorMapMixing
```
public 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)
  - hasNormalMapping
```
public boolean hasNormalMapping()
```
    Description copied from interface: Renderer
    
    Queries whether or not this renderer supports normal mapping.
    
    Specified by:
    
    hasNormalMapping in interface Renderer
    
    Returns:
    
    true if normal mapping is supported.
  - 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)
  - hasBumpMapping
```
public boolean hasBumpMapping()
```
    Description copied from interface: Renderer
    
    Queries whether or not this renderer supports bump mapping.
    
    Specified by:
    
    hasBumpMapping in interface Renderer
    
    Returns:
    
    true if bump mapping is supported.
  - 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)
  - 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
  - drawTriangles
```
public void drawTriangles(RenderObject robj,
                          int gidx,
                          int offset,
                          int count)
```
    Description copied from interface: Renderer
    
    Draws a selection of 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
    
    offset - triangle offset at which to start rendering
    
    count - number of triangles to draw
  - 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,
                      int gidx)
```
    Description copied from interface: Renderer
    
    Draws all the lines in the specified line group of the render object, using the current material and shading.
    
    Specified by:
    
    drawLines in interface Renderer
    
    Parameters:
    
    robj - render object
    
    gidx - line group index
  - 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
  - drawLines
```
public void drawLines(RenderObject robj,
                      int gidx,
                      int offset,
                      int count,
                      Renderer.LineStyle style,
                      double rad)
```
    Description copied from interface: Renderer
    
    Draws a selection of 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
    
    offset - line offset at which to begin drawing
    
    count - number of lines to draw
    
    style - line style to use for drawing
    
    rad - radius for solid lines or width for pixel-based lines
  - 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,
                       int gidx)
```
    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.
    
    Specified by:
    
    drawPoints in interface Renderer
    
    Parameters:
    
    robj - render object
    
    gidx - point group index
  - 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
  - drawPoints
```
public void drawPoints(RenderObject robj,
                       int gidx,
                       int offset,
                       int count,
                       Renderer.PointStyle style,
                       double rad)
```
    Description copied from interface: Renderer
    
    Draws a selection of 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
    
    offset - point offset at which to begin within the point group
    
    count - number of points to draw
    
    style - point style to use for drawing
    
    rad - radius for spheres or width for pixel-based points
  - drawVertices
```
public void drawVertices(RenderObject robj,
                         Renderer.DrawMode mode)
```
    Description copied from interface: Renderer
    
    Draws all the vertices associated with the specified RenderObject, using a specified drawing mode and the current material and shading.
    
    Specified by:
    
    drawVertices in interface Renderer
    
    Parameters:
    
    robj - render object
    
    mode - drawing mode to be used for drawing the vertices
  - 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
  - drawVertices
```
public void drawVertices(RenderObject robj,
                         VertexIndexArray idxs,
                         int offset,
                         int count,
                         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. Additionally, this method allows specification of an offset and vertex count.
    
    Specified by:
    
    drawVertices in interface Renderer
    
    Parameters:
    
    robj - render object
    
    idxs - vertex indices
    
    offset - index offset
    
    count - index count
    
    mode - drawing mode to be used for drawing the vertices
  - 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
  - drawTriangles
```
public void drawTriangles(RenderObject robj,
                          int gidx,
                          RenderInstances rinst)
```
    Description copied from interface: Renderer
    
    Draws the specified group of triangles, repeated for each instance in rinst.
    
    Specified by:
    
    drawTriangles in interface Renderer
    
    Parameters:
    
    robj - object to draw
    
    gidx - triangle group to draw
    
    rinst - instance to draw
  - drawLines
```
public void drawLines(RenderObject robj,
                      int gidx,
                      RenderInstances rinst)
```
    Description copied from interface: Renderer
    
    Draws the specified group of lines, repeated for each instance in rinst. Lines are drawn as Renderer.LineStyle.LINE and use the current line-width, as determined by Renderer.getLineWidth().
    
    Specified by:
    
    drawLines in interface Renderer
    
    Parameters:
    
    robj - object to draw
    
    gidx - line group to draw
    
    rinst - instance to draw
  - drawPoints
```
public void drawPoints(RenderObject robj,
                       int gidx,
                       RenderInstances rinst)
```
    Description copied from interface: Renderer
    
    Draws the specified group of points, repeated for each instance in rinst. Points are drawn as Renderer.PointStyle.POINT and use the current point-size, as determined by Renderer.getPointSize().
    
    Specified by:
    
    drawPoints in interface Renderer
    
    Parameters:
    
    robj - object to draw
    
    gidx - point group to draw
    
    rinst - instance to draw
  - 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
  - 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)
  - getModelMatrix
```
public void getModelMatrix(AffineTransform3d X)
```
    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:
    
    X - returns the current model matrix value
  - 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
  - setModelMatrix
```
public void setModelMatrix(AffineTransform3dBase X)
```
    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:
    
    X - new model matrix value
  - setModelMatrix2d
```
public void setModelMatrix2d(double left,
                             double right,
                             double bottom,
                             double top)
```
    Description copied from interface: Renderer
    
    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()
  - 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
  - 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)
  - 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
  - setDepthOffset
```
public void setDepthOffset(int offset)
```
    Description copied from interface: Renderer
    
    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()
```
    Description copied from interface: Renderer
    
    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)
  - 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)
  - hasSelection
```
public boolean hasSelection()
```
    Description copied from interface: Renderer
    
    Queries whether or not this Renderer supports selection.
    
    Specified by:
    
    hasSelection in interface Renderer
    
    Returns:
    
    true if selection is supported.
  - isSelecting
```
public boolean isSelecting()
```
    Description copied from interface: Renderer
    
    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.
  - 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.
  - 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.
  - setHighlighting
```
public boolean setHighlighting(boolean enable)
```
    Description copied from interface: Renderer
    
    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
  - beginSelectionQuery
```
public void beginSelectionQuery(int qid)
```
    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:
    
    qid - 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 qid)
```
    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
    
    qid - 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()
  - 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
  - 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)
  - 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(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)
  - 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(float tx,
                            float 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 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:
    
    tx - texture x coordinate
    
    ty - texture y coordinate
    
    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
  - 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.

Class StlRenderer

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

Field Detail

DEFAULT_AXIS_RADIUS_RATIO

Constructor Detail

StlRenderer

Method Detail

begin

begin

end

getScreenHeight

getScreenWidth

getViewPlaneHeight

getViewPlaneWidth

distancePerPixel

centerDistancePerPixel

getCenter

isOrthogonal

getViewPlaneDistance

getFarPlaneDistance

getPointSize

setPointSize

getLineWidth

setLineWidth

getFaceStyle

setFaceStyle

getColorInterpolation

setColorInterpolation

hasVertexColorMixing

getVertexColorMixing

setVertexColorMixing

getShading

setShading

getAxisRadiusRatio

setAxisRadiusRatio

drawPoint

drawPoint

drawPoint

drawLine

drawLine

drawLine

drawTriangle

drawTriangle

getSurfaceResolution

setSurfaceResolution

drawSphere

drawSphere

drawCube

drawCube

drawBox

drawBox

drawBox

drawSpindle

drawSpindle

drawCylinder

drawCylinder

drawCone

drawCone

drawArrow

drawArrow

drawArrow

drawAxes

drawAxes

drawAxes

drawSolidAxes

drawSolidAxes

drawAxes

drawPoint

drawPoint

drawLine

drawLine

drawRay

drawLine

drawLine