Renderer (Artisynth API documentation)

All Known Subinterfaces:

GLRenderer, Viewer

All Known Implementing Classes:

GL2Viewer, GL3Viewer, GLViewer, StlRenderer
```
public interface Renderer
```

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Renderer.AxisDrawStyle` Specifies how coordinate axes should be drawn.
`static class`	`Renderer.ColorInterpolation` Indicates the space in which color interpolation is performed by this Renderer.
`static class`	`Renderer.ColorMixing` Specifies how vertex coloring or textures are combined with material coloring
`static class`	`Renderer.DrawMode` Defines various vertex-based primitives
`static class`	`Renderer.FaceStyle` When rendering triangles, specifies which sides are drawn, where front and back correspond to the sides associated with counter-clockwise and clockwise vertex ordering, respectively.
`static class`	`Renderer.HighlightStyle` Specifies how highlighting is performed by this renderer.
`static class`	`Renderer.LineStyle` For some drawing primitives, specifies the rendering style for line segments.
`static class`	`Renderer.PointStyle` For some drawing primitives, specifies the rendering style for points.
`static class`	`Renderer.Shading` Specifies the current shading style.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`HIGHLIGHT` Flag requesting that an object be rendered with highlighting.
`static int`	`SORT_FACES` Flag requesting that faces of a mesh be sorted before rendering

Method Summary

All Methods Instance Methods Abstract 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.
`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 `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 p)` 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`	`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 `beginSelectionQuery(int)`.
`void`	`endSubSelection()` Ends object sub-selection that was initiated with a call to `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 X)` 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`	`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 `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.

- Field Detail
  - HIGHLIGHT
```
static final int HIGHLIGHT
```
    Flag requesting that an object be rendered with highlighting.
    
    See Also:
    
    Constant Field Values
  - SORT_FACES
```
static final int SORT_FACES
```
    Flag requesting that faces of a mesh be sorted before rendering
    
    See Also:
    
    Constant Field Values
- Method Detail
  - getScreenHeight
```
int getScreenHeight()
```
    Returns the screen height, in pixels
    
    Returns:
    
    screen height
  - getScreenWidth
```
int getScreenWidth()
```
    Returns the screen width, in pixels
    
    Returns:
    
    screen width
  - getViewPlaneHeight
```
double getViewPlaneHeight()
```
    Returns the height of the view plane, in model coordinates. The view plane corresponds to the clipping plane nearest the viewer.
    
    Returns:
    
    view plane height
  - getViewPlaneWidth
```
double getViewPlaneWidth()
```
    Returns the width of the view plane, in model coordinates. The view plane corresponds to the clipping plane nearest the viewer.
    
    Returns:
    
    view plane width
  - centerDistancePerPixel
```
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. The displacement is given with respect to model coordinates.
    
    Returns:
    
    displacement distance corresponding to one pixel
  - getCenter
```
Point3d getCenter()
```
    Returns the current center point
    
    Returns:
    
    center point, in world coordinates
  - distancePerPixel
```
double distancePerPixel(Vector3d p)
```
    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.
    
    Parameters:
    
    p - point undergoing the displacement
    
    Returns:
    
    displacement distance corresponding to one pixel
  - isOrthogonal
```
boolean isOrthogonal()
```
    Returns true if this renderer is currently configured for orthogonal projection.
    
    Returns:
    
    true if projection is orthogonal
  - getViewPlaneDistance
```
double getViewPlaneDistance()
```
    Returns the distance, in model coordinates, from the eye to view plane (which corresponds to the far clip plane). This is a positive number.
    
    Returns:
    
    distance to the near clip plane
    
    See Also:
    
    getFarPlaneDistance()
  - getFarPlaneDistance
```
double getFarPlaneDistance()
```
    Returns the distance, in model coordinates, from the eye to the far clip plane. This is a positive number.
    
    Returns:
    
    distance to the far clip plane
    
    See Also:
    
    getViewPlaneDistance()
  - getPointSize
```
float getPointSize()
```
    Returns the current size for rendering points, in pixels.
    
    Returns:
    
    current point size (in pixels).
    
    See Also:
    
    setPointSize(float)
  - setPointSize
```
void setPointSize(float size)
```
    Sets the size for rendering points, in pixels. The default size is 1.
    
    Parameters:
    
    size - new point size (in pixels).
    
    See Also:
    
    getPointSize()
  - getLineWidth
```
float getLineWidth()
```
    Returns the current width for rendering lines, in pixels.
    
    Returns:
    
    current line width (in pixels).
    
    See Also:
    
    setLineWidth(float)
  - setLineWidth
```
void setLineWidth(float width)
```
    Sets the width for rendering lines, in pixels. The default size is 1.
    
    Parameters:
    
    width - new line width (in pixels).
    
    See Also:
    
    getLineWidth()
  - getFaceStyle
```
Renderer.FaceStyle getFaceStyle()
```
    Returns the current mode for rendering faces.
    
    Returns:
    
    current face rendering mode
    
    See Also:
    
    setFaceStyle(maspack.render.Renderer.FaceStyle)
  - setFaceStyle
```
Renderer.FaceStyle setFaceStyle(Renderer.FaceStyle style)
```
    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.
    
    Parameters:
    
    style - new face style
    
    Returns:
    
    previous face style
    
    See Also:
    
    getFaceStyle()
  - getColorInterpolation
```
Renderer.ColorInterpolation getColorInterpolation()
```
    Returns the color interpolation currently being used by this Renderer.
    
    Returns:
    
    current color interpolation
  - setColorInterpolation
```
Renderer.ColorInterpolation setColorInterpolation(Renderer.ColorInterpolation interp)
```
    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.
    
    Parameters:
    
    interp - new color interpolation mode
    
    Returns:
    
    previous color interpolation mode
  - hasVertexColorMixing
```
boolean hasVertexColorMixing(Renderer.ColorMixing cmix)
```
    Queries whether or not a specified method for combining vertex coloring and material coloring is supported by this Renderer.
    
    Returns:
    
    true if the color mixing method is supported
  - getVertexColorMixing
```
Renderer.ColorMixing getVertexColorMixing()
```
    Returns the method used for combining vertex coloring and material coloring.
    
    Returns:
    
    current color mixing method
  - setVertexColorMixing
```
Renderer.ColorMixing setVertexColorMixing(Renderer.ColorMixing cmix)
```
    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 hasVertexColorMixing(maspack.render.Renderer.ColorMixing) to test whether a method is suuported.
    
    Parameters:
    
    cmix - new color mixing method
    
    Returns:
    
    previous color mixing method
  - getShading
```
Renderer.Shading getShading()
```
    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.
    
    Returns:
    
    current shading model
  - setShading
```
Renderer.Shading setShading(Renderer.Shading shading)
```
    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.
    
    Parameters:
    
    shading - new shading model to be used
    
    Returns:
    
    previous shading model
  - getAxisRadiusRatio
```
double getAxisRadiusRatio()
```
    Returns the axis radius ratio. See setAxisRadiusRatio(double) for more information.
    
    Returns:
    
    axis render ratio
  - setAxisRadiusRatio
```
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.
    
    Parameters:
    
    ratio - new axis render ratio
  - drawPoint
```
void drawPoint(Vector3d pnt)
```
    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.
    
    Parameters:
    
    pnt - location of the point
  - drawPoint
```
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. This method is functionally equivalent to drawPoint(Vector3d).
    
    Parameters:
    
    px - x coordinate of the point
    
    py - y coordinate of the point
    
    pz - z coordinate of the point
  - drawPoint
```
void drawPoint(float[] pnt)
```
    Draws a single point located at pnt in model coordinates, using the current point size, material, and shading. This method is functionally equivalent to drawPoint(Vector3d).
    
    Parameters:
    
    pnt - array (of length 3) giving the point to draw
  - drawLine
```
void drawLine(Vector3d pnt0,
              Vector3d pnt1)
```
    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.
    
    Parameters:
    
    pnt0 - first point
    
    pnt1 - second point
  - drawLine
```
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. This method is functionally equivalent to drawLine(Vector3d,Vector3d).
    
    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
```
void drawLine(float[] pnt0,
              float[] pnt1)
```
    Draws a single line between two points in model coordinates, using the current line width, material, and shading. This method is functionally equivalent to drawLine(Vector3d,Vector3d).
    
    Parameters:
    
    pnt0 - array (of length 3) giving the first point
    
    pnt1 - array (of length 3) giving the second point
  - drawTriangle
```
void drawTriangle(Vector3d pnt0,
                  Vector3d pnt1,
                  Vector3d pnt2)
```
    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.
    
    Parameters:
    
    pnt0 - first point
    
    pnt1 - second point
    
    pnt2 - third point
  - drawTriangle
```
void drawTriangle(float[] pnt0,
                  float[] pnt1,
                  float[] pnt2)
```
    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 drawTriangle(Vector3d,Vector3d,Vector3d).
    
    Parameters:
    
    pnt0 - first point
    
    pnt1 - second point
    
    pnt2 - third point
  - getSurfaceResolution
```
int getSurfaceResolution()
```
    Returns the resolution used for creating mesh representations of curved solids.
    
    Returns:
    
    resolution for approximating curved surfaces
    
    See Also:
    
    setSurfaceResolution(int)
  - setSurfaceResolution
```
int setSurfaceResolution(int nsegs)
```
    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.
    
    Parameters:
    
    nsegs - resolution for curved surfaces
    
    Returns:
    
    previous resolution
  - drawSphere
```
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. The point is located in model coordinates. The resolution of the sphere is specified by getSurfaceResolution().
    
    Parameters:
    
    pnt - center of the sphere
    
    rad - radius of the sphere
  - drawSphere
```
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. This method is functionally equivalent to drawSphere(Vector3d,double).
    
    Parameters:
    
    pnt - center of the sphere
    
    rad - radius of the sphere
  - drawCube
```
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.
    
    Parameters:
    
    pnt - center of the cube
    
    w - width of the cube
  - drawCube
```
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.
    
    Parameters:
    
    pnt - center of the cube
    
    w - width of the cube
  - drawBox
```
void drawBox(float[] pnt,
             double wx,
             double wy,
             double wz)
```
    Draws an axis-aligned box in model coordinates, using the current shading and material.
    
    Parameters:
    
    pnt - center of the box
    
    wx - width in x
    
    wy - width in y
    
    wz - width in z
  - drawBox
```
void drawBox(Vector3d pnt,
             Vector3d widths)
```
    Draws an axis-aligned box in model coordinates, using the current shading and material.
    
    Parameters:
    
    pnt - center of the box
    
    widths - x,y,z widths of the box
  - drawBox
```
void drawBox(RigidTransform3d TBM,
             Vector3d widths)
```
    Draws a box centered on the specified transform in model coordinates, using the current shading and material.
    
    Parameters:
    
    TBM - transform from box to model coordinates on which the box is centered
    
    widths - x,y,z widths of the box
  - drawSpindle
```
void drawSpindle(Vector3d pnt0,
                 Vector3d pnt1,
                 double rad)
```
    Draws a spindle between two points in model coordinates, using the current shading and material. The resolution is specified by getSurfaceResolution().
    
    Parameters:
    
    pnt0 - first end point
    
    pnt1 - second end point
    
    rad - radius of the spindle
  - drawSpindle
```
void drawSpindle(float[] pnt0,
                 float[] pnt1,
                 double rad)
```
    Draws a spindle between two points in model coordinates, using the current shading and material. The resolution is specified by getSurfaceResolution().
    
    Parameters:
    
    pnt0 - first end point
    
    pnt1 - second end point
    
    rad - radius of the spindle
  - drawCylinder
```
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. The resolution is specified by getSurfaceResolution().
    
    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
```
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. The resolution is specified by getSurfaceResolution().
    
    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
```
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. A cone is like a cylinder, except that it can have different radii at the end points. The resolution is specified by getSurfaceResolution().
    
    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
```
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. A cone is like a cylinder, except that it can have different radii at the end points. The resolution is specified by getSurfaceResolution().
    
    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
```
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. 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 getSurfaceResolution().
    
    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
```
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. The arrow is rendered as described for drawArrow(Vector3d,Vector3d,double,boolean).
    
    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
  - drawArrow
```
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. This method is functionally equivalent to drawArrow(Vector3d,Vector3d,double,boolean) except that the points are specified using float[].
    
    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
  - drawAxes
```
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. 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.
    
    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 getAxisRadiusRatio().
    
    highlight - if true, indicates that the axes should be highlighted.
  - drawAxes
```
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. This method is identical to drawAxes(RigidTransform3d,AxisDrawStyle,double,int,double,boolean), except that the length of each axis can be specified separately.
    
    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 getAxisRadiusRatio().
    
    highlight - if true, indicates that the axes should be highlighted.
  - drawAxes
```
void drawAxes(RigidTransform3d X,
              double len,
              int width,
              boolean highlight)
```
    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.
    
    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.
  - drawAxes
```
void drawAxes(RigidTransform3d X,
              double[] lens,
              int width,
              boolean highlight)
```
    Draws a set of coordinate axes representing a rigid coordinate frame X. This method is functionally equivalent to 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.
    
    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.
  - drawSolidAxes
```
void drawSolidAxes(RigidTransform3d X,
                   double len,
                   double rad,
                   boolean highlight)
```
    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.
    
    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 getAxisRadiusRatio().
    
    highlight - if true, indicates that the axes should be highlighted.
  - drawSolidAxes
```
void drawSolidAxes(RigidTransform3d X,
                   double[] lens,
                   double rad,
                   boolean highlight)
```
    Draws a solid set of coordinate axes representing a rigid coordinate frame X. This method is functionally equivalent to 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.
    
    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 getAxisRadiusRatio().
    
    highlight - if true, indicates that the axes should be highlighted.
  - drawPoint
```
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.
    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.
    
    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
```
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. This method is functionally equivalent to drawPoint(RenderProps,Vector3d,boolean) except that the point is specified using float[].
    
    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
```
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.
    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.
    
    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
```
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. This method is functionally equivalent to drawLine(RenderProps,Vector3d,Vector3d,boolean) except that the points are specified using float[].
    
    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
```
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. This method is functionally equivalent to drawLine(RenderProps,float[],float[],boolean), except for the additional control provided by the arguments color and capped.
    
    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
```
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. This method is functionally equivalent to drawLine(RenderProps,float[],float[],boolean), except for the additional control provided by the argument capped.
    
    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
  - drawRay
```
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. 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.
    
    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
  - drawArrow
```
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. The method behaves similarly to drawArrow(float[],float[],double,boolean), with the cylinder radius determine instead by props.getLineRadius().
    
    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
```
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.
    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.
    
    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
```
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. 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.
    
    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
```
void setDefaultFont(java.awt.Font font)
```
    Sets default font for text rendering
    
    Parameters:
    
    font - default font. The font size largely impacts the resolution of the renderer characters. A value of at least 32pt is recommended.
  - getDefaultFont
```
java.awt.Font getDefaultFont()
```
    Retrieves the default font.
    
    Returns:
    
    default font.
  - hasTextRendering
```
boolean hasTextRendering()
```
    Queries whether or not this renderer supports text rendering.
    
    Returns:
    
    true if text rendering is supported.
  - drawText
```
double drawText(java.lang.String str,
                float[] pos,
                double emSize)
```
    Draws text in the x-y plane in model coordinates. Uses a default font.
    
    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
```
double drawText(java.awt.Font font,
                java.lang.String str,
                float[] pos,
                double emSize)
```
    Draws text in the x-y plane in model coordinates.
    
    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
```
double drawText(java.lang.String str,
                Vector3d pos,
                double emSize)
```
    Draws text in the x-y plane in model coordinates. Uses a default font.
    
    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
```
double drawText(java.awt.Font font,
                java.lang.String str,
                Vector3d pos,
                double emSize)
```
    Draws text in the x-y plane in model coordinates.
    
    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
```
Vector3d getEyeZDirection()
```
    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.
    
    Returns:
    
    current z direction of the eye frame
  - begin2DRendering
```
boolean begin2DRendering()
```
    Puts this Renderer into 2D rendering mode, or returns false if 2D rendering is not supported. This method behaves identically to begin2DRendering(double,double), only with the existing screen width and height used for w and h.
    
    Returns:
    
    true if 2D rendering is supported
    
    Throws:
    
    java.lang.IllegalStateException - if this Renderer is currently in 2D rendering mode.
    
    See Also:
    
    getScreenWidth(), getScreenHeight(), has2DRendering()
  - begin2DRendering
```
boolean begin2DRendering(double w,
                         double h)
```
    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.
    
    Parameters:
    
    w - width of the screen coordinates
    
    h - height of the screen coordinates
    
    Returns:
    
    true if 2D rendering is supported
    
    Throws:
    
    java.lang.IllegalStateException - if this Renderer is currently in 2D rendering mode.
    
    See Also:
    
    has2DRendering()
  - has2DRendering
```
boolean has2DRendering()
```
    Returns true if this Renderer supports 2D rendering mode.
    
    Returns:
    
    true if 2D rendering is supported
    
    See Also:
    
    is2DRendering()
  - end2DRendering
```
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.
    
    Throws:
    
    java.lang.IllegalStateException - if this Renderer is not currently in 2D rendering mode.
  - is2DRendering
```
boolean is2DRendering()
```
    Check whether the Renderer is currently in 2D rendering mode.
    
    Returns:
    
    true if in 2D rendering mode.
  - setColor
```
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. 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);
 
```
    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
```
void setColor(float[] rgba)
```
    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);
 
```
    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
```
void setColor(java.awt.Color color)
```
    Sets the diffuse and ambient colors to be used for subsequent rendering of primitives. The method is functionally equivalent to setColor(float[]), with the RGBA values being obtained from the color components of color.
    
    Parameters:
    
    color - specifies RGBA color values.
  - setColor
```
void setColor(float r,
              float g,
              float b)
```
    Sets the diffuse and ambient colors to be used for subsequent rendering of primitives. The method is functionally equivalent to setColor(float[]), only with alpha assumed to be 1.
    
    Parameters:
    
    r - red value
    
    g - green value
    
    b - blue value
  - setColor
```
void setColor(float r,
              float g,
              float b,
              float a)
```
    Sets the diffuse and ambient colors to be used for subsequent rendering of primitives. The method is functionally equivalent to setColor(float[]).
    
    Parameters:
    
    r - red value
    
    g - green value
    
    b - blue value
    
    a - alpha value
  - setFrontColor
```
void setFrontColor(float[] rgba)
```
    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 setBackColor(float[]).
    
    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
```
float[] getFrontColor(float[] rgba)
```
    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).
    
    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
```
void setBackColor(float[] rgba)
```
    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.
    
    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
```
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. 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.
    
    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
```
void setEmission(float[] rgb)
```
    Sets the emission color to be used for subsequent rendering of primitives. The default emission color has a value of (0, 0, 0).
    
    Parameters:
    
    rgb - array of length 3 specifying RGB values in the range [0,1].
  - getEmission
```
float[] getEmission(float[] rgb)
```
    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.
    
    Parameters:
    
    rgb - optional storage for returning the RGB values.
    
    Returns:
    
    RGB values for the emission color
  - setSpecular
```
void setSpecular(float[] rgb)
```
    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).
    
    Parameters:
    
    rgb - array of length 3 specifying RGB values in the range [0,1].
  - getSpecular
```
float[] getSpecular(float[] rgb)
```
    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.
    
    Parameters:
    
    rgb - optional storage for returning the RGB values.
    
    Returns:
    
    RGB values for the specular color
  - setShininess
```
void setShininess(float s)
```
    Sets the shininess parameter to be used for subsequent rendering of primitives (see getShininess(). This should be in the range [0,128], and the default value is 32.
    
    Parameters:
    
    s - shininess parameter
  - getShininess
```
float getShininess()
```
    Returns the current shininess parameter. This is the specular exponent of the lighting equation, and is in the range [0,128],
    
    Returns:
    
    shininess parameter
  - setFrontAlpha
```
void setFrontAlpha(float a)
```
    Sets the alpha value for the front material.
    
    Parameters:
    
    a - alpha value, in the range [0,1].
  - setPointColoring
```
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. 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 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.
    
    Parameters:
    
    props - supplies the shininess and point color values
    
    highlight - if true, enables highlighting
  - setLineColoring
```
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. 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 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.
    
    Parameters:
    
    props - supplies the shininess and line color values
    
    highlight - if true, enables highlighting
  - setEdgeColoring
```
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. 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 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.
    
    Parameters:
    
    props - supplies the shininess and edge (or line) color values
    
    highlight - if true, enables highlighting
  - setFaceColoring
```
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. 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 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.
    
    Parameters:
    
    props - supplies the shininess and front and back color values
    
    highlight - if true, enables highlighting
  - setFaceColoring
```
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. 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 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.
    
    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
```
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. 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.
    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
```
Renderer.Shading setPointShading(RenderProps props)
```
    Sets the shading appropriate to the point style specified in props. If props.getPointStyle() is Renderer.PointStyle.POINT, then shading is set to Renderer.Shading.NONE; otherwise, it is set to props.getShading().
    
    Parameters:
    
    props - properties giving the shading and point style
    
    Returns:
    
    the previous shading setting
  - setLineShading
```
Renderer.Shading setLineShading(RenderProps props)
```
    Sets the shading appropriate to the line style specified in props. If props.getLineStyle() is Renderer.LineStyle.LINE, then shading is set to Renderer.Shading.NONE; otherwise, it is set to props.getShading().
    
    Parameters:
    
    props - properties giving the shading and line style
    
    Returns:
    
    the previous shading setting
  - setPropsShading
```
Renderer.Shading setPropsShading(RenderProps props)
```
    Sets the shading to that shading specified by props.getShading().
    
    Parameters:
    
    props - properties giving the shading
    
    Returns:
    
    the previous shading setting
  - hasColorMapping
```
boolean hasColorMapping()
```
    Queries whether or not this renderer supports color mapping.
    
    Returns:
    
    true if color mapping is supported.
  - hasColorMapMixing
```
boolean hasColorMapMixing(Renderer.ColorMixing cmix)
```
    Queries whether or not a specified method for combining color map and material coloring is supported by this Renderer.
    
    Returns:
    
    true if the color mixing method is supported
  - setColorMap
```
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. Once a color map is set, it will be applied to any subsequent draw operation for which the vertices contain texture coordinates.
    
    Parameters:
    
    props - properties for the color map, or null to disable
    
    Returns:
    
    the previous color map properties
  - getColorMap
```
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.
    
    Returns:
    
    current color map properties.
    
    See Also:
    
    setColorMap(maspack.render.ColorMapProps)
  - hasNormalMapping
```
boolean hasNormalMapping()
```
    Queries whether or not this renderer supports normal mapping.
    
    Returns:
    
    true if normal mapping is supported.
  - setNormalMap
```
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. 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.
    
    Parameters:
    
    props - properties for the normal mapping, or null to disable
    
    Returns:
    
    the previous normal map properties
  - getNormalMap
```
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.
    
    Returns:
    
    current normal mapping properties.
    
    See Also:
    
    setNormalMap(maspack.render.NormalMapProps)
  - hasBumpMapping
```
boolean hasBumpMapping()
```
    Queries whether or not this renderer supports bump mapping.
    
    Returns:
    
    true if bump mapping is supported.
  - setBumpMap
```
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. 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.
    
    Parameters:
    
    props - properties for the bump mapping, or null to disable
    
    Returns:
    
    the previous bump map properties
  - getBumpMap
```
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.
    
    Returns:
    
    current bump mapping properties.
    
    See Also:
    
    setBumpMap(maspack.render.BumpMapProps)
  - drawTriangles
```
void drawTriangles(RenderObject robj)
```
    Draws all the triangles in the first triangle group of the specified render object, using the current material and shading.
    
    Parameters:
    
    robj - render object
  - drawTriangles
```
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.
    
    Parameters:
    
    robj - render object
    
    gidx - triangle group index
  - drawTriangles
```
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.
    
    Parameters:
    
    robj - render object
    
    gidx - triangle group index
    
    offset - triangle offset at which to start rendering
    
    count - number of triangles to draw
  - drawLines
```
void drawLines(RenderObject robj)
```
    Draws all the lines in the first line group of the specified render object, using the current material and shading.
    
    Parameters:
    
    robj - render object
  - drawLines
```
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.
    
    Parameters:
    
    robj - render object
    
    gidx - line group index
  - drawLines
```
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. 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.
    
    Parameters:
    
    robj - render object
    
    style - line style to use for drawing
    
    rad - radius for solid lines or width for pixel-based lines
  - drawLines
```
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. 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.
    
    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
```
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. 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.
    
    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
```
void drawPoints(RenderObject robj)
```
    Draws all the points in the first point group of the specified render object, using the current material and shading.
    
    Parameters:
    
    robj - render object
  - drawPoints
```
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.
    
    Parameters:
    
    robj - render object
    
    gidx - point group index
  - drawPoints
```
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. 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.
    
    Parameters:
    
    robj - render object
    
    style - point style to use for drawing
    
    rad - radius for spheres or width for pixel-based points
  - drawPoints
```
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. 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.
    
    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
```
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. 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.
    
    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
```
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.
    
    Parameters:
    
    robj - render object
    
    mode - drawing mode to be used for drawing the vertices
  - drawVertices
```
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. 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.
    
    Parameters:
    
    robj - render object
    
    idxs - vertex indices
    
    mode - drawing mode to be used for drawing the vertices
  - drawVertices
```
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. 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.
    
    Parameters:
    
    robj - render object
    
    idxs - vertex indices
    
    offset - index offset
    
    count - index count
    
    mode - drawing mode to be used for drawing the vertices
  - draw
```
void draw(RenderObject robj)
```
    Draws all the primitives in the first point, line and triangles groups.
    
    Parameters:
    
    robj - render object
  - drawTriangles
```
void drawTriangles(RenderObject robj,
                   int gidx,
                   RenderInstances rinst)
```
    Draws the specified group of triangles, repeated for each instance in rinst.
    
    Parameters:
    
    robj - object to draw
    
    gidx - triangle group to draw
    
    rinst - instance to draw
  - drawLines
```
void drawLines(RenderObject robj,
               int gidx,
               RenderInstances rinst)
```
    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 getLineWidth().
    
    Parameters:
    
    robj - object to draw
    
    gidx - line group to draw
    
    rinst - instance to draw
  - drawPoints
```
void drawPoints(RenderObject robj,
                int gidx,
                RenderInstances rinst)
```
    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 getPointSize().
    
    Parameters:
    
    robj - object to draw
    
    gidx - point group to draw
    
    rinst - instance to draw
  - pushModelMatrix
```
void pushModelMatrix()
```
    Saves the model matrix by pushing it onto the model matrix stack.
  - getModelMatrix
```
AffineTransform3dBase getModelMatrix()
```
    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.
    
    Returns:
    
    model matrix value (may be modified by the user)
  - getModelMatrix
```
void getModelMatrix(AffineTransform3d X)
```
    Gets the current model matrix. The model matrix is the transformation from model coordinates to world coordinates.
    
    Parameters:
    
    X - returns the current model matrix value
  - translateModelMatrix
```
void translateModelMatrix(double tx,
                          double ty,
                          double tz)
```
    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    ]
 
```
    Parameters:
    
    tx - translation along x
    
    ty - translation along y
    
    tz - translation along z
  - rotateModelMatrix
```
void rotateModelMatrix(double zdeg,
                       double ydeg,
                       double xdeg)
```
    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 ]
 
```
    Parameters:
    
    zdeg - rotation about z axis (degrees)
    
    ydeg - rotation about new y axis (degrees)
    
    xdeg - rotation about new x axis (degrees)
  - scaleModelMatrix
```
void scaleModelMatrix(double s)
```
    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  ]
 
```
    Parameters:
    
    s - scale factor
  - mulModelMatrix
```
void mulModelMatrix(AffineTransform3dBase X)
```
    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    ]
 
```
    Parameters:
    
    X - transform to multiply the model matrix by
  - setModelMatrix
```
void setModelMatrix(AffineTransform3dBase X)
```
    Sets the model matrix to the specified transform. The model matrix is the transformation from model coordinates to world coordinates.
    
    Parameters:
    
    X - new model matrix value
  - setModelMatrix2d
```
void setModelMatrix2d(double left,
                      double right,
                      double bottom,
                      double top)
```
    Sets the model matrix to perform scaling and translation in the x-y plane so that the model coordinates (left,bottom) and (right,top) map onto (-1,1) and (1,1) in world coordinates. When in 2d rendering mode, this means that (left,bottom) and (right,top) will correspond to the lower left and top right of the screen.
    
    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:
    
    is2DRendering()
  - popModelMatrix
```
boolean popModelMatrix()
```
    Restores the model matrix by popping it off the model matrix stack
    
    Returns:
    
    false if the model matrix stack is empty
  - getViewMatrix
```
RigidTransform3d getViewMatrix()
```
    Gets the current view matrix. The view matrix is the transformation from world coordinates to eye coordinates.
    
    Returns:
    
    view matrix value (may be modified by the user)
  - getViewMatrix
```
void getViewMatrix(RigidTransform3d TWE)
```
    Gets the current view matrix. The view matrix is the transformation from world coordinates to eye coordinates.
    
    Parameters:
    
    TWE - returns the current transform from world to eye coordinates
  - setDepthOffset
```
void setDepthOffset(int offset)
```
    Set a depth offset for the projection matrix. Each unit represents enough depth to account for one bin in the depth buffer. Positive values bring following objects closer to the screen, while negative values send them father away. The default value is 0.
    Depth offsets are used to help resolve z-fighting, in which overlapping primitives drawn in the same plane compete for visibility. If the plane has a considerable tilt with respect to the viewer, then an offset larger than one may be needed to resolve the issue.
    
    Parameters:
    
    offset - new depth offset value
  - getDepthOffset
```
int getDepthOffset()
```
    The current depth offset level. See setDepthOffset(int) for a description. The default value is 0.
    
    Returns:
    
    the current depth offset (in depth bins)
  - setTextureMatrix
```
void setTextureMatrix(AffineTransform2dBase T)
```
    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.
    
    Parameters:
    
    T - new texture transform matrix
  - getTextureMatrix
```
AffineTransform2dBase getTextureMatrix()
```
    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.
    
    Returns:
    
    texture matrix value (may be modified by the user)
  - getTextureMatrix
```
void getTextureMatrix(AffineTransform2d X)
```
    Gets the current texture matrix. The texture matrix is the transformation applied to texture coordinates.
    
    Parameters:
    
    X - returns the current texture matrix value
    
    See Also:
    
    setTextureMatrix(AffineTransform2dBase)
  - hasSelection
```
boolean hasSelection()
```
    Queries whether or not this Renderer supports selection.
    
    Returns:
    
    true if selection is supported.
  - isSelecting
```
boolean isSelecting()
```
    Returns true if the renderer is currently performing a selection render. When this is the case, the application should avoid calls affecting color and lighting.
    
    Returns:
    
    true if the renderer is in selection mode.
  - getHighlightStyle
```
Renderer.HighlightStyle getHighlightStyle()
```
    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.
    
    Returns:
    
    current highlighting method.
  - getHighlightColor
```
void getHighlightColor(float[] rgba)
```
    Returns the color that is used to highlight objects when the highlighting method is Renderer.HighlightStyle.COLOR.
    
    Parameters:
    
    rgba - array of length 3 or 4 in which the RGB or RGBA components of the highlight color are returned.
  - setHighlighting
```
boolean setHighlighting(boolean enable)
```
    Enables or disables highlighting. If highlighting is enabled, subsequent primitives will be rendered in a highlighted fashion using the style indicated by Renderer.HighlightStyle. If the style is Renderer.HighlightStyle.COLOR, highlighting is done by setting the effective color to the highlight color.
    
    Parameters:
    
    enable - if true, enable highlighting.
    
    Returns:
    
    previous highlighting value
    
    See Also:
    
    getHighlightColor(float[])
  - getHighlighting
```
boolean getHighlighting()
```
    Queries whether or not highlighting is enabled.
    
    Returns:
    
    true if highlighting is enabled
  - beginSelectionQuery
```
void beginSelectionQuery(int qid)
```
    Begins a selection query with the {\it query identifier} qid. If the rendering that occurs between this call and the subsequent call to 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.
    
    Parameters:
    
    qid - identifier for the selection query
    
    See Also:
    
    endSelectionQuery()
  - endSelectionQuery
```
void endSelectionQuery()
```
    Ends a selection query that was initiated with a call to beginSelectionQuery(int).
    
    See Also:
    
    beginSelectionQuery(int)
  - beginSubSelection
```
void beginSubSelection(IsSelectable s,
                       int qid)
```
    Begins selection for a IsSelectable sthat manages its own selection; this call should be used in place of 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.
    
    Parameters:
    
    s - Selectable that is managing its own sub-selection
    
    qid - current selection query identifier
  - endSubSelection
```
void endSubSelection()
```
    Ends object sub-selection that was initiated with a call to beginSubSelection(maspack.render.IsSelectable, int).
    
    See Also:
    
    endSubSelection()
  - isSelectable
```
boolean isSelectable(IsSelectable s)
```
    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.
  - beginDraw
```
void beginDraw(Renderer.DrawMode mode)
```
    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.
    
    Parameters:
    
    mode - specifies the primitive to be built while in draw mode.
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is currently in draw mode
  - addVertex
```
void addVertex(float px,
               float py,
               float pz)
```
    Adds a vertex to a primitive being drawn while in draw mode.
    
    Parameters:
    
    px - vertex x coordinate
    
    py - vertex y coordinate
    
    pz - vertex z coordinate
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is not in draw mode
    
    See Also:
    
    beginDraw(maspack.render.Renderer.DrawMode)
  - addVertex
```
void addVertex(double px,
               double py,
               double pz)
```
    Adds a vertex to a primitive being drawn while in draw mode.
    
    Parameters:
    
    px - vertex x coordinate
    
    py - vertex y coordinate
    
    pz - vertex z coordinate
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is not in draw mode
    
    See Also:
    
    beginDraw(maspack.render.Renderer.DrawMode)
  - addVertex
```
void addVertex(Vector3d pnt)
```
    Adds a vertex to a primitive being drawn while in draw mode.
    
    Parameters:
    
    pnt - coordinates for the vertex
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is not in draw mode
    
    See Also:
    
    beginDraw(maspack.render.Renderer.DrawMode)
  - addVertex
```
void addVertex(float[] pnt)
```
    Adds a vertex to a primitive being drawn while in draw mode.
    
    Parameters:
    
    pnt - coordinates for the vertex
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is not in draw mode
    
    See Also:
    
    beginDraw(maspack.render.Renderer.DrawMode)
  - setNormal
```
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. This normal will remain in effect until a subsequent setNormal call. The normal does not need to be normalized.
    
    Parameters:
    
    nx - normal x coordinate
    
    ny - normal y coordinate
    
    nz - normal z coordinate
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is not in draw mode
    
    See Also:
    
    beginDraw(maspack.render.Renderer.DrawMode)
  - setNormal
```
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. This method is functionally equivalent to setNormal(float,float,float).
    
    Parameters:
    
    nx - normal x coordinate
    
    ny - normal y coordinate
    
    nz - normal z coordinate
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is not in draw mode
    
    See Also:
    
    beginDraw(maspack.render.Renderer.DrawMode)
  - setNormal
```
void setNormal(Vector3d nrm)
```
    Sets the normal to be associated with the next vertex to be added while in draw mode. This method is functionally equivalent to to setNormal(float,float,float).
    
    Parameters:
    
    nrm - normal coordinates
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is not in draw mode
    
    See Also:
    
    beginDraw(maspack.render.Renderer.DrawMode)
  - setTextureCoord
```
void setTextureCoord(float tx,
                     float ty)
```
    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]
    
    Parameters:
    
    tx - texture x coordinate
    
    ty - texture y coordinate
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is not in draw mode
    
    See Also:
    
    beginDraw(maspack.render.Renderer.DrawMode)
  - setTextureCoord
```
void setTextureCoord(double tx,
                     double ty)
```
    Sets the texture coordinate to be associated with the next vertex to be added while in draw mode. This method is functionally equivalent to setTextureCoord(float,float).
    
    Parameters:
    
    tx - texture x coordinate
    
    ty - texture y coordinate
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is not in draw mode
    
    See Also:
    
    beginDraw(maspack.render.Renderer.DrawMode)
  - setTextureCoord
```
void setTextureCoord(Vector2d tex)
```
    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 setTextureCoord(float,float).
    
    Parameters:
    
    tex - texture coordinates
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is not in draw mode
    
    See Also:
    
    beginDraw(maspack.render.Renderer.DrawMode)
  - endDraw
```
void endDraw()
```
    Ends draw mode. This is analogous to glEnd() in the old GL specification.
    
    Throws:
    
    java.lang.IllegalStateException - if the renderer is not in draw mode
  - restoreDefaultState
```
void restoreDefaultState(boolean strictChecking)
```
    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.
    
    Parameters:
    
    strictChecking - if true, enables strict checking.
    
    Throws:
    
    java.lang.IllegalStateException - if strict checking is enabled and fails.

Interface Renderer

Nested Class Summary

Field Summary

Method Summary

Field Detail

HIGHLIGHT

SORT_FACES

Method Detail

getScreenHeight

getScreenWidth

getViewPlaneHeight

getViewPlaneWidth

centerDistancePerPixel

getCenter

distancePerPixel

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

drawAxes

drawSolidAxes

drawSolidAxes

drawPoint

drawPoint

drawLine

drawLine

drawLine

drawLine

drawRay

drawArrow

drawLineStrip

getTextBounds

setDefaultFont

getDefaultFont

hasTextRendering

drawText

drawText