Package processing.awt

Class PGraphicsJava2D

java.lang.Object
processing.core.PImage
processing.core.PGraphics
processing.awt.PGraphicsJava2D
All Implemented Interfaces:
Cloneable, PConstants
public class PGraphicsJava2D extends PGraphics
Subclass for PGraphics that implements the graphics API using Java2D.

To get access to the Java 2D "Graphics2D" object for the default renderer, use: 

 Graphics2D g2 = (Graphics2D) g.getNative();
This will let you do Graphics2D calls directly, but is not supported in any way shape or form. Which just means "have fun, but don't complain if it breaks."

Advanced debugging notes for Java2D.

  • Field Details

    • g2

      public Graphics2D g2

    • fillGradient

      public boolean fillGradient

    • fillGradientObject

      public Paint fillGradientObject

    • strokeGradient

      public boolean strokeGradient

    • strokeGradientObject

      public Paint strokeGradientObject

  • Constructor Details

    • PGraphicsJava2D

      public PGraphicsJava2D()

  • Method Details

    • setSize

      public void setSize(int w, int h)
      Queues a size change, won't happen until beginDraw().
      Overrides:
      setSize in class PGraphics

    • createSurface

      public PSurface createSurface()
      Overrides:
      createSurface in class PGraphics

    • getNative

      public Object getNative()
      Returns the java.awt.Graphics2D object used by this renderer.
      Overrides:
      getNative in class PImage

    • checkImage

      public Graphics2D checkImage()

    • beginDraw

      public void beginDraw()
      Description copied from class: PGraphics
      Sets the default properties for a PGraphics object. It should be called before anything is drawn into the object.

      Advanced

      When creating your own PGraphics, you should call this before drawing anything.
      Overrides:
      beginDraw in class PGraphics

    • endDraw

      public void endDraw()
      Description copied from class: PGraphics
      Finalizes the rendering of a PGraphics object so that it can be shown on screen.

      Advanced

      When creating your own PGraphics, you should call this when you're finished drawing.

      Overrides:
      endDraw in class PGraphics

    • hint

      public void hint(int which)
      Description copied from class: PGraphics
      Set various hints and hacks for the renderer. This is used to handle obscure rendering features that cannot be implemented in a consistent manner across renderers. Many options will often graduate to standard features instead of hints over time.

      hint(ENABLE_OPENGL_4X_SMOOTH)- Enable 4x anti-aliasing for P3D. This can help force anti-aliasing if it has not been enabled by the user. On some graphics cards, this can also be set by the graphics driver's control panel, however not all cards make this available. This hint must be called immediately after the size() command because it resets the renderer, obliterating any settings and anything drawn (and like size(), re-running the code that came before it again).

      hint(DISABLE_OPENGL_2X_SMOOTH) - In Processing 1.0, Processing always enables 2x smoothing when the P3D renderer is used. This hint disables the default 2x smoothing and returns the smoothing behavior found in earlier releases, where smooth() and noSmooth() could be used to enable and disable smoothing, though the quality was inferior.

      hint(ENABLE_NATIVE_FONTS) - Use the native version fonts when they are installed, rather than the bitmapped version from a .vlw file. This is useful with the default (or JAVA2D) renderer setting, as it will improve font rendering speed. This is not enabled by default, because it can be misleading while testing because the type will look great on your machine (because you have the font installed) but lousy on others' machines if the identical font is unavailable. This option can only be set per-sketch, and must be called before any use of textFont().

      hint(DISABLE_DEPTH_TEST) - Disable the zbuffer, allowing you to draw on top of everything at will. When depth testing is disabled, items will be drawn to the screen sequentially, like a painting. This hint is most often used to draw in 3D, then draw in 2D on top of it (for instance, to draw GUI controls in 2D on top of a 3D interface). Starting in release 0149, this will also clear the depth buffer. Restore the default with hint(ENABLE_DEPTH_TEST), but note that with the depth buffer cleared, any 3D drawing that happens later in draw() will ignore existing shapes on the screen.

      hint(ENABLE_DEPTH_SORT) - Enable primitive z-sorting of triangles and lines in P3D and OPENGL. This can slow performance considerably, and the algorithm is not yet perfect. Restore the default with hint(DISABLE_DEPTH_SORT).

      hint(DISABLE_OPENGL_ERROR_REPORT) - Speeds up the P3D renderer setting by not checking for errors while running. Undo with hint(ENABLE_OPENGL_ERROR_REPORT).

      hint(ENABLE_BUFFER_READING) - Depth and stencil buffers in P2D/P3D will be down-sampled to make PGL#readPixels work with multisampling. Enabling this introduces some overhead, so if you experience bad performance, disable multisampling with noSmooth() instead. This hint is not intended to be enabled and disabled repeatedly, so call this once in setup() or after creating your PGraphics2D/3D. You can restore the default with hint(DISABLE_BUFFER_READING) if you don't plan to read depth from this PGraphics anymore.

      hint(ENABLE_KEY_REPEAT) - Auto-repeating key events are discarded by default (works only in P2D/P3D); use this hint to get all the key events (including auto-repeated). Call hint(DISABLE_KEY_REPEAT) to get events only when the key goes physically up or down.

      hint(DISABLE_ASYNC_SAVEFRAME) - P2D/P3D only - save() and saveFrame() will not use separate threads for saving and will block until the image is written to the drive. This was the default behavior in 3.0b7 and before. To enable, call hint(ENABLE_ASYNC_SAVEFRAME).
      Overrides:
      hint in class PGraphics
      Parameters:
      which - name of the hint to be enabled or disabled
      See Also:

    • beginShape

      public void beginShape(int kind)
      Description copied from class: PGraphics
      Using the beginShape() and endShape() functions allow creating more complex forms. beginShape() begins recording vertices for a shape and endShape() stops recording. The value of the kind parameter tells it which types of shapes to create from the provided vertices. With no mode specified, the shape can be any irregular polygon. The parameters available for beginShape() are POINTS, LINES, TRIANGLES, TRIANGLE_FAN, TRIANGLE_STRIP, QUADS, and QUAD_STRIP. After calling the beginShape() function, a series of vertex() commands must follow. To stop drawing the shape, call endShape(). The vertex() function with two parameters specifies a position in 2D and the vertex() function with three parameters specifies a position in 3D. Each shape will be outlined with the current stroke color and filled with the fill color.

      Transformations such as translate(), rotate(), and scale() do not work within beginShape(). It is also not possible to use other shapes, such as ellipse() or rect() within beginShape().

      The P2D and P3D renderers allow stroke() and fill() to be altered on a per-vertex basis, but the default renderer does not. Settings such as strokeWeight(), strokeCap(), and strokeJoin() cannot be changed while inside a beginShape()/endShape() block with any renderer.
      Overrides:
      beginShape in class PGraphics
      Parameters:
      kind - Either POINTS, LINES, TRIANGLES, TRIANGLE_FAN, TRIANGLE_STRIP, QUADS, or QUAD_STRIP
      See Also:

    • texture

      public void texture(PImage image)
      Description copied from class: PGraphics
      Sets a texture to be applied to vertex points. The texture() function must be called between beginShape() and endShape() and before any calls to vertex(). This function only works with the P2D and P3D renderers.

      When textures are in use, the fill color is ignored. Instead, use tint() to specify the color of the texture as it is applied to the shape.

      Overrides:
      texture in class PGraphics
      Parameters:
      image - reference to a PImage object
      See Also:

    • vertex

      public void vertex(float x, float y)
      Overrides:
      vertex in class PGraphics

    • vertex

      public void vertex(float x, float y, float z)
      Overrides:
      vertex in class PGraphics

    • vertex

      public void vertex(float[] v)
      Description copied from class: PGraphics
      Used by renderer subclasses or PShape to efficiently pass in already formatted vertex information.
      Overrides:
      vertex in class PGraphics
      Parameters:
      v - vertex parameters, as a float array of length VERTEX_FIELD_COUNT

    • vertex

      public void vertex(float x, float y, float u, float v)
      Overrides:
      vertex in class PGraphics

    • vertex

      public void vertex(float x, float y, float z, float u, float v)
      Description copied from class: PGraphics
      All shapes are constructed by connecting a series of vertices. vertex() is used to specify the vertex coordinates for points, lines, triangles, quads, and polygons. It is used exclusively within the beginShape() and endShape() functions.

      Drawing a vertex in 3D using the z parameter requires the P3D parameter in combination with size, as shown in the above example.

      This function is also used to map a texture onto geometry. The texture() function declares the texture to apply to the geometry and the u and v coordinates set define the mapping of this texture to the form. By default, the coordinates used for u and v are specified in relation to the image's size in pixels, but this relation can be changed with textureMode().
      Overrides:
      vertex in class PGraphics
      Parameters:
      x - x-coordinate of the vertex
      y - y-coordinate of the vertex
      z - z-coordinate of the vertex
      u - horizontal coordinate for the texture mapping
      v - vertical coordinate for the texture mapping
      See Also:

    • beginContour

      public void beginContour()
      Description copied from class: PGraphics
      Use the beginContour() and endContour() function to create negative shapes within shapes such as the center of the letter "O". beginContour() begins recording vertices for the shape and endContour() stops recording. The vertices that define a negative shape must "wind" in the opposite direction from the exterior shape. First draw vertices for the exterior shape in clockwise order, then for internal shapes, draw vertices counterclockwise.

      These functions can only be used within a beginShape()/endShape() pair and transformations such as translate(), rotate(), and scale() do not work within a beginContour()/endContour() pair. It is also not possible to use other shapes, such as ellipse() or rect() within.
      Overrides:
      beginContour in class PGraphics

    • endContour

      public void endContour()
      Description copied from class: PGraphics
      Use the beginContour() and endContour() function to create negative shapes within shapes such as the center of the letter "O". beginContour() begins recording vertices for the shape and endContour() stops recording. The vertices that define a negative shape must "wind" in the opposite direction from the exterior shape. First draw vertices for the exterior shape in clockwise order, then for internal shapes, draw vertices counterclockwise.

      These functions can only be used within a beginShape()/endShape() pair and transformations such as translate(), rotate(), and scale() do not work within a beginContour()/endContour() pair. It is also not possible to use other shapes, such as ellipse() or rect() within.
      Overrides:
      endContour in class PGraphics

    • endShape

      public void endShape(int mode)
      Description copied from class: PGraphics
      The endShape() function is the companion to beginShape() and may only be called after beginShape(). When endshape() is called, all the image data defined since the previous call to beginShape() is written into the image buffer. The constant CLOSE as the value for the MODE parameter to close the shape (to connect the beginning and the end).
      Overrides:
      endShape in class PGraphics
      Parameters:
      mode - use CLOSE to close the shape
      See Also:

    • noClip

      public void noClip()
      Description copied from class: PGraphics
      Disables the clipping previously started by the clip() function.
      Overrides:
      noClip in class PGraphics

    • bezierVertex

      public void bezierVertex(float x1, float y1, float x2, float y2, float x3, float y3)
      Overrides:
      bezierVertex in class PGraphics

    • bezierVertex

      public void bezierVertex(float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4)
      Description copied from class: PGraphics
      Specifies vertex coordinates for Bézier curves. Each call to bezierVertex() defines the position of two control points and one anchor point of a Bézier curve, adding a new segment to a line or shape. The first time bezierVertex() is used within a beginShape() call, it must be prefaced with a call to vertex() to set the first anchor point. This function must be used between beginShape() and endShape() and only when there is no MODE parameter specified to beginShape(). Using the 3D version requires rendering with P3D (see the Environment reference for more information).
      Overrides:
      bezierVertex in class PGraphics
      Parameters:
      x2 - the x-coordinate of the 1st control point
      y2 - the y-coordinate of the 1st control point
      z2 - the z-coordinate of the 1st control point
      x3 - the x-coordinate of the 2nd control point
      y3 - the y-coordinate of the 2nd control point
      z3 - the z-coordinate of the 2nd control point
      x4 - the x-coordinate of the anchor point
      y4 - the y-coordinate of the anchor point
      z4 - the z-coordinate of the anchor point
      See Also:

    • quadraticVertex

      public void quadraticVertex(float ctrlX, float ctrlY, float endX, float endY)
      Description copied from class: PGraphics
      Specifies vertex coordinates for quadratic Bézier curves. Each call to quadraticVertex() defines the position of one control point and one anchor point of a Bézier curve, adding a new segment to a line or shape. The first time quadraticVertex() is used within a beginShape() call, it must be prefaced with a call to vertex() to set the first anchor point. This function must be used between beginShape() and endShape() and only when there is no MODE parameter specified to beginShape(). Using the 3D version requires rendering with P3D (see the Environment reference for more information).
      Overrides:
      quadraticVertex in class PGraphics
      Parameters:
      ctrlX - the x-coordinate of the control point
      ctrlY - the y-coordinate of the control point
      endX - the x-coordinate of the anchor point
      endY - the y-coordinate of the anchor point
      See Also:

    • quadraticVertex

      public void quadraticVertex(float x2, float y2, float z2, float x4, float y4, float z4)
      Overrides:
      quadraticVertex in class PGraphics
      z2 - the z-coordinate of the control point
      z4 - the z-coordinate of the anchor point

    • curveVertex

      public void curveVertex(float x, float y, float z)
      Overrides:
      curveVertex in class PGraphics
      z - the z-coordinate of the vertex

    • point

      public void point(float x, float y)
      Description copied from class: PGraphics
      Draws a point, a coordinate in space at the dimension of one pixel. The first parameter is the horizontal value for the point, the second value is the vertical value for the point, and the optional third value is the depth value. Drawing this shape in 3D with the z parameter requires the P3D parameter in combination with size() as shown in the above example.

      Use stroke() to set the color of a point().

      Point appears round with the default strokeCap(ROUND) and square with strokeCap(PROJECT). Points are invisible with strokeCap(SQUARE) (no cap).

      Using point() with strokeWeight(1) or smaller may draw nothing to the screen, depending on the graphics settings of the computer. Workarounds include setting the pixel using set() or drawing the point using either circle() or square().
      Overrides:
      point in class PGraphics
      Parameters:
      x - x-coordinate of the point
      y - y-coordinate of the point
      See Also:

    • line

      public void line(float x1, float y1, float x2, float y2)
      Description copied from class: PGraphics
      Draws a line (a direct path between two points) to the screen. The version of line() with four parameters draws the line in 2D. To color a line, use the stroke() function. A line cannot be filled, therefore the fill() function will not affect the color of a line. 2D lines are drawn with a width of one pixel by default, but this can be changed with the strokeWeight() function. The version with six parameters allows the line to be placed anywhere within XYZ space. Drawing this shape in 3D with the z parameter requires the P3D parameter in combination with size() as shown in the above example.
      Overrides:
      line in class PGraphics
      Parameters:
      x1 - x-coordinate of the first point
      y1 - y-coordinate of the first point
      x2 - x-coordinate of the second point
      y2 - y-coordinate of the second point
      See Also:

    • triangle

      public void triangle(float x1, float y1, float x2, float y2, float x3, float y3)
      Description copied from class: PGraphics
      A triangle is a plane created by connecting three points. The first two arguments specify the first point, the middle two arguments specify the second point, and the last two arguments specify the third point.
      Overrides:
      triangle in class PGraphics
      Parameters:
      x1 - x-coordinate of the first point
      y1 - y-coordinate of the first point
      x2 - x-coordinate of the second point
      y2 - y-coordinate of the second point
      x3 - x-coordinate of the third point
      y3 - y-coordinate of the third point
      See Also:

    • quad

      public void quad(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
      Description copied from class: PGraphics
      A quad is a quadrilateral, a four sided polygon. It is similar to a rectangle, but the angles between its edges are not constrained to ninety degrees. The first pair of parameters (x1,y1) sets the first vertex and the subsequent pairs should proceed clockwise or counter-clockwise around the defined shape.
      Overrides:
      quad in class PGraphics
      Parameters:
      x1 - x-coordinate of the first corner
      y1 - y-coordinate of the first corner
      x2 - x-coordinate of the second corner
      y2 - y-coordinate of the second corner
      x3 - x-coordinate of the third corner
      y3 - y-coordinate of the third corner
      x4 - x-coordinate of the fourth corner
      y4 - y-coordinate of the fourth corner

    • box

      public void box(float w, float h, float d)
      Overrides:
      box in class PGraphics
      Parameters:
      w - dimension of the box in the x-dimension
      h - dimension of the box in the y-dimension
      d - dimension of the box in the z-dimension

    • sphere

      public void sphere(float r)
      Description copied from class: PGraphics
      A sphere is a hollow ball made from tessellated triangles.

      Advanced

      Implementation notes:

      cache all the points of the sphere in a static array top and bottom are just a bunch of triangles that land in the center point

      sphere is a series of concentric circles who radii vary along the shape, based on, err... cos or something 

       [toxi 031031] new sphere code. removed all multiplies with
 radius, as scale() will take care of that anyway

 [toxi 031223] updated sphere code (removed modulo)
 and introduced sphereAt(x,y,z,r)
 to avoid additional translate()'s on the user/sketch side

 [davbol 080801] now using separate sphereDetailU/V
      Overrides:
      sphere in class PGraphics
      Parameters:
      r - the radius of the sphere
      See Also:

    • bezierDetail

      public void bezierDetail(int detail)
      Ignored (not needed) in Java 2D.
      Overrides:
      bezierDetail in class PGraphics
      Parameters:
      detail - resolution of the curves
      See Also:

    • curveDetail

      public void curveDetail(int detail)
      Ignored (not needed) in Java 2D.
      Overrides:
      curveDetail in class PGraphics
      Parameters:
      detail - resolution of the curves
      See Also:

    • loadShape

      public PShape loadShape(String filename, String options)
      Overrides:
      loadShape in class PGraphics

    • textAscent

      public float textAscent()
      Description copied from class: PGraphics
      Returns ascent of the current font at its current size. This information is useful for determining the height of the font above the baseline.
      Overrides:
      textAscent in class PGraphics
      See Also:

    • textDescent

      public float textDescent()
      Description copied from class: PGraphics
      Returns descent of the current font at its current size. This information is useful for determining the height of the font below the baseline.
      Overrides:
      textDescent in class PGraphics
      See Also:

    • pushMatrix

      public void pushMatrix()
      Description copied from class: PGraphics
      Pushes the current transformation matrix onto the matrix stack. Understanding pushMatrix() and popMatrix() requires understanding the concept of a matrix stack. The pushMatrix() function saves the current coordinate system to the stack and popMatrix() restores the prior coordinate system. pushMatrix() and popMatrix() are used in conjunction with the other transformation functions and may be embedded to control the scope of the transformations.
      Overrides:
      pushMatrix in class PGraphics
      See Also:

    • popMatrix

      public void popMatrix()
      Description copied from class: PGraphics
      Pops the current transformation matrix off the matrix stack. Understanding pushing and popping requires understanding the concept of a matrix stack. The pushMatrix() function saves the current coordinate system to the stack and popMatrix() restores the prior coordinate system. pushMatrix() and popMatrix() are used in conjunction with the other transformation functions and may be embedded to control the scope of the transformations.
      Overrides:
      popMatrix in class PGraphics
      See Also:

    • translate

      public void translate(float tx, float ty)
      Description copied from class: PGraphics
      Specifies an amount to displace objects within the display window. The x parameter specifies left/right translation, the y parameter specifies up/down translation, and the z parameter specifies translations toward/away from the screen. Using this function with the z parameter requires using P3D as a parameter in combination with size as shown in the above example.

      Transformations are cumulative and apply to everything that happens after and subsequent calls to the function accumulates the effect. For example, calling translate(50, 0) and then translate(20, 0) is the same as translate(70, 0). If translate() is called within draw(), the transformation is reset when the loop begins again. This function can be further controlled by using pushMatrix() and popMatrix().

      Overrides:
      translate in class PGraphics
      Parameters:
      tx - left/right translation
      ty - up/down translation
      See Also:

    • rotate

      public void rotate(float angle)
      Description copied from class: PGraphics
      Rotates a shape the amount specified by the angle parameter. Angles should be specified in radians (values from 0 to TWO_PI) or converted to radians with the radians() function.

      Objects are always rotated around their relative position to the origin and positive numbers rotate objects in a clockwise direction. Transformations apply to everything that happens after and subsequent calls to the function accumulates the effect. For example, calling rotate(HALF_PI) and then rotate(HALF_PI) is the same as rotate(PI). All transformations are reset when draw() begins again.

      Technically, rotate() multiplies the current transformation matrix by a rotation matrix. This function can be further controlled by the pushMatrix() and popMatrix().
      Overrides:
      rotate in class PGraphics
      Parameters:
      angle - angle of rotation specified in radians
      See Also:

    • rotateX

      public void rotateX(float angle)
      Description copied from class: PGraphics
      Rotates a shape around the x-axis the amount specified by the angle parameter. Angles should be specified in radians (values from 0 to PI*2) or converted to radians with the radians() function. Objects are always rotated around their relative position to the origin and positive numbers rotate objects in a counterclockwise direction. Transformations apply to everything that happens after and subsequent calls to the function accumulates the effect. For example, calling rotateX(PI/2) and then rotateX(PI/2) is the same as rotateX(PI). If rotateX() is called within the draw(), the transformation is reset when the loop begins again. This function requires using P3D as a third parameter to size() as shown in the example above.
      Overrides:
      rotateX in class PGraphics
      Parameters:
      angle - angle of rotation specified in radians
      See Also:

    • rotateY

      public void rotateY(float angle)
      Description copied from class: PGraphics
      Rotates a shape around the y-axis the amount specified by the angle parameter. Angles should be specified in radians (values from 0 to PI*2) or converted to radians with the radians() function. Objects are always rotated around their relative position to the origin and positive numbers rotate objects in a counterclockwise direction. Transformations apply to everything that happens after and subsequent calls to the function accumulates the effect. For example, calling rotateY(PI/2) and then rotateY(PI/2) is the same as rotateY(PI). If rotateY() is called within the draw(), the transformation is reset when the loop begins again. This function requires using P3D as a third parameter to size() as shown in the examples above.
      Overrides:
      rotateY in class PGraphics
      Parameters:
      angle - angle of rotation specified in radians
      See Also:

    • rotateZ

      public void rotateZ(float angle)
      Description copied from class: PGraphics
      Rotates a shape around the z-axis the amount specified by the angle parameter. Angles should be specified in radians (values from 0 to PI*2) or converted to radians with the radians() function. Objects are always rotated around their relative position to the origin and positive numbers rotate objects in a counterclockwise direction. Transformations apply to everything that happens after and subsequent calls to the function accumulates the effect. For example, calling rotateZ(PI/2) and then rotateZ(PI/2) is the same as rotateZ(PI). If rotateZ() is called within the draw(), the transformation is reset when the loop begins again. This function requires using P3D as a third parameter to size() as shown in the examples above.
      Overrides:
      rotateZ in class PGraphics
      Parameters:
      angle - angle of rotation specified in radians
      See Also:

    • rotate

      public void rotate(float angle, float vx, float vy, float vz)
      Description copied from class: PGraphics

      Advanced

      Rotate about a vector in space. Same as the glRotatef() function.
      Overrides:
      rotate in class PGraphics

    • scale

      public void scale(float s)
      Description copied from class: PGraphics
      Increases or decreases the size of a shape by expanding and contracting vertices. Objects always scale from their relative origin to the coordinate system. Scale values are specified as decimal percentages. For example, the function call scale(2.0) increases the dimension of a shape by 200%.

      Transformations apply to everything that happens after and subsequent calls to the function multiply the effect. For example, calling scale(2.0) and then scale(1.5) is the same as scale(3.0). If scale() is called within draw(), the transformation is reset when the loop begins again. Using this function with the z parameter requires using P3D as a parameter for size(), as shown in the third example above. This function can be further controlled with pushMatrix() and popMatrix().
      Overrides:
      scale in class PGraphics
      Parameters:
      s - percentage to scale the object
      See Also:

    • scale

      public void scale(float sx, float sy)
      Description copied from class: PGraphics

      Advanced

      Scale in X and Y. Equivalent to scale(sx, sy, 1).

      Not recommended for use in 3D, because the z-dimension is just scaled by 1, since there's no way to know what else to scale it by.

      Overrides:
      scale in class PGraphics
      Parameters:
      sx - percentage to scale the object in the x-axis
      sy - percentage to scale the object in the y-axis

    • scale

      public void scale(float sx, float sy, float sz)
      Overrides:
      scale in class PGraphics
      sz - percentage to scale the object in the z-axis

    • shearX

      public void shearX(float angle)
      Description copied from class: PGraphics
      Shears a shape around the x-axis the amount specified by the angle parameter. Angles should be specified in radians (values from 0 to PI*2) or converted to radians with the radians() function. Objects are always sheared around their relative position to the origin and positive numbers shear objects in a clockwise direction. Transformations apply to everything that happens after and subsequent calls to the function accumulates the effect. For example, calling shearX(PI/2) and then shearX(PI/2) is the same as shearX(PI). If shearX() is called within the draw(), the transformation is reset when the loop begins again.

      Technically, shearX() multiplies the current transformation matrix by a rotation matrix. This function can be further controlled by the pushMatrix() and popMatrix() functions.
      Overrides:
      shearX in class PGraphics
      Parameters:
      angle - angle of shear specified in radians
      See Also:

    • shearY

      public void shearY(float angle)
      Description copied from class: PGraphics
      Shears a shape around the y-axis the amount specified by the angle parameter. Angles should be specified in radians (values from 0 to PI*2) or converted to radians with the radians() function. Objects are always sheared around their relative position to the origin and positive numbers shear objects in a clockwise direction. Transformations apply to everything that happens after and subsequent calls to the function accumulates the effect. For example, calling shearY(PI/2) and then shearY(PI/2) is the same as shearY(PI). If shearY() is called within the draw(), the transformation is reset when the loop begins again.

      Technically, shearY() multiplies the current transformation matrix by a rotation matrix. This function can be further controlled by the pushMatrix() and popMatrix() functions.
      Overrides:
      shearY in class PGraphics
      Parameters:
      angle - angle of shear specified in radians
      See Also:

    • resetMatrix

      public void resetMatrix()
      Description copied from class: PGraphics
      Replaces the current matrix with the identity matrix. The equivalent function in OpenGL is glLoadIdentity().
      Overrides:
      resetMatrix in class PGraphics
      See Also:

    • applyMatrix

      public void applyMatrix(float n00, float n01, float n02, float n10, float n11, float n12)
      Overrides:
      applyMatrix in class PGraphics
      Parameters:
      n00 - numbers which define the 4x4 matrix to be multiplied
      n01 - numbers which define the 4x4 matrix to be multiplied
      n02 - numbers which define the 4x4 matrix to be multiplied
      n10 - numbers which define the 4x4 matrix to be multiplied
      n11 - numbers which define the 4x4 matrix to be multiplied
      n12 - numbers which define the 4x4 matrix to be multiplied

    • applyMatrix

      public void applyMatrix(float n00, float n01, float n02, float n03, float n10, float n11, float n12, float n13, float n20, float n21, float n22, float n23, float n30, float n31, float n32, float n33)
      Overrides:
      applyMatrix in class PGraphics
      n03 - numbers which define the 4x4 matrix to be multiplied
      n13 - numbers which define the 4x4 matrix to be multiplied
      n20 - numbers which define the 4x4 matrix to be multiplied
      n21 - numbers which define the 4x4 matrix to be multiplied
      n22 - numbers which define the 4x4 matrix to be multiplied
      n23 - numbers which define the 4x4 matrix to be multiplied
      n30 - numbers which define the 4x4 matrix to be multiplied
      n31 - numbers which define the 4x4 matrix to be multiplied
      n32 - numbers which define the 4x4 matrix to be multiplied
      n33 - numbers which define the 4x4 matrix to be multiplied

    • getMatrix

      public PMatrix getMatrix()
      Overrides:
      getMatrix in class PGraphics

    • getMatrix

      public PMatrix2D getMatrix(PMatrix2D target)
      Description copied from class: PGraphics
      Copy the current transformation matrix into the specified target. Pass in null to create a new matrix.
      Overrides:
      getMatrix in class PGraphics

    • getMatrix

      public PMatrix3D getMatrix(PMatrix3D target)
      Description copied from class: PGraphics
      Copy the current transformation matrix into the specified target. Pass in null to create a new matrix.
      Overrides:
      getMatrix in class PGraphics

    • setMatrix

      public void setMatrix(PMatrix2D source)
      Description copied from class: PGraphics
      Set the current transformation to the contents of the specified source.
      Overrides:
      setMatrix in class PGraphics

    • setMatrix

      public void setMatrix(PMatrix3D source)
      Description copied from class: PGraphics
      Set the current transformation to the contents of the specified source.
      Overrides:
      setMatrix in class PGraphics

    • printMatrix

      public void printMatrix()
      Description copied from class: PGraphics
      Prints the current matrix to the Console (the text window at the bottom of Processing).
      Overrides:
      printMatrix in class PGraphics
      See Also:

    • screenX

      public float screenX(float x, float y)
      Description copied from class: PGraphics
      Takes a three-dimensional X, Y, Z position and returns the X value for where it will appear on a (two-dimensional) screen.
      Overrides:
      screenX in class PGraphics
      Parameters:
      x - 3D x-coordinate to be mapped
      y - 3D y-coordinate to be mapped
      See Also:

    • screenY

      public float screenY(float x, float y)
      Description copied from class: PGraphics
      Takes a three-dimensional X, Y, Z position and returns the Y value for where it will appear on a (two-dimensional) screen.
      Overrides:
      screenY in class PGraphics
      Parameters:
      x - 3D x-coordinate to be mapped
      y - 3D y-coordinate to be mapped
      See Also:

    • screenX

      public float screenX(float x, float y, float z)
      Overrides:
      screenX in class PGraphics
      z - 3D z-coordinate to be mapped

    • screenY

      public float screenY(float x, float y, float z)
      Overrides:
      screenY in class PGraphics
      z - 3D z-coordinate to be mapped

    • screenZ

      public float screenZ(float x, float y, float z)
      Description copied from class: PGraphics
      Takes a three-dimensional X, Y, Z position and returns the Z value for where it will appear on a (two-dimensional) screen.
      Overrides:
      screenZ in class PGraphics
      Parameters:
      x - 3D x-coordinate to be mapped
      y - 3D y-coordinate to be mapped
      z - 3D z-coordinate to be mapped
      See Also:

    • strokeCap

      public void strokeCap(int cap)
      Description copied from class: PGraphics
      Sets the style for rendering line endings. These ends are either squared, extended, or rounded, each of which specified with the corresponding parameters: SQUARE, PROJECT, and ROUND. The default cap is ROUND.

      To make point() appear square, use strokeCap(PROJECT). Using strokeCap(SQUARE) (no cap) causes points to become invisible.
      Overrides:
      strokeCap in class PGraphics
      Parameters:
      cap - either SQUARE, PROJECT, or ROUND
      See Also:

    • strokeJoin

      public void strokeJoin(int join)
      Description copied from class: PGraphics
      Sets the style of the joints which connect line segments. These joints are either mitered, beveled, or rounded and specified with the corresponding parameters MITER, BEVEL, and ROUND. The default joint is MITER.
      Overrides:
      strokeJoin in class PGraphics
      Parameters:
      join - either MITER, BEVEL, ROUND
      See Also:

    • strokeWeight

      public void strokeWeight(float weight)
      Description copied from class: PGraphics
      Sets the width of the stroke used for lines, points, and the border around shapes. All widths are set in units of pixels.

      Using point() with strokeWeight(1) or smaller may draw nothing to the screen, depending on the graphics settings of the computer. Workarounds include setting the pixel using set() or drawing the point using either circle() or square().
      Overrides:
      strokeWeight in class PGraphics
      Parameters:
      weight - the weight (in pixels) of the stroke
      See Also:

    • backgroundImpl

      public void backgroundImpl()

    • beginRaw

      public void beginRaw(PGraphics recorderRaw)
      Description copied from class: PGraphics
      Record individual lines and triangles by echoing them to another renderer.
      Overrides:
      beginRaw in class PGraphics

    • endRaw

      public void endRaw()
      Overrides:
      endRaw in class PGraphics

    • loadPixels

      public void loadPixels()
      Description copied from class: PImage
      Loads the pixel data of the current display window into the pixels[] array. This function must always be called before reading from or writing to pixels[]. Subsequent changes to the display window will not be reflected in pixels until loadPixels() is called again.

      Advanced

      Call this when you want to mess with the pixels[] array.

      For subclasses where the pixels[] buffer isn't set by default, this should copy all data into the pixels[] array

      Overrides:
      loadPixels in class PImage

    • updatePixels

      public void updatePixels(int x, int y, int c, int d)
      Update the pixels[] buffer to the PGraphics image.

      Unlike in PImage, where updatePixels() only requests that the update happens, in PGraphicsJava2D, this will happen immediately.

      Overrides:
      updatePixels in class PImage
      Parameters:
      x - x-coordinate of the upper-left corner
      y - y-coordinate of the upper-left corner
      c - width
      d - height

    • get

      public int get(int x, int y)
      Description copied from class: PImage
      Reads the color of any pixel or grabs a section of an image. If no parameters are specified, the entire image is returned. Use the x and y parameters to get the value of one pixel. Get a section of the display window by specifying an additional width and height parameter. When getting an image, the x and y parameters define the coordinates for the upper-left corner of the image, regardless of the current imageMode().

      If the pixel requested is outside the image window, black is returned. The numbers returned are scaled according to the current color ranges, but only RGB values are returned by this function. For example, even though you may have drawn a shape with colorMode(HSB), the numbers returned will be in RGB format.

      Getting the color of a single pixel with get(x, y) is easy, but not as fast as grabbing the data directly from pixels[]. The equivalent statement to get(x, y) using pixels[] is pixels[y*width+x]. See the reference for pixels[] for more information.

      Advanced

      Returns an ARGB "color" type (a packed 32-bit int) with the color. If the coordinate is outside the image, zero is returned (black, but completely transparent).

      If the image is in RGB format (i.e. on a PVideo object), the value will get its high bits set, just to avoid cases where they haven't been set already.

      If the image is in ALPHA format, this returns a white with its alpha value set.

      This function is included primarily for beginners. It is quite slow because it has to check to see if the x, y that was provided is inside the bounds, and then has to check to see what image type it is. If you want things to be more efficient, access the pixels[] array directly.

      Overrides:
      get in class PImage
      Parameters:
      x - x-coordinate of the pixel
      y - y-coordinate of the pixel
      See Also:

    • set

      public void set(int x, int y, int argb)
      Description copied from class: PImage
      Changes the color of any pixel or writes an image directly into the display window.

      The x and y parameters specify the pixel to change and the color parameter specifies the color value. The color parameter is affected by the current color mode (the default is RGB values from 0 to 255). When setting an image, the x and y parameters define the coordinates for the upper-left corner of the image, regardless of the current imageMode().

      Setting the color of a single pixel with set(x, y) is easy, but not as fast as putting the data directly into pixels[]. The equivalent statement to set(x, y, #000000) using pixels[] is pixels[y*width+x] = #000000. See the reference for pixels[] for more information.
      Overrides:
      set in class PImage
      Parameters:
      x - x-coordinate of the pixel
      y - y-coordinate of the pixel
      argb - any value of the color datatype
      See Also:

    • mask

      public void mask(int[] alpha)
      Overrides:
      mask in class PImage
      Parameters:
      alpha - array of integers used as the alpha channel, needs to be the same length as the image's pixel array.

    • mask

      public void mask(PImage alpha)
      Description copied from class: PImage
      Masks part of an image from displaying by loading another image and using it as an alpha channel. This mask image should only contain grayscale data, but only the blue color channel is used. The mask image needs to be the same size as the image to which it is applied.

      In addition to using a mask image, an integer array containing the alpha channel data can be specified directly. This method is useful for creating dynamically generated alpha masks. This array must be of the same length as the target image's pixels array and should contain only grayscale data of values between 0-255.

      Advanced

      Set alpha channel for an image. Black colors in the source image will make the destination image completely transparent, and white will make things fully opaque. Gray values will be in-between steps.

      Strictly speaking the "blue" value from the source image is used as the alpha color. For a fully grayscale image, this is correct, but for a color image it's not 100% accurate. For a more accurate conversion, first use filter(GRAY) which will make the image into a "correct" grayscale by performing a proper luminance-based conversion.

      Overrides:
      mask in class PImage
      Parameters:
      alpha - image to use as the mask

    • copy

      public void copy(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh)
      Description copied from class: PImage
      Copies a region of pixels from one image into another. If the source and destination regions aren't the same size, it will automatically resize source pixels to fit the specified target region. No alpha information is used in the process, however if the source image has an alpha channel set, it will be copied as well.

      As of release 0149, this function ignores imageMode().
      Overrides:
      copy in class PImage
      Parameters:
      sx - X coordinate of the source's upper left corner
      sy - Y coordinate of the source's upper left corner
      sw - source image width
      sh - source image height
      dx - X coordinate of the destination's upper left corner
      dy - Y coordinate of the destination's upper left corner
      dw - destination image width
      dh - destination image height
      See Also:

    • copy

      public void copy(PImage src, int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh)
      Overrides:
      copy in class PImage
      Parameters:
      src - an image variable referring to the source image.