processing.awt

Class PGraphicsJava2D

java.lang.Object

processing.core.PImage

processing.core.PGraphics

processing.awt.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 Summary

Fields

Modifier and Type	Field and Description
boolean	fillGradient
java.awt.Paint	fillGradientObject
java.awt.Graphics2D	g2
boolean	strokeGradient
java.awt.Paint	strokeGradientObject

Fields inherited from class processing.core.PGraphics

A, AB, AG, ambientB, ambientColor, ambientG, ambientR, AR, B, backgroundColor, BEEN_LIT, bezierDetail, colorMode, colorModeA, colorModeX, colorModeY, colorModeZ, curveDetail, curveTightness, DA, DB, DEFAULT_VERTICES, DG, DR, EB, edge, EDGE, EG, ellipseMode, emissiveB, emissiveColor, emissiveG, emissiveR, ER, fill, fillColor, G, HAS_NORMAL, image, imageMode, normalX, normalY, normalZ, NX, NY, NZ, pixelCount, R, rectMode, SA, SB, setAmbient, SG, shapeMode, SHINE, shininess, smooth, SPB, specularB, specularColor, specularG, specularR, SPG, sphereDetailU, sphereDetailV, SPR, SR, stroke, strokeCap, strokeColor, strokeJoin, strokeWeight, SW, textAlign, textAlignY, textFont, textLeading, textMode, textSize, textureImage, textureMode, textureU, textureV, tint, tintColor, TX, TY, TZ, U, V, VERTEX_FIELD_COUNT, VW, VX, VY, VZ

Fields inherited from class processing.core.PImage

ALPHA_MASK, BLUE_MASK, format, GREEN_MASK, height, loaded, parent, pixelDensity, pixelHeight, pixels, pixelWidth, RED_MASK, width

Fields inherited from interface processing.core.PConstants

ADD, ALPHA, ALT, AMBIENT, ARC, ARGB, ARROW, BACKSPACE, BASELINE, BEVEL, BEZIER_VERTEX, BLEND, BLUR, BOTTOM, BOX, BREAK, BURN, CENTER, CHATTER, CHORD, CLAMP, CLOSE, CODED, COMPLAINT, CONTROL, CORNER, CORNERS, CROSS, CURVE_VERTEX, CUSTOM, DARKEST, DEG_TO_RAD, DELETE, DIAMETER, DIFFERENCE, DILATE, DIRECTIONAL, DISABLE_ASYNC_SAVEFRAME, DISABLE_BUFFER_READING, DISABLE_DEPTH_MASK, DISABLE_DEPTH_SORT, DISABLE_DEPTH_TEST, DISABLE_KEY_REPEAT, DISABLE_NATIVE_FONTS, DISABLE_OPENGL_ERRORS, DISABLE_OPTIMIZED_STROKE, DISABLE_STROKE_PERSPECTIVE, DISABLE_STROKE_PURE, DISABLE_TEXTURE_MIPMAPS, DODGE, DOWN, DXF, ELLIPSE, ENABLE_ASYNC_SAVEFRAME, ENABLE_BUFFER_READING, ENABLE_DEPTH_MASK, ENABLE_DEPTH_SORT, ENABLE_DEPTH_TEST, ENABLE_KEY_REPEAT, ENABLE_NATIVE_FONTS, ENABLE_OPENGL_ERRORS, ENABLE_OPTIMIZED_STROKE, ENABLE_STROKE_PERSPECTIVE, ENABLE_STROKE_PURE, ENABLE_TEXTURE_MIPMAPS, ENTER, EPSILON, ERODE, ESC, EXCLUSION, FX2D, GIF, GRAY, GROUP, HALF_PI, HAND, HARD_LIGHT, HINT_COUNT, HSB, IMAGE, INVERT, JAVA2D, JPEG, LANDSCAPE, LEFT, LIGHTEST, LINE, LINE_LOOP, LINE_STRIP, LINES, LINUX, MACOSX, MAX_FLOAT, MAX_INT, MIN_FLOAT, MIN_INT, MITER, MODEL, MODELVIEW, MOVE, MULTIPLY, NORMAL, OPAQUE, OPEN, OPENGL, ORTHOGRAPHIC, OTHER, OVERLAY, P2D, P3D, PATH, PDF, PERSPECTIVE, PI, PIE, platformNames, POINT, POINTS, POLYGON, PORTRAIT, POSTERIZE, PROBLEM, PROJECT, PROJECTION, QUAD, QUAD_BEZIER_VERTEX, QUAD_STRIP, QUADRATIC_VERTEX, QUADS, QUARTER_PI, RAD_TO_DEG, RADIUS, RECT, REPEAT, REPLACE, RETURN, RGB, RIGHT, ROUND, SCREEN, SHAPE, SHIFT, SOFT_LIGHT, SPAN, SPHERE, SPOT, SQUARE, SUBTRACT, SVG, TAB, TARGA, TAU, TEXT, THIRD_PI, THRESHOLD, TIFF, TOP, TRIANGLE, TRIANGLE_FAN, TRIANGLE_STRIP, TRIANGLES, TWO_PI, UP, VERTEX, WAIT, WHITESPACE, WINDOWS, X, Y, Z

Constructor Summary

Constructors

Constructor and Description
PGraphicsJava2D()

Method Summary

Modifier and Type	Method and Description
void	applyMatrix(float n00, float n01, float n02, float n10, float n11, float n12)
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)
void	backgroundImpl() Actual implementation of clearing the background, now that the internal variables for background color have been set.
void	beginContour()
void	beginDraw() ( begin auto-generated from PGraphics_beginDraw.xml ) Sets the default properties for a PGraphics object.
void	beginRaw(PGraphics recorderRaw) Record individual lines and triangles by echoing them to another renderer.
void	beginShape(int kind) ( begin auto-generated from beginShape.xml ) Using the beginShape() and endShape() functions allow creating more complex forms.
void	bezierDetail(int detail) Ignored (not needed) in Java 2D.
void	bezierVertex(float x1, float y1, float x2, float y2, float x3, float y3)
void	bezierVertex(float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4) ( begin auto-generated from bezierVertex.xml ) Specifies vertex coordinates for Bezier curves.
void	box(float w, float h, float d)
java.awt.Graphics2D	checkImage()
void	copy(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh) ( begin auto-generated from PImage_copy.xml ) Copies a region of pixels from one image into another.
void	copy(PImage src, int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh)
PSurface	createSurface()
void	curveDetail(int detail) Ignored (not needed) in Java 2D.
void	curveVertex(float x, float y, float z)
void	endContour()
void	endDraw() ( begin auto-generated from PGraphics_endDraw.xml ) Finalizes the rendering of a PGraphics object so that it can be shown on screen.
void	endRaw()
void	endShape(int mode) ( begin auto-generated from endShape.xml ) The endShape() function is the companion to beginShape() and may only be called after beginShape().
int	get(int x, int y) ( begin auto-generated from PImage_get.xml ) Reads the color of any pixel or grabs a section of an image.
java.awt.Image	getImage() Still need a means to get the java.awt.Image object, since getNative() is going to return the Graphics2D object.
PMatrix	getMatrix()
PMatrix2D	getMatrix(PMatrix2D target) Copy the current transformation matrix into the specified target.
PMatrix3D	getMatrix(PMatrix3D target) Copy the current transformation matrix into the specified target.
java.lang.Object	getNative() Returns the java.awt.Graphics2D object used by this renderer.
void	hint(int which) ( begin auto-generated from hint.xml ) Set various hints and hacks for the renderer.
void	line(float x1, float y1, float x2, float y2) ( begin auto-generated from line.xml ) Draws a line (a direct path between two points) to the screen.
void	loadPixels() ( begin auto-generated from PImage_loadPixels.xml ) Loads the pixel data for the image into its pixels[] array.
PShape	loadShape(java.lang.String filename, java.lang.String options)
void	mask(int[] alpha)
void	mask(PImage alpha) ( 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.
void	noClip() ( begin auto-generated from noClip.xml ) Disables the clipping previously started by the clip() function.
void	point(float x, float y) ( begin auto-generated from point.xml ) Draws a point, a coordinate in space at the dimension of one pixel.
void	popMatrix() ( begin auto-generated from popMatrix.xml ) Pops the current transformation matrix off the matrix stack.
void	printMatrix() ( begin auto-generated from printMatrix.xml ) Prints the current matrix to the Console (the text window at the bottom of Processing).
void	pushMatrix() ( begin auto-generated from pushMatrix.xml ) Pushes the current transformation matrix onto the matrix stack.
void	quad(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4) ( begin auto-generated from quad.xml ) A quad is a quadrilateral, a four sided polygon.
void	quadraticVertex(float ctrlX, float ctrlY, float endX, float endY)
void	quadraticVertex(float x2, float y2, float z2, float x4, float y4, float z4)
void	resetMatrix() ( begin auto-generated from resetMatrix.xml ) Replaces the current matrix with the identity matrix.
void	rotate(float angle) ( begin auto-generated from rotate.xml ) Rotates a shape the amount specified by the angle parameter.
void	rotate(float angle, float vx, float vy, float vz) Advanced
void	rotateX(float angle) ( begin auto-generated from rotateX.xml ) Rotates a shape around the x-axis the amount specified by the angle parameter.
void	rotateY(float angle) ( begin auto-generated from rotateY.xml ) Rotates a shape around the y-axis the amount specified by the angle parameter.
void	rotateZ(float angle) ( begin auto-generated from rotateZ.xml ) Rotates a shape around the z-axis the amount specified by the angle parameter.
void	scale(float s) ( begin auto-generated from scale.xml ) Increases or decreases the size of a shape by expanding and contracting vertices.
void	scale(float sx, float sy) Advanced
void	scale(float sx, float sy, float sz)
float	screenX(float x, float y) ( begin auto-generated from screenX.xml ) Takes a three-dimensional X, Y, Z position and returns the X value for where it will appear on a (two-dimensional) screen.
float	screenX(float x, float y, float z)
float	screenY(float x, float y) ( begin auto-generated from screenY.xml ) Takes a three-dimensional X, Y, Z position and returns the Y value for where it will appear on a (two-dimensional) screen.
float	screenY(float x, float y, float z)
float	screenZ(float x, float y, float z) ( 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.
void	set(int x, int y, int argb) ( 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.
void	setMatrix(PMatrix2D source) Set the current transformation to the contents of the specified source.
void	setMatrix(PMatrix3D source) Set the current transformation to the contents of the specified source.
void	shearX(float angle) ( begin auto-generated from shearX.xml ) Shears a shape around the x-axis the amount specified by the angle parameter.
void	shearY(float angle) ( begin auto-generated from shearY.xml ) Shears a shape around the y-axis the amount specified by the angle parameter.
void	sphere(float r) ( begin auto-generated from sphere.xml ) A sphere is a hollow ball made from tessellated triangles.
void	strokeCap(int cap) ( begin auto-generated from strokeCap.xml ) Sets the style for rendering line endings.
void	strokeJoin(int join) ( begin auto-generated from strokeJoin.xml ) Sets the style of the joints which connect line segments.
void	strokeWeight(float weight) ( begin auto-generated from strokeWeight.xml ) Sets the width of the stroke used for lines, points, and the border around shapes.
float	textAscent() ( begin auto-generated from textAscent.xml ) Returns ascent of the current font at its current size.
float	textDescent() ( begin auto-generated from textDescent.xml ) Returns descent of the current font at its current size.
void	texture(PImage image) ( begin auto-generated from texture.xml ) Sets a texture to be applied to vertex points.
void	translate(float tx, float ty) ( begin auto-generated from translate.xml ) Specifies an amount to displace objects within the display window.
void	triangle(float x1, float y1, float x2, float y2, float x3, float y3) ( begin auto-generated from triangle.xml ) A triangle is a plane created by connecting three points.
void	updatePixels(int x, int y, int c, int d) Update the pixels[] buffer to the PGraphics image.
void	vertex(float[] v) Used by renderer subclasses or PShape to efficiently pass in already formatted vertex information.
void	vertex(float x, float y)
void	vertex(float x, float y, float z)
void	vertex(float x, float y, float u, float v)
void	vertex(float x, float y, float z, float u, float v) ( begin auto-generated from vertex.xml ) All shapes are constructed by connecting a series of vertices.

Methods inherited from class processing.core.PGraphics

alpha, ambient, ambient, ambient, ambientLight, ambientLight, applyMatrix, applyMatrix, applyMatrix, arc, arc, attrib, attrib, attrib, attribColor, attribNormal, attribPosition, background, background, background, background, background, background, background, beginCamera, beginPGL, beginShape, bezier, bezier, bezierPoint, bezierTangent, blendMode, blue, box, brightness, camera, camera, circle, clear, clip, color, color, color, color, color, color, color, color, color, colorMode, colorMode, colorMode, colorMode, createShape, createShape, createShape, curve, curve, curvePoint, curveTangent, curveTightness, curveVertex, directionalLight, displayable, dispose, edge, ellipse, ellipseMode, emissive, emissive, emissive, endCamera, endPGL, endShape, fill, fill, fill, fill, fill, fill, filter, flush, frustum, getCache, getRaw, getStyle, getStyle, green, haveRaw, hue, image, image, image, imageMode, is2D, is2X, is3D, isGL, lerpColor, lerpColor, lightFalloff, lights, lightSpecular, line, loadShader, loadShader, loadShape, modelX, modelY, modelZ, noFill, noLights, normal, noSmooth, noStroke, noTexture, noTint, ortho, ortho, ortho, perspective, perspective, point, pointLight, pop, popStyle, printCamera, printProjection, push, pushStyle, rect, rect, rect, rectMode, red, removeCache, resetShader, resetShader, saturation, save, setCache, setMatrix, setParent, setPath, setPrimary, setSize, shader, shader, shape, shape, shape, shapeMode, shininess, showDepthWarning, showDepthWarningXYZ, showException, showMethodWarning, showMissingWarning, showVariationWarning, showWarning, showWarning, smooth, smooth, specular, specular, specular, sphereDetail, sphereDetail, spotLight, square, stroke, stroke, stroke, stroke, stroke, stroke, style, text, text, text, text, text, text, text, text, text, text, text, textAlign, textAlign, textFont, textFont, textLeading, textMode, textSize, textureMode, textureWrap, textWidth, textWidth, textWidth, tint, tint, tint, tint, tint, tint, translate

Methods inherited from class processing.core.PImage

blend, blend, blendColor, clone, copy, filter, filter, get, get, getModifiedX1, getModifiedX2, getModifiedY1, getModifiedY2, init, init, isLoaded, isModified, resize, set, setLoaded, setLoaded, setModified, setModified, updatePixels

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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

createSurface

public PSurface createSurface()

Overrides:

createSurface in class PGraphics

getImage

public java.awt.Image getImage()

Still need a means to get the java.awt.Image object, since getNative() is going to return the Graphics2D object.

Overrides:

getImage in class PImage

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)

texture

public void texture(PImage image)

Description copied from class: PGraphics

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

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. ( end auto-generated )

Overrides:

texture in class PGraphics

Parameters:

image - reference to a PImage object

See Also:

PGraphics.textureMode(int), PGraphics.textureWrap(int), PGraphics.beginShape(int), PGraphics.endShape(int), PGraphics.vertex(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

vertex

public void vertex(float x,
                   float y,
                   float z,
                   float u,
                   float v)

Description copied from class: PGraphics

( begin auto-generated from vertex.xml ) 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 and is used exclusively within the beginShape() and endShape() function.

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 the 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(). ( end auto-generated )

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:

PGraphics.beginShape(int), PGraphics.endShape(int), PGraphics.bezierVertex(float, float, float, float, float, float, float, float, float), PGraphics.quadraticVertex(float, float, float, float, float, float), PGraphics.curveVertex(float, float, float), PGraphics.texture(PImage)

beginContour

public void beginContour()

Overrides:

beginContour in class PGraphics

endContour

public void endContour()

Overrides:

endContour 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 ctrlX,
                            float ctrlY,
                            float endX,
                            float endY)

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:

PGraphics.curveVertex(float, float, float), PGraphics.vertex(float, float, float, float, float), PGraphics.bezierVertex(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

See Also:

PGraphics.stroke(int)

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)

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:

PGraphics.curve(float, float, float, float, float, float, float, float, float, float, float, float), PGraphics.curveVertex(float, float, float), PGraphics.curveTightness(float)

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:

PGraphics.curve(float, float, float, float, float, float, float, float, float, float, float, float), PGraphics.curveVertex(float, float), PGraphics.curveTightness(float)

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()

pushMatrix

public void pushMatrix()

Description copied from class: PGraphics

( begin auto-generated from pushMatrix.xml ) 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 conjuction with the other transformation functions and may be embedded to control the scope of the transformations. ( end auto-generated )

Overrides:

pushMatrix in class PGraphics

See Also:

PGraphics.popMatrix(), PGraphics.translate(float, float, float), PGraphics.scale(float), PGraphics.rotate(float), PGraphics.rotateX(float), PGraphics.rotateY(float), PGraphics.rotateZ(float)

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)

resetMatrix

public void resetMatrix()

Description copied from class: PGraphics

( begin auto-generated from resetMatrix.xml ) Replaces the current matrix with the identity matrix. The equivalent function in OpenGL is glLoadIdentity(). ( end auto-generated )

Overrides:

resetMatrix in class PGraphics

See Also:

PGraphics.pushMatrix(), PGraphics.popMatrix(), PGraphics.applyMatrix(PMatrix), PGraphics.printMatrix()

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

( begin auto-generated from printMatrix.xml ) Prints the current matrix to the Console (the text window at the bottom of Processing). ( end auto-generated )

Overrides:

printMatrix in class PGraphics

See Also:

PGraphics.pushMatrix(), PGraphics.popMatrix(), PGraphics.resetMatrix(), PGraphics.applyMatrix(PMatrix)

screenX

public float screenX(float x,
                     float y)

Description copied from class: PGraphics

( begin auto-generated from screenX.xml ) Takes a three-dimensional X, Y, Z position and returns the X value for where it will appear on a (two-dimensional) screen. ( end auto-generated )

Overrides:

screenX in class PGraphics

Parameters:

x - 3D x-coordinate to be mapped

y - 3D y-coordinate to be mapped

See Also:

PGraphics.screenY(float, float, float), PGraphics.screenZ(float, float, float)

screenY

public float screenY(float x,
                     float y)

Description copied from class: PGraphics

( begin auto-generated from screenY.xml ) Takes a three-dimensional X, Y, Z position and returns the Y value for where it will appear on a (two-dimensional) screen. ( end auto-generated )

Overrides:

screenY in class PGraphics

Parameters:

x - 3D x-coordinate to be mapped

y - 3D y-coordinate to be mapped

See Also:

PGraphics.screenX(float, float, float), PGraphics.screenZ(float, float, float)

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)

strokeCap

public void strokeCap(int cap)

Description copied from class: PGraphics

( begin auto-generated from strokeCap.xml ) Sets the style for rendering line endings. These ends are either squared, extended, or rounded and specified with the corresponding parameters SQUARE, PROJECT, and ROUND. The default cap is ROUND.

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:

strokeCap in class PGraphics

Parameters:

cap - either SQUARE, PROJECT, or ROUND

See Also:

PGraphics.stroke(int, float), PGraphics.strokeWeight(float), PGraphics.strokeJoin(int), PApplet.size(int, int, String, String)

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

endRaw

public void endRaw()

Overrides:

endRaw 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)

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

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

( 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.