Documentation of 'processing.awt.PGraphicsJava2D' Java class
PGraphicsJava2D
Skip navigation links
processing.awt

Class PGraphicsJava2D

  • All Implemented Interfaces:
    java.lang.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 Detail

      • g2

        public java.awt.Graphics2D g2

      • fillGradient

        public boolean fillGradient

      • fillGradientObject

        public java.awt.Paint fillGradientObject

      • strokeGradient

        public boolean strokeGradient

      • strokeGradientObject

        public java.awt.Paint strokeGradientObject

    • Constructor Detail

      • PGraphicsJava2D

        public PGraphicsJava2D()

    • Method Detail

      • getNative

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

      • checkImage

        public java.awt.Graphics2D checkImage()

      • beginDraw

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

        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
        ( begin auto-generated from PGraphics_endDraw.xml ) Finalizes the rendering of a PGraphics object so that it can be shown on screen. ( end auto-generated )

        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
        ( begin auto-generated from hint.xml ) 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 downsampled 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 repeatedely, 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).

        As of release 0149, unhint() has been removed in favor of adding additional ENABLE/DISABLE constants to reset the default behavior. This prevents the double negatives, and also reinforces which hints can be enabled or disabled. ( end auto-generated )
        Overrides:
        hint in class PGraphics
        Parameters:
        which - name of the hint to be enabled or disabled
        See Also:
        PGraphics, PApplet.createGraphics(int, int, String, String), PApplet.size(int, int)

      • beginShape

        public void beginShape(int kind)
        Description copied from class: PGraphics
        ( begin auto-generated from beginShape.xml ) 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 MODE 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 P3D renderer settings allow stroke() and fill() settings to be altered per-vertex, however the default P2D renderer does not. Settings such as strokeWeight(), strokeCap(), and strokeJoin() cannot be changed while inside a beginShape()/endShape() block with any renderer. ( end auto-generated )
        Overrides:
        beginShape in class PGraphics
        Parameters:
        kind - Either POINTS, LINES, TRIANGLES, TRIANGLE_FAN, TRIANGLE_STRIP, QUADS, or QUAD_STRIP
        See Also:
        PShape, PGraphics.endShape(), PGraphics.vertex(float, float, float, float, float), PGraphics.curveVertex(float, float, float), PGraphics.bezierVertex(float, float, float, float, float, float, float, float, float)

      • 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

      • endShape

        public void endShape(int mode)
        Description copied from class: PGraphics
        ( begin auto-generated from endShape.xml ) The endShape() function is the companion to beginShape() and may only be called after beginShape(). When endshape() is called, all of 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). ( end auto-generated )
        Overrides:
        endShape in class PGraphics
        Parameters:
        mode - use CLOSE to close the shape
        See Also:
        PShape, PGraphics.beginShape(int)

      • noClip

        public void noClip()
        Description copied from class: PGraphics
        ( begin auto-generated from noClip.xml ) Disables the clipping previously started by the clip() function. ( end auto-generated )
        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
        ( begin auto-generated from bezierVertex.xml ) Specifies vertex coordinates for Bezier curves. Each call to bezierVertex() defines the position of two control points and one anchor point of a Bezier 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). ( end auto-generated )
        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:
        PGraphics.curveVertex(float, float, float), PGraphics.vertex(float, float, float, float, float), PGraphics.quadraticVertex(float, float, float, float, float, float), PGraphics.bezier(float, float, float, float, float, float, float, float, float, float, float, float)

      • 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
        ( begin auto-generated from point.xml ) 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. ( end auto-generated )
        Overrides:
        point in class PGraphics
        Parameters:
        x - x-coordinate of the point
        y - y-coordinate of the point

      • line

        public void line(float x1,
                 float y1,
                 float x2,
                 float y2)
        Description copied from class: PGraphics
        ( begin auto-generated from line.xml ) 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. ( end auto-generated )
        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:
        PGraphics.strokeWeight(float), PGraphics.strokeJoin(int), PGraphics.strokeCap(int), PGraphics.beginShape()

      • triangle

        public void triangle(float x1,
                     float y1,
                     float x2,
                     float y2,
                     float x3,
                     float y3)
        Description copied from class: PGraphics
        ( begin auto-generated from triangle.xml ) 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. ( end auto-generated )
        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:
        PApplet.beginShape()

      • 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
        ( begin auto-generated from quad.xml ) 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. ( end auto-generated )
        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
        ( begin auto-generated from sphere.xml ) A sphere is a hollow ball made from tessellated triangles. ( end auto-generated )

        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, er.. 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 modulos)
 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:
        PGraphics.sphereDetail(int)

      • loadShape

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

      • textAscent

        public float textAscent()
        Description copied from class: PGraphics
        ( begin auto-generated from textAscent.xml ) Returns ascent of the current font at its current size. This information is useful for determining the height of the font above the baseline. For example, adding the textAscent() and textDescent() values will give you the total height of the line. ( end auto-generated )
        Overrides:
        textAscent in class PGraphics
        See Also:
        PGraphics.textDescent()

      • textDescent

        public float textDescent()
        Description copied from class: PGraphics
        ( begin auto-generated from textDescent.xml ) Returns descent of the current font at its current size. This information is useful for determining the height of the font below the baseline. For example, adding the textAscent() and textDescent() values will give you the total height of the line. ( end auto-generated )
        Overrides:
        textDescent in class PGraphics
        See Also:
        PGraphics.textAscent()

      • popMatrix

        public void popMatrix()
        Description copied from class: PGraphics
        ( begin auto-generated from popMatrix.xml ) 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 conjuction with the other transformation functions and may be embedded to control the scope of the transformations. ( end auto-generated )
        Overrides:
        popMatrix in class PGraphics
        See Also:
        PGraphics.pushMatrix()

      • translate

        public void translate(float tx,
                      float ty)
        Description copied from class: PGraphics
        ( begin auto-generated from translate.xml ) 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 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 the pushMatrix() and popMatrix(). ( end auto-generated )
        Overrides:
        translate in class PGraphics
        Parameters:
        tx - left/right translation
        ty - up/down translation
        See Also:
        PGraphics.popMatrix(), PGraphics.pushMatrix(), PGraphics.rotate(float), PGraphics.rotateX(float), PGraphics.rotateY(float), PGraphics.rotateZ(float), PGraphics.scale(float, float, float)

      • rotate

        public void rotate(float angle)
        Description copied from class: PGraphics
        ( begin auto-generated from rotate.xml ) 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 tranformations 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(). ( end auto-generated )
        Overrides:
        rotate in class PGraphics
        Parameters:
        angle - angle of rotation specified in radians
        See Also:
        PGraphics.popMatrix(), PGraphics.pushMatrix(), PGraphics.rotateX(float), PGraphics.rotateY(float), PGraphics.rotateZ(float), PGraphics.scale(float, float, float), PApplet.radians(float)

      • rotateX

        public void rotateX(float angle)
        Description copied from class: PGraphics
        ( begin auto-generated from rotateX.xml ) 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. ( end auto-generated )
        Overrides:
        rotateX in class PGraphics
        Parameters:
        angle - angle of rotation specified in radians
        See Also:
        PGraphics.popMatrix(), PGraphics.pushMatrix(), PGraphics.rotate(float), PGraphics.rotateY(float), PGraphics.rotateZ(float), PGraphics.scale(float, float, float), PGraphics.translate(float, float, float)

      • rotateY

        public void rotateY(float angle)
        Description copied from class: PGraphics
        ( begin auto-generated from rotateY.xml ) 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. ( end auto-generated )
        Overrides:
        rotateY in class PGraphics
        Parameters:
        angle - angle of rotation specified in radians
        See Also:
        PGraphics.popMatrix(), PGraphics.pushMatrix(), PGraphics.rotate(float), PGraphics.rotateX(float), PGraphics.rotateZ(float), PGraphics.scale(float, float, float), PGraphics.translate(float, float, float)

      • rotateZ

        public void rotateZ(float angle)
        Description copied from class: PGraphics
        ( begin auto-generated from rotateZ.xml ) 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. ( end auto-generated )
        Overrides:
        rotateZ in class PGraphics
        Parameters:
        angle - angle of rotation specified in radians
        See Also:
        PGraphics.popMatrix(), PGraphics.pushMatrix(), PGraphics.rotate(float), PGraphics.rotateX(float), PGraphics.rotateY(float), PGraphics.scale(float, float, float), PGraphics.translate(float, float, float)

      • 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
        ( begin auto-generated from scale.xml ) 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 fuction with the z parameter requires using P3D as a parameter for size() as shown in the example above. This function can be further controlled by pushMatrix() and popMatrix(). ( end auto-generated )
        Overrides:
        scale in class PGraphics
        Parameters:
        s - percentage to scale the object
        See Also:
        PGraphics.pushMatrix(), PGraphics.popMatrix(), PGraphics.translate(float, float, float), PGraphics.rotate(float), PGraphics.rotateX(float), PGraphics.rotateY(float), PGraphics.rotateZ(float)

      • 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
        ( begin auto-generated from shearX.xml ) 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. ( end auto-generated )
        Overrides:
        shearX in class PGraphics
        Parameters:
        angle - angle of shear specified in radians
        See Also:
        PGraphics.popMatrix(), PGraphics.pushMatrix(), PGraphics.shearY(float), PGraphics.scale(float, float, float), PGraphics.translate(float, float, float), PApplet.radians(float)

      • shearY

        public void shearY(float angle)
        Description copied from class: PGraphics
        ( begin auto-generated from shearY.xml ) 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. ( end auto-generated )
        Overrides:
        shearY in class PGraphics
        Parameters:
        angle - angle of shear specified in radians
        See Also:
        PGraphics.popMatrix(), PGraphics.pushMatrix(), PGraphics.shearX(float), PGraphics.scale(float, float, float), PGraphics.translate(float, float, float), PApplet.radians(float)

      • 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 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

      • 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
        ( begin auto-generated from screenZ.xml ) Takes a three-dimensional X, Y, Z position and returns the Z value for where it will appear on a (two-dimensional) screen. ( end auto-generated )
        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:
        PGraphics.screenX(float, float, float), PGraphics.screenY(float, float, float)

      • strokeJoin

        public void strokeJoin(int join)
        Description copied from class: PGraphics
        ( begin auto-generated from strokeJoin.xml ) 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.

        This function is not available with the P3D renderer, (see Issue 123). More information about the renderers can be found in the size() reference. ( end auto-generated )
        Overrides:
        strokeJoin in class PGraphics
        Parameters:
        join - either MITER, BEVEL, ROUND
        See Also:
        PGraphics.stroke(int, float), PGraphics.strokeWeight(float), PGraphics.strokeCap(int)

      • strokeWeight

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

        When drawing with P3D, series of connected lines (such as the stroke around a polygon, triangle, or ellipse) produce unattractive results when a thick stroke weight is set (see Issue 123). With P3D, the minimum and maximum values for strokeWeight() are controlled by the graphics card and the operating system's OpenGL implementation. For instance, the thickness may not go higher than 10 pixels. ( end auto-generated )
        Overrides:
        strokeWeight in class PGraphics
        Parameters:
        weight - the weight (in pixels) of the stroke
        See Also:
        PGraphics.stroke(int, float), PGraphics.strokeJoin(int), PGraphics.strokeCap(int)

      • backgroundImpl

        public void backgroundImpl()
        Description copied from class: PGraphics
        Actual implementation of clearing the background, now that the internal variables for background color have been set. Called by the backgroundFromCalc() method, which is what all the other background() methods call once the work is done.

      • 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

      • loadPixels

        public void loadPixels()
        Description copied from class: PImage
        ( begin auto-generated from PImage_loadPixels.xml ) Loads the pixel data for the image into its pixels[] array. This function must always be called before reading from or writing to pixels[].

        renderers may or may not seem to require loadPixels() or updatePixels(). However, the rule is that any time you want to manipulate the pixels[] array, you must first call loadPixels(), and after changes have been made, call updatePixels(). Even if the renderer may not seem to use this function in the current Processing release, this will always be subject to change. ( end auto-generated )

        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
        ( begin auto-generated from PImage_get.xml ) 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 of 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. ( end auto-generated )

        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:
        PApplet.set(int, int, int), PApplet.pixels, PApplet.copy(PImage, int, int, int, int, int, int, int, int)

      • get

        public PImage get()
        Description copied from class: PImage
        Returns a copy of this PImage. Equivalent to get(0, 0, width, height). Deprecated, just use copy() instead.
        Overrides:
        get in class PImage

      • set

        public void set(int x,
                int y,
                int argb)
        Description copied from class: PImage
        ( begin auto-generated from PImage_set.xml ) 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. ( end auto-generated )
        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:
        PImage.get(int, int, int, int), PImage.pixels, PImage.copy(PImage, int, int, int, int, int, int, int, int)

      • mask

        public void mask(int[] alpha)
        Overrides:
        mask in class PImage

      • mask

        public void mask(PImage alpha)
        Description copied from class: PImage
        ( begin auto-generated from PImage_mask.xml ) 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. ( end auto-generated )

        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
        ( begin auto-generated from PImage_copy.xml ) 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(). ( end auto-generated )
        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:
        PGraphics.alpha(int), PImage.blend(PImage, int, int, int, int, int, int, int, int, int)

      • 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.
Skip navigation links

DataMelt 3.0 © DataMelt by jWork.ORG

You see the box below because you did not login.