Package processing.core

Class PApplet

java.lang.Object

processing.core.PApplet

All Implemented Interfaces:

PConstants

public class PApplet
extends Object
implements PConstants

Base class for all sketches that use processing.core.

The Window Size and Full Screen page on the Wiki has useful information about sizing, multiple displays, full screen, etc.

Processing uses active mode rendering. All animation tasks happen on the "Processing Animation Thread". The setup() and draw() methods are handled by that thread, and events (like mouse movement and key presses, which are fired by the event dispatch thread or EDT) are queued to be safely handled at the end of draw().

Starting with 3.0a6, blit operations are on the EDT, so as not to cause GUI problems with Swing and AWT. In the case of the default renderer, the sketch renders to an offscreen image, then the EDT is asked to bring that image to the screen.

For code that needs to run on the EDT, use EventQueue.invokeLater(). When doing so, be careful to synchronize between that code and the Processing animation thread. That is, you can't call Processing methods from the EDT or at any random time from another thread. Use of a callback function or the registerXxx() methods in PApplet can help ensure that your code doesn't do something naughty.

As of Processing 3.0, we have removed Applet as the base class for PApplet. This means that we can remove lots of legacy code, however one downside is that it's no longer possible (without extra code) to embed a PApplet into another Java application.

As of Processing 3.0, we have discontinued support for versions of Java prior to 1.8. We don't have enough people to support it, and for a project of our (tiny) size, we should be focusing on the future, rather than working around legacy Java code.

Field Summary

Fields

Modifier and Type	Field	Description
String[]	args	Command line options passed in from main().
static final String	ARGS_BGCOLOR
static final String	ARGS_DISABLE_AWT	Disable AWT so that LWJGL and others can run
static final String	ARGS_DISPLAY	Used by the PDE to suggest a display (set in prefs, passed on Run)
static final String	ARGS_EDITOR_LOCATION	Position of the upper left-hand corner of the editor window that launched this sketch.
static final String	ARGS_EXTERNAL
static final String	ARGS_FULL_SCREEN
static final String	ARGS_HIDE_STOP
static final String	ARGS_LOCATION	Location for where to position the sketch window on screen.
static final String	ARGS_PRESENT
static final String	ARGS_SKETCH_FOLDER	Allows the user or PdeEditor to set a specific sketch folder path.
static final String	ARGS_STOP_COLOR
static final String	ARGS_UI_SCALE
static final String	ARGS_WINDOW_COLOR
static final int	DEFAULT_HEIGHT
static final int	DEFAULT_WIDTH	Default width and height for sketch when not specified
int	displayHeight	System variable that stores the height of the computer screen.
int	displayWidth	System variable that stores the width of the computer screen.
static final String	EXTERNAL_MOVE	When run externally to a PDE Editor, this is sent by the sketch whenever the window is moved.
static final String	EXTERNAL_STOP	When run externally to a PdeEditor, this is sent by the sketch when it quits.
boolean	finished	true if the sketch has stopped permanently.
boolean	firstMouse	Deprecated. Please refrain from using this variable, it will be removed from future releases of Processing because it cannot be used consistently across platforms and input methods.
boolean	focused	Confirms if a Processing program is "focused", meaning that it is active and will accept input from mouse or keyboard.
int	frameCount	The system variable frameCount contains the number o frames displayed since the program started.
float	frameRate	The system variable frameRate contains the approximate frame rate of the software as it executes.
PGraphics	g	The PGraphics renderer associated with this PApplet
int	height	System variable which stores the height of the display window.
static final int	javaPlatform
static final float	javaVersion	Deprecated.
static final String	javaVersionName	Full name of the Java version (i.e.
char	key	The system variable key always contains the value of the most recent key on the keyboard that was used (either pressed or released).
int	keyCode	The variable keyCode is used to detect special keys such as the UP, DOWN, LEFT, RIGHT arrow keys and ALT, CONTROL, SHIFT.
KeyEvent	keyEvent	Deprecated. Use a key event handler that passes an event instead.
boolean	keyPressed	The boolean system variable keyPressed is true if any key is pressed and false if no keys are pressed.
int	mouseButton	When a mouse button is pressed, the value of the system variable mouseButton is set to either LEFT, RIGHT, or CENTER, depending on which button is pressed.
MouseEvent	mouseEvent	Deprecated. Use a mouse event handler that passes an event instead.
boolean	mousePressed	The mousePressed variable stores whether a mouse button has been pressed.
int	mouseX	The system variable mouseX always contains the current horizontal coordinate of the mouse.
int	mouseY	The system variable mouseY always contains the current vertical coordinate of the mouse.
int	pixelDensity
int	pixelHeight	When pixelDensity(2) is used to make use of a high resolution display (called a Retina display on OS X or high-dpi on Windows and Linux), the width and height of the sketch do not change, but the number of pixels is doubled.
int[]	pixels	The pixels[] array contains the values for all the pixels in the display window.
int	pixelWidth	When pixelDensity(2) is used to make use of a high resolution display (called a Retina display on OS X or high-dpi on Windows and Linux), the width and height of the sketch do not change, but the number of pixels is doubled.
static int	platform	Current platform in use, one of the PConstants WINDOWS, MACOS, LINUX or OTHER.
int	pmouseX	The system variable pmouseX always contains the horizontal position of the mouse in the frame previous to the current frame. You may find that pmouseX and pmouseY have different values when referenced inside of draw() and inside of mouse events like mousePressed() and mouseMoved().
int	pmouseY	The system variable pmouseY always contains the vertical position of the mouse in the frame previous to the current frame.
float	ratioLeft	Offset from left when windowRatio is in use.
float	ratioScale	Amount of scaling to be applied for the window ratio.
float	ratioTop	Offset from the top when windowRatio is in use.
PGraphics	recorder	A leech graphics object that is echoing all events.
int	rheight
int	rmouseX	Version of mouseX/mouseY to use with windowRatio().
int	rmouseY
int	rwidth	Version of width/height to use with windowRatio().
static boolean	useNativeSelect	Whether to use native (AWT) dialogs for selectInput and selectOutput.
int	width	System variable which stores the width of the display window.
int	windowX
int	windowY

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, MACOS, 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	Description
PApplet()

Method Summary

Modifier and Type	Method	Description
static final float	abs(float n)	Calculates the absolute value (magnitude) of a number.
static final int	abs(int n)
static final float	acos(float value)	The inverse of cos(), returns the arc cosine of a value.
final float	alpha(int rgb)	Extracts the alpha value from a color.
void	ambient(float gray)
void	ambient(float v1, float v2, float v3)
void	ambient(int rgb)	Sets the ambient reflectance for shapes drawn to the screen.
void	ambientLight(float v1, float v2, float v3)	Adds an ambient light.
void	ambientLight(float v1, float v2, float v3, float x, float y, float z)
static byte[]	append(byte[] array, byte value)	Expands an array by one element and adds data to the new position.
static char[]	append(char[] array, char value)
static float[]	append(float[] array, float value)
static int[]	append(int[] array, int value)
static Object	append(Object array, Object value)
static String[]	append(String[] array, String value)
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	applyMatrix(PMatrix source)	Multiplies the current matrix by the one specified through the parameters.
void	applyMatrix(PMatrix2D source)
void	applyMatrix(PMatrix3D source)
void	arc(float a, float b, float c, float d, float start, float stop)	Draws an arc to the screen.
void	arc(float a, float b, float c, float d, float start, float stop, int mode)
static void	arraycopy(Object src, int srcPosition, Object dst, int dstPosition, int length)	Deprecated.
static void	arraycopy(Object src, Object dst)	Deprecated.
static void	arraycopy(Object src, Object dst, int length)	Deprecated.
static void	arrayCopy(Object src, int srcPosition, Object dst, int dstPosition, int length)	Copies an array (or part of an array) to another array.
static void	arrayCopy(Object src, Object dst)	Shortcut to copy the entire contents of the source into the destination array.
static void	arrayCopy(Object src, Object dst, int length)	Convenience method for arraycopy().
static final float	asin(float value)	The inverse of sin(), returns the arc sine of a value.
static final float	atan(float value)	The inverse of tan(), returns the arc tangent of a value.
static final float	atan2(float y, float x)	Calculates the angle (in radians) from a specified point to the coordinate origin as measured from the positive x-axis.
void	attrib(String name, boolean... values)
void	attrib(String name, float... values)
void	attrib(String name, int... values)
void	attribColor(String name, int color)
void	attribNormal(String name, float nx, float ny, float nz)
void	attribPosition(String name, float x, float y, float z)
void	background(float gray)
void	background(float gray, float alpha)
void	background(float v1, float v2, float v3)
void	background(float v1, float v2, float v3, float alpha)
void	background(int rgb)	The background() function sets the color used for the background of the Processing window.
void	background(int rgb, float alpha)
void	background(PImage image)	Takes an RGB or ARGB image and sets it as the background.
void	beginCamera()	The beginCamera() and endCamera() functions enable advanced customization of the camera space.
void	beginContour()	Use the beginContour() and endContour() function to create negative shapes within shapes such as the center of the letter "O".
PGL	beginPGL()
PGraphics	beginRaw(String renderer, String filename)	To create vectors from 3D data, use the beginRaw() and endRaw() commands.
void	beginRaw(PGraphics rawGraphics)
PGraphics	beginRecord(String renderer, String filename)	Opens a new file and all subsequent drawing functions are echoed to this file as well as the display window.
void	beginRecord(PGraphics recorder)
void	beginShape()	Start a new shape of type POLYGON
void	beginShape(int kind)	Using the beginShape() and endShape() functions allow creating more complex forms.
void	bezier(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
void	bezier(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4)	Draws a Bézier curve on the screen.
void	bezierDetail(int detail)	Sets the resolution at which Bézier curves display.
float	bezierPoint(float a, float b, float c, float d, float t)	Evaluates the Bezier at point t for points a, b, c, d.
float	bezierTangent(float a, float b, float c, float d, float t)	Calculates the tangent of a point on a Bézier curve.
void	bezierVertex(float x2, float y2, float x3, float y3, float x4, float y4)
void	bezierVertex(float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4)	Specifies vertex coordinates for Bézier curves.
static final String	binary(byte value)	Returns a String that contains the binary value of a byte.
static final String	binary(char value)	Returns a String that contains the binary value of a char.
static final String	binary(int value)	Returns a String that contains the binary value of an int.
static final String	binary(int value, int digits)	Converts an int, byte, char, or color to a String containing the equivalent binary notation.
void	blend(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, int mode)
void	blend(PImage src, int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, int mode)	Blends a region of pixels into the image specified by the img parameter.
static int	blendColor(int c1, int c2, int mode)
void	blendMode(int mode)	Blends the pixels in the display window according to a defined mode.
final float	blue(int rgb)	Extracts the blue value from a color, scaled to match current colorMode().
void	box(float size)	A box is an extruded rectangle.
void	box(float w, float h, float d)
final float	brightness(int rgb)	Extracts the brightness value from a color.
void	camera()	Sets the position of the camera through setting the eye position, the center of the scene, and which axis is facing upward.
void	camera(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ)
static final int	ceil(float n)	Calculates the closest int value that is greater than or equal to the value of the parameter.
void	checkAlpha()	Check the alpha on an image, using a really primitive loop.
static String	checkExtension(String filename)	Get the compression-free extension for this filename.
final int	choice(int high)	Return a random integer from 0 up to (but not including) the specified value for “high”.
final int	choice(int low, int high)	Return a random integer from “low” up to (but not including) the specified value for “high”.
void	circle(float x, float y, float extent)	Draws a circle to the screen.
void	clear()	Clears the pixels within a buffer.
void	clip(float a, float b, float c, float d)	Limits the rendering to the boundaries of a rectangle defined by the parameters.
final int	color(float fgray)
final int	color(float fgray, float falpha)
final int	color(float v1, float v2, float v3)
final int	color(float v1, float v2, float v3, float alpha)
final int	color(int gray)	Creates colors for storing in variables of the color datatype.
final int	color(int gray, int alpha)	As of 0116 this also takes color(#FF8800, alpha)
final int	color(int v1, int v2, int v3)
final int	color(int v1, int v2, int v3, int alpha)
void	colorMode(int mode)	Changes the way Processing interprets color data.
void	colorMode(int mode, float max)
void	colorMode(int mode, float max1, float max2, float max3)
void	colorMode(int mode, float max1, float max2, float max3, float maxA)
static boolean[]	concat(boolean[] a, boolean[] b)	Concatenates two arrays.
static byte[]	concat(byte[] a, byte[] b)
static char[]	concat(char[] a, char[] b)
static float[]	concat(float[] a, float[] b)
static int[]	concat(int[] a, int[] b)
static Object	concat(Object a, Object b)
static String[]	concat(String[] a, String[] b)
static final float	constrain(float amt, float low, float high)	Constrains a value to not exceed a maximum and minimum value.
static final int	constrain(int amt, int low, int high)
PImage	copy()
void	copy(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh)	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)
static final float	cos(float angle)	Calculates the cosine of an angle.
PFont	createFont(String name, float size)
PFont	createFont(String name, float size, boolean smooth)
PFont	createFont(String name, float size, boolean smooth, char[] charset)	Dynamically converts a font to the format used by Processing from a .ttf or .otf file inside the sketch's "data" folder or a font that's installed elsewhere on the computer.
PGraphics	createGraphics(int w, int h)
PGraphics	createGraphics(int w, int h, String renderer)	Creates and returns a new PGraphics object.
PGraphics	createGraphics(int w, int h, String renderer, String path)	Create an offscreen graphics surface for drawing, in this case for a renderer that writes to a file (such as PDF or DXF).
PImage	createImage(int w, int h, int format)	Creates a new PImage (the datatype for storing images).
static InputStream	createInput(File file)
InputStream	createInput(String filename)	This is a function for advanced programmers to open a Java InputStream.
InputStream	createInputRaw(String filename)	Call openStream() without automatic gzip decompression.
static OutputStream	createOutput(File file)
OutputStream	createOutput(String filename)	Similar to createInput(), this creates a Java OutputStream for a given filename or path.
static void	createPath(File file)
static void	createPath(String path)	Takes a path and creates any in-between folders if they don't already exist.
static BufferedReader	createReader(File file)
static BufferedReader	createReader(InputStream input)
BufferedReader	createReader(String filename)	Creates a BufferedReader object that can be used to read files line-by-line as individual String objects.
PShape	createShape()	The createShape() function is used to define a new shape.
PShape	createShape(int type)
PShape	createShape(int kind, float... p)
static PrintWriter	createWriter(File file)
static PrintWriter	createWriter(OutputStream output)
PrintWriter	createWriter(String filename)	Creates a new file in the sketch folder, and a PrintWriter object to write to it.
void	cursor()	Show the cursor after noCursor() was called.
void	cursor(int kind)	Set the cursor type
void	cursor(PImage img)	Replace the cursor with the specified PImage.
void	cursor(PImage img, int x, int y)	Sets the cursor to a predefined symbol or an image, or makes it visible if already hidden.
void	curve(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)	Draws a curved line on the screen.
void	curve(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4)
void	curveDetail(int detail)	Sets the resolution at which curves display.
float	curvePoint(float a, float b, float c, float d, float t)	Evaluates the curve at point t for points a, b, c, d.
float	curveTangent(float a, float b, float c, float d, float t)	Calculates the tangent of a point on a curve.
void	curveTightness(float tightness)	Modifies the quality of forms created with curve() and curveVertex().
void	curveVertex(float x, float y)	Specifies vertex coordinates for curves.
void	curveVertex(float x, float y, float z)
File	dataFile(String where)	Return a full path to an item in the data folder as a File object.
String	dataPath(String where)	This function almost certainly does not do the thing you want it to. The data path is handled differently on each platform, and should not be considered a location to write files.
static int	day()	Processing communicates with the clock on your computer.
static void	debug(String msg)
static final float	degrees(float radians)	Converts a radian measurement to its corresponding value in degrees.
void	delay(int napTime)	The delay() function causes the program to halt for a specified time.
static File	desktopFile(String what)
static String	desktopPath(String what)
void	die(String what)	Function for an application to kill itself and display an error.
void	die(String what, Exception e)	Same as above but with an exception.
void	directionalLight(float v1, float v2, float v3, float nx, float ny, float nz)	Adds a directional light.
int	displayDensity()	This function returns the number "2" if the screen is a high-density screen (called a Retina display on OS X or high-dpi on Windows and Linux) and a "1" if not.
int	displayDensity(int display)
void	dispose()	Called to dispose of resources and shut down the sketch.
static final float	dist(float x1, float y1, float x2, float y2)
static final float	dist(float x1, float y1, float z1, float x2, float y2, float z2)	Calculates the distance between two points.
void	draw()	Called directly after setup(), the draw() function continuously executes the lines of code contained inside its block until the program is stopped or noLoop() is called.
void	edge(boolean edge)	Sets whether the upcoming vertex is part of an edge.
void	ellipse(float a, float b, float c, float d)	Draws an ellipse (oval) to the screen.
void	ellipseMode(int mode)	Modifies the location from which ellipses are drawn by changing the way in which parameters given to ellipse() are interpreted. The default mode is ellipseMode(CENTER), which interprets the first two parameters of ellipse() as the shape's center point, while the third and fourth parameters are its width and height. ellipseMode(RADIUS) also uses the first two parameters of ellipse() as the shape's center point, but uses the third and fourth parameters to specify half of the shape's width and height. ellipseMode(CORNER) interprets the first two parameters of ellipse() as the upper-left corner of the shape, while the third and fourth parameters are its width and height. ellipseMode(CORNERS) interprets the first two parameters of ellipse() as the location of one corner of the ellipse's bounding box, and the third and fourth parameters as the location of the opposite corner. The parameter must be written in ALL CAPS because Processing is a case-sensitive language.
void	emissive(float gray)	gray number specifying value between white and black
void	emissive(float v1, float v2, float v3)
void	emissive(int rgb)	Sets the emissive color of the material used for drawing shapes drawn to the screen.
void	endCamera()	The beginCamera() and endCamera() functions enable advanced customization of the camera space.
void	endContour()	Use the beginContour() and endContour() function to create negative shapes within shapes such as the center of the letter "O".
void	endPGL()
void	endRaw()	Complement to beginRaw(); they must always be used together.
void	endRecord()	Stops the recording process started by beginRecord() and closes the file.
void	endShape()
void	endShape(int mode)	The endShape() function is the companion to beginShape() and may only be called after beginShape().
static Process	exec(String... args)	Pass a set of arguments directly to the command line.
static int	exec(StringList stdout, StringList stderr, String... args)	Alternative version of exec() that retrieves stdout and stderr into the StringList objects provided.
void	exit()	Quits/stops/exits the program.
void	exitActual()	Some subclasses (I'm looking at you, processing.py) might wish to do something other than actually terminate the JVM.
boolean	exitCalled()
static final float	exp(float n)	Returns Euler's number e (2.71828...) raised to the power of the value parameter.
static boolean[]	expand(boolean[] list)	Increases the size of a one-dimensional array.
static boolean[]	expand(boolean[] list, int newSize)
static byte[]	expand(byte[] list)
static byte[]	expand(byte[] list, int newSize)
static char[]	expand(char[] list)
static char[]	expand(char[] list, int newSize)
static double[]	expand(double[] list)
static double[]	expand(double[] list, int newSize)
static float[]	expand(float[] list)
static float[]	expand(float[] list, int newSize)
static int[]	expand(int[] list)
static int[]	expand(int[] list, int newSize)
static long[]	expand(long[] list)
static long[]	expand(long[] list, int newSize)
static Object	expand(Object array)
static Object	expand(Object list, int newSize)
static String[]	expand(String[] list)
static String[]	expand(String[] list, int newSize)
void	fill(float gray)
void	fill(float gray, float alpha)
void	fill(float v1, float v2, float v3)
void	fill(float v1, float v2, float v3, float alpha)
void	fill(int rgb)	Sets the color used to fill shapes.
void	fill(int rgb, float alpha)
void	filter(int kind)
void	filter(int kind, float param)	Filters the image as defined by one of the following modes: THRESHOLD Converts the image to black and white pixels depending on if they are above or below the threshold defined by the level parameter.
void	filter(PShader shader)
static final int	floor(float n)	Calculates the closest int value that is less than or equal to the value of the parameter.
void	flush()
void	focusGained()
void	focusLost()
void	frameMoved(int newX, int newY)	When running from the PDE, this saves the window position for next time the sketch is run.
void	frameRate(float fps)	Specifies the number of frames to be displayed every second.
void	frustum(float left, float right, float bottom, float top, float near, float far)	Sets a perspective matrix as defined by the parameters. A frustum is a geometric form: a pyramid with its top cut off.
void	fullScreen()	Create a full-screen sketch using the default renderer.
void	fullScreen(int display)
void	fullScreen(String renderer)	This function is new for Processing 3.0.
void	fullScreen(String renderer, int display)
PImage	get()	Returns a copy of this PImage.
int	get(int x, int y)	Reads the color of any pixel or grabs a section of an image.
PImage	get(int x, int y, int w, int h)
static String	getExtension(String filename)
PGraphics	getGraphics()
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.
PSurface	getSurface()
final float	green(int rgb)	Extracts the green value from a color, scaled to match current colorMode().
void	handleDraw()
static final String	hex(byte value)	Converts an int, byte, char, or color to a String containing the equivalent hexadecimal notation.
static final String	hex(char value)
static final String	hex(int value)
static final String	hex(int value, int digits)
static void	hideMenuBar()	Convenience method, should only be called by PSurface subclasses.
void	hint(int which)
static int	hour()	Processing communicates with the clock on your computer.
final float	hue(int rgb)	Extracts the hue value from a color.
void	image(PImage img, float a, float b)	The image() function draws an image to the display window.
void	image(PImage img, float a, float b, float c, float d)
void	image(PImage img, float a, float b, float c, float d, int u1, int v1, int u2, int v2)	Draw an image(), also specifying u/v coordinates.
void	imageMode(int mode)	Modifies the location from which images are drawn by changing the way in which parameters given to image() are interpreted. The default mode is imageMode(CORNER), which interprets the second and third parameters of image() as the upper-left corner of the image.
String	insertFrame(String what)	Check a string for #### signs to see if the frame number should be inserted.
boolean	isLooping()
static String	join(String[] list, char separator)	Combines an array of Strings into one String, each separated by the character(s) used for the separator parameter.
static String	join(String[] list, String separator)
void	keyPressed()	The keyPressed() function is called once every time a key is pressed.
void	keyPressed(KeyEvent event)
void	keyReleased()	The keyReleased() function is called once every time a key is released.
void	keyReleased(KeyEvent event)
void	keyTyped()	The keyTyped() function is called once every time a key is pressed, but action keys such as Ctrl, Shift, and Alt are ignored.
void	keyTyped(KeyEvent event)
static Process	launch(String... args)	Attempts to open an application or file using your platform's launcher.
static final float	lerp(float start, float stop, float amt)	Calculates a number between two numbers at a specific increment.
int	lerpColor(int c1, int c2, float amt)	Calculates a new color that is a blend of two other colors.
static int	lerpColor(int c1, int c2, float amt, int mode)
void	lightFalloff(float constant, float linear, float quadratic)	Sets the falloff rates for point lights, spotlights, and ambient lights.
void	lights()	Sets the default ambient light, directional light, falloff, and specular values.
void	lightSpecular(float v1, float v2, float v3)	Sets the specular color for lights.
void	line(float x1, float y1, float x2, float y2)	Draws a line (a direct path between two points) to the screen.
void	line(float x1, float y1, float z1, float x2, float y2, float z2)
void	link(String url)	Links to a webpage either in the same window or in a new window.
static File[]	listFiles(File base, String... options)
File[]	listFiles(String path, String... options)
String[]	listPaths(String path, String... options)
static byte[]	loadBytes(File file)
static byte[]	loadBytes(InputStream input)
byte[]	loadBytes(String filename)	Reads the contents of a file and places it in a byte array.
PFont	loadFont(String filename)	Loads a .vlw formatted font into a PFont object.
PImage	loadImage(String filename)	Loads an image into a variable of type PImage.
PImage	loadImage(String filename, String extension)
static JSONArray	loadJSONArray(File file)
JSONArray	loadJSONArray(String filename)	Loads an array of JSON objects from the data folder or a URL, and returns a JSONArray.
static JSONObject	loadJSONObject(File file)
JSONObject	loadJSONObject(String filename)	Loads a JSON from the data folder or a URL, and returns a JSONObject. All files loaded and saved by the Processing API use UTF-8 encoding.
void	loadPixels()	Loads the pixel data of the current display window into the pixels[] array.
PShader	loadShader(String fragFilename)	Loads a shader into the PShader object.
PShader	loadShader(String fragFilename, String vertFilename)
PShape	loadShape(String filename)	Loads geometry into a variable of type PShape.
PShape	loadShape(String filename, String options)
static String[]	loadStrings(BufferedReader reader)
static String[]	loadStrings(File file)
static String[]	loadStrings(InputStream input)
String[]	loadStrings(String filename)	Reads the contents of a file and creates a String array of its individual lines.
Table	loadTable(String filename)	Reads the contents of a file or URL and creates a Table object with its values.
Table	loadTable(String filename, String options)	Options may contain "header", "tsv", "csv", or "bin" separated by commas.
XML	loadXML(String filename)	Reads the contents of a file or URL and creates an XML object with its values.
XML	loadXML(String filename, String options)
static final float	log(float n)	Calculates the natural logarithm (the base-e logarithm) of a number.
void	loop()	By default, Processing loops through draw() continuously, executing the code within it.
static final float	mag(float a, float b)
static final float	mag(float a, float b, float c)	Calculates the magnitude (or length) of a vector.
static void	main(Class<?> mainClass, String... args)	Convenience method so that PApplet.main(YourSketch.class) launches a sketch, rather than having to call getName() on it.
static void	main(String mainClass)	Convenience method so that PApplet.main("YourSketch") launches a sketch, rather than having to wrap it into a single element String array.
static void	main(String[] args)	main() method for running this class from the command line.
static void	main(String mainClass, String[] sketchArgs)	Convenience method so that PApplet.main("YourSketch", args) launches a sketch, rather than having to wrap it into a String array, and appending the 'args' array when not null.
static final float	map(float value, float start1, float stop1, float start2, float stop2)	Re-maps a number from one range to another. In the first example above, the number 25 is converted from a value in the range of 0 to 100 into a value that ranges from the left edge of the window (0) to the right edge (width). As shown in the second example, numbers outside the range are not clamped to the minimum and maximum parameters values, because out-of-range values are often intentional and useful.
void	mask(PImage img)	Masks part of an image from displaying by loading another image and using it as an alpha channel.
static String[]	match(String str, String regexp)	This function is used to apply a regular expression to a piece of text, and return matching groups (elements found inside parentheses) as a String array.
static String[][]	matchAll(String str, String regexp)	This function is used to apply a regular expression to a piece of text, and return a list of matching groups (elements found inside parentheses) as a two-dimensional String array.
static final float	max(float[] list)
static final float	max(float a, float b)
static final float	max(float a, float b, float c)
static final int	max(int[] list)
static final int	max(int a, int b)	Determines the largest value in a sequence of numbers, and then returns that value.
static final int	max(int a, int b, int c)
void	method(String name)	Call a method in the current class based on its name.
int	millis()	Returns the number of milliseconds (thousandths of a second) since starting the sketch.
static final float	min(float[] list)
static final float	min(float a, float b)
static final float	min(float a, float b, float c)	Determines the smallest value in a sequence of numbers, and then returns that value.
static final int	min(int[] list)
static final int	min(int a, int b)
static final int	min(int a, int b, int c)
static int	minute()	Processing communicates with the clock on your computer.
float	modelX(float x, float y, float z)	Returns the three-dimensional X, Y, Z position in model space.
float	modelY(float x, float y, float z)	Returns the three-dimensional X, Y, Z position in model space.
float	modelZ(float x, float y, float z)	Returns the three-dimensional X, Y, Z position in model space.
static int	month()	Processing communicates with the clock on your computer.
void	mouseClicked()	The mouseClicked() function is called after a mouse button has been pressed and then released.
void	mouseClicked(MouseEvent event)
void	mouseDragged()	The mouseDragged() function is called once every time the mouse moves while a mouse button is pressed.
void	mouseDragged(MouseEvent event)
void	mouseEntered()
void	mouseEntered(MouseEvent event)
void	mouseExited()
void	mouseExited(MouseEvent event)
void	mouseMoved()	The mouseMoved() function is called every time the mouse moves and a mouse button is not pressed.
void	mouseMoved(MouseEvent event)
void	mousePressed()	The mousePressed() function is called once after every time a mouse button is pressed.
void	mousePressed(MouseEvent event)
void	mouseReleased()	The mouseReleased() function is called every time a mouse button is released.
void	mouseReleased(MouseEvent event)
void	mouseWheel()
void	mouseWheel(MouseEvent event)	The code within the mouseWheel() event function is run when the mouse wheel is moved.
static String	nf(float num)
static String[]	nf(float[] nums)
static String[]	nf(float[] nums, int left, int right)
static String	nf(float num, int left, int right)
static String[]	nf(int[] nums, int digits)	Utility function for formatting numbers into strings.
static String	nf(int num, int digits)
static String[]	nfc(float[] nums, int right)
static String	nfc(float num, int right)
static String	nfc(int num)
static String[]	nfc(int[] nums)	Utility function for formatting numbers into strings and placing appropriate commas to mark units of 1000.
static String[]	nfp(float[] nums, int left, int right)
static String	nfp(float num, int left, int right)
static String[]	nfp(int[] nums, int digits)
static String	nfp(int num, int digits)	Utility function for formatting numbers into strings.
static String[]	nfs(float[] nums, int left, int right)
static String	nfs(float num, int left, int right)
static String[]	nfs(int[] nums, int digits)
static String	nfs(int num, int digits)	Utility function for formatting numbers into strings.
void	noClip()	Disables the clipping previously started by the clip() function.
void	noCursor()	Hides the cursor from view.
void	noFill()	Disables filling geometry.
float	noise(float x)
float	noise(float x, float y)
float	noise(float x, float y, float z)	Returns the Perlin noise value at specified coordinates.
void	noiseDetail(int lod)	Adjusts the character and level of detail produced by the Perlin noise function.
void	noiseDetail(int lod, float falloff)
void	noiseSeed(long seed)	Sets the seed value for noise().
void	noLights()	Disable all lighting.
void	noLoop()	Stops Processing from continuously executing the code within draw().
static final float	norm(float value, float start, float stop)	Normalizes a number from another range into a value between 0 and 1.
void	normal(float nx, float ny, float nz)	Sets the current normal vector.
void	noSmooth()	Draws all geometry and fonts with jagged (aliased) edges and images with hard edges between the pixels when enlarged rather than interpolating pixels.
void	noStroke()	Disables drawing the stroke (outline).
void	noTexture()	Removes texture image for current shape.
void	noTint()	Removes the current fill value for displaying images and reverts to displaying images with their original hues.
void	orientation(int which)
void	ortho()	Sets an orthographic projection and defines a parallel clipping volume.
void	ortho(float left, float right, float bottom, float top)
void	ortho(float left, float right, float bottom, float top, float near, float far)
static final boolean	parseBoolean(int what)	Convert an integer to a boolean.
static final boolean[]	parseBoolean(int[] what)	Convert an int array to a boolean array.
static final boolean	parseBoolean(String what)	Convert the string "true" or "false" to a boolean.
static final boolean[]	parseBoolean(String[] what)
static final byte	parseByte(boolean what)
static final byte[]	parseByte(boolean[] what)
static final byte	parseByte(char what)
static final byte[]	parseByte(char[] what)
static final byte	parseByte(float what)
static final byte[]	parseByte(float[] what)
static final byte	parseByte(int what)
static final byte[]	parseByte(int[] what)
static final char	parseChar(byte what)
static final char[]	parseChar(byte[] what)
static final char	parseChar(int what)
static final char[]	parseChar(int[] what)
static final float[]	parseFloat(byte[] what)
static final float	parseFloat(int what)	Convert an int to a float value.
static final float[]	parseFloat(int[] what)
static final float	parseFloat(String what)
static final float[]	parseFloat(String[] what)
static final float[]	parseFloat(String[] what, float missing)
static final float	parseFloat(String what, float otherwise)
static final int	parseInt(boolean what)
static final int[]	parseInt(boolean[] what)
static final int	parseInt(byte what)	Note that parseInt() will un-sign a signed byte value.
static final int[]	parseInt(byte[] what)
static final int	parseInt(char what)	Note that parseInt('5') is unlike String in the sense that it won't return 5, but the ascii value.
static final int[]	parseInt(char[] what)
static final int	parseInt(float what)	Same as floor(), or an (int) cast.
static int[]	parseInt(float[] what)
static final int	parseInt(String what)	Parse a String into an int value.
static int[]	parseInt(String[] what)	Make an array of int elements from an array of String objects.
static int[]	parseInt(String[] what, int missing)	Make an array of int elements from an array of String objects.
static final int	parseInt(String what, int otherwise)	Parse a String to an int, and provide an alternate value that should be used when the number is invalid.
JSONArray	parseJSONArray(String input)	Takes a String, parses its contents, and returns a JSONArray.
JSONObject	parseJSONObject(String input)	Takes a String, parses its contents, and returns a JSONObject.
XML	parseXML(String xmlString)	Takes a String, parses its contents, and returns an XML object.
XML	parseXML(String xmlString, String options)
void	pause()	Sketch has been paused.
void	perspective()	Sets a perspective projection applying foreshortening, making distant objects appear smaller than closer ones.
void	perspective(float fovy, float aspect, float zNear, float zFar)
void	pixelDensity(int density)	This function makes it possible to render using all the pixels on high resolutions screens like Apple Retina and Windows HiDPI.
void	point(float x, float y)	Draws a point, a coordinate in space at the dimension of one pixel.
void	point(float x, float y, float z)
void	pointLight(float v1, float v2, float v3, float x, float y, float z)	Adds a point light.
void	pop()	The pop() function restores the previous drawing style settings and transformations after push() has changed them.
void	popMatrix()	Pops the current transformation matrix off the matrix stack.
void	popStyle()	The pushStyle() function saves the current style settings and popStyle() restores the prior settings; these functions are always used together.
void	postEvent(Event pe)	Add an event to the internal event queue, or process it immediately if the sketch is not currently looping.
void	postWindowMoved(int newX, int newY)	Internal use only: called by Surface objects to queue a position event to call windowPositioned() when it's safe, which is after the beginDraw() call and before the draw().
void	postWindowResized(int newWidth, int newHeight)	Internal use only: called by Surface objects to queue a resize event to call windowResized() when it's safe, which is after the beginDraw() call and before the draw().
static final float	pow(float n, float e)	Facilitates exponential expressions.
static void	print(boolean what)
static void	print(byte what)	The print() function writes to the console area, the black rectangle at the bottom of the Processing environment.
static void	print(char what)
static void	print(double what)
static void	print(float what)
static void	print(int what)
static void	print(long what)
static void	print(Object... variables)
static void	print(String what)
static void	printArray(Object what)	The printArray() function writes array data to the text area of the Processing environment's console.
void	printCamera()	Prints the current camera matrix to the Console (the text window at the bottom of Processing).
static void	println()	The println() function writes to the console area, the black rectangle at the bottom of the Processing environment.
static void	println(boolean what)
static void	println(byte what)
static void	println(char what)
static void	println(double what)
static void	println(float what)
static void	println(int what)
static void	println(long what)
static void	println(Object what)	For arrays, use printArray() instead.
static void	println(Object... variables)
static void	println(String what)
void	printMatrix()	Prints the current matrix to the Console (the text window at the bottom of Processing).
void	printProjection()	Prints the current projection matrix to the Console (the text window at the bottom of Processing).
void	push()	The push() function saves the current drawing style settings and transformations, while pop() restores these settings.
void	pushMatrix()	Pushes the current transformation matrix onto the matrix stack.
void	pushStyle()	The pushStyle() function saves the current style settings and popStyle() restores the prior settings.
void	quad(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)	A quad is a quadrilateral, a four sided polygon.
void	quadraticVertex(float cx, float cy, float x3, float y3)	Specifies vertex coordinates for quadratic Bézier curves.
void	quadraticVertex(float cx, float cy, float cz, float x3, float y3, float z3)
static final float	radians(float degrees)	Converts a degree measurement to its corresponding value in radians.
final float	random(float high)
final float	random(float low, float high)	Generates random numbers.
final float	randomGaussian()	Returns a float from a random series of numbers having a mean of 0 and standard deviation of 1.
final void	randomSeed(long seed)	Sets the seed value for random().
void	rect(float a, float b, float c, float d)	Draws a rectangle to the screen.
void	rect(float a, float b, float c, float d, float r)
void	rect(float a, float b, float c, float d, float tl, float tr, float br, float bl)
void	rectMode(int mode)	Modifies the location from which rectangles are drawn by changing the way in which parameters given to rect() are interpreted. The default mode is rectMode(CORNER), which interprets the first two parameters of rect() as the upper-left corner of the shape, while the third and fourth parameters are its width and height. rectMode(CORNERS) interprets the first two parameters of rect() as the location of one corner, and the third and fourth parameters as the location of the opposite corner. rectMode(CENTER) interprets the first two parameters of rect() as the shape's center point, while the third and fourth parameters are its width and height. rectMode(RADIUS) also uses the first two parameters of rect() as the shape's center point, but uses the third and fourth parameters to specify half of the shape's width and height. The parameter must be written in ALL CAPS because Processing is a case-sensitive language.
final float	red(int rgb)	Extracts the red value from a color, scaled to match current colorMode().
void	redraw()	Executes the code within draw() one time.
void	registerMethod(String methodName, Object target)	Register a built-in event so that it can be fired for libraries, etc.
PImage	requestImage(String filename)
PImage	requestImage(String filename, String extension)	This function loads images on a separate thread so that your sketch doesn't freeze while images load during setup().
void	resetMatrix()	Replaces the current matrix with the identity matrix.
void	resetShader()	Restores the default shaders.
void	resetShader(int kind)
void	resume()	Sketch has resumed.
static boolean[]	reverse(boolean[] list)	Reverses the order of an array.
static byte[]	reverse(byte[] list)
static char[]	reverse(char[] list)
static float[]	reverse(float[] list)
static int[]	reverse(int[] list)
static Object	reverse(Object list)
static String[]	reverse(String[] list)
void	rotate(float angle)	Rotates a shape the amount specified by the angle parameter.
void	rotate(float angle, float x, float y, float z)	Advanced
void	rotateX(float angle)	Rotates a shape around the x-axis the amount specified by the angle parameter.
void	rotateY(float angle)	Rotates a shape around the y-axis the amount specified by the angle parameter.
void	rotateZ(float angle)	Rotates a shape around the z-axis the amount specified by the angle parameter.
static final int	round(float n)	Calculates the integer closest to the n parameter.
static void	runSketch(String[] args, PApplet constructedSketch)
final float	saturation(int rgb)	Extracts the saturation value from a color.
void	save(String filename)	Saves an image from the display window.
static void	saveBytes(File file, byte[] data)
static void	saveBytes(OutputStream output, byte[] data)
void	saveBytes(String filename, byte[] data)	As the opposite of loadBytes(), this function will write an entire array of bytes to a file.
File	saveFile(String where)	Identical to savePath(), but returns a File object.
void	saveFrame()
void	saveFrame(String filename)	Saves a numbered sequence of images, one image each time the function is run.
boolean	saveJSONArray(JSONArray json, String filename)	Writes the contents of a JSONArray object to a file.
boolean	saveJSONArray(JSONArray json, String filename, String options)
boolean	saveJSONObject(JSONObject json, String filename)	Writes the contents of a JSONObject object to a file.
boolean	saveJSONObject(JSONObject json, String filename, String options)
String	savePath(String where)	Returns a path adjacent the application to save to.
static boolean	saveStream(File target, InputStream source)
boolean	saveStream(File target, String source)	Identical to the other saveStream(), but writes to a File object, for greater control over the file location.
static void	saveStream(OutputStream target, InputStream source)
boolean	saveStream(String target, InputStream source)
boolean	saveStream(String target, String source)	Save the contents of a stream to a file in the sketch folder.
static void	saveStrings(File file, String[] data)
static void	saveStrings(OutputStream output, String[] data)
void	saveStrings(String filename, String[] data)	Writes an array of Strings to a file, one line per String.
boolean	saveTable(Table table, String filename)	Writes the contents of a Table object to a file.
boolean	saveTable(Table table, String filename, String options)
boolean	saveXML(XML xml, String filename)	Writes the contents of an XML object to a file.
boolean	saveXML(XML xml, String filename, String options)
void	scale(float s)	Increases or decreases the size of a shape by expanding and contracting vertices.
void	scale(float x, float y)	Advanced
void	scale(float x, float y, float z)
float	screenX(float x, float y)	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)	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)	Takes a three-dimensional X, Y, Z position and returns the Z value for where it will appear on a (two-dimensional) screen.
static int	second()	Processing communicates with the clock on your computer.
static void	selectCallback(File selectedFile, String callbackMethod, Object callbackObject)
void	selectFolder(String prompt, String callback)	Opens a platform-specific file chooser dialog to select a folder.
void	selectFolder(String prompt, String callback, File file)
void	selectFolder(String prompt, String callback, File file, Object callbackObject)
void	selectInput(String prompt, String callback)	Open a platform-specific file chooser dialog to select a file for input.
void	selectInput(String prompt, String callback, File file)
void	selectInput(String prompt, String callback, File file, Object callbackObject)
void	selectOutput(String prompt, String callback)	Opens a platform-specific file chooser dialog to select a file for output.
void	selectOutput(String prompt, String callback, File file)
void	selectOutput(String prompt, String callback, File file, Object callbackObject)
void	set(int x, int y, int c)	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	set(int x, int y, PImage img)	Advanced
void	setMatrix(PMatrix source)	Set the current transformation matrix to the contents of another.
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	setSize(int width, int height)	Called by PSurface objects to set the width and height variables, and update the pixelWidth and pixelHeight variables.
void	settings()	The settings() function is new with Processing 3.0.
void	setup()	The setup() function is run once, when the program starts.
void	shader(PShader shader)	Applies the shader specified by the parameters.
void	shader(PShader shader, int kind)
void	shape(PShape shape)
void	shape(PShape shape, float x, float y)	Draws shapes to the display window.
void	shape(PShape shape, float a, float b, float c, float d)
void	shapeMode(int mode)	Modifies the location from which shapes draw.
void	shearX(float angle)	Shears a shape around the x-axis the amount specified by the angle parameter.
void	shearY(float angle)	Shears a shape around the y-axis the amount specified by the angle parameter.
static int	shell(StringList stdout, StringList stderr, String... args)	Same as exec() above, but prefixes the call with a shell.
void	shininess(float shine)	Sets the amount of gloss in the surface of shapes.
static boolean[]	shorten(boolean[] list)	Decreases an array by one element and returns the shortened array.
static byte[]	shorten(byte[] list)
static char[]	shorten(char[] list)
static float[]	shorten(float[] list)
static int[]	shorten(int[] list)
static Object	shorten(Object list)
static String[]	shorten(String[] list)
static void	showDepthWarning(String method)	Display a warning that the specified method is only available with 3D.
static void	showDepthWarningXYZ(String method)	Display a warning that the specified method that takes x, y, z parameters can only be used with x and y parameters in this renderer.
static void	showMethodWarning(String method)	Display a warning that the specified method is simply unavailable.
static void	showMissingWarning(String method)	Display a warning that the specified method is not implemented, meaning that it could be either a completely missing function, although other variations of it may still work properly.
static void	showVariationWarning(String str)	Error that a particular variation of a method is unavailable (even though other variations are).
static final float	sin(float angle)	Calculates the sine of an angle.
void	size(int width, int height)	Defines the dimension of the display window width and height in units of pixels.
void	size(int width, int height, String renderer)
void	size(int width, int height, String renderer, String path)
final int	sketchDisplay()
File	sketchFile(String where)
final boolean	sketchFullScreen()
final int	sketchHeight()
final String	sketchOutputPath()
final OutputStream	sketchOutputStream()
String	sketchPath()
String	sketchPath(String where)	Prepend the sketch folder path to the filename (or path) that is passed in.
final int	sketchPixelDensity()
final String	sketchRenderer()
final int	sketchSmooth()
final int	sketchWidth()
final int	sketchWindowColor()
void	smooth()
void	smooth(int level)	Draws all geometry with smooth (anti-aliased) edges.
static byte[]	sort(byte[] list)	Sorts an array of numbers from smallest to largest, or puts an array of words in alphabetical order.
static byte[]	sort(byte[] list, int count)
static char[]	sort(char[] list)
static char[]	sort(char[] list, int count)
static float[]	sort(float[] list)
static float[]	sort(float[] list, int count)
static int[]	sort(int[] list)
static int[]	sort(int[] list, int count)
static String[]	sort(String[] list)
static String[]	sort(String[] list, int count)
void	specular(float gray)	gray number specifying value between white and black
void	specular(float v1, float v2, float v3)
void	specular(int rgb)	Sets the specular color of the materials used for shapes drawn to the screen, which sets the color of highlights.
void	sphere(float r)	A sphere is a hollow ball made from tessellated triangles.
void	sphereDetail(int res)	Controls the detail used to render a sphere by adjusting the number of vertices of the sphere mesh.
void	sphereDetail(int ures, int vres)
static final boolean[]	splice(boolean[] list, boolean[] value, int index)
static final boolean[]	splice(boolean[] list, boolean value, int index)	Inserts a value or an array of values into an existing array.
static final byte[]	splice(byte[] list, byte[] value, int index)
static final byte[]	splice(byte[] list, byte value, int index)
static final char[]	splice(char[] list, char[] value, int index)
static final char[]	splice(char[] list, char value, int index)
static final float[]	splice(float[] list, float[] value, int index)
static final float[]	splice(float[] list, float value, int index)
static final int[]	splice(int[] list, int[] value, int index)
static final int[]	splice(int[] list, int value, int index)
static final Object	splice(Object list, Object value, int index)
static final String[]	splice(String[] list, String[] value, int index)
static final String[]	splice(String[] list, String value, int index)
static String[]	split(String value, char delim)	The split() function breaks a String into pieces using a character or string as the delimiter.
static String[]	split(String value, String delim)
static String[]	splitTokens(String value)
static String[]	splitTokens(String value, String delim)	The splitTokens() function splits a String at one or many character delimiters or "tokens".
void	spotLight(float v1, float v2, float v3, float x, float y, float z, float nx, float ny, float nz, float angle, float concentration)	Adds a spotlight.
static final float	sq(float n)	Squares a number (multiplies a number by itself).
static final float	sqrt(float n)	Calculates the square root of a number.
void	square(float x, float y, float extent)	Draws a square to the screen.
void	start()	Called by the application context to start running (or resume) the sketch.
void	stop()	Called by the application context to stop running (or pause) the sketch.
static final String	str(boolean value)
static final String[]	str(boolean[] values)
static final String	str(byte value)
static final String[]	str(byte[] values)
static final String	str(char value)
static final String[]	str(char[] values)
static final String	str(float value)
static final String[]	str(float[] values)
static final String	str(int value)
static final String[]	str(int[] values)
void	stroke(float gray)
void	stroke(float gray, float alpha)
void	stroke(float v1, float v2, float v3)
void	stroke(float v1, float v2, float v3, float alpha)
void	stroke(int rgb)	Sets the color used to draw lines and borders around shapes.
void	stroke(int rgb, float alpha)
void	strokeCap(int cap)	Sets the style for rendering line endings.
void	strokeJoin(int join)	Sets the style of the joints which connect line segments.
void	strokeWeight(float weight)	Sets the width of the stroke used for lines, points, and the border around shapes.
void	style(PStyle s)
static boolean[]	subset(boolean[] list, int start)
static boolean[]	subset(boolean[] list, int start, int count)	Extracts an array of elements from an existing array.
static byte[]	subset(byte[] list, int start)
static byte[]	subset(byte[] list, int start, int count)
static char[]	subset(char[] list, int start)
static char[]	subset(char[] list, int start, int count)
static double[]	subset(double[] list, int start)
static double[]	subset(double[] list, int start, int count)
static float[]	subset(float[] list, int start)
static float[]	subset(float[] list, int start, int count)
static int[]	subset(int[] list, int start)
static int[]	subset(int[] list, int start, int count)
static long[]	subset(long[] list, int start)
static long[]	subset(long[] list, int start, int count)
static Object	subset(Object list, int start)
static Object	subset(Object list, int start, int count)
static String[]	subset(String[] list, int start)
static String[]	subset(String[] list, int start, int count)
static final float	tan(float angle)	Calculates the ratio of the sine and cosine of an angle.
void	text(char[] chars, int start, int stop, float x, float y)	Advanced
void	text(char[] chars, int start, int stop, float x, float y, float z)
void	text(char c, float x, float y)	Draws text to the screen.
void	text(char c, float x, float y, float z)
void	text(float num, float x, float y)	This does a basic number formatting, to avoid the generally ugly appearance of printing floats.
void	text(float num, float x, float y, float z)
void	text(int num, float x, float y)
void	text(int num, float x, float y, float z)
void	text(String str, float x, float y)	Advanced
void	text(String str, float x, float y, float z)	Same as above but with a z coordinate.
void	text(String str, float x1, float y1, float x2, float y2)	Advanced
void	textAlign(int alignX)
void	textAlign(int alignX, int alignY)	Sets the current alignment for drawing text.
float	textAscent()	Returns ascent of the current font at its current size.
float	textDescent()	Returns descent of the current font at its current size.
void	textFont(PFont which)	Sets the current font that will be drawn with the text() function.
void	textFont(PFont which, float size)
void	textLeading(float leading)	Sets the spacing between lines of text in units of pixels.
void	textMode(int mode)	Sets the way text draws to the screen, either as texture maps or as vector geometry.
void	textSize(float size)	Sets the current font size.
void	texture(PImage image)	Sets a texture to be applied to vertex points.
void	textureMode(int mode)	Sets the coordinate space for texture mapping.
void	textureWrap(int wrap)	Defines if textures repeat or draw once within a texture map.
float	textWidth(char c)
float	textWidth(char[] chars, int start, int length)
float	textWidth(String str)	Calculates and returns the width of any character or text string.
void	thread(String name)	Processing sketches follow a specific sequence of steps: setup() first, followed by draw() over and over and over again in a loop.
void	tint(float gray)
void	tint(float gray, float alpha)
void	tint(float v1, float v2, float v3)
void	tint(float v1, float v2, float v3, float alpha)
void	tint(int rgb)	Sets the fill value for displaying images.
void	tint(int rgb, float alpha)
void	translate(float x, float y)	Specifies an amount to displace objects within the display window.
void	translate(float x, float y, float z)
void	triangle(float x1, float y1, float x2, float y2, float x3, float y3)	A triangle is a plane created by connecting three points.
static String	trim(String str)	Removes whitespace characters from the beginning and end of a String.
static String[]	trim(String[] array)
static final int	unbinary(String value)	Converts a String representation of a binary number to its equivalent integer value.
static final int	unhex(String value)	Converts a String representation of a hexadecimal number to its equivalent integer value.
void	unregisterMethod(String name, Object target)
void	updatePixels()	Updates the display window with the data in the pixels[] array.
void	updatePixels(int x1, int y1, int x2, int y2)
static String	urlDecode(String str)
static String	urlEncode(String str)
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)	All shapes are constructed by connecting a series of vertices.
void	windowMove(int x, int y)
void	windowMoved()	Called when the window is moved
void	windowRatio(int wide, int high)	Scale the sketch as if it fits this specific width and height.
void	windowResizable(boolean resizable)
void	windowResize(int newWidth, int newHeight)
void	windowResized()	Called when window is resized.
void	windowTitle(String title)
static int	year()	Processing communicates with the clock on your computer.

Methods inherited from class java.lang.Object

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

Field Details

javaVersionName

public static final String javaVersionName

Full name of the Java version (i.e. 1.5.0_11).

javaPlatform

public static final int javaPlatform

javaVersion

@Deprecated
public static final float javaVersion

Deprecated.

Do not use; javaPlatform or javaVersionName are better options. For instance, javaPlatform is useful when you need a number for comparison, i.e. "if (javaPlatform >= 9)".

platform

public static int platform

Current platform in use, one of the PConstants WINDOWS, MACOS, LINUX or OTHER.

useNativeSelect

public static boolean useNativeSelect

Whether to use native (AWT) dialogs for selectInput and selectOutput. The native dialogs on some platforms can be ugly, buggy, or missing features. For 3.3.5, this defaults to true on all platforms.

g

public PGraphics g

The PGraphics renderer associated with this PApplet

displayWidth

public int displayWidth

System variable that stores the width of the computer screen. For example, if the current screen resolution is 1920x1080, displayWidth is 1920 and displayHeight is 1080.

See Also:

• displayHeight
• size(int, int)

displayHeight

public int displayHeight

System variable that stores the height of the computer screen. For example, if the current screen resolution is 1920x1080, displayWidth is 1920 and displayHeight is 1080.

See Also:

• displayWidth
• size(int, int)

windowX

public int windowX

windowY

public int windowY

recorder

public PGraphics recorder

A leech graphics object that is echoing all events.

args

public String[] args

Command line options passed in from main(). This does not include the arguments passed in to PApplet itself.

See Also:

• main(java.lang.String[])

DEFAULT_WIDTH

public static final int DEFAULT_WIDTH

Default width and height for sketch when not specified

See Also:

• Constant Field Values

DEFAULT_HEIGHT

public static final int DEFAULT_HEIGHT

See Also:

• Constant Field Values

pixels

public int[] pixels

The pixels[] array contains the values for all the pixels in the display window. These values are of the color datatype. This array is defined by the size of the display window. For example, if the window is 100 x 100 pixels, there will be 10,000 values and if the window is 200 x 300 pixels, there will be 60,000 values. When the pixel density is set to higher than 1 with the pixelDensity() function, these values will change. See the reference for pixelWidth or pixelHeight for more information.

Before accessing this array, the data must be loaded with the loadPixels() function. Failure to do so may result in a NullPointerException. Subsequent changes to the display window will not be reflected in pixels until loadPixels() is called again. After pixels has been modified, the updatePixels() function must be run to update the content of the display window.

See Also:

• loadPixels()
• updatePixels()
• get(int, int, int, int)
• set(int, int, int)
• PImage
• pixelDensity(int)
• pixelWidth
• pixelHeight

width

public int width

System variable which stores the width of the display window. This value is set by the first parameter of the size() function. For example, the function call size(320, 240) sets the width variable to the value 320. The value of width defaults to 100 if size() is not used in a program.

See Also:

• height
• size(int, int)

height

public int height

System variable which stores the height of the display window. This value is set by the second parameter of the size() function. For example, the function call size(320, 240) sets the height variable to the value 240. The value of height defaults to 100 if size() is not used in a program.

See Also:

• width
• size(int, int)

pixelWidth

public int pixelWidth

When pixelDensity(2) is used to make use of a high resolution display (called a Retina display on OS X or high-dpi on Windows and Linux), the width and height of the sketch do not change, but the number of pixels is doubled. As a result, all operations that use pixels (like loadPixels(), get(), set(), etc.) happen in this doubled space. As a convenience, the variables pixelWidth and pixelHeight hold the actual width and height of the sketch in pixels. This is useful for any sketch that uses the pixels[] array, for instance, because the number of elements in the array will be pixelWidth*pixelHeight, not width*height.

See Also:

• pixelHeight
• pixelDensity(int)
• displayDensity()

pixelHeight

public int pixelHeight

When pixelDensity(2) is used to make use of a high resolution display (called a Retina display on OS X or high-dpi on Windows and Linux), the width and height of the sketch do not change, but the number of pixels is doubled. As a result, all operations that use pixels (like loadPixels(), get(), set(), etc.) happen in this doubled space. As a convenience, the variables pixelWidth and pixelHeight hold the actual width and height of the sketch in pixels. This is useful for any sketch that uses the pixels[] array, for instance, because the number of elements in the array will be pixelWidth*pixelHeight, not width*height.

See Also:

• pixelWidth
• pixelDensity(int)
• displayDensity()

rmouseX

public int rmouseX

Version of mouseX/mouseY to use with windowRatio().

rmouseY

public int rmouseY

rwidth

public int rwidth

Version of width/height to use with windowRatio().

rheight

public int rheight

ratioLeft

public float ratioLeft

Offset from left when windowRatio is in use.

ratioTop

public float ratioTop

Offset from the top when windowRatio is in use.

ratioScale

public float ratioScale

Amount of scaling to be applied for the window ratio.

mouseX

public int mouseX

The system variable mouseX always contains the current horizontal coordinate of the mouse.

Note that Processing can only track the mouse position when the pointer is over the current window. The default value of mouseX is 0, so 0 will be returned until the mouse moves in front of the sketch window. (This typically happens when a sketch is first run.) Once the mouse moves away from the window, mouseX will continue to report its most recent position.

See Also:

• mouseY
• pmouseX
• pmouseY
• mousePressed
• mousePressed()
• mouseReleased()
• mouseClicked()
• mouseMoved()
• mouseDragged()
• mouseButton
• mouseWheel(MouseEvent)

mouseY

public int mouseY

The system variable mouseY always contains the current vertical coordinate of the mouse.

Note that Processing can only track the mouse position when the pointer is over the current window. The default value of mouseY is 0, so 0 will be returned until the mouse moves in front of the sketch window. (This typically happens when a sketch is first run.) Once the mouse moves away from the window, mouseY will continue to report its most recent position.

See Also:

• mouseX
• pmouseX
• pmouseY
• mousePressed
• mousePressed()
• mouseReleased()
• mouseClicked()
• mouseMoved()
• mouseDragged()
• mouseButton
• mouseWheel(MouseEvent)

pmouseX

public int pmouseX

The system variable pmouseX always contains the horizontal position of the mouse in the frame previous to the current frame.

You may find that pmouseX and pmouseY have different values when referenced inside of draw() and inside of mouse events like mousePressed() and mouseMoved(). Inside draw(), pmouseX and pmouseY update only once per frame (once per trip through the draw() loop). But inside mouse events, they update each time the event is called. If these values weren't updated immediately during events, then the mouse position would be read only once per frame, resulting in slight delays and choppy interaction. If the mouse variables were always updated multiple times per frame, then something like line(pmouseX, pmouseY, mouseX, mouseY) inside draw() would have lots of gaps, because pmouseX may have changed several times in between the calls to line().

If you want values relative to the previous frame, use pmouseX and pmouseY inside draw(). If you want continuous response, use pmouseX and pmouseY inside the mouse event functions.

See Also:

• mouseX
• mouseY
• pmouseY
• mousePressed
• mousePressed()
• mouseReleased()
• mouseClicked()
• mouseMoved()
• mouseDragged()
• mouseButton
• mouseWheel(MouseEvent)

pmouseY

public int pmouseY

The system variable pmouseY always contains the vertical position of the mouse in the frame previous to the current frame. More detailed information about how pmouseY is updated inside of draw() and mouse events is explained in the reference for pmouseX.

See Also:

• mouseX
• mouseY
• pmouseX
• mousePressed
• mousePressed()
• mouseReleased()
• mouseClicked()
• mouseMoved()
• mouseDragged()
• mouseButton
• mouseWheel(MouseEvent)

firstMouse

@Deprecated
public boolean firstMouse

Deprecated.

Please refrain from using this variable, it will be removed from future releases of Processing because it cannot be used consistently across platforms and input methods.

Used to set pmouseX/Y to mouseX/Y the first time mouseX/Y are used, otherwise pmouseX/Y are always zero, causing a nasty jump.

Just using (frameCount == 0) won't work since mouseXxxxx() may not be called until a couple frames into things.

mouseButton

public int mouseButton

When a mouse button is pressed, the value of the system variable mouseButton is set to either LEFT, RIGHT, or CENTER, depending on which button is pressed. (If no button is pressed, mouseButton may be reset to 0. For that reason, it's best to use mousePressed first to test if any button is being pressed, and only then test the value of mouseButton, as shown in the examples above.)

Advanced:

If running on macOS, a ctrl-click will be interpreted as the right-hand mouse button (unlike Java, which reports it as the left mouse).

See Also:

• mouseX
• mouseY
• pmouseX
• pmouseY
• mousePressed
• mousePressed()
• mouseReleased()
• mouseClicked()
• mouseMoved()
• mouseDragged()
• mouseWheel(MouseEvent)

mousePressed

public boolean mousePressed

The mousePressed variable stores whether a mouse button has been pressed. The mouseButton variable (see the related reference entry) can be used to determine which button has been pressed.

Mouse and keyboard events only work when a program has draw(). Without draw(), the code is only run once and then stops listening for events.

See Also:

• mouseX
• mouseY
• pmouseX
• pmouseY
• mousePressed()
• mouseReleased()
• mouseClicked()
• mouseMoved()
• mouseDragged()
• mouseButton
• mouseWheel(MouseEvent)

mouseEvent

@Deprecated
public MouseEvent mouseEvent

Deprecated.

Use a mouse event handler that passes an event instead.

key

public char key

The system variable key always contains the value of the most recent key on the keyboard that was used (either pressed or released).

For non-ASCII keys, use the keyCode variable. The keys included in the ASCII specification (BACKSPACE, TAB, ENTER, RETURN, ESC, and DELETE) do not require checking to see if they key is coded, and you should simply use the key variable instead of keyCode If you're making cross-platform projects, note that the ENTER key is commonly used on PCs and Unix and the RETURN key is used instead on Macintosh. Check for both ENTER and RETURN to make sure your program will work for all platforms.

There are issues with how keyCode behaves across different renderers and operating systems. Watch out for unexpected behavior as you switch renderers and operating systems.

Advanced

Last key pressed.

If it's a coded key, i.e. UP/DOWN/CTRL/SHIFT/ALT, this will be set to CODED (0xffff or 65535).

See Also:

• keyCode
• keyPressed
• keyPressed()
• keyReleased()

keyCode

public int keyCode

The variable keyCode is used to detect special keys such as the UP, DOWN, LEFT, RIGHT arrow keys and ALT, CONTROL, SHIFT.

When checking for these keys, it can be useful to first check if the key is coded. This is done with the conditional if (key == CODED), as shown in the example above.

The keys included in the ASCII specification (BACKSPACE, TAB, ENTER, RETURN, ESC, and DELETE) do not require checking to see if the key is coded; for those keys, you should simply use the key variable directly (and not keyCode). If you're making cross-platform projects, note that the ENTER key is commonly used on PCs and Unix, while the RETURN key is used on Macs. Make sure your program will work on all platforms by checking for both ENTER and RETURN.

For those familiar with Java, the values for UP and DOWN are simply shorter versions of Java's KeyEvent.VK_UP and KeyEvent.VK_DOWN. Other keyCode values can be found in the Java KeyEvent reference.

There are issues with how keyCode behaves across different renderers and operating systems. Watch out for unexpected behavior as you switch renderers and operating systems, and also whenever you are using keys not mentioned in this reference entry.

If you are using P2D or P3D as your renderer, use the NEWT KeyEvent constants.

Advanced

When "key" is set to CODED, this will contain a Java key code.

For the arrow keys, keyCode will be one of UP, DOWN, LEFT and RIGHT. ALT, CONTROL and SHIFT are also available. A full set of constants can be obtained from java.awt.event.KeyEvent, from the VK_XXXX variables.

See Also:

• key
• keyPressed
• keyPressed()
• keyReleased()

keyPressed

public boolean keyPressed

The boolean system variable keyPressed is true if any key is pressed and false if no keys are pressed.

Note that there is a similarly named function called keyPressed(). See its reference page for more information.

See Also:

• key
• keyCode
• keyPressed()
• keyReleased()

keyEvent

@Deprecated
public KeyEvent keyEvent

Deprecated.

Use a key event handler that passes an event instead.

The last KeyEvent object passed into a mouse function.

focused

public boolean focused

Confirms if a Processing program is "focused", meaning that it is active and will accept input from mouse or keyboard. This variable is true if it is focused and false if not.

frameRate

public float frameRate

The system variable frameRate contains the approximate frame rate of the software as it executes. The initial value is 10 fps and is updated with each frame. The value is averaged (integrated) over several frames. As such, this value won't be valid until after 5-10 frames.

See Also:

• frameRate(float)
• frameCount

frameCount

public int frameCount

The system variable frameCount contains the number o frames displayed since the program started. Inside setup() the value is 0 and during the first iteration of draw it is 1, etc.

See Also:

• frameRate(float)
• frameRate

finished

public volatile boolean finished

true if the sketch has stopped permanently.

ARGS_EDITOR_LOCATION

public static final String ARGS_EDITOR_LOCATION

Position of the upper left-hand corner of the editor window that launched this sketch.

See Also:

• Constant Field Values

ARGS_EXTERNAL

public static final String ARGS_EXTERNAL

See Also:

• Constant Field Values

ARGS_LOCATION

public static final String ARGS_LOCATION

Location for where to position the sketch window on screen.

This is used by the editor to when saving the previous sketch location, or could be used by other classes to launch at a specific position on-screen.

See Also:

• Constant Field Values

ARGS_DISPLAY

public static final String ARGS_DISPLAY

Used by the PDE to suggest a display (set in prefs, passed on Run)

See Also:

• Constant Field Values

ARGS_DISABLE_AWT

public static final String ARGS_DISABLE_AWT

Disable AWT so that LWJGL and others can run

See Also:

• Constant Field Values

ARGS_BGCOLOR

public static final String ARGS_BGCOLOR

See Also:

• Constant Field Values

ARGS_FULL_SCREEN

public static final String ARGS_FULL_SCREEN

See Also:

• Constant Field Values

ARGS_WINDOW_COLOR

public static final String ARGS_WINDOW_COLOR

See Also:

• Constant Field Values

ARGS_PRESENT

public static final String ARGS_PRESENT

See Also:

• Constant Field Values

ARGS_STOP_COLOR

public static final String ARGS_STOP_COLOR

See Also:

• Constant Field Values

ARGS_HIDE_STOP

public static final String ARGS_HIDE_STOP

See Also:

• Constant Field Values

ARGS_SKETCH_FOLDER

public static final String ARGS_SKETCH_FOLDER

Allows the user or PdeEditor to set a specific sketch folder path.

Used by PdeEditor to pass in the location where saveFrame() and all that stuff should write things.

See Also:

• Constant Field Values

ARGS_UI_SCALE

public static final String ARGS_UI_SCALE

See Also:

• Constant Field Values

EXTERNAL_STOP

public static final String EXTERNAL_STOP

When run externally to a PdeEditor, this is sent by the sketch when it quits.

See Also:

• Constant Field Values

EXTERNAL_MOVE

public static final String EXTERNAL_MOVE

When run externally to a PDE Editor, this is sent by the sketch whenever the window is moved.

This is used so that the editor can re-open the sketch window in the same position as the user last left it.

See Also:

• Constant Field Values

pixelDensity

public int pixelDensity

Constructor Details

PApplet

public PApplet()

Method Details

getSurface

public PSurface getSurface()

settings

public void settings()

The settings() function is new with Processing 3.0. It's not needed in most sketches. It's only useful when it's absolutely necessary to define the parameters to size() with a variable. Alternately, the settings() function is necessary when using Processing code outside the Processing Development Environment (PDE). For example, when using the Eclipse code editor, it's necessary to use settings() to define the size() and smooth() values for a sketch..

The settings() method runs before the sketch has been set up, so other Processing functions cannot be used at that point. For instance, do not use loadImage() inside settings(). The settings() method runs "passively" to set a few variables, compared to the setup() command that call commands in the Processing API.

See Also:

• fullScreen()
• setup()
• size(int,int)
• smooth()

sketchWidth

public final int sketchWidth()

sketchHeight

public final int sketchHeight()

sketchRenderer

public final String sketchRenderer()

sketchSmooth

public final int sketchSmooth()

sketchFullScreen

public final boolean sketchFullScreen()

sketchDisplay

public final int sketchDisplay()

sketchOutputPath

public final String sketchOutputPath()

sketchOutputStream

public final OutputStream sketchOutputStream()

sketchWindowColor

public final int sketchWindowColor()

sketchPixelDensity

public final int sketchPixelDensity()

displayDensity

public int displayDensity()

This function returns the number "2" if the screen is a high-density screen (called a Retina display on OS X or high-dpi on Windows and Linux) and a "1" if not. This information is useful for a program to adapt to run at double the pixel density on a screen that supports it.

See Also:

• pixelDensity(int)
• size(int,int)

displayDensity

public int displayDensity(int display)

Parameters:

display - the display number to check (1-indexed to match the Preferences dialog box)

pixelDensity

public void pixelDensity(int density)

This function makes it possible to render using all the pixels on high resolutions screens like Apple Retina and Windows HiDPI. This function can only be run once within a program, and must be called right after size() in a program without a setup() function, or within setup() if present.

pixelDensity() should only be used with hardcoded numbers (in almost all cases this number will be 2) or in combination with displayDensity() as in the third example above.

When the pixel density is set to more than 1, it changes the pixel operations including the way get(), set(), blend(), copy(), and updatePixels() all work. See the reference for pixelWidth and pixelHeight for more information.

To use variables as the arguments to pixelDensity() function, place the pixelDensity() function within the settings() function. There is more information about this on the settings() reference page.

Parameters:

density - 1 or 2

See Also:

• pixelWidth
• pixelHeight

setSize

public void setSize(int width,
 int height)

Called by PSurface objects to set the width and height variables, and update the pixelWidth and pixelHeight variables.

smooth

public void smooth()

smooth

public void smooth(int level)

Draws all geometry with smooth (anti-aliased) edges. This behavior is the default, so smooth() only needs to be used when a program needs to set the smoothing in a different way. The level parameter increases the amount of smoothness. This is the level of over sampling applied to the graphics buffer.

With the P2D and P3D renderers, smooth(2) is the default, this is called "2x anti-aliasing." The code smooth(4) is used for 4x anti-aliasing and smooth(8) is specified for "8x anti-aliasing." The maximum anti-aliasing level is determined by the hardware of the machine that is running the software, so smooth(4) and smooth(8) will not work with every computer.

The default renderer uses smooth(3) by default. This is bicubic smoothing. The other option for the default renderer is smooth(2), which is bilinear smoothing.

With Processing 3.0, smooth() is handled differently than in earlier releases. In 2.x and earlier, it was possible to use smooth() and noSmooth() to turn on and off antialiasing within a sketch. Now, because of how the software has changed, smooth() can only be set once within a sketch. It can be used either at the top of a sketch without a setup(), or after the size() function when used in a sketch with setup(). The noSmooth() function also follows the same rules.

When smooth() is used with a PGraphics object, it should be run right after the object is created with createGraphics(), as shown in the Reference in the third example.

Parameters:

level - either 2, 3, 4, or 8 depending on the renderer

noSmooth

public void noSmooth()

Draws all geometry and fonts with jagged (aliased) edges and images with hard edges between the pixels when enlarged rather than interpolating pixels. Note that smooth() is active by default, so it is necessary to call noSmooth() to disable smoothing of geometry, fonts, and images. Since the release of Processing 3.0, the noSmooth() function can only be run once for each sketch, either at the top of a sketch without a setup(), or after the size() function when used in a sketch with setup(). See the examples above for both scenarios.

getGraphics

public PGraphics getGraphics()

orientation

public void orientation(int which)

start

public void start()

Called by the application context to start running (or resume) the sketch.

stop

public void stop()

Called by the application context to stop running (or pause) the sketch.

pause

public void pause()

Sketch has been paused. Called when switching tabs in a browser or swapping to a different application on Android. Also called just before quitting. Use to safely disable things like serial, sound, or sensors.

resume

public void resume()

Sketch has resumed. Called when switching tabs in a browser or swapping to this application on Android. Also called on startup. Use this to safely disable things like serial, sound, or sensors.

registerMethod

public void registerMethod(String methodName,
 Object target)

Register a built-in event so that it can be fired for libraries, etc. Supported events include:

• pre – at the very top of the draw() method (safe to draw)
• draw – at the end of the draw() method (safe to draw)
• post – after draw() has exited (not safe to draw)
• pause – called when the sketch is paused
• resume – called when the sketch is resumed
• dispose – when the sketch is shutting down (definitely not safe to draw)
  In addition, the new (for 2.0) processing.event classes are passed to the following event types:
  • mouseEvent
  • keyEvent
  • touchEvent
  The older java.awt events are no longer supported. See the Library Wiki page for more details.

Parameters:

methodName - name of the method to be called

target - the target object that should receive the event

unregisterMethod

public void unregisterMethod(String name,
 Object target)

setup

public void setup()

The setup() function is run once, when the program starts. It's used to define initial environment properties such as screen size and to load media such as images and fonts as the program starts. There can only be one setup() function for each program, and it shouldn't be called again after its initial execution.

If the sketch is a different dimension than the default, the size() function or fullScreen() function must be the first line in setup().

Note: Variables declared within setup() are not accessible within other functions, including draw().

See Also:

• size(int, int)
• loop()
• noLoop()
• draw()

Usage:

web_application

draw

public void draw()

Called directly after setup(), the draw() function continuously executes the lines of code contained inside its block until the program is stopped or noLoop() is called. draw() is called automatically and should never be called explicitly. All Processing programs update the screen at the end of draw(), never earlier.

To stop the code inside of draw() from running continuously, use noLoop(), redraw() and loop(). If noLoop() is used to stop the code in draw() from running, then redraw() will cause the code inside draw() to run a single time, and loop() will cause the code inside draw() to resume running continuously.

The number of times draw() executes in each second may be controlled with the frameRate() function.

It is common to call background() near the beginning of the draw() loop to clear the contents of the window, as shown in the first example above. Since pixels drawn to the window are cumulative, omitting background() may result in unintended results.

There can only be one draw() function for each sketch, and draw() must exist if you want the code to run continuously, or to process events such as mousePressed(). Sometimes, you might have an empty call to draw() in your program, as shown in the second example above.

See Also:

• setup()
• loop()
• noLoop()
• redraw()
• frameRate(float)
• PGraphics.background(float, float, float, float)

Usage:

web_application

fullScreen

public void fullScreen()

Create a full-screen sketch using the default renderer.

fullScreen

public void fullScreen(int display)

fullScreen

public void fullScreen(String renderer)

This function is new for Processing 3.0. It opens a sketch using the full size of the computer's display. This function must be the first line in setup(). The size() and fullScreen() functions cannot both be used in the same program, just choose one.

When fullScreen() is used without a parameter, it draws the sketch to the screen currently selected inside the Preferences window. When it is used with a single parameter, this number defines the screen to display to program on (e.g. 1, 2, 3...). When used with two parameters, the first defines the renderer to use (e.g. P2D) and the second defines the screen. The SPAN parameter can be used in place of a screen number to draw the sketch as a full-screen window across all the attached displays if there are more than one.

Prior to Processing 3.0, a full-screen program was defined with size(displayWidth, displayHeight).

Parameters:

renderer - the renderer to use, e.g. P2D, P3D, JAVA2D (default)

See Also:

• settings()
• setup()
• size(int,int)
• smooth()

fullScreen

public void fullScreen(String renderer,
 int display)

Parameters:

display - the screen to run the sketch on (1, 2, 3, etc. or on multiple screens using SPAN)

size

public void size(int width,
 int height)

Defines the dimension of the display window width and height in units of pixels. In a program that has the setup() function, the size() function must be the first line of code inside setup(), and the setup() function must appear in the code tab with the same name as your sketch folder.

The built-in variables width and height are set by the parameters passed to this function. For example, running size(640, 480) will assign 640 to the width variable and 480 to the height variable. If size() is not used, the window will be given a default size of 100 x 100 pixels.

The size() function can only be used once inside a sketch, and it cannot be used for resizing. Use windowResize() instead.

To run a sketch that fills the screen, use the fullScreen() function, rather than using size(displayWidth, displayHeight).

The renderer parameter selects which rendering engine to use. For example, if you will be drawing 3D shapes, use P3D. The default renderer is slower for some situations (for instance large or high-resolution displays) but generally has higher quality than the other renderers for 2D drawing.

In addition to the default renderer, other renderers are:

P2D (Processing 2D): 2D graphics renderer that makes use of OpenGL-compatible graphics hardware.

P3D (Processing 3D): 3D graphics renderer that makes use of OpenGL-compatible graphics hardware.

FX2D (JavaFX 2D): A 2D renderer that uses JavaFX, which may be faster for some applications, but has some compatibility quirks. Use “Manage Libraries” to download and install the JavaFX library.

PDF: The PDF renderer draws 2D graphics directly to an Acrobat PDF file. This produces excellent results when you need vector shapes for high-resolution output or printing. You must first use Import Library → PDF to make use of the library. More information can be found in the PDF library reference.

SVG: The SVG renderer draws 2D graphics directly to an SVG file. This is great for importing into other vector programs or using for digital fabrication. It is not as feature-complete as other renderers. Like PDF, you must first use Import Library → SVG Export to make use the SVG library.

As of Processing 3.0, to use variables as the parameters to size() function, place the size() function within the settings() function (instead of setup()). There is more information about this on the settings() reference page.

The maximum width and height is limited by your operating system, and is usually the width and height of your actual screen. On some machines it may simply be the number of pixels on your current screen, meaning that a screen of 800 x 600 could support size(1600, 300), since that is the same number of pixels. This varies widely, so you'll have to try different rendering modes and sizes until you get what you're looking for. If you need something larger, use createGraphics to create a non-visible drawing surface.

The minimum width and height is around 100 pixels in each direction. This is the smallest that is supported across Windows, macOS, and Linux. We enforce the minimum size so that sketches will run identically on different machines.

Parameters:

width - width of the display window in units of pixels

height - height of the display window in units of pixels

See Also:

• width
• height
• setup()
• settings()
• fullScreen()

size

public void size(int width,
 int height,
 String renderer)

size

public void size(int width,
 int height,
 String renderer,
 String path)

createGraphics

public PGraphics createGraphics(int w,
 int h)

createGraphics

public PGraphics createGraphics(int w,
 int h,
 String renderer)

Creates and returns a new PGraphics object. Use this class if you need to draw into an offscreen graphics buffer. The first two parameters define the width and height in pixels. The third, optional parameter specifies the renderer. It can be defined as P2D, P3D, PDF, or SVG. If the third parameter isn't used, the default renderer is set. The PDF and SVG renderers require the filename parameter.

It's important to consider the renderer used with createGraphics() in relation to the main renderer specified in size(). For example, it's only possible to use P2D or P3D with createGraphics() when one of them is defined in size(). Unlike Processing 1.0, P2D and P3D use OpenGL for drawing, and when using an OpenGL renderer it's necessary for the main drawing surface to be OpenGL-based. If P2D or P3D are used as the renderer in size(), then any of the options can be used with createGraphics(). If the default renderer is used in size(), then only the default, PDF, or SVG can be used with createGraphics().

It's important to run all drawing functions between the beginDraw() and endDraw(). As the exception to this rule, smooth() should be run on the PGraphics object before beginDraw(). See the reference for smooth() for more detail.

The createGraphics() function should almost never be used inside draw() because of the memory and time needed to set up the graphics. One-time or occasional use during draw() might be acceptable, but code that calls createGraphics() at 60 frames per second might run out of memory or freeze your sketch.

Unlike the main drawing surface which is completely opaque, surfaces created with createGraphics() can have transparency. This makes it possible to draw into a graphics and maintain the alpha channel. By using save() to write a PNG or TGA file, the transparency of the graphics object will be honored.

Advanced

Create an offscreen PGraphics object for drawing. This can be used for bitmap or vector images drawing or rendering.

• Do not use "new PGraphicsXxxx()", use this method. This method ensures that internal variables are set up properly that tie the new graphics context back to its parent PApplet.
• The basic way to create bitmap images is to use the saveFrame() function.
• If you want to create a really large scene and write that, first make sure that you've allocated a lot of memory in the Preferences.
• If you want to create images that are larger than the screen, you should create your own PGraphics object, draw to that, and use save().

  
   PGraphics big;
  
   void setup() {
     big = createGraphics(3000, 3000);
  
     big.beginDraw();
     big.background(128);
     big.line(20, 1800, 1800, 900);
     // etc..
     big.endDraw();
  
     // make sure the file is written to the sketch folder
     big.save("big.tif");
   }
  
   

• It's important to always wrap drawing to createGraphics() with beginDraw() and endDraw() (beginFrame() and endFrame() prior to revision 0115). The reason is that the renderer needs to know when drawing has stopped, so that it can update itself internally. This also handles calling the defaults() method, for people familiar with that.
• With Processing 0115 and later, it's possible to write images in formats other than the default .tga and .tiff. The exact formats and background information can be found in the developer's reference for PImage.save().

Parameters:

w - width in pixels

h - height in pixels

renderer - Either P2D, P3D, or PDF

See Also:

• PGraphics()

createGraphics

public PGraphics createGraphics(int w,
 int h,
 String renderer,
 String path)

Create an offscreen graphics surface for drawing, in this case for a renderer that writes to a file (such as PDF or DXF).

Parameters:

path - the name of the file (can be an absolute or relative path)

createImage

public PImage createImage(int w,
 int h,
 int format)

Creates a new PImage (the datatype for storing images). This provides a fresh buffer of pixels to play with. Set the size of the buffer with the width and height parameters. The format parameter defines how the pixels are stored. See the PImage reference for more information.

Be sure to include all three parameters, specifying only the width and height (but no format) will produce a strange error.

Advanced users please note that createImage() should be used instead of the syntax new PImage().

Advanced

Preferred method of creating new PImage objects, ensures that a reference to the parent PApplet is included, which makes save() work without needing an absolute path.

Parameters:

w - width in pixels

h - height in pixels

format - Either RGB, ARGB, ALPHA (grayscale alpha channel)

See Also:

• PImage
• PGraphics

handleDraw

public void handleDraw()

redraw

public void redraw()

Executes the code within draw() one time. This functions allows the program to update the display window only when necessary, for example when an event registered by mousePressed() or keyPressed() occurs.

In structuring a program, it only makes sense to call redraw() within events such as mousePressed(). This is because redraw() does not run draw() immediately (it only sets a flag that indicates an update is needed).

The redraw() function does not work properly when called inside draw(). To enable/disable animations, use loop() and noLoop().

See Also:

• draw()
• loop()
• noLoop()
• frameRate(float)

Usage:

web_application

loop

public void loop()

By default, Processing loops through draw() continuously, executing the code within it. However, the draw() loop may be stopped by calling noLoop(). In that case, the draw() loop can be resumed with loop().

See Also:

• noLoop()
• redraw()
• draw()

Usage:

web_application

noLoop

public void noLoop()

Stops Processing from continuously executing the code within draw(). If loop() is called, the code in draw() begin to run continuously again. If using noLoop() in setup(), it should be the last line inside the block.

When noLoop() is used, it's not possible to manipulate or access the screen inside event handling functions such as mousePressed() or keyPressed(). Instead, use those functions to call redraw() or loop(), which will run draw(), which can update the screen properly. This means that when noLoop() has been called, no drawing can happen, and functions like saveFrame() or loadPixels() may not be used.

Note that if the sketch is resized, redraw() will be called to update the sketch, even after noLoop() has been specified. Otherwise, the sketch would enter an odd state until loop() was called.

See Also:

• loop()
• redraw()
• draw()

Usage:

web_application

isLooping

public boolean isLooping()

postEvent

public void postEvent(Event pe)

Add an event to the internal event queue, or process it immediately if the sketch is not currently looping.

mousePressed

public void mousePressed()

The mousePressed() function is called once after every time a mouse button is pressed. The mouseButton variable (see the related reference entry) can be used to determine which button has been pressed.

Mouse and keyboard events only work when a program has draw(). Without draw(), the code is only run once and then stops listening for events.

Advanced

If you must, use int button = mouseEvent.getButton(); to figure out which button was clicked. It will be one of: MouseEvent.BUTTON1, MouseEvent.BUTTON2, MouseEvent.BUTTON3 Note, however, that this is completely inconsistent across platforms.

See Also:

• mouseX
• mouseY
• pmouseX
• pmouseY
• mousePressed
• mouseReleased()
• mouseClicked()
• mouseMoved()
• mouseDragged()
• mouseButton
• mouseWheel(MouseEvent)

mousePressed

public void mousePressed(MouseEvent event)

mouseReleased

public void mouseReleased()

The mouseReleased() function is called every time a mouse button is released.

Mouse and keyboard events only work when a program has draw(). Without draw(), the code is only run once and then stops listening for events.

See Also:

• mouseX
• mouseY
• pmouseX
• pmouseY
• mousePressed
• mousePressed()
• mouseClicked()
• mouseMoved()
• mouseDragged()
• mouseButton
• mouseWheel(MouseEvent)

mouseReleased

public void mouseReleased(MouseEvent event)

mouseClicked

public void mouseClicked()

The mouseClicked() function is called after a mouse button has been pressed and then released.

Mouse and keyboard events only work when a program has draw(). Without draw(), the code is only run once and then stops listening for events.

Advanced

When the mouse is clicked, mousePressed() will be called, then mouseReleased(), then mouseClicked(). Note that mousePressed is already false inside mouseClicked().

See Also:

• mouseX
• mouseY
• pmouseX
• pmouseY
• mousePressed
• mousePressed()
• mouseReleased()
• mouseMoved()
• mouseDragged()
• mouseButton
• mouseWheel(MouseEvent)

mouseClicked

public void mouseClicked(MouseEvent event)

mouseDragged

public void mouseDragged()

The mouseDragged() function is called once every time the mouse moves while a mouse button is pressed. (If a button is not being pressed, mouseMoved() is called instead.)

Mouse and keyboard events only work when a program has draw(). Without draw(), the code is only run once and then stops listening for events.

See Also:

• mouseX
• mouseY
• pmouseX
• pmouseY
• mousePressed
• mousePressed()
• mouseReleased()
• mouseClicked()
• mouseMoved()
• mouseButton
• mouseWheel(MouseEvent)

mouseDragged

public void mouseDragged(MouseEvent event)

mouseMoved

public void mouseMoved()

The mouseMoved() function is called every time the mouse moves and a mouse button is not pressed. (If a button is being pressed, mouseDragged() is called instead.)

Mouse and keyboard events only work when a program has draw(). Without draw(), the code is only run once and then stops listening for events.

See Also:

• mouseX
• mouseY
• pmouseX
• pmouseY
• mousePressed
• mousePressed()
• mouseReleased()
• mouseClicked()
• mouseDragged()
• mouseButton
• mouseWheel(MouseEvent)

mouseMoved

public void mouseMoved(MouseEvent event)

mouseEntered

public void mouseEntered()

mouseEntered

public void mouseEntered(MouseEvent event)

mouseExited

public void mouseExited()

mouseExited

public void mouseExited(MouseEvent event)

mouseWheel

public void mouseWheel()

mouseWheel

public void mouseWheel(MouseEvent event)

The code within the mouseWheel() event function is run when the mouse wheel is moved. (Some mice don't have wheels and this function is only applicable with mice that have a wheel.) The getCount() function used within mouseWheel() returns positive values when the mouse wheel is rotated down (toward the user), and negative values for the other direction (up or away from the user). On OS X with "natural" scrolling enabled, the values are opposite.

Mouse and keyboard events only work when a program has draw(). Without draw(), the code is only run once and then stops listening for events.

Parameters:

event - the MouseEvent

See Also:

• mouseX
• mouseY
• pmouseX
• pmouseY
• mousePressed
• mousePressed()
• mouseReleased()
• mouseClicked()
• mouseMoved()
• mouseDragged()
• mouseButton

keyPressed

public void keyPressed()

The keyPressed() function is called once every time a key is pressed. The key that was pressed is stored in the key variable.

For non-ASCII keys, use the keyCode variable. The keys included in the ASCII specification (BACKSPACE, TAB, ENTER, RETURN, ESC, and DELETE) do not require checking to see if the key is coded; for those keys, you should simply use the key variable directly (and not keyCode). If you're making cross-platform projects, note that the ENTER key is commonly used on PCs and Unix, while the RETURN key is used on Macs. Make sure your program will work on all platforms by checking for both ENTER and RETURN.

Because of how operating systems handle key repeats, holding down a key may cause multiple calls to keyPressed(). The rate of repeat is set by the operating system, and may be configured differently on each computer.

Note that there is a similarly named boolean variable called keyPressed. See its reference page for more information.

Mouse and keyboard events only work when a program has draw(). Without draw(), the code is only run once and then stops listening for events.

With the release of macOS Sierra, Apple changed how key repeat works, so keyPressed may not function as expected. See here for details of the problem and how to fix it.

Advanced

Called each time a single key on the keyboard is pressed. Because of how operating systems handle key repeats, holding down a key will cause multiple calls to keyPressed(), because the OS repeat takes over.

Examples for key handling: (Tested on Windows XP, please notify if different on other platforms, I have a feeling macOS and Linux may do otherwise)

 1. Pressing 'a' on the keyboard:
    keyPressed  with key == 'a' and keyCode == 'A'
    keyTyped    with key == 'a' and keyCode ==  0
    keyReleased with key == 'a' and keyCode == 'A'

 2. Pressing 'A' on the keyboard:
    keyPressed  with key == 'A' and keyCode == 'A'
    keyTyped    with key == 'A' and keyCode ==  0
    keyReleased with key == 'A' and keyCode == 'A'

 3. Pressing 'shift', then 'a' on the keyboard (caps lock is off):
    keyPressed  with key == CODED and keyCode == SHIFT
    keyPressed  with key == 'A'   and keyCode == 'A'
    keyTyped    with key == 'A'   and keyCode == 0
    keyReleased with key == 'A'   and keyCode == 'A'
    keyReleased with key == CODED and keyCode == SHIFT

 4. Holding down the 'a' key.
    The following will happen several times,
    depending on your machine's "key repeat rate" settings:
    keyPressed  with key == 'a' and keyCode == 'A'
    keyTyped    with key == 'a' and keyCode ==  0
    When you finally let go, you'll get:
    keyReleased with key == 'a' and keyCode == 'A'

 5. Pressing and releasing the 'shift' key
    keyPressed  with key == CODED and keyCode == SHIFT
    keyReleased with key == CODED and keyCode == SHIFT
    (note there is no keyTyped)

 6. Pressing the tab key in a Component with Java 1.4 will
    normally do nothing, but PApplet dynamically shuts
    this behavior off if Java 1.4 is in use (tested 1.4.2_05 Windows).
    Java 1.1 (Microsoft VM) passes the TAB key through normally.
    Not tested on other platforms or for 1.3.
 

See Also:

• key
• keyCode
• keyPressed
• keyReleased()

keyPressed

public void keyPressed(KeyEvent event)

keyReleased

public void keyReleased()

The keyReleased() function is called once every time a key is released. The key that was released will be stored in the key variable. See key and keyCode for more information.

Mouse and keyboard events only work when a program has draw(). Without draw(), the code is only run once and then stops listening for events.

See Also:

• key
• keyCode
• keyPressed
• keyPressed()

keyReleased

public void keyReleased(KeyEvent event)

keyTyped

public void keyTyped()

The keyTyped() function is called once every time a key is pressed, but action keys such as Ctrl, Shift, and Alt are ignored.

Because of how operating systems handle key repeats, holding down a key may cause multiple calls to keyTyped(). The rate of repeat is set by the operating system, and may be configured differently on each computer.

Mouse and keyboard events only work when a program has draw(). Without draw(), the code is only run once and then stops listening for events.

See Also:

• keyPressed
• key
• keyCode
• keyReleased()

keyTyped

public void keyTyped(KeyEvent event)

focusGained

public void focusGained()

focusLost

public void focusLost()

millis

public int millis()

Returns the number of milliseconds (thousandths of a second) since starting the sketch. This information is often used for timing animation sequences.

Advanced

This is a function, rather than a variable, because it may change multiple times per frame.

See Also:

• second()
• minute()
• hour()
• day()
• month()
• year()

second

public static int second()

Processing communicates with the clock on your computer. The second() function returns the current second as a value from 0 to 59.

See Also:

• millis()
• minute()
• hour()
• day()
• month()
• year()

minute

public static int minute()

Processing communicates with the clock on your computer. The minute() function returns the current minute as a value from 0 to 59.

See Also:

• millis()
• second()
• hour()
• day()
• month()
• year()

hour

public static int hour()

Processing communicates with the clock on your computer. The hour() function returns the current hour as a value from 0 to 23.

See Also:

• millis()
• second()
• minute()
• day()
• month()
• year()

day

public static int day()

Processing communicates with the clock on your computer. The day() function returns the current day as a value from 1 to 31.

Advanced

Get the current day of the month (1 through 31).

If you're looking for the day of the week (M-F or whatever) or day of the year (1..365) then use java's Calendar.get()

See Also:

• millis()
• second()
• minute()
• hour()
• month()
• year()

month

public static int month()

Processing communicates with the clock on your computer. The month() function returns the current month as a value from 1 to 12.

See Also:

• millis()
• second()
• minute()
• hour()
• day()
• year()

year

public static int year()

Processing communicates with the clock on your computer. The year() function returns the current year as an integer (2003, 2004, 2005, etc).

See Also:

• millis()
• second()
• minute()
• hour()
• day()
• month()

delay

public void delay(int napTime)

The delay() function causes the program to halt for a specified time. Delay times are specified in thousandths of a second. For example, running delay(3000) will stop the program for three seconds and delay(500) will stop the program for a half-second.

The screen only updates when the end of draw() is reached, so delay() cannot be used to slow down drawing. For instance, you cannot use delay() to control the timing of an animation.

The delay() function should only be used for pausing scripts (i.e. a script that needs to pause a few seconds before attempting a download, or a sketch that needs to wait a few milliseconds before reading from the serial port).

Parameters:

napTime - milliseconds to pause before running draw() again

See Also:

• frameRate
• draw()

frameRate

public void frameRate(float fps)

Specifies the number of frames to be displayed every second. For example, the function call frameRate(30) will attempt to refresh 30 times a second. If the processor is not fast enough to maintain the specified rate, the frame rate will not be achieved. Setting the frame rate within setup() is recommended. The default rate is 60 frames per second.

Parameters:

fps - number of desired frames per second

See Also:

• frameRate
• frameCount
• setup()
• draw()
• loop()
• noLoop()
• redraw()

link

public void link(String url)

Links to a webpage either in the same window or in a new window. The complete URL must be specified.

Parameters:

url - the complete URL, as a String in quotes

launch

public static Process launch(String... args)

Attempts to open an application or file using your platform's launcher. The filename parameter is a String specifying the file name and location. The location parameter must be a full path name, or the name of an executable in the system's PATH. In most cases, using a full path is the best option, rather than relying on the system PATH. Be sure to make the file executable before attempting to open it (chmod +x).

This function (roughly) emulates what happens when you double-click an application or document in the macOS Finder, the Windows Explorer, or your favorite Linux file manager. If you're trying to run command line functions directly, use the exec() function instead (see below).

This function behaves differently on each platform. On Windows, the parameters are sent to the Windows shell via "cmd /c". On Mac OS X, the "open" command is used (type "man open" in Terminal.app for documentation). On Linux, it first tries gnome-open, then kde-open, but if neither are available, it sends the command to the shell and prays that something useful happens.

For users familiar with Java, this is not the same as Runtime.exec(), because the launcher command is prepended. Instead, the exec(String[]) function is a shortcut for Runtime.getRuntime.exec(String[]). The exec() function is documented in the JavaDoc in the PApplet class.

Parameters:

args - arguments to the launcher, e.g. a filename.

Usage:

Application

exec

public static Process exec(String... args)

Pass a set of arguments directly to the command line. Uses Java's Runtime.exec() method. This is different from the launch() method, which uses the operating system's launcher to open the files. It's always a good idea to use a full path to the executable here.

 exec("/usr/bin/say", "welcome to the command line");
 

Or if you want to wait until it's completed, something like this:

 Process p = exec("/usr/bin/say", "waiting until done");
 try {
   int result = p.waitFor();
   println("the process returned " + result);
 } catch (InterruptedException e) { }
 

You can also get the system output and error streams from the Process object, but that's more that we'd like to cover here.

Returns:

a Process object

exec

public static int exec(StringList stdout,
 StringList stderr,
 String... args)

Alternative version of exec() that retrieves stdout and stderr into the StringList objects provided. This is a convenience function that handles simple exec() calls. If the results will be more than a couple lines, you shouldn't use this function, you should use a more elaborate method that makes use of proper threading (to drain the shell output) and error handling to address the many things that can go wrong within this method.

Parameters:

stdout - a non-null StringList object to be filled with any output

stderr - a non-null StringList object to be filled with error lines

args - each argument to be passed as a series of String objects

Returns:

the result returned from the application, or -1 if an Exception occurs before the application is able to return a result.

shell

public static int shell(StringList stdout,
 StringList stderr,
 String... args)

Same as exec() above, but prefixes the call with a shell.

die

public void die(String what)

Function for an application to kill itself and display an error. Mostly this is here to be improved later.

die

public void die(String what,
 Exception e)

Same as above but with an exception. Also needs work.

exit

public void exit()

Quits/stops/exits the program. Programs without a draw() function exit automatically after the last line has run, but programs with draw() run continuously until the program is manually stopped or exit() is run.

Rather than terminating immediately, exit() will cause the sketch to exit after draw() has completed (or after setup() completes if called during the setup() function).

For Java programmers, this is not the same as System.exit(). Further, System.exit() should not be used because closing out an application while draw() is running may cause a crash (particularly with P3D).

exitCalled

public boolean exitCalled()

exitActual

public void exitActual()

Some subclasses (I'm looking at you, processing.py) might wish to do something other than actually terminate the JVM. This gives them a chance to do whatever they have in mind when cleaning up.

dispose

public void dispose()

Called to dispose of resources and shut down the sketch. Destroys the thread, dispose the renderer,and notify listeners.

Not to be called or overridden by users. If called multiple times, will only notify listeners once. Register a "dispose" listener instead.

method

public void method(String name)

Call a method in the current class based on its name.

Note that the function being called must be public. Inside the PDE, 'public' is automatically added, but when used without the preprocessor, (like from Eclipse) you'll have to do it yourself.

thread

public void thread(String name)

Processing sketches follow a specific sequence of steps: setup() first, followed by draw() over and over and over again in a loop. A thread is also a series of steps with a beginning, a middle, and an end. A Processing sketch is a single thread, often referred to as the "Animation" thread. Other threads' sequences, however, can run independently of the main animation loop. In fact, you can launch any number of threads at one time, and they will all run concurrently.

You cannot draw to the screen from a function called by thread(). Because it runs independently, the code will not be synchronized to the animation thread, causing strange or at least inconsistent results. Use thread() to load files or do other tasks that take time. When the task is finished, set a variable that indicates the task is complete, and check that from inside your draw() method.

Processing uses threads quite often, such as with library functions like captureEvent() and movieEvent(). These functions are triggered by a different thread running behind the scenes, and they alert Processing whenever they have something to report. This is useful when you need to perform a task that takes too long and would slow down the main animation's frame rate, such as grabbing data from the network. If a separate thread gets stuck or has an error, the entire program won't grind to a halt, since the error only stops that individual thread.

Writing your own thread can be a complex endeavor that involves extending the Java Thread class. However, the thread() method is a quick and dirty way to implement a simple thread in Processing. By passing in a String that matches the name of a function declared elsewhere in the sketch, Processing will execute that function in a separate thread.

Parameters:

name - name of the function to be executed in a separate thread

See Also:

• setup()
• draw()
• loop()
• noLoop()

Usage:

Application

save

public void save(String filename)

Saves an image from the display window. Append a file extension to the name of the file, to indicate the file format to be used: either TIFF (.tif), TARGA (.tga), JPEG (.jpg), or PNG (.png). If no extension is included in the filename, the image will save in TIFF format and .tif will be added to the name. These files are saved to the sketch's folder, which may be opened by selecting "Show sketch folder" from the "Sketch" menu. Alternatively, the files can be saved to any location on the computer by using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows).

All images saved from the main drawing window will be opaque. To save images without a background, use createGraphics().

Parameters:

filename - any sequence of letters and numbers

See Also:

• saveFrame()
• createGraphics(int, int, String)

saveFrame

public void saveFrame()

saveFrame

public void saveFrame(String filename)

Saves a numbered sequence of images, one image each time the function is run. To save an image that is identical to the display window, run the function at the end of draw() or within mouse and key events such as mousePressed() and keyPressed(). Use the Movie Maker program in the Tools menu to combine these images to a movie.

If saveFrame() is used without parameters, it will save files as screen-0000.tif, screen-0001.tif, and so on. You can specify the name of the sequence with the filename parameter, including hash marks (####), which will be replaced by the current frameCount value. (The number of hash marks is used to determine how many digits to include in the file names.) Append a file extension, to indicate the file format to be used: either TIFF (.tif), TARGA (.tga), JPEG (.jpg), or PNG (.png). Image files are saved to the sketch's folder, which may be opened by selecting "Show Sketch Folder" from the "Sketch" menu.

Alternatively, the files can be saved to any location on the computer by using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows).

All images saved from the main drawing window will be opaque. To save images without a background, use createGraphics().

Parameters:

filename - any sequence of letters or numbers that ends with either ".tif", ".tga", ".jpg", or ".png"

See Also:

• save(String)
• createGraphics(int, int, String, String)
• frameCount

insertFrame

public String insertFrame(String what)

Check a string for #### signs to see if the frame number should be inserted. Used for functions like saveFrame() and beginRecord() to replace the # marks with the frame number. If only one # is used, it will be ignored, under the assumption that it's probably not intended to be the frame number.

cursor

public void cursor(int kind)

Set the cursor type

Parameters:

kind - either ARROW, CROSS, HAND, MOVE, TEXT, or WAIT

cursor

public void cursor(PImage img)

Replace the cursor with the specified PImage. The x- and y- coordinate of the center will be the center of the image.

cursor

public void cursor(PImage img,
 int x,
 int y)

Sets the cursor to a predefined symbol or an image, or makes it visible if already hidden. If you are trying to set an image as the cursor, the recommended size is 16x16 or 32x32 pixels. The values for parameters x and y must be less than the dimensions of the image.

Setting or hiding the cursor does not generally work with "Present" mode (when running full-screen).

With the P2D and P3D renderers, a generic set of cursors are used because the OpenGL renderer doesn't have access to the default cursor images for each platform (Issue 3791).

Parameters:

img - any variable of type PImage

x - the horizontal active spot of the cursor

y - the vertical active spot of the cursor

See Also:

• noCursor()

cursor

public void cursor()

Show the cursor after noCursor() was called. Notice that the program remembers the last set cursor type

noCursor

public void noCursor()

Hides the cursor from view. Will not work when running the program in a web browser or when running in full screen (Present) mode.

Advanced

Hide the cursor by creating a transparent image and using it as a custom cursor.

See Also:

• cursor()

Usage:

Application

print

public static void print(byte what)

The print() function writes to the console area, the black rectangle at the bottom of the Processing environment. This function is often helpful for looking at the data a program is producing. The companion function println() works like print(), but creates a new line of text for each call to the function. More than one parameter can be passed into the function by separating them with commas. Alternatively, individual elements can be separated with quotes ("") and joined with the addition operator (+).

Using print() on an object will output null, a memory location that may look like "@10be08," or the result of the toString() method from the object that's being printed. Advanced users who want more useful output when calling print() on their own classes can add a toString() method to the class that returns a String.

Note that the console is relatively slow. It works well for occasional messages, but does not support high-speed, real-time output (such as at 60 frames per second). It should also be noted, that a print() within a for loop can sometimes lock up the program, and cause the sketch to freeze.

Parameters:

what - data to print to console

See Also:

• println()
• printArray(Object)
• join(String[], char)

Usage:

IDE

print

public static void print(boolean what)

print

public static void print(char what)

print

public static void print(int what)

print

public static void print(long what)

print

public static void print(float what)

print

public static void print(double what)

print

public static void print(String what)

print

public static void print(Object... variables)

Parameters:

variables - list of data, separated by commas

println

public static void println()

The println() function writes to the console area, the black rectangle at the bottom of the Processing environment. This function is often helpful for looking at the data a program is producing. Each call to this function creates a new line of output. More than one parameter can be passed into the function by separating them with commas. Alternatively, individual elements can be separated with quotes ("") and joined with the addition operator (+).

Before Processing 2.1, println() was used to write array data to the console. Now, use printArray() to write array data to the console.

Note that the console is relatively slow. It works well for occasional messages, but does not support high-speed, real-time output (such as at 60 frames per second). It should also be noted, that a println() within a for loop can sometimes lock up the program, and cause the sketch to freeze.

See Also:

• print(byte)
• printArray(Object)

Usage:

IDE

println

public static void println(byte what)

Parameters:

what - data to print to console

println

public static void println(boolean what)

println

public static void println(char what)

println

public static void println(int what)

println

public static void println(long what)

println

public static void println(float what)

println

public static void println(double what)

println

public static void println(String what)

println

public static void println(Object... variables)

Parameters:

variables - list of data, separated by commas

println

public static void println(Object what)

For arrays, use printArray() instead. This function causes a warning because the new print(Object...) and println(Object...) functions can't be reliably bound by the compiler.

printArray

public static void printArray(Object what)

The printArray() function writes array data to the text area of the Processing environment's console. A new line is put between each element of the array. This function can only print one dimensional arrays. Note that the console is relatively slow. It works well for occasional messages, but does not support high-speed, real-time output (such as at 60 frames per second).

Parameters:

what - one-dimensional array

See Also:

• print(byte)
• println()

Usage:

IDE

debug

public static void debug(String msg)

abs

public static final float abs(float n)

Calculates the absolute value (magnitude) of a number. The absolute value of a number is always positive.

Parameters:

n - number to compute

abs

public static final int abs(int n)

sq

public static final float sq(float n)

Squares a number (multiplies a number by itself). The result is always a positive number, as multiplying two negative numbers always yields a positive result. For example, -1 * -1 = 1.

Parameters:

n - number to square

See Also:

• sqrt(float)

sqrt

public static final float sqrt(float n)

Calculates the square root of a number. The square root of a number is always positive, even though there may be a valid negative root. The square root s of number a is such that s*s = a. It is the opposite of squaring.

Parameters:

n - non-negative number

See Also:

• pow(float, float)
• sq(float)

log

public static final float log(float n)

Calculates the natural logarithm (the base-e logarithm) of a number. This function expects the values greater than 0.0.

Parameters:

n - number greater than 0.0

exp

public static final float exp(float n)

Returns Euler's number e (2.71828...) raised to the power of the value parameter.

Parameters:

n - exponent to raise

pow

public static final float pow(float n,
 float e)

Facilitates exponential expressions. The pow() function is an efficient way of multiplying numbers by themselves (or their reciprocal) in large quantities. For example, pow(3, 5) is equivalent to the expression 3*3*3*3*3 and pow(3, -5) is equivalent to 1 / 3*3*3*3*3.

Parameters:

n - base of the exponential expression

e - power by which to raise the base

See Also:

• sqrt(float)

max

public static final int max(int a,
 int b)

Determines the largest value in a sequence of numbers, and then returns that value. max() accepts either two or three float or int values as parameters, or an array of any length.

Parameters:

a - first number to compare

b - second number to compare

See Also:

• min(float, float, float)

max

public static final float max(float a,
 float b)

max

public static final int max(int a,
 int b,
 int c)

Parameters:

c - third number to compare

max

public static final float max(float a,
 float b,
 float c)

max

public static final int max(int[] list)

Parameters:

list - array of numbers to compare

max

public static final float max(float[] list)

min

public static final int min(int a,
 int b)

min

public static final float min(float a,
 float b)

min

public static final int min(int a,
 int b,
 int c)

min

public static final float min(float a,
 float b,
 float c)

Determines the smallest value in a sequence of numbers, and then returns that value. min() accepts either two or three float or int values as parameters, or an array of any length.

Parameters:

a - first number

b - second number

c - third number

See Also:

• max(float, float, float)

min

public static final int min(int[] list)

Parameters:

list - array of numbers to compare

min

public static final float min(float[] list)

constrain

public static final int constrain(int amt,
 int low,
 int high)

constrain

public static final float constrain(float amt,
 float low,
 float high)

Constrains a value to not exceed a maximum and minimum value.

Parameters:

amt - the value to constrain

low - minimum limit

high - maximum limit

See Also:

• max(float, float, float)
• min(float, float, float)

sin

public static final float sin(float angle)

Calculates the sine of an angle. This function expects the values of the angle parameter to be provided in radians (values from 0 to 6.28). Values are returned in the range -1 to 1.

Parameters:

angle - an angle in radians

See Also:

• cos(float)
• tan(float)
• radians(float)

cos

public static final float cos(float angle)

Calculates the cosine of an angle. This function expects the values of the angle parameter to be provided in radians (values from 0 to PI*2). Values are returned in the range -1 to 1.

Parameters:

angle - an angle in radians

See Also:

• sin(float)
• tan(float)
• radians(float)

tan

public static final float tan(float angle)

Calculates the ratio of the sine and cosine of an angle. This function expects the values of the angle parameter to be provided in radians (values from 0 to PI*2). Values are returned in the range infinity to -infinity.

Parameters:

angle - an angle in radians

See Also:

• cos(float)
• sin(float)
• radians(float)

asin

public static final float asin(float value)

The inverse of sin(), returns the arc sine of a value. This function expects the values in the range of -1 to 1 and values are returned in the range -PI/2 to PI/2.

Parameters:

value - the value whose arc sine is to be returned

See Also:

• sin(float)
• acos(float)
• atan(float)

acos

public static final float acos(float value)

The inverse of cos(), returns the arc cosine of a value. This function expects the values in the range of -1 to 1 and values are returned in the range 0 to PI (3.1415927).

Parameters:

value - the value whose arc cosine is to be returned

See Also:

• cos(float)
• asin(float)
• atan(float)

atan

public static final float atan(float value)

The inverse of tan(), returns the arc tangent of a value. This function expects the values in the range of -Infinity to Infinity (exclusive) and values are returned in the range -PI/2 to PI/2 .

Parameters:

value - -Infinity to Infinity (exclusive)

See Also:

• tan(float)
• asin(float)
• acos(float)

atan2

public static final float atan2(float y,
 float x)

Calculates the angle (in radians) from a specified point to the coordinate origin as measured from the positive x-axis. Values are returned as a float in the range from PI to -PI. The atan2() function is most often used for orienting geometry to the position of the cursor. Note: The y-coordinate of the point is the first parameter and the x-coordinate is the second due the structure of calculating the tangent.

Parameters:

y - y-coordinate of the point

x - x-coordinate of the point

See Also:

• tan(float)

degrees

public static final float degrees(float radians)

Converts a radian measurement to its corresponding value in degrees. Radians and degrees are two ways of measuring the same thing. There are 360 degrees in a circle and 2*PI radians in a circle. For example, 90° = PI/2 = 1.5707964. All trigonometric functions in Processing require their parameters to be specified in radians.

Parameters:

radians - radian value to convert to degrees

See Also:

• radians(float)

radians

public static final float radians(float degrees)

Converts a degree measurement to its corresponding value in radians. Radians and degrees are two ways of measuring the same thing. There are 360 degrees in a circle and 2*PI radians in a circle. For example, 90° = PI/2 = 1.5707964. All trigonometric functions in Processing require their parameters to be specified in radians.

Parameters:

degrees - degree value to convert to radians

See Also:

• degrees(float)

ceil

public static final int ceil(float n)

Calculates the closest int value that is greater than or equal to the value of the parameter. For example, ceil(9.03) returns the value 10.

Parameters:

n - number to round up

See Also:

• floor(float)
• round(float)

floor

public static final int floor(float n)

Calculates the closest int value that is less than or equal to the value of the parameter.

Parameters:

n - number to round down

See Also:

• ceil(float)
• round(float)

round

public static final int round(float n)

Calculates the integer closest to the n parameter. For example, round(133.8) returns the value 134.

Parameters:

n - number to round

See Also:

• floor(float)
• ceil(float)

mag

public static final float mag(float a,
 float b)

mag

public static final float mag(float a,
 float b,
 float c)

Calculates the magnitude (or length) of a vector. A vector is a direction in space commonly used in computer graphics and linear algebra. Because it has no "start" position, the magnitude of a vector can be thought of as the distance from coordinate (0,0) to its (x,y) value. Therefore, mag() is a shortcut for writing dist(0, 0, x, y).

Parameters:

a - first value

b - second value

c - third value

See Also:

• dist(float, float, float, float)

dist

public static final float dist(float x1,
 float y1,
 float x2,
 float y2)

dist

public static final float dist(float x1,
 float y1,
 float z1,
 float x2,
 float y2,
 float z2)

Calculates the distance between two points.

Parameters:

x1 - x-coordinate of the first point

y1 - y-coordinate of the first point

z1 - z-coordinate of the first point

x2 - x-coordinate of the second point

y2 - y-coordinate of the second point

z2 - z-coordinate of the second point

lerp

public static final float lerp(float start,
 float stop,
 float amt)

Calculates a number between two numbers at a specific increment. The amt parameter is the amount to interpolate between the two values where 0.0 equal to the first point, 0.1 is very near the first point, 0.5 is half-way in between, etc. The lerp function is convenient for creating motion along a straight path and for drawing dotted lines.

Parameters:

start - first value

stop - second value

amt - float between 0.0 and 1.0

See Also:

• PGraphics.curvePoint(float, float, float, float, float)
• PGraphics.bezierPoint(float, float, float, float, float)
• PVector.lerp(PVector, float)
• PGraphics.lerpColor(int, int, float)

norm

public static final float norm(float value,
 float start,
 float stop)

Normalizes a number from another range into a value between 0 and 1. Identical to map(value, low, high, 0, 1).

Numbers outside the range are not clamped to 0 and 1, because out-of-range values are often intentional and useful. (See the second example above.)

Parameters:

value - the incoming value to be converted

start - lower bound of the value's current range

stop - upper bound of the value's current range

See Also:

• map(float, float, float, float, float)
• lerp(float, float, float)

map

public static final float map(float value,
 float start1,
 float stop1,
 float start2,
 float stop2)

Re-maps a number from one range to another.

In the first example above, the number 25 is converted from a value in the range of 0 to 100 into a value that ranges from the left edge of the window (0) to the right edge (width).

As shown in the second example, numbers outside the range are not clamped to the minimum and maximum parameters values, because out-of-range values are often intentional and useful.

Parameters:

value - the incoming value to be converted

start1 - lower bound of the value's current range

stop1 - upper bound of the value's current range

start2 - lower bound of the value's target range

stop2 - upper bound of the value's target range

See Also:

• norm(float, float, float)
• lerp(float, float, float)

random

public final float random(float high)

randomGaussian

public final float randomGaussian()

Returns a float from a random series of numbers having a mean of 0 and standard deviation of 1. Each time the randomGaussian() function is called, it returns a number fitting a Gaussian, or normal, distribution. There is theoretically no minimum or maximum value that randomGaussian() might return. Rather, there is just a very low probability that values far from the mean will be returned; and a higher probability that numbers near the mean will be returned.

See Also:

• random(float,float)
• noise(float, float, float)

random

public final float random(float low,
 float high)

Generates random numbers. Each time the random() function is called, it returns an unexpected value within the specified range. If only one parameter is passed to the function, it will return a float between zero and the value of the high parameter. For example, random(5) returns values between 0 and 5 (starting at zero, and up to, but not including, 5).

If two parameters are specified, the function will return a float with a value between the two values. For example, random(-5, 10.2) returns values starting at -5 and up to (but not including) 10.2. To convert a floating-point random number to an integer, use the int() function.

Parameters:

low - lower limit

high - upper limit

See Also:

• randomSeed(long)
• noise(float, float, float)

randomSeed

public final void randomSeed(long seed)

Sets the seed value for random(). By default, random() produces different results each time the program is run. Set the seed parameter to a constant to return the same pseudo-random numbers each time the software is run.

Parameters:

seed - seed value

See Also:

• random(float,float)
• noise(float, float, float)
• noiseSeed(long)

choice

public final int choice(int high)

Return a random integer from 0 up to (but not including) the specified value for “high”. This is the same as calling random() and casting the result to an int.

choice

public final int choice(int low,
 int high)

Return a random integer from “low” up to (but not including) the specified value for “high”. This is the same as calling random() and casting the result to an int.

noise

public float noise(float x)

noise

public float noise(float x,
 float y)

noise

public float noise(float x,
 float y,
 float z)

Returns the Perlin noise value at specified coordinates. Perlin noise is a random sequence generator producing a more natural, harmonic succession of numbers than that of the standard random() function. It was developed by Ken Perlin in the 1980s and has been used in graphical applications to generate procedural textures, shapes, terrains, and other seemingly organic forms.

In contrast to the random() function, Perlin noise is defined in an infinite n-dimensional space, in which each pair of coordinates corresponds to a fixed semi-random value (fixed only for the lifespan of the program). The resulting value will always be between 0.0 and 1.0. Processing can compute 1D, 2D and 3D noise, depending on the number of coordinates given. The noise value can be animated by moving through the noise space, as demonstrated in the first example above. The 2nd and 3rd dimensions can also be interpreted as time.

The actual noise structure is similar to that of an audio signal, in respect to the function's use of frequencies. Similar to the concept of harmonics in physics, Perlin noise is computed over several octaves which are added together for the final result.

Another way to adjust the character of the resulting sequence is the scale of the input coordinates. As the function works within an infinite space, the value of the coordinates doesn't matter as such; only the distance between successive coordinates is important (such as when using noise() within a loop). As a general rule, the smaller the difference between coordinates, the smoother the resulting noise sequence. Steps of 0.005-0.03 work best for most applications, but this will differ depending on use.

There have been debates over the accuracy of the implementation of noise in Processing. For clarification, it's an implementation of "classic Perlin noise" from 1983, and not the newer "simplex noise" method from 2001.

Parameters:

x - x-coordinate in noise space

y - y-coordinate in noise space

z - z-coordinate in noise space

See Also:

• noiseSeed(long)
• noiseDetail(int, float)
• random(float,float)

noiseDetail

public void noiseDetail(int lod)

Adjusts the character and level of detail produced by the Perlin noise function. Similar to harmonics in physics, noise is computed over several octaves. Lower octaves contribute more to the output signal and as such define the overall intensity of the noise, whereas higher octaves create finer-grained details in the noise sequence.

By default, noise is computed over 4 octaves with each octave contributing exactly half than its predecessor, starting at 50% strength for the first octave. This falloff amount can be changed by adding a function parameter. For example, a falloff factor of 0.75 means each octave will now have 75% impact (25% less) of the previous lower octave. While any number between 0.0 and 1.0 is valid, note that values greater than 0.5 may result in noise() returning values greater than 1.0.

By changing these parameters, the signal created by the noise() function can be adapted to fit very specific needs and characteristics.

Parameters:

lod - number of octaves to be used by the noise

See Also:

• noise(float, float, float)

noiseDetail

public void noiseDetail(int lod,
 float falloff)

Parameters:

falloff - falloff factor for each octave

See Also:

• noiseDetail(int)

noiseSeed

public void noiseSeed(long seed)

Sets the seed value for noise(). By default, noise() produces different results each time the program is run. Set the value parameter to a constant to return the same pseudo-random numbers each time the software is run.

Parameters:

seed - seed value

See Also:

• noise(float, float, float)
• noiseDetail(int, float)
• random(float,float)
• randomSeed(long)

loadImage

public PImage loadImage(String filename)

Loads an image into a variable of type PImage. Four types of images ( .gif, .jpg, .tga, .png) images may be loaded. To load correctly, images must be located in the data directory of the current sketch.

In most cases, load all images in setup() to preload them at the start of the program. Loading images inside draw() will reduce the speed of a program. Images cannot be loaded outside setup() unless they're inside a function that's called after setup() has already run.

Alternatively, the file maybe be loaded from anywhere on the local computer using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows), or the filename parameter can be a URL for a file found on a network.

If the file is not available or an error occurs, null will be returned and an error message will be printed to the console. The error message does not halt the program, however the null value may cause a NullPointerException if your code does not check whether the value returned is null.

The extension parameter is used to determine the image type in cases where the image filename does not end with a proper extension. Specify the extension as the second parameter to loadImage(), as shown in the third example on this page. Note that CMYK images are not supported.

Depending on the type of error, a PImage object may still be returned, but the width and height of the image will be set to -1. This happens if bad image data is returned or cannot be decoded properly. Sometimes this happens with image URLs that produce a 403 error or that redirect to a password prompt, because loadImage() will attempt to interpret the HTML as image data.

Parameters:

filename - name of file to load, can be .gif, .jpg, .tga, or a handful of other image types depending on your platform

See Also:

• PImage
• PGraphics.image(PImage, float, float, float, float)
• PGraphics.imageMode(int)
• PGraphics.background(float, float, float, float)

loadImage

public PImage loadImage(String filename,
 String extension)

Parameters:

extension - type of image to load, for example "png", "gif", "jpg"

requestImage

public PImage requestImage(String filename)

requestImage

public PImage requestImage(String filename,
 String extension)

This function loads images on a separate thread so that your sketch doesn't freeze while images load during setup(). While the image is loading, its width and height will be 0. If an error occurs while loading the image, its width and height will be set to -1. You'll know when the image has loaded properly because its width and height will be greater than 0. Asynchronous image loading (particularly when downloading from a server) can dramatically improve performance.

The extension parameter is used to determine the image type in cases where the image filename does not end with a proper extension. Specify the extension as the second parameter to requestImage().

Parameters:

filename - name of the file to load, can be .gif, .jpg, .tga, or a handful of other image types depending on your platform

extension - the type of image to load, for example "png", "gif", "jpg"

See Also:

• PImage
• loadImage(String, String)

loadXML

public XML loadXML(String filename)

Reads the contents of a file or URL and creates an XML object with its values. If a file is specified, it must be located in the sketch's "data" folder. The filename parameter can also be a URL to a file found online.

All files loaded and saved by the Processing API use UTF-8 encoding. If you need to load an XML file that's not in UTF-8 format, see the developer's reference for the XML object.

Parameters:

filename - name of a file in the data folder or a URL.

See Also:

• XML
• parseXML(String)
• saveXML(XML, String)
• loadBytes(String)
• loadStrings(String)
• loadTable(String)

loadXML

public XML loadXML(String filename,
 String options)

parseXML

public XML parseXML(String xmlString)

Takes a String, parses its contents, and returns an XML object. If the String does not contain XML data or cannot be parsed, a null value is returned.

parseXML() is most useful when pulling data dynamically, such as from third-party APIs. Normally, API results would be saved to a String, and then can be converted to a structured XML object using parseXML(). Be sure to check if null is returned before performing operations on the new XML object, in case the String content could not be parsed.

If your data already exists as an XML file in the data folder, it is simpler to use loadXML().

Parameters:

xmlString - the content to be parsed as XML

Returns:

an XML object, or null

See Also:

• XML
• loadXML(String)
• saveXML(XML, String)

parseXML

public XML parseXML(String xmlString,
 String options)

saveXML

public boolean saveXML(XML xml,
 String filename)

Writes the contents of an XML object to a file. By default, this file is saved to the sketch's folder. This folder is opened by selecting "Show Sketch Folder" from the "Sketch" menu.

Alternatively, the file can be saved to any location on the computer by using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows).

All files loaded and saved by the Processing API use UTF-8 encoding.

Parameters:

xml - the XML object to save to disk

filename - name of the file to write to

See Also:

• XML
• loadXML(String)
• parseXML(String)

saveXML

public boolean saveXML(XML xml,
 String filename,
 String options)

parseJSONObject

public JSONObject parseJSONObject(String input)

Takes a String, parses its contents, and returns a JSONObject. If the String does not contain JSONObject data or cannot be parsed, a null value is returned.

parseJSONObject() is most useful when pulling data dynamically, such as from third-party APIs. Normally, API results would be saved to a String, and then can be converted to a structured JSONObject using parseJSONObject(). Be sure to check if null is returned before performing operations on the new JSONObject in case the String content could not be parsed.

If your data already exists as a JSON file in the data folder, it is simpler to use loadJSONObject().

Parameters:

input - String to parse as a JSONObject

See Also:

• loadJSONObject(String)
• saveJSONObject(JSONObject, String)

loadJSONObject

public JSONObject loadJSONObject(String filename)

Loads a JSON from the data folder or a URL, and returns a JSONObject.

All files loaded and saved by the Processing API use UTF-8 encoding.

Parameters:

filename - name of a file in the data folder or a URL

See Also:

• JSONObject
• JSONArray
• loadJSONArray(String)
• saveJSONObject(JSONObject, String)
• saveJSONArray(JSONArray, String)

loadJSONObject

public static JSONObject loadJSONObject(File file)

saveJSONObject

public boolean saveJSONObject(JSONObject json,
 String filename)

Writes the contents of a JSONObject object to a file. By default, this file is saved to the sketch's folder. This folder is opened by selecting "Show Sketch Folder" from the "Sketch" menu.

Alternatively, the file can be saved to any location on the computer by using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows).

All files loaded and saved by the Processing API use UTF-8 encoding.

Parameters:

json - the JSONObject to save

filename - the name of the file to save to

See Also:

• JSONObject
• JSONArray
• loadJSONObject(String)
• loadJSONArray(String)
• saveJSONArray(JSONArray, String)

saveJSONObject

public boolean saveJSONObject(JSONObject json,
 String filename,
 String options)

Parameters:

options - "compact" and "indent=N", replace N with the number of spaces

parseJSONArray

public JSONArray parseJSONArray(String input)

Takes a String, parses its contents, and returns a JSONArray. If the String does not contain JSONArray data or cannot be parsed, a null value is returned.

parseJSONArray() is most useful when pulling data dynamically, such as from third-party APIs. Normally, API results would be saved to a String, and then can be converted to a structured JSONArray using parseJSONArray(). Be sure to check if null is returned before performing operations on the new JSONArray in case the String content could not be parsed.

If your data already exists as a JSON file in the data folder, it is simpler to use loadJSONArray().

Parameters:

input - String to parse as a JSONArray

See Also:

• JSONObject
• loadJSONObject(String)
• saveJSONObject(JSONObject, String)

loadJSONArray

public JSONArray loadJSONArray(String filename)

Loads an array of JSON objects from the data folder or a URL, and returns a JSONArray. Per standard JSON syntax, the array must be enclosed in a pair of hard brackets [], and each object within the array must be separated by a comma.

All files loaded and saved by the Processing API use UTF-8 encoding.

Parameters:

filename - name of a file in the data folder or a URL

See Also:

• JSONArray
• loadJSONObject(String)
• saveJSONObject(JSONObject, String)
• saveJSONArray(JSONArray, String)

loadJSONArray

public static JSONArray loadJSONArray(File file)

saveJSONArray

public boolean saveJSONArray(JSONArray json,
 String filename)

Writes the contents of a JSONArray object to a file. By default, this file is saved to the sketch's folder. This folder is opened by selecting "Show Sketch Folder" from the "Sketch" menu.

Alternatively, the file can be saved to any location on the computer by using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows).

All files loaded and saved by the Processing API use UTF-8 encoding.

Parameters:

json - the JSONArray to save

filename - the name of the file to save to

See Also:

• JSONObject
• JSONArray
• loadJSONObject(String)
• loadJSONArray(String)
• saveJSONObject(JSONObject, String)

saveJSONArray

public boolean saveJSONArray(JSONArray json,
 String filename,
 String options)

Parameters:

options - "compact" and "indent=N", replace N with the number of spaces

loadTable

public Table loadTable(String filename)

Reads the contents of a file or URL and creates a Table object with its values. If a file is specified, it must be located in the sketch's "data" folder. The filename parameter can also be a URL to a file found online. The filename must either end in an extension or an extension must be specified in the options parameter. For example, to use tab-separated data, include "tsv" in the options parameter if the filename or URL does not end in .tsv. Note: If an extension is in both places, the extension in the options is used.

If the file contains a header row, include "header" in the options parameter. If the file does not have a header row, then simply omit the "header" option.

Some CSV files contain newline (CR or LF) characters inside cells. This is rare, but adding the "newlines" option will handle them properly. (This is not enabled by default because the parsing code is much slower.)

When specifying multiple options, separate them with commas, as in: loadTable("data.csv", "header, tsv")

All files loaded and saved by the Processing API use UTF-8 encoding.

Parameters:

filename - name of a file in the data folder or a URL.

See Also:

• Table
• saveTable(Table, String)
• loadBytes(String)
• loadStrings(String)
• loadXML(String)

loadTable

public Table loadTable(String filename,
 String options)

Options may contain "header", "tsv", "csv", or "bin" separated by commas.

Another option is "dictionary=filename.tsv", which allows users to specify a "dictionary" file that contains a mapping of the column titles and the data types used in the table file. This can be far more efficient (in terms of speed and memory usage) for loading and parsing tables. The dictionary file can only be tab-separated values (.tsv) and its extension will be ignored. This option was added in Processing 2.0.2.

Parameters:

options - may contain "header", "tsv", "csv", or "bin" separated by commas

saveTable

public boolean saveTable(Table table,
 String filename)

Writes the contents of a Table object to a file. By default, this file is saved to the sketch's folder. This folder is opened by selecting "Show Sketch Folder" from the "Sketch" menu.

Alternatively, the file can be saved to any location on the computer by using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows).

All files loaded and saved by the Processing API use UTF-8 encoding.

Parameters:

table - the Table object to save to a file

filename - the filename to which the Table should be saved

See Also:

• Table
• loadTable(String)

saveTable

public boolean saveTable(Table table,
 String filename,
 String options)

Parameters:

options - can be one of "tsv", "csv", "bin", or "html"

loadFont

public PFont loadFont(String filename)

Loads a .vlw formatted font into a PFont object. Create a .vlw font by selecting "Create Font..." from the Tools menu. This tool creates a texture for each alphanumeric character and then adds them as a .vlw file to the current sketch's data folder. Because the letters are defined as textures (and not vector data) the size at which the fonts are created must be considered in relation to the size at which they are drawn. For example, load a 32pt font if the sketch displays the font at 32 pixels or smaller. Conversely, if a 12pt font is loaded and displayed at 48pts, the letters will be distorted because the program will be stretching a small graphic to a large size.

Like loadImage() and other functions that load data, the loadFont() function should not be used inside draw(), because it will slow down the sketch considerably, as the font will be re-loaded from the disk (or network) on each frame. It's recommended to load files inside setup()

To load correctly, fonts must be located in the "data" folder of the current sketch. Alternatively, the file maybe be loaded from anywhere on the local computer using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows), or the filename parameter can be a URL for a file found on a network.

If the file is not available or an error occurs, null will be returned and an error message will be printed to the console. The error message does not halt the program, however the null value may cause a NullPointerException if your code does not check whether the value returned is null.

Use createFont() (instead of loadFont()) to enable vector data to be used with the default renderer setting. This can be helpful when many font sizes are needed, or when using any renderer based on the default renderer, such as the PDF library.

Parameters:

filename - name of the font to load

See Also:

• PFont
• PGraphics.textFont(PFont, float)
• createFont(String, float, boolean, char[])

createFont

public PFont createFont(String name,
 float size)

createFont

public PFont createFont(String name,
 float size,
 boolean smooth)

createFont

public PFont createFont(String name,
 float size,
 boolean smooth,
 char[] charset)

Dynamically converts a font to the format used by Processing from a .ttf or .otf file inside the sketch's "data" folder or a font that's installed elsewhere on the computer. If you want to use a font installed on your computer, use the PFont.list() method to first determine the names for the fonts recognized by the computer and are compatible with this function. Not all fonts can be used and some might work with one operating system and not others. When sharing a sketch with other people or posting it on the web, you may need to include a .ttf or .otf version of your font in the data directory of the sketch because other people might not have the font installed on their computer. Only fonts that can legally be distributed should be included with a sketch.

The size parameter states the font size you want to generate. The smooth parameter specifies if the font should be anti-aliased or not. The charset parameter is an array of chars that specifies the characters to generate.

This function allows Processing to work with the font natively in the default renderer, so the letters are defined by vector geometry and are rendered quickly. In the P2D and P3D renderers, the function sets the project to render the font as a series of small textures. For instance, when using the default renderer, the actual native version of the font will be employed by the sketch, improving drawing quality and performance. With the P2D and P3D renderers, the bitmapped version will be used to improve speed and appearance, but the results are poor when exporting if the sketch does not include the .otf or .ttf file, and the requested font is not available on the machine running the sketch.

Parameters:

name - name of the font to load

size - point size of the font

smooth - true for an anti-aliased font, false for aliased

charset - array containing characters to be generated

See Also:

• PFont
• PGraphics.textFont(PFont, float)
• PGraphics.text(String, float, float, float, float)
• loadFont(String)

selectInput

public void selectInput(String prompt,
 String callback)

Open a platform-specific file chooser dialog to select a file for input. After the selection is made, the selected File will be passed to the 'callback' function. If the dialog is closed or canceled, null will be sent to the function, so that the program is not waiting for additional input. The callback is necessary because of how threading works.

Advanced

 void setup() {
   selectInput("Select a file to process:", "fileSelected");
 }

 void fileSelected(File selection) {
   if (selection == null) {
     println("Window was closed or the user hit cancel.");
   } else {
     println("User selected " + fileSelected.getAbsolutePath());
   }
 }
 

For advanced users, the method must be 'public', which is true for all methods inside a sketch when run from the PDE, but must explicitly be set when using Eclipse or other development environments.

Parameters:

prompt - message to the user

callback - name of the method to be called when the selection is made

selectInput

public void selectInput(String prompt,
 String callback,
 File file)

selectInput

public void selectInput(String prompt,
 String callback,
 File file,
 Object callbackObject)

selectOutput

public void selectOutput(String prompt,
 String callback)

Opens a platform-specific file chooser dialog to select a file for output. After the selection is made, the selected File will be passed to the 'callback' function. If the dialog is closed or canceled, null will be sent to the function, so that the program is not waiting for additional input. The callback is necessary because of how threading works.

Parameters:

prompt - message to the user

callback - name of the method to be called when the selection is made

selectOutput

public void selectOutput(String prompt,
 String callback,
 File file)

selectOutput

public void selectOutput(String prompt,
 String callback,
 File file,
 Object callbackObject)

selectFolder

public void selectFolder(String prompt,
 String callback)

Opens a platform-specific file chooser dialog to select a folder. After the selection is made, the selection will be passed to the 'callback' function. If the dialog is closed or canceled, null will be sent to the function, so that the program is not waiting for additional input. The callback is necessary because of how threading works.

Parameters:

prompt - message to the user

callback - name of the method to be called when the selection is made

selectFolder

public void selectFolder(String prompt,
 String callback,
 File file)

selectFolder

public void selectFolder(String prompt,
 String callback,
 File file,
 Object callbackObject)

selectCallback

public static void selectCallback(File selectedFile,
 String callbackMethod,
 Object callbackObject)

listPaths

public String[] listPaths(String path,
 String... options)

listFiles

public File[] listFiles(String path,
 String... options)

listFiles

public static File[] listFiles(File base,
 String... options)

checkExtension

public static String checkExtension(String filename)

Get the compression-free extension for this filename.

Parameters:

filename - The filename to check

Returns:

an extension, skipping past .gz if it's present

createReader

public BufferedReader createReader(String filename)

Creates a BufferedReader object that can be used to read files line-by-line as individual String objects. This is the complement to the createWriter() function. For more information about the BufferedReader class and its methods like readLine() and close used in the above example, please consult a Java reference.

Starting with Processing release 0134, all files loaded and saved by the Processing API use UTF-8 encoding. In previous releases, the default encoding for your platform was used, which causes problems when files are moved to other platforms.

Parameters:

filename - name of the file to be opened

See Also:

• BufferedReader
• createWriter(String)
• PrintWriter

createReader

public static BufferedReader createReader(File file)

createReader

public static BufferedReader createReader(InputStream input)

createWriter

public PrintWriter createWriter(String filename)

Creates a new file in the sketch folder, and a PrintWriter object to write to it. For the file to be made correctly, it should be flushed and must be closed with its flush() and close() methods (see above example).

Starting with Processing release 0134, all files loaded and saved by the Processing API use UTF-8 encoding. In previous releases, the default encoding for your platform was used, which causes problems when files are moved to other platforms.

Parameters:

filename - name of the file to be created

See Also:

• PrintWriter
• createReader(java.lang.String)
• BufferedReader

createWriter

public static PrintWriter createWriter(File file)

createWriter

public static PrintWriter createWriter(OutputStream output)

createInput

public InputStream createInput(String filename)

This is a function for advanced programmers to open a Java InputStream. It's useful if you want to use the facilities provided by PApplet to easily open files from the data folder or from a URL, but want an InputStream object so that you can use other parts of Java to take more control of how the stream is read.

The filename passed in can be:
- A URL, for instance openStream("http://processing.org/")
- A file in the sketch's data folder
- The full path to a file to be opened locally (when running as an application)

If the requested item doesn't exist, null is returned. If not online, this will also check to see if the user is asking for a file whose name isn't properly capitalized. If capitalization is different, an error will be printed to the console. This helps prevent issues that appear when a sketch is exported to the web, where case sensitivity matters, as opposed to running from inside the Processing Development Environment on Windows or macOS, where case sensitivity is preserved but ignored.

If the file ends with .gz, the stream will automatically be gzip decompressed. If you don't want the automatic decompression, use the related function createInputRaw().
In earlier releases, this function was called openStream().

Advanced

Simplified method to open a Java InputStream.

This method is useful if you want to use the facilities provided by PApplet to easily open things from the data folder or from a URL, but want an InputStream object so that you can use other Java methods to take more control of how the stream is read.

If the requested item doesn't exist, null is returned. (Prior to 0096, die() would be called, killing the sketch)

For 0096+, the "data" folder is exported intact with subfolders, and openStream() properly handles subdirectories from the data folder

If not online, this will also check to see if the user is asking for a file whose name isn't properly capitalized. This helps prevent issues when a sketch is exported to the web, where case sensitivity matters, as opposed to Windows and the macOS default where case sensitivity is preserved but ignored.

It is strongly recommended that libraries use this method to open data files, so that the loading sequence is handled in the same way as functions like loadBytes(), loadImage(), etc.

The filename passed in can be:

• A URL, for instance openStream("http://processing.org/");
• A file in the sketch's data folder
• Another file to be opened locally (when running as an application)

Parameters:

filename - the name of the file to use as input

See Also:

• createOutput(String)
• selectOutput(String,String)
• selectInput(String,String)

createInputRaw

public InputStream createInputRaw(String filename)

Call openStream() without automatic gzip decompression.

createInput

public static InputStream createInput(File file)

loadBytes

public byte[] loadBytes(String filename)

Reads the contents of a file and places it in a byte array. If the name of the file is used as the parameter, as in the above example, the file must be loaded in the sketch's "data" directory/folder.

Alternatively, the file maybe be loaded from anywhere on the local computer using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows), or the filename parameter can be a URL for a file found on a network.

If the file is not available or an error occurs, null will be returned and an error message will be printed to the console. The error message does not halt the program, however the null value may cause a NullPointerException if your code does not check whether the value returned is null.

Parameters:

filename - name of a file in the data folder or a URL.

See Also:

• loadStrings(String)
• saveStrings(String, String[])
• saveBytes(String, byte[])

loadBytes

public static byte[] loadBytes(InputStream input)

loadBytes

public static byte[] loadBytes(File file)

loadStrings

public static String[] loadStrings(File file)

loadStrings

public String[] loadStrings(String filename)

Reads the contents of a file and creates a String array of its individual lines. If the name of the file is used as the parameter, as in the above example, the file must be loaded in the sketch's "data" directory/folder.

Alternatively, the file maybe be loaded from anywhere on the local computer using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows), or the filename parameter can be a URL for a file found on a network.

If the file is not available or an error occurs, null will be returned and an error message will be printed to the console. The error message does not halt the program, however the null value may cause a NullPointerException if your code does not check whether the value returned is null.

Starting with Processing release 0134, all files loaded and saved by the Processing API use UTF-8 encoding. In previous releases, the default encoding for your platform was used, which causes problems when files are moved to other platforms.

Advanced

Load data from a file and shove it into a String array.

Exceptions are handled internally, when an error, occurs, an exception is printed to the console and 'null' is returned, but the program continues running. This is a tradeoff between 1) showing the user that there was a problem but 2) not requiring that all i/o code is contained in try/catch blocks, for the sake of new users (or people who are just trying to get things done in an informal "scripting" fashion). If you want to handle exceptions, use Java methods for I/O.

Parameters:

filename - name of the file or url to load

See Also:

• loadBytes(String)
• saveStrings(String, String[])
• saveBytes(String, byte[])

loadStrings

public static String[] loadStrings(InputStream input)

loadStrings

public static String[] loadStrings(BufferedReader reader)

createOutput

public OutputStream createOutput(String filename)

Similar to createInput(), this creates a Java OutputStream for a given filename or path. The file will be created in the sketch folder, or in the same folder as an exported application.

If the path does not exist, intermediate folders will be created. If an exception occurs, it will be printed to the console, and null will be returned.

This function is a convenience over the Java approach that requires you to 1) create a FileOutputStream object, 2) determine the exact file location, and 3) handle exceptions. Exceptions are handled internally by the function, which is more appropriate for "sketch" projects.

If the output filename ends with .gz, the output will be automatically GZIP compressed as it is written.

Parameters:

filename - name of the file to open

See Also:

• createInput(String)
• selectOutput(String,String)

createOutput

public static OutputStream createOutput(File file)

saveStream

public boolean saveStream(String target,
 String source)

Save the contents of a stream to a file in the sketch folder. This is basically saveBytes(blah, loadBytes()), but done more efficiently (and with less confusing syntax).

The target parameter can be either a String specifying a file name, or, for greater control over the file location, a File object. (Note that, unlike some other functions, this will not automatically compress or uncompress gzip files.)

Parameters:

target - name of the file to write to

source - location to read from (a filename, path, or URL)

See Also:

• createOutput(String)

saveStream

public boolean saveStream(File target,
 String source)

Identical to the other saveStream(), but writes to a File object, for greater control over the file location.

Note that unlike other api methods, this will not automatically compress or uncompress gzip files.

saveStream

public boolean saveStream(String target,
 InputStream source)

saveStream

public static boolean saveStream(File target,
 InputStream source)

saveStream

public static void saveStream(OutputStream target,
 InputStream source)
                       throws IOException

Throws:

IOException

saveBytes

public void saveBytes(String filename,
 byte[] data)

As the opposite of loadBytes(), this function will write an entire array of bytes to a file. The data is saved in binary format. This file is saved to the sketch's folder, which is opened by selecting "Show Sketch Folder" from the "Sketch" menu. Alternatively, the files can be saved to any location on the computer by using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows).

Parameters:

filename - name of the file to write to

data - array of bytes to be written

See Also:

• loadStrings(String)
• loadBytes(String)
• saveStrings(String, String[])

saveBytes

public static void saveBytes(File file,
 byte[] data)

saveBytes

public static void saveBytes(OutputStream output,
 byte[] data)

saveStrings

public void saveStrings(String filename,
 String[] data)

Writes an array of Strings to a file, one line per String. By default, this file is saved to the sketch's folder. This folder is opened by selecting "Show Sketch Folder" from the "Sketch" menu.

Alternatively, the file can be saved to any location on the computer by using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows).

Starting with Processing 1.0, all files loaded and saved by the Processing API use UTF-8 encoding. In earlier releases, the default encoding for your platform was used, which causes problems when files are moved to other platforms.

Parameters:

filename - filename for output

data - string array to be written

See Also:

• loadStrings(String)
• loadBytes(String)
• saveBytes(String, byte[])

saveStrings

public static void saveStrings(File file,
 String[] data)

saveStrings

public static void saveStrings(OutputStream output,
 String[] data)

sketchPath

public String sketchPath()

sketchPath

public String sketchPath(String where)

Prepend the sketch folder path to the filename (or path) that is passed in. External libraries should use this function to save to the sketch folder.

This will also cause an error if the sketch is not inited properly, meaning that init() was never called on the PApplet when hosted my some other main() or by other code. For proper use of init(), see the examples in the main description text for PApplet.

sketchFile

public File sketchFile(String where)

savePath

public String savePath(String where)

Returns a path adjacent the application to save to. Like sketchPath(), but creates any in-between folders so that things save properly.

All saveXxxx() functions use the path to the sketch folder, rather than its data folder. Once exported, the data folder will be found inside the jar file of the exported application. In this case, it's not possible to save data into the jar file, because it will often be running from a server, or marked in-use if running from a local file system. With this in mind, saving to the data path doesn't make sense anyway. If you know you're running locally, and want to save to the data folder, use saveXxxx("data/blah.dat").

saveFile

public File saveFile(String where)

Identical to savePath(), but returns a File object.

desktopFile

public static File desktopFile(String what)

desktopPath

public static String desktopPath(String what)

dataPath

public String dataPath(String where)

This function almost certainly does not do the thing you want it to. The data path is handled differently on each platform, and should not be considered a location to write files. It should also not be assumed that this location can be read from or listed. This function is used internally as a possible location for reading files. It's still "public" as a holdover from earlier code.

Libraries should use createInput() to get an InputStream or createOutput() to get an OutputStream. sketchPath() can be used to get a location relative to the sketch. Again, do not use this to get relative locations of files. You'll be disappointed when your app runs on different platforms.

dataFile

public File dataFile(String where)

Return a full path to an item in the data folder as a File object. See the dataPath() method for more information.

createPath

public static void createPath(String path)

Takes a path and creates any in-between folders if they don't already exist. Useful when trying to save to a subfolder that may not actually exist.

createPath

public static void createPath(File file)

getExtension

public static String getExtension(String filename)

urlEncode

public static String urlEncode(String str)

urlDecode

public static String urlDecode(String str)

sort

public static byte[] sort(byte[] list)

Sorts an array of numbers from smallest to largest, or puts an array of words in alphabetical order. The original array is not modified; a re-ordered array is returned. The count parameter states the number of elements to sort. For example, if there are 12 elements in an array and count is set to 5, only the first 5 elements in the array will be sorted.

Parameters:

list - array to sort

See Also:

• reverse(boolean[])

sort

public static byte[] sort(byte[] list,
 int count)

Parameters:

count - number of elements to sort, starting from 0

sort

public static char[] sort(char[] list)

sort

public static char[] sort(char[] list,
 int count)

sort

public static int[] sort(int[] list)

sort

public static int[] sort(int[] list,
 int count)

sort

public static float[] sort(float[] list)

sort

public static float[] sort(float[] list,
 int count)

sort

public static String[] sort(String[] list)

sort

public static String[] sort(String[] list,
 int count)

arrayCopy

public static void arrayCopy(Object src,
 int srcPosition,
 Object dst,
 int dstPosition,
 int length)

Copies an array (or part of an array) to another array. The src array is copied to the dst array, beginning at the position specified by srcPosition and into the position specified by dstPosition. The number of elements to copy is determined by length. Note that copying values overwrites existing values in the destination array. To append values instead of overwriting them, use concat().

The simplified version with only two arguments — arrayCopy(src, dst) — copies an entire array to another of the same size. It is equivalent to arrayCopy(src, 0, dst, 0, src.length).

Using this function is far more efficient for copying array data than iterating through a for() loop and copying each element individually. This function only copies references, which means that for most purposes it only copies one-dimensional arrays (a single set of brackets). If used with a two (or three or more) dimensional array, it will only copy the references at the first level, because a two-dimensional array is simply an "array of arrays". This does not produce an error, however, because this is often the desired behavior. Internally, this function calls Java's System.arraycopy() method, so most things that apply there are inherited.

Parameters:

src - the source array

srcPosition - starting position in the source array

dst - the destination array of the same data type as the source array

dstPosition - starting position in the destination array

length - number of array elements to be copied

See Also:

• concat(boolean[], boolean[])

arrayCopy

public static void arrayCopy(Object src,
 Object dst,
 int length)

Convenience method for arraycopy(). Identical to arraycopy(src, 0, dst, 0, length);

arrayCopy

public static void arrayCopy(Object src,
 Object dst)

Shortcut to copy the entire contents of the source into the destination array. Identical to arraycopy(src, 0, dst, 0, src.length);

arraycopy

@Deprecated
public static void arraycopy(Object src,
 int srcPosition,
 Object dst,
 int dstPosition,
 int length)

Deprecated.

Use arrayCopy() instead.

arraycopy

@Deprecated
public static void arraycopy(Object src,
 Object dst,
 int length)

Deprecated.

Use arrayCopy() instead.

arraycopy

@Deprecated
public static void arraycopy(Object src,
 Object dst)

Deprecated.

Use arrayCopy() instead.

expand

public static boolean[] expand(boolean[] list)

Increases the size of a one-dimensional array. By default, this function doubles the size of the array, but the optional newSize parameter provides precise control over the increase in size.

When using an array of objects, the data returned from the function must be cast to the object array's data type. For example: SomeClass[] items = (SomeClass[]) expand(originalArray)

Parameters:

list - the array to expand

See Also:

• shorten(boolean[])

expand

public static boolean[] expand(boolean[] list,
 int newSize)

Parameters:

newSize - new size for the array

expand

public static byte[] expand(byte[] list)

expand

public static byte[] expand(byte[] list,
 int newSize)

expand

public static char[] expand(char[] list)

expand

public static char[] expand(char[] list,
 int newSize)

expand

public static int[] expand(int[] list)

expand

public static int[] expand(int[] list,
 int newSize)

expand

public static long[] expand(long[] list)

expand

public static long[] expand(long[] list,
 int newSize)

expand

public static float[] expand(float[] list)

expand

public static float[] expand(float[] list,
 int newSize)

expand

public static double[] expand(double[] list)

expand

public static double[] expand(double[] list,
 int newSize)

expand

public static String[] expand(String[] list)

expand

public static String[] expand(String[] list,
 int newSize)

expand

public static Object expand(Object array)

expand

public static Object expand(Object list,
 int newSize)

append

public static byte[] append(byte[] array,
 byte value)

Expands an array by one element and adds data to the new position. The datatype of the element parameter must be the same as the datatype of the array.

When using an array of objects, the data returned from the function must be cast to the object array's data type. For example: SomeClass[] items = (SomeClass[]) append(originalArray, element).

Parameters:

array - array to append

value - new data for the array

See Also:

• shorten(boolean[])
• expand(boolean[])

append

public static char[] append(char[] array,
 char value)

append

public static int[] append(int[] array,
 int value)

append

public static float[] append(float[] array,
 float value)

append

public static String[] append(String[] array,
 String value)

append

public static Object append(Object array,
 Object value)

shorten

public static boolean[] shorten(boolean[] list)

Decreases an array by one element and returns the shortened array.

When using an array of objects, the data returned from the function must be cast to the object array's data type. For example: SomeClass[] items = (SomeClass[]) shorten(originalArray).

Parameters:

list - array to shorten

See Also:

• append(byte[], byte)
• expand(boolean[])

shorten

public static byte[] shorten(byte[] list)

shorten

public static char[] shorten(char[] list)

shorten

public static int[] shorten(int[] list)

shorten

public static float[] shorten(float[] list)

shorten

public static String[] shorten(String[] list)

shorten

public static Object shorten(Object list)

splice

public static final boolean[] splice(boolean[] list,
 boolean value,
 int index)

Inserts a value or an array of values into an existing array. The first two parameters must be arrays of the same datatype. The first parameter specifies the initial array to be modified, and the second parameter defines the data to be inserted. The third parameter is an index value which specifies the array position from which to insert data. (Remember that array index numbering starts at zero, so the first position is 0, the second position is 1, and so on.)

When splicing an array of objects, the data returned from the function must be cast to the object array's data type. For example: SomeClass[] items = (SomeClass[]) splice(array1, array2, index)

Parameters:

list - array to splice into

value - value to be spliced in

index - position in the array from which to insert data

See Also:

• concat(boolean[], boolean[])
• subset(boolean[], int, int)

splice

public static final boolean[] splice(boolean[] list,
 boolean[] value,
 int index)

splice

public static final byte[] splice(byte[] list,
 byte value,
 int index)

splice

public static final byte[] splice(byte[] list,
 byte[] value,
 int index)

splice

public static final char[] splice(char[] list,
 char value,
 int index)

splice

public static final char[] splice(char[] list,
 char[] value,
 int index)

splice

public static final int[] splice(int[] list,
 int value,
 int index)

splice

public static final int[] splice(int[] list,
 int[] value,
 int index)

splice

public static final float[] splice(float[] list,
 float value,
 int index)

splice

public static final float[] splice(float[] list,
 float[] value,
 int index)

splice

public static final String[] splice(String[] list,
 String value,
 int index)

splice

public static final String[] splice(String[] list,
 String[] value,
 int index)

splice

public static final Object splice(Object list,
 Object value,
 int index)

subset

public static boolean[] subset(boolean[] list,
 int start)

subset

public static boolean[] subset(boolean[] list,
 int start,
 int count)

Extracts an array of elements from an existing array. The list parameter defines the array from which the elements will be copied, and the start and count parameters specify which elements to extract. If no count is given, elements will be extracted from the start to the end of the array. When specifying the start, remember that the first array element is 0. This function does not change the source array.

When using an array of objects, the data returned from the function must be cast to the object array's data type. For example: SomeClass[] items = (SomeClass[]) subset(originalArray, 0, 4)

Parameters:

list - array to extract from

start - position to begin

count - number of values to extract

See Also:

• splice(boolean[], boolean, int)

subset

public static byte[] subset(byte[] list,
 int start)

subset

public static byte[] subset(byte[] list,
 int start,
 int count)

subset

public static char[] subset(char[] list,
 int start)

subset

public static char[] subset(char[] list,
 int start,
 int count)

subset

public static int[] subset(int[] list,
 int start)

subset

public static int[] subset(int[] list,
 int start,
 int count)

subset

public static long[] subset(long[] list,
 int start)

subset

public static long[] subset(long[] list,
 int start,
 int count)

subset

public static float[] subset(float[] list,
 int start)

subset

public static float[] subset(float[] list,
 int start,
 int count)

subset

public static double[] subset(double[] list,
 int start)

subset

public static double[] subset(double[] list,
 int start,
 int count)

subset

public static String[] subset(String[] list,
 int start)

subset

public static String[] subset(String[] list,
 int start,
 int count)

subset

public static Object subset(Object list,
 int start)

subset

public static Object subset(Object list,
 int start,
 int count)

concat

public static boolean[] concat(boolean[] a,
 boolean[] b)

Concatenates two arrays. For example, concatenating the array { 1, 2, 3 } and the array { 4, 5, 6 } yields { 1, 2, 3, 4, 5, 6 }. Both parameters must be arrays of the same datatype.

When using an array of objects, the data returned from the function must be cast to the object array's data type. For example: SomeClass[] items = (SomeClass[]) concat(array1, array2).

Parameters:

a - first array to concatenate

b - second array to concatenate

See Also:

• splice(boolean[], boolean, int)
• arrayCopy(Object, int, Object, int, int)

concat

public static byte[] concat(byte[] a,
 byte[] b)

concat

public static char[] concat(char[] a,
 char[] b)

concat

public static int[] concat(int[] a,
 int[] b)

concat

public static float[] concat(float[] a,
 float[] b)

concat

public static String[] concat(String[] a,
 String[] b)

concat

public static Object concat(Object a,
 Object b)

reverse

public static boolean[] reverse(boolean[] list)

Reverses the order of an array.

Parameters:

list - booleans[], bytes[], chars[], ints[], floats[], or Strings[]

See Also:

• sort(String[], int)

reverse

public static byte[] reverse(byte[] list)

reverse

public static char[] reverse(char[] list)

reverse

public static int[] reverse(int[] list)

reverse

public static float[] reverse(float[] list)

reverse

public static String[] reverse(String[] list)

reverse

public static Object reverse(Object list)

trim

public static String trim(String str)

Removes whitespace characters from the beginning and end of a String. In addition to standard whitespace characters such as space, carriage return, and tab, this function also removes the Unicode "nbsp" (U+00A0) character and the zero width no-break space (U+FEFF) character.

Parameters:

str - any string

See Also:

• split(String, String)
• join(String[], char)

trim

public static String[] trim(String[] array)

Parameters:

array - a String array

join

public static String join(String[] list,
 char separator)

Combines an array of Strings into one String, each separated by the character(s) used for the separator parameter. To join arrays of ints or floats, it's necessary to first convert them to Strings using nf() or nfs().

Parameters:

list - array of Strings

separator - char or String to be placed between each item

See Also:

• split(String, String)
• trim(String)
• nf(float, int, int)
• nfs(float, int, int)

join

public static String join(String[] list,
 String separator)

splitTokens

public static String[] splitTokens(String value)

splitTokens

public static String[] splitTokens(String value,
 String delim)

The splitTokens() function splits a String at one or many character delimiters or "tokens". The delim parameter specifies the character or characters to be used as a boundary.

If no delim characters are specified, any whitespace character is used to split. Whitespace characters include tab (\t), line feed (\n), carriage return (\r), form feed (\f), and space.

After using this function to parse incoming data, it is common to convert the data from Strings to integers or floats by using the datatype conversion functions int() and float().

Parameters:

value - the String to be split

delim - list of individual characters that will be used as separators

See Also:

• split(String, String)
• join(String[], String)
• trim(String)

split

public static String[] split(String value,
 char delim)

The split() function breaks a String into pieces using a character or string as the delimiter. The delim parameter specifies the character or characters that mark the boundaries between each piece. A String[] array is returned that contains each of the pieces.

If the result is a set of numbers, you can convert the String[] array to a float[] or int[] array using the datatype conversion functions int() and float(). (See the second example above.)

The splitTokens() function works in a similar fashion, except that it splits using a range of characters instead of a specific character or sequence.

Parameters:

value - the String to be split

delim - the character or String used to separate the data

Usage:

web_application

split

public static String[] split(String value,
 String delim)

match

public static String[] match(String str,
 String regexp)

This function is used to apply a regular expression to a piece of text, and return matching groups (elements found inside parentheses) as a String array. If there are no matches, a null value will be returned. If no groups are specified in the regular expression, but the sequence matches, an array of length 1 (with the matched text as the first element of the array) will be returned.

To use the function, first check to see if the result is null. If the result is null, then the sequence did not match at all. If the sequence did match, an array is returned.

If there are groups (specified by sets of parentheses) in the regular expression, then the contents of each will be returned in the array. Element [0] of a regular expression match returns the entire matching string, and the match groups start at element [1] (the first group is [1], the second [2], and so on).

The syntax can be found in the reference for Java's Pattern class. For regular expression syntax, read the Java Tutorial on the topic.

Parameters:

str - the String to be searched

regexp - the regexp to be used for matching

See Also:

• matchAll(String, String)
• split(String, String)
• splitTokens(String, String)
• join(String[], String)
• trim(String)

matchAll

public static String[][] matchAll(String str,
 String regexp)

This function is used to apply a regular expression to a piece of text, and return a list of matching groups (elements found inside parentheses) as a two-dimensional String array. If there are no matches, a null value will be returned. If no groups are specified in the regular expression, but the sequence matches, a two-dimensional array is still returned, but the second dimension is only of length one.

To use the function, first check to see if the result is null. If the result is null, then the sequence did not match at all. If the sequence did match, a 2D array is returned.

If there are groups (specified by sets of parentheses) in the regular expression, then the contents of each will be returned in the array. Assuming a loop with counter variable i, element [i][0] of a regular expression match returns the entire matching string, and the match groups start at element [i][1] (the first group is [i][1], the second [i][2], and so on).

The syntax can be found in the reference for Java's Pattern class. For regular expression syntax, read the Java Tutorial on the topic.

Parameters:

str - the String to be searched

regexp - the regexp to be used for matching

See Also:

• match(String, String)
• split(String, String)
• splitTokens(String, String)
• join(String[], String)
• trim(String)

parseBoolean

public static final boolean parseBoolean(int what)

Convert an integer to a boolean. Because of how Java handles upgrading numbers, this will also cover byte and char (as they will upgrade to an int without any sort of explicit cast).

The preprocessor will convert boolean(what) to parseBoolean(what).

Returns:

false if 0, true if any other number

parseBoolean

public static final boolean parseBoolean(String what)

Convert the string "true" or "false" to a boolean.

Returns:

true if 'what' is "true" or "TRUE", false otherwise

parseBoolean

public static final boolean[] parseBoolean(int[] what)

Convert an int array to a boolean array. An int equal to zero will return false, and any other value will return true.

Returns:

array of boolean elements

parseBoolean

public static final boolean[] parseBoolean(String[] what)

parseByte

public static final byte parseByte(boolean what)

parseByte

public static final byte parseByte(char what)

parseByte

public static final byte parseByte(int what)

parseByte

public static final byte parseByte(float what)

parseByte

public static final byte[] parseByte(boolean[] what)

parseByte

public static final byte[] parseByte(char[] what)

parseByte

public static final byte[] parseByte(int[] what)

parseByte

public static final byte[] parseByte(float[] what)

parseChar

public static final char parseChar(byte what)

parseChar

public static final char parseChar(int what)

parseChar

public static final char[] parseChar(byte[] what)

parseChar

public static final char[] parseChar(int[] what)

parseInt

public static final int parseInt(boolean what)

parseInt

public static final int parseInt(byte what)

Note that parseInt() will un-sign a signed byte value.

parseInt

public static final int parseInt(char what)

Note that parseInt('5') is unlike String in the sense that it won't return 5, but the ascii value. This is because ((int) someChar) returns the ascii value, and parseInt() is just longhand for the cast.

parseInt

public static final int parseInt(float what)

Same as floor(), or an (int) cast.

parseInt

public static final int parseInt(String what)

Parse a String into an int value. Returns 0 if the value is bad.

parseInt

public static final int parseInt(String what,
 int otherwise)

Parse a String to an int, and provide an alternate value that should be used when the number is invalid. If there's a decimal place, it will be truncated, making this more of a toInt() than parseInt() function. This is because the method is used internally for casting. Not ideal, but the name was chosen before that clarification was made.

parseInt

public static final int[] parseInt(boolean[] what)

parseInt

public static final int[] parseInt(byte[] what)

parseInt

public static final int[] parseInt(char[] what)

parseInt

public static int[] parseInt(float[] what)

parseInt

public static int[] parseInt(String[] what)

Make an array of int elements from an array of String objects. If the String can't be parsed as a number, it will be set to zero.

 String s[] = { "1", "300", "44" };
 int numbers[] = parseInt(s);
 // numbers will contain { 1, 300, 44 }
 

parseInt

public static int[] parseInt(String[] what,
 int missing)

Make an array of int elements from an array of String objects. If the String can't be parsed as a number, its entry in the array will be set to the value of the "missing" parameter.

 String s[] = { "1", "300", "apple", "44" };
 int numbers[] = parseInt(s, 9999);
 // numbers will contain { 1, 300, 9999, 44 }
 

parseFloat

public static final float parseFloat(int what)

Convert an int to a float value. Also handles bytes because of Java's rules for upgrading values.

parseFloat

public static final float parseFloat(String what)

parseFloat

public static final float parseFloat(String what,
 float otherwise)

parseFloat

public static final float[] parseFloat(byte[] what)

parseFloat

public static final float[] parseFloat(int[] what)

parseFloat

public static final float[] parseFloat(String[] what)

parseFloat

public static final float[] parseFloat(String[] what,
 float missing)

str

public static final String str(boolean value)

str

public static final String str(byte value)

str

public static final String str(char value)

str

public static final String str(int value)

str

public static final String str(float value)

str

public static final String[] str(boolean[] values)

str

public static final String[] str(byte[] values)

str

public static final String[] str(char[] values)

str

public static final String[] str(int[] values)

str

public static final String[] str(float[] values)

nf

public static String nf(float num)

nf

public static String[] nf(float[] nums)

nf

public static String[] nf(int[] nums,
 int digits)

Utility function for formatting numbers into strings. There are two versions: one for formatting floats, and one for formatting ints. The values for the digits and right parameters should always be positive integers. The left parameter should be positive or 0. If it is zero, only the right side is formatted.

As shown in the above example, nf() is used to add zeros to the left and/or right of a number. This is typically for aligning a list of numbers. To remove digits from a floating-point number, use the int(), ceil(), floor(), or round() functions.

Parameters:

nums - the numbers to format

digits - number of digits to pad with zero

See Also:

• nfs(float, int, int)
• nfp(float, int, int)
• nfc(float, int)
• int(float)

nf

public static String nf(int num,
 int digits)

Parameters:

num - the number to format

nfc

public static String[] nfc(int[] nums)

Utility function for formatting numbers into strings and placing appropriate commas to mark units of 1000. There are four versions: one for formatting ints, one for formatting an array of ints, one for formatting floats, and one for formatting an array of floats.

The value for the right parameter should always be a positive integer.

For a non-US locale, this will insert periods instead of commas, or whatever is appropriate for that region.

Parameters:

nums - the numbers to format

See Also:

• nf(float, int, int)
• nfp(float, int, int)
• nfs(float, int, int)

nfc

public static String nfc(int num)

Parameters:

num - the number to format

nfs

public static String nfs(int num,
 int digits)

Utility function for formatting numbers into strings. Similar to nf() but leaves a blank space in front of positive numbers, so they align with negative numbers in spite of the minus symbol. There are two versions, one for formatting floats and one for formatting ints. The values for the digits, left, and right parameters should always be positive integers.

Parameters:

num - the number to format

digits - number of digits to pad with zeroes

See Also:

• nf(float, int, int)
• nfp(float, int, int)
• nfc(float, int)

nfs

public static String[] nfs(int[] nums,
 int digits)

Parameters:

nums - the numbers to format

nfp

public static String nfp(int num,
 int digits)

Utility function for formatting numbers into strings. Similar to nf() but puts a "+" in front of positive numbers and a "-" in front of negative numbers. There are two versions: one for formatting floats, and one for formatting ints. The values for the digits, left, and right parameters should always be positive integers.

Parameters:

num - the number to format

digits - number of digits to pad with zeroes

See Also:

• nf(float, int, int)
• nfs(float, int, int)
• nfc(float, int)

nfp

public static String[] nfp(int[] nums,
 int digits)

Parameters:

nums - the numbers to format

nf

public static String[] nf(float[] nums,
 int left,
 int right)

Parameters:

left - number of digits to the left of the decimal point

right - number of digits to the right of the decimal point

nf

public static String nf(float num,
 int left,
 int right)

nfc

public static String[] nfc(float[] nums,
 int right)

Parameters:

right - number of digits to the right of the decimal point

nfc

public static String nfc(float num,
 int right)

nfs

public static String[] nfs(float[] nums,
 int left,
 int right)

Parameters:

left - the number of digits to the left of the decimal point

right - the number of digits to the right of the decimal point

nfs

public static String nfs(float num,
 int left,
 int right)

nfp

public static String[] nfp(float[] nums,
 int left,
 int right)

Parameters:

left - the number of digits to the left of the decimal point

right - the number of digits to the right of the decimal point

nfp

public static String nfp(float num,
 int left,
 int right)

hex

public static final String hex(byte value)

Converts an int, byte, char, or color to a String containing the equivalent hexadecimal notation. For example, the color value produced by color(0, 102, 153) will convert to the String value "FF006699". This function can help make your geeky debugging sessions much happier.

Note that the maximum number of digits is 8, because an int value can only represent up to 32 bits. Specifying more than 8 digits will not increase the length of the String further.

Parameters:

value - the value to convert

See Also:

• unhex(String)
• binary(byte)
• unbinary(String)

hex

public static final String hex(char value)

hex

public static final String hex(int value)

hex

public static final String hex(int value,
 int digits)

Parameters:

digits - the number of digits (maximum 8)

unhex

public static final int unhex(String value)

Converts a String representation of a hexadecimal number to its equivalent integer value.

Parameters:

value - String to convert to an integer

See Also:

• hex(int, int)
• binary(byte)
• unbinary(String)

binary

public static final String binary(byte value)

Returns a String that contains the binary value of a byte. The returned value will always have 8 digits.

binary

public static final String binary(char value)

Returns a String that contains the binary value of a char. The returned value will always have 16 digits because chars are two bytes long.

binary

public static final String binary(int value)

Returns a String that contains the binary value of an int. The length depends on the size of the number itself. If you want a specific number of digits use binary(int what, int digits) to specify how many.

binary

public static final String binary(int value,
 int digits)

Converts an int, byte, char, or color to a String containing the equivalent binary notation. For example, the color value produced by color(0, 102, 153, 255) will convert to the String value "11111111000000000110011010011001". This function can help make your geeky debugging sessions much happier.

Note that the maximum number of digits is 32, because an int value can only represent up to 32 bits. Specifying more than 32 digits will have no effect.

Parameters:

value - value to convert

digits - number of digits to return

See Also:

• unbinary(String)
• hex(int,int)
• unhex(String)

unbinary

public static final int unbinary(String value)

Converts a String representation of a binary number to its equivalent integer value. For example, unbinary("00001000") will return 8.

Parameters:

value - String to convert to an integer

See Also:

• binary(byte)
• hex(int,int)
• unhex(String)

color

public final int color(int gray)

Creates colors for storing in variables of the color datatype. The parameters are interpreted as RGB or HSB values depending on the current colorMode(). The default mode is RGB values from 0 to 255 and, therefore, color(255, 204, 0) will return a bright yellow color (see the first example above).

Note that if only one value is provided to color(), it will be interpreted as a grayscale value. Add a second value, and it will be used for alpha transparency. When three values are specified, they are interpreted as either RGB or HSB values. Adding a fourth value applies alpha transparency.

Note that when using hexadecimal notation, it is not necessary to use color(), as in: color c = #006699

More about how colors are stored can be found in the reference for the color datatype.

Parameters:

gray - number specifying value between white and black

See Also:

• colorMode(int)

color

public final int color(float fgray)

Parameters:

fgray - number specifying value between white and black

color

public final int color(int gray,
 int alpha)

As of 0116 this also takes color(#FF8800, alpha)

Parameters:

alpha - relative to current color range

color

public final int color(float fgray,
 float falpha)

color

public final int color(int v1,
 int v2,
 int v3)

Parameters:

v1 - red or hue values relative to the current color range

v2 - green or saturation values relative to the current color range

v3 - blue or brightness values relative to the current color range

color

public final int color(int v1,
 int v2,
 int v3,
 int alpha)

color

public final int color(float v1,
 float v2,
 float v3)

color

public final int color(float v1,
 float v2,
 float v3,
 float alpha)

lerpColor

public int lerpColor(int c1,
 int c2,
 float amt)

Calculates a new color that is a blend of two other colors. The amt parameter controls the amount of each color to use where an amount of 0.0 will produce the first color, 1.0 will return the second color, and 0.5 is halfway in between. Values between 0.0 and 1.0 will interpolate between the two colors in that proportion.
An amount below 0 will be treated as 0. Likewise, amounts above 1 will be capped at 1. This is different from the behavior of lerp(), but necessary because otherwise numbers outside the range will produce strange and unexpected colors.

Parameters:

c1 - interpolate from this color

c2 - interpolate to this color

amt - between 0.0 and 1.0

See Also:

• PImage.blendColor(int, int, int)
• PGraphics.color(float, float, float, float)
• lerp(float, float, float)

Usage:

web_application

blendColor

public static int blendColor(int c1,
 int c2,
 int mode)

windowTitle

public void windowTitle(String title)

windowResize

public void windowResize(int newWidth,
 int newHeight)

postWindowResized

public void postWindowResized(int newWidth,
 int newHeight)

Internal use only: called by Surface objects to queue a resize event to call windowResized() when it's safe, which is after the beginDraw() call and before the draw(). Note that this is only the notification that the resize has happened.

windowResized

public void windowResized()

Called when window is resized.

windowResizable

public void windowResizable(boolean resizable)

windowMove

public void windowMove(int x,
 int y)

frameMoved

public void frameMoved(int newX,
 int newY)

When running from the PDE, this saves the window position for next time the sketch is run. Needs to remain a separate method so that it can be overridden by Python Mode.

postWindowMoved

public void postWindowMoved(int newX,
 int newY)

Internal use only: called by Surface objects to queue a position event to call windowPositioned() when it's safe, which is after the beginDraw() call and before the draw(). Note that this is only the notification that the window is in a new position.

windowMoved

public void windowMoved()

Called when the window is moved

windowRatio

public void windowRatio(int wide,
 int high)

Scale the sketch as if it fits this specific width and height. This will also scale the mouseX and mouseY variables (as well as pmouseX and pmouseY). Note that it will not have an effect on MouseEvent objects (i.e. event.getX() and event.getY()) because their exact behavior may interact strangely with other libraries.

main

public static void main(String[] args)

main() method for running this class from the command line.

Usage: PApplet [options] <class name> [sketch args]

• The [options] are one or several of the parameters seen below.
• The class name is required. If you're running outside the PDE and your class is in a package, this should include the full name. That means that if the class is called Sketchy and the package is com.sketchycompany then com.sketchycompany.Sketchy should be used as the class name.
• The [sketch args] are any command line parameters you want to send to the sketch itself. These will be passed into the args[] array in PApplet.

  The simplest way to turn and sketch into an application is to add the following code to your program:

  static public void main(String args[]) {
     PApplet.main("YourSketchName");
   }

  That will properly launch your code from a double-clickable .jar or from the command line.

   Parameters useful for launching or also used by the PDE:
  
   --location=x,y         Upper left-hand corner of where the sketch
                          should appear on screen. If not used,
                          the default is to center on the main screen.
  
   --present              Presentation mode: blanks the entire screen and
                          shows the sketch by itself. If the sketch is
                          smaller than the screen, the surrounding area
                          will use the --window-color setting.
  
   --hide-stop            Use to hide the stop button in situations where
                          you don't want to allow users to exit. also
                          see the FAQ on information for capturing the ESC
                          key when running in presentation mode.
  
   --stop-color=#xxxxxx   Color of the 'stop' text used to quit a
                          sketch when it's in present mode.
  
   --window-color=#xxxxxx Background color of the window. The color used
                          around the sketch when it's smaller than the
                          minimum window size for the OS, and the matte
                          color when using 'present' mode.
  
   --sketch-path          Location of where to save files from functions
                          like saveStrings() or saveFrame(). defaults to
                          the folder that the java application was
                          launched from, which means if this isn't set by
                          the pde, everything goes into the same folder
                          as processing.exe.
  
   --display=n            Set what display should be used by this sketch.
                          Displays are numbered starting from 1. This will
                          be overridden by fullScreen() calls that specify
                          a display. Omitting this option will cause the
                          default display to be used.
  
   Parameters used by Processing when running via the PDE
  
   --external             set when the sketch is being used by the PDE
  
   --editor-location=x,y  position of the upper left-hand corner of the
                          editor window, for placement of sketch window
  
   All parameters *after* the sketch class name are passed to the sketch
   itself and available from its 'args' array while the sketch is running.

See Also:

main

public static void main(Class<?> mainClass,
 String... args)

Convenience method so that PApplet.main(YourSketch.class) launches a sketch, rather than having to call getName() on it.

main

public static void main(String mainClass)

Convenience method so that PApplet.main("YourSketch") launches a sketch, rather than having to wrap it into a single element String array.

Parameters:

mainClass - name of the class to load (with package if any)

main

public static void main(String mainClass,
 String[] sketchArgs)

Convenience method so that PApplet.main("YourSketch", args) launches a sketch, rather than having to wrap it into a String array, and appending the 'args' array when not null.

Parameters:

mainClass - name of the class to load (with package if any)

sketchArgs - command line arguments to pass to the sketch's 'args' array. Note that this is not the same as the args passed to (and understood by) PApplet such as --display.

runSketch

public static void runSketch(String[] args,
 PApplet constructedSketch)

hideMenuBar

public static void hideMenuBar()

Convenience method, should only be called by PSurface subclasses.

beginRecord

public PGraphics beginRecord(String renderer,
 String filename)

Opens a new file and all subsequent drawing functions are echoed to this file as well as the display window. The beginRecord() function requires two parameters, the first is the renderer and the second is the file name. This function is always used with endRecord() to stop the recording process and close the file.

Note that beginRecord() will only pick up any settings that happen after it has been called. For instance, if you call textFont() before beginRecord(), then that font will not be set for the file that you're recording to.

beginRecord() works only with the PDF and SVG renderers.

Parameters:

renderer - PDF or SVG

filename - filename for output

See Also:

• endRecord()

beginRecord

public void beginRecord(PGraphics recorder)

endRecord

public void endRecord()

Stops the recording process started by beginRecord() and closes the file.

See Also:

• beginRecord(String, String)

beginRaw

public PGraphics beginRaw(String renderer,
 String filename)

To create vectors from 3D data, use the beginRaw() and endRaw() commands. These commands will grab the shape data just before it is rendered to the screen. At this stage, your entire scene is nothing but a long list of individual lines and triangles. This means that a shape created with sphere() function will be made up of hundreds of triangles, rather than a single object. Or that a multi-segment line shape (such as a curve) will be rendered as individual segments.

When using beginRaw() and endRaw(), it's possible to write to either a 2D or 3D renderer. For instance, beginRaw() with the PDF library will write the geometry as flattened triangles and lines, even if recording from the P3D renderer.

If you want a background to show up in your files, use rect(0, 0, width, height) after setting the fill() to the background color. Otherwise, the background will not be rendered to the file because the background is not shape.

Using hint(ENABLE_DEPTH_SORT) can improve the appearance of 3D geometry drawn to 2D file formats. See the hint() reference for more details.

See examples in the reference for the PDF and DXF libraries for more information.

Parameters:

renderer - for example, PDF or DXF

filename - filename for output

See Also:

• endRaw()
• hint(int)

beginRaw

public void beginRaw(PGraphics rawGraphics)

Parameters:

rawGraphics - PGraphics context that raw shapes will be written to

endRaw

public void endRaw()

Complement to beginRaw(); they must always be used together. See the beginRaw() reference for details.

See Also:

• beginRaw(String, String)

loadPixels

public void loadPixels()

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

Advanced

Override the g.pixels[] function to set the pixels[] array that's part of the PApplet object. Allows the use of pixels[] in the code, rather than g.pixels[].

See Also:

• pixels
• updatePixels()

updatePixels

public void updatePixels()

Updates the display window with the data in the pixels[] array. Use in conjunction with loadPixels(). If you're only reading pixels from the array, there's no need to call updatePixels() — updating is only necessary to apply changes.

See Also:

• loadPixels()
• pixels

updatePixels

public void updatePixels(int x1,
 int y1,
 int x2,
 int y2)

Parameters:

x1 - x-coordinate of the upper-left corner

y1 - y-coordinate of the upper-left corner

x2 - width of the region

y2 - height of the region

beginPGL

public PGL beginPGL()

endPGL

public void endPGL()

flush

public void flush()

hint

public void hint(int which)

beginShape

public void beginShape()

Start a new shape of type POLYGON

beginShape

public void beginShape(int kind)

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

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

The P2D and P3D renderers allow stroke() and fill() to be altered on a per-vertex basis, but the default renderer does not. Settings such as strokeWeight(), strokeCap(), and strokeJoin() cannot be changed while inside a beginShape()/endShape() block with any renderer.

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)

edge

public void edge(boolean edge)

Sets whether the upcoming vertex is part of an edge. Equivalent to glEdgeFlag(), for people familiar with OpenGL.

normal

public void normal(float nx,
 float ny,
 float nz)

Sets the current normal vector. Used for drawing three-dimensional shapes and surfaces, normal() specifies a vector perpendicular to a shape's surface which, in turn, determines how lighting affects it. Processing attempts to automatically assign normals to shapes, but since that's imperfect, this is a better option when you want more control. This function is identical to glNormal3f() in OpenGL.

Parameters:

nx - x direction

ny - y direction

nz - z direction

See Also:

• PGraphics.beginShape(int)
• PGraphics.endShape(int)
• PGraphics.lights()

attribPosition

public void attribPosition(String name,
 float x,
 float y,
 float z)

attribNormal

public void attribNormal(String name,
 float nx,
 float ny,
 float nz)

attribColor

public void attribColor(String name,
 int color)

attrib

public void attrib(String name,
 float... values)

attrib

public void attrib(String name,
 int... values)

attrib

public void attrib(String name,
 boolean... values)

textureMode

public void textureMode(int mode)

Sets the coordinate space for texture mapping. The default mode is IMAGE, which refers to the actual coordinates of the image. NORMAL refers to a normalized space of values ranging from 0 to 1. This function only works with the P2D and P3D renderers.

With IMAGE, if an image is 100 x 200 pixels, mapping the image onto the entire size of a quad would require the points (0,0) (100, 0) (100,200) (0,200). The same mapping in NORMAL is (0,0) (1,0) (1,1) (0,1).

Parameters:

mode - either IMAGE or NORMAL

See Also:

• PGraphics.texture(PImage)
• PGraphics.textureWrap(int)

textureWrap

public void textureWrap(int wrap)

Defines if textures repeat or draw once within a texture map. The two parameters are CLAMP (the default behavior) and REPEAT. This function only works with the P2D and P3D renderers.

Parameters:

wrap - Either CLAMP (default) or REPEAT

See Also:

• PGraphics.texture(PImage)
• PGraphics.textureMode(int)

texture

public void texture(PImage image)

Sets a texture to be applied to vertex points. The texture() function must be called between beginShape() and endShape() and before any calls to vertex(). This function only works with the P2D and P3D renderers.

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

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)

noTexture

public void noTexture()

Removes texture image for current shape. Needs to be called between beginShape and endShape

vertex

public void vertex(float x,
 float y)

vertex

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

vertex

public void vertex(float[] v)

Used by renderer subclasses or PShape to efficiently pass in already formatted vertex information.

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)

vertex

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

All shapes are constructed by connecting a series of vertices. vertex() is used to specify the vertex coordinates for points, lines, triangles, quads, and polygons. It is used exclusively within the beginShape() and endShape() functions.

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

This function is also used to map a texture onto geometry. The texture() function declares the texture to apply to the geometry and the u and v coordinates set define the mapping of this texture to the form. By default, the coordinates used for u and v are specified in relation to the image's size in pixels, but this relation can be changed with textureMode().

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

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

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

endContour

public void endContour()

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

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

endShape

public void endShape()

endShape

public void endShape(int mode)

The endShape() function is the companion to beginShape() and may only be called after beginShape(). When endshape() is called, all the image data defined since the previous call to beginShape() is written into the image buffer. The constant CLOSE as the value for the MODE parameter to close the shape (to connect the beginning and the end).

Parameters:

mode - use CLOSE to close the shape

See Also:

• PShape
• PGraphics.beginShape(int)

loadShape

public PShape loadShape(String filename)

Loads geometry into a variable of type PShape. SVG and OBJ files may be loaded. To load correctly, the file must be located in the data directory of the current sketch. In most cases, loadShape() should be used inside setup() because loading shapes inside draw() will reduce the speed of a sketch.

Alternatively, the file maybe be loaded from anywhere on the local computer using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows), or the filename parameter can be a URL for a file found on a network.

If the file is not available or an error occurs, null will be returned and an error message will be printed to the console. The error message does not halt the program, however the null value may cause a NullPointerException if your code does not check whether the value returned is null.

Parameters:

filename - name of file to load, can be .svg or .obj

See Also:

• PShape
• createShape()

loadShape

public PShape loadShape(String filename,
 String options)

createShape

public PShape createShape()

The createShape() function is used to define a new shape. Once created, this shape can be drawn with the shape() function. The basic way to use the function defines new primitive shapes. One of the following parameters are used as the first parameter: ELLIPSE, RECT, ARC, TRIANGLE, SPHERE, BOX, QUAD, or LINE. The parameters for each of these different shapes are the same as their corresponding functions: ellipse(), rect(), arc(), triangle(), sphere(), box(), quad(), and line(). The first example above clarifies how this works.

Custom, unique shapes can be made by using createShape() without a parameter. After the shape is started, the drawing attributes and geometry can be set directly to the shape within the beginShape() and endShape() methods. See the second example above for specifics, and the reference for beginShape() for all of its options.

The createShape() function can also be used to make a complex shape made of other shapes. This is called a "group" and it's created by using the parameter GROUP as the first parameter. See the fourth example above to see how it works.

After using createShape(), stroke and fill color can be set by calling methods like setFill() and setStroke(), as seen in the examples above. The complete list of methods and fields for the PShape class are in the Processing Javadoc.

See Also:

• PShape
• PShape.endShape()
• loadShape(String)

createShape

public PShape createShape(int type)

createShape

public PShape createShape(int kind,
 float... p)

Parameters:

kind - either POINT, LINE, TRIANGLE, QUAD, RECT, ELLIPSE, ARC, BOX, SPHERE

p - parameters that match the kind of shape

loadShader

public PShader loadShader(String fragFilename)

Loads a shader into the PShader object. The shader file must be loaded in the sketch's "data" folder/directory to load correctly. Shaders are compatible with the P2D and P3D renderers, but not with the default renderer.

Alternatively, the file maybe be loaded from anywhere on the local computer using an absolute path (something that starts with / on Unix and Linux, or a drive letter on Windows), or the filename parameter can be a URL for a file found on a network.

If the file is not available or an error occurs, null will be returned and an error message will be printed to the console. The error message does not halt the program, however the null value may cause a NullPointerException if your code does not check whether the value returned is null.

Parameters:

fragFilename - name of fragment shader file

loadShader

public PShader loadShader(String fragFilename,
 String vertFilename)

Parameters:

vertFilename - name of vertex shader file

shader

public void shader(PShader shader)

Applies the shader specified by the parameters. It's compatible with the P2D and P3D renderers, but not with the default renderer.

Parameters:

shader - name of shader file

shader

public void shader(PShader shader,
 int kind)

Parameters:

kind - type of shader, either POINTS, LINES, or TRIANGLES

resetShader

public void resetShader()

Restores the default shaders. Code that runs after resetShader() will not be affected by previously defined shaders.

resetShader

public void resetShader(int kind)

Parameters:

kind - type of shader, either POINTS, LINES, or TRIANGLES

filter

public void filter(PShader shader)

Parameters:

shader - the fragment shader to apply

clip

public void clip(float a,
 float b,
 float c,
 float d)

Limits the rendering to the boundaries of a rectangle defined by the parameters. The boundaries are drawn based on the state of the imageMode() function, either CORNER, CORNERS, or CENTER.

Parameters:

a - x-coordinate of the rectangle, by default

b - y-coordinate of the rectangle, by default

c - width of the rectangle, by default

d - height of the rectangle, by default

noClip

public void noClip()

Disables the clipping previously started by the clip() function.

blendMode

public void blendMode(int mode)

Blends the pixels in the display window according to a defined mode. There is a choice of the following modes to blend the source pixels (A) with the ones of pixels already in the display window (B). Each pixel's final color is the result of applying one of the blend modes with each channel of (A) and (B) independently. The red channel is compared with red, green with green, and blue with blue.

BLEND - linear interpolation of colors: C = A*factor + B. This is the default.

ADD - additive blending with white clip: C = min(A*factor + B, 255)

SUBTRACT - subtractive blending with black clip: C = max(B - A*factor, 0)

DARKEST - only the darkest color succeeds: C = min(A*factor, B)

LIGHTEST - only the lightest color succeeds: C = max(A*factor, B)

DIFFERENCE - subtract colors from underlying image.

EXCLUSION - similar to DIFFERENCE, but less extreme.

MULTIPLY - multiply the colors, result will always be darker.

SCREEN - opposite multiply, uses inverse values of the colors.

REPLACE - the pixels entirely replace the others and don't utilize alpha (transparency) values

We recommend using blendMode() and not the previous blend() function. However, unlike blend(), the blendMode() function does not support the following: HARD_LIGHT, SOFT_LIGHT, OVERLAY, DODGE, BURN. On older hardware, the LIGHTEST, DARKEST, and DIFFERENCE modes might not be available as well.

Parameters:

mode - the blending mode to use

bezierVertex

public void bezierVertex(float x2,
 float y2,
 float x3,
 float y3,
 float x4,
 float y4)

bezierVertex

public void bezierVertex(float x2,
 float y2,
 float z2,
 float x3,
 float y3,
 float z3,
 float x4,
 float y4,
 float z4)

Specifies vertex coordinates for Bézier curves. Each call to bezierVertex() defines the position of two control points and one anchor point of a Bézier curve, adding a new segment to a line or shape. The first time bezierVertex() is used within a beginShape() call, it must be prefaced with a call to vertex() to set the first anchor point. This function must be used between beginShape() and endShape() and only when there is no MODE parameter specified to beginShape(). Using the 3D version requires rendering with P3D (see the Environment reference for more information).

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 cx,
 float cy,
 float x3,
 float y3)

Specifies vertex coordinates for quadratic Bézier curves. Each call to quadraticVertex() defines the position of one control point and one anchor point of a Bézier curve, adding a new segment to a line or shape. The first time quadraticVertex() is used within a beginShape() call, it must be prefaced with a call to vertex() to set the first anchor point. This function must be used between beginShape() and endShape() and only when there is no MODE parameter specified to beginShape(). Using the 3D version requires rendering with P3D (see the Environment reference for more information).

Parameters:

cx - the x-coordinate of the control point

cy - the y-coordinate of the control point

x3 - the x-coordinate of the anchor point

y3 - 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 cx,
 float cy,
 float cz,
 float x3,
 float y3,
 float z3)

Parameters:

cz - the z-coordinate of the control point

z3 - the z-coordinate of the anchor point

curveVertex

public void curveVertex(float x,
 float y)

Specifies vertex coordinates for curves. This function may only be used between beginShape() and endShape() and only when there is no MODE parameter specified to beginShape(). The first and last points in a series of curveVertex() lines will be used to guide the beginning and end of the curve. A minimum of four points is required to draw a tiny curve between the second and third points. Adding a fifth point with curveVertex() will draw the curve between the second, third, and fourth points. The curveVertex() function is an implementation of Catmull-Rom splines. Using the 3D version requires rendering with P3D (see the Environment reference for more information).

Parameters:

x - the x-coordinate of the vertex

y - the y-coordinate of the vertex

See Also:

• PGraphics.curve(float, float, float, float, float, float, float, float, float, float, float, float)
• PGraphics.beginShape(int)
• PGraphics.endShape(int)
• PGraphics.vertex(float, float, float, float, float)
• PGraphics.bezier(float, float, float, float, float, float, float, float, float, float, float, float)
• PGraphics.quadraticVertex(float, float, float, float, float, float)

curveVertex

public void curveVertex(float x,
 float y,
 float z)

Parameters:

z - the z-coordinate of the vertex

point

public void point(float x,
 float y)

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

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

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

Using point() with strokeWeight(1) or smaller may draw nothing to the screen, depending on the graphics settings of the computer. Workarounds include setting the pixel using set() or drawing the point using either circle() or square().

Parameters:

x - x-coordinate of the point

y - y-coordinate of the point

See Also:

• PGraphics.stroke(int)

point

public void point(float x,
 float y,
 float z)

Parameters:

z - z-coordinate of the point

line

public void line(float x1,
 float y1,
 float x2,
 float y2)

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.

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

line

public void line(float x1,
 float y1,
 float z1,
 float x2,
 float y2,
 float z2)

Parameters:

z1 - z-coordinate of the first point

z2 - z-coordinate of the second point

triangle

public void triangle(float x1,
 float y1,
 float x2,
 float y2,
 float x3,
 float y3)

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.

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:

• beginShape()

quad

public void quad(float x1,
 float y1,
 float x2,
 float y2,
 float x3,
 float y3,
 float x4,
 float y4)

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.

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

rectMode

public void rectMode(int mode)

Modifies the location from which rectangles are drawn by changing the way in which parameters given to rect() are interpreted.

The default mode is rectMode(CORNER), which interprets the first two parameters of rect() as the upper-left corner of the shape, while the third and fourth parameters are its width and height.

rectMode(CORNERS) interprets the first two parameters of rect() as the location of one corner, and the third and fourth parameters as the location of the opposite corner.

rectMode(CENTER) interprets the first two parameters of rect() as the shape's center point, while the third and fourth parameters are its width and height.

rectMode(RADIUS) also uses the first two parameters of rect() as the shape's center point, but uses the third and fourth parameters to specify half of the shape's width and height.

The parameter must be written in ALL CAPS because Processing is a case-sensitive language.

Parameters:

mode - either CORNER, CORNERS, CENTER, or RADIUS

See Also:

• PGraphics.rect(float, float, float, float)

rect

public void rect(float a,
 float b,
 float c,
 float d)

Draws a rectangle to the screen. A rectangle is a four-sided shape with every angle at ninety degrees. By default, the first two parameters set the location of the upper-left corner, the third sets the width, and the fourth sets the height. The way these parameters are interpreted, however, may be changed with the rectMode() function.

To draw a rounded rectangle, add a fifth parameter, which is used as the radius value for all four corners.

To use a different radius value for each corner, include eight parameters. When using eight parameters, the latter four set the radius of the arc at each corner separately, starting with the top-left corner and moving clockwise around the rectangle.

Parameters:

a - x-coordinate of the rectangle by default

b - y-coordinate of the rectangle by default

c - width of the rectangle by default

d - height of the rectangle by default

See Also:

• PGraphics.rectMode(int)
• PGraphics.quad(float, float, float, float, float, float, float, float)

rect

public void rect(float a,
 float b,
 float c,
 float d,
 float r)

Parameters:

r - radii for all four corners

rect

public void rect(float a,
 float b,
 float c,
 float d,
 float tl,
 float tr,
 float br,
 float bl)

Parameters:

tl - radius for top-left corner

tr - radius for top-right corner

br - radius for bottom-right corner

bl - radius for bottom-left corner

square

public void square(float x,
 float y,
 float extent)

Draws a square to the screen. A square is a four-sided shape with every angle at ninety degrees and each side is the same length. By default, the first two parameters set the location of the upper-left corner, the third sets the width and height. The way these parameters are interpreted, however, may be changed with the rectMode() function.

Parameters:

x - x-coordinate of the rectangle by default

y - y-coordinate of the rectangle by default

extent - width and height of the rectangle by default

See Also:

• PGraphics.rect(float, float, float, float)
• PGraphics.rectMode(int)

ellipseMode

public void ellipseMode(int mode)

Modifies the location from which ellipses are drawn by changing the way in which parameters given to ellipse() are interpreted.

The default mode is ellipseMode(CENTER), which interprets the first two parameters of ellipse() as the shape's center point, while the third and fourth parameters are its width and height.

ellipseMode(RADIUS) also uses the first two parameters of ellipse() as the shape's center point, but uses the third and fourth parameters to specify half of the shape's width and height.

ellipseMode(CORNER) interprets the first two parameters of ellipse() as the upper-left corner of the shape, while the third and fourth parameters are its width and height.

ellipseMode(CORNERS) interprets the first two parameters of ellipse() as the location of one corner of the ellipse's bounding box, and the third and fourth parameters as the location of the opposite corner.

The parameter must be written in ALL CAPS because Processing is a case-sensitive language.

Parameters:

mode - either CENTER, RADIUS, CORNER, or CORNERS

See Also:

• ellipse(float, float, float, float)
• arc(float, float, float, float, float, float)

ellipse

public void ellipse(float a,
 float b,
 float c,
 float d)

Draws an ellipse (oval) to the screen. An ellipse with equal width and height is a circle. By default, the first two parameters set the location, and the third and fourth parameters set the shape's width and height. The origin may be changed with the ellipseMode() function.

Parameters:

a - x-coordinate of the ellipse

b - y-coordinate of the ellipse

c - width of the ellipse by default

d - height of the ellipse by default

See Also:

• ellipseMode(int)
• arc(float, float, float, float, float, float)

arc

public void arc(float a,
 float b,
 float c,
 float d,
 float start,
 float stop)

Draws an arc to the screen. Arcs are drawn along the outer edge of an ellipse defined by the a, b, c, and d parameters. The origin of the arc's ellipse may be changed with the ellipseMode() function. Use the start and stop parameters to specify the angles (in radians) at which to draw the arc. The start/stop values must be in clockwise order.

There are three ways to draw an arc; the rendering technique used is defined by the optional seventh parameter. The three options, depicted in the above examples, are PIE, OPEN, and CHORD. The default mode is the OPEN stroke with a PIE fill.

In some cases, the arc() function isn't accurate enough for smooth drawing. For example, the shape may jitter on screen when rotating slowly. If you're having an issue with how arcs are rendered, you'll need to draw the arc yourself with beginShape()/endShape() or a PShape.

Parameters:

a - x-coordinate of the arc's ellipse

b - y-coordinate of the arc's ellipse

c - width of the arc's ellipse by default

d - height of the arc's ellipse by default

start - angle to start the arc, specified in radians

stop - angle to stop the arc, specified in radians

See Also:

• ellipse(float, float, float, float)
• ellipseMode(int)
• radians(float)
• degrees(float)

arc

public void arc(float a,
 float b,
 float c,
 float d,
 float start,
 float stop,
 int mode)

circle

public void circle(float x,
 float y,
 float extent)

Draws a circle to the screen. By default, the first two parameters set the location of the center, and the third sets the shape's width and height. The origin may be changed with the ellipseMode() function.

Parameters:

x - x-coordinate of the ellipse

y - y-coordinate of the ellipse

extent - width and height of the ellipse by default

See Also:

• ellipse(float, float, float, float)
• ellipseMode(int)

box

public void box(float size)

A box is an extruded rectangle. A box with equal dimension on all sides is a cube.

Parameters:

size - dimension of the box in all dimensions (creates a cube)

See Also:

• PGraphics.sphere(float)

box

public void box(float w,
 float h,
 float d)

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

sphereDetail

public void sphereDetail(int res)

Controls the detail used to render a sphere by adjusting the number of vertices of the sphere mesh. The default resolution is 30, which creates a fairly detailed sphere definition with vertices every 360/30 = 12 degrees. If you're going to render a great number of spheres per frame, it is advised to reduce the level of detail using this function. The setting stays active until sphereDetail() is called again with a new parameter and so should not be called prior to every sphere() statement, unless you wish to render spheres with different settings, e.g. using less detail for smaller spheres or ones further away from the camera. To control the detail of the horizontal and vertical resolution independently, use the version of the functions with two parameters.

Advanced

Code for sphereDetail() submitted by toxi [031031]. Code for enhanced u/v version from davbol [080801].

Parameters:

res - number of segments (minimum 3) used per full circle revolution

See Also:

• PGraphics.sphere(float)

sphereDetail

public void sphereDetail(int ures,
 int vres)

Parameters:

ures - number of segments used longitudinally per full circle revolution

vres - number of segments used latitudinally from top to bottom

sphere

public void sphere(float r)

A sphere is a hollow ball made from tessellated triangles.

Advanced

Implementation notes:

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

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

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

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

 [davbol 080801] now using separate sphereDetailU/V
 

Parameters:

r - the radius of the sphere

See Also:

• PGraphics.sphereDetail(int)

bezierPoint

public float bezierPoint(float a,
 float b,
 float c,
 float d,
 float t)

Evaluates the Bezier at point t for points a, b, c, d. The parameter t varies between 0 and 1, a and d are points on the curve, and b and c are the control points. This can be done once with the x coordinates and a second time with the y coordinates to get the location of a Bézier curve at t.

Advanced

For instance, to convert the following example:

 stroke(255, 102, 0);
 line(85, 20, 10, 10);
 line(90, 90, 15, 80);
 stroke(0, 0, 0);
 bezier(85, 20, 10, 10, 90, 90, 15, 80);

 // draw it in gray, using 10 steps instead of the default 20
 // this is a slower way to do it, but useful if you need
 // to do things with the coordinates at each step
 stroke(128);
 beginShape(LINE_STRIP);
 for (int i = 0; i <= 10; i++) {
   float t = i / 10.0f;
   float x = bezierPoint(85, 10, 90, 15, t);
   float y = bezierPoint(20, 10, 90, 80, t);
   vertex(x, y);
 }
 endShape();

Parameters:

a - coordinate of first point on the curve

b - coordinate of first control point

c - coordinate of second control point

d - coordinate of second point on the curve

t - value between 0 and 1

See Also:

• PGraphics.bezier(float, float, float, float, float, float, float, float, float, float, float, float)
• PGraphics.bezierVertex(float, float, float, float, float, float)
• PGraphics.curvePoint(float, float, float, float, float)

bezierTangent

public float bezierTangent(float a,
 float b,
 float c,
 float d,
 float t)

Calculates the tangent of a point on a Bézier curve. There is a good definition of tangent on Wikipedia.

Advanced

Code submitted by Dave Bollinger (davbol) for release 0136.

Parameters:

a - coordinate of first point on the curve

b - coordinate of first control point

c - coordinate of second control point

d - coordinate of second point on the curve

t - value between 0 and 1

See Also:

• PGraphics.bezier(float, float, float, float, float, float, float, float, float, float, float, float)
• PGraphics.bezierVertex(float, float, float, float, float, float)
• PGraphics.curvePoint(float, float, float, float, float)

bezierDetail

public void bezierDetail(int detail)

Sets the resolution at which Bézier curves display. The default value is 20. This function is only useful when using the P2D or P3D renderer; the default (JAVA2D) renderer does not use this information.

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)

bezier

public void bezier(float x1,
 float y1,
 float x2,
 float y2,
 float x3,
 float y3,
 float x4,
 float y4)

bezier

public void bezier(float x1,
 float y1,
 float z1,
 float x2,
 float y2,
 float z2,
 float x3,
 float y3,
 float z3,
 float x4,
 float y4,
 float z4)

Draws a Bézier curve on the screen. These curves are defined by a series of anchor and control points. The first two parameters specify the first anchor point and the last two parameters specify the other anchor point. The middle parameters specify the control points which define the shape of the curve. The curves were developed by French engineer Pierre Bezier. Using the 3D version requires rendering with P3D (see the Environment reference for more information).

Advanced

Draw a cubic Bézier curve. The first and last points are the on-curve points. The middle two are the 'control' points, or 'handles' in an application like Illustrator.

Identical to typing:

beginShape();
 vertex(x1, y1);
 bezierVertex(x2, y2, x3, y3, x4, y4);
 endShape();
 

In Postscript-speak, this would be:

moveto(x1, y1);
 curveto(x2, y2, x3, y3, x4, y4);

If you were to try and continue that curve like so:

curveto(x5, y5, x6, y6, x7, y7);

This would be done in processing by adding these statements:

bezierVertex(x5, y5, x6, y6, x7, y7)
 

To draw a quadratic (instead of cubic) curve, use the control point twice by doubling it:

bezier(x1, y1, cx, cy, cx, cy, x2, y2);

Parameters:

x1 - coordinates for the first anchor point

y1 - coordinates for the first anchor point

z1 - coordinates for the first anchor point

x2 - coordinates for the first control point

y2 - coordinates for the first control point

z2 - coordinates for the first control point

x3 - coordinates for the second control point

y3 - coordinates for the second control point

z3 - coordinates for the second control point

x4 - coordinates for the second anchor point

y4 - coordinates for the second anchor point

z4 - coordinates for the second anchor point

See Also:

• PGraphics.bezierVertex(float, float, float, float, float, float)
• PGraphics.curve(float, float, float, float, float, float, float, float, float, float, float, float)

curvePoint

public float curvePoint(float a,
 float b,
 float c,
 float d,
 float t)

Evaluates the curve at point t for points a, b, c, d. The parameter t may range from 0 (the start of the curve) and 1 (the end of the curve). a and d are the control points, and b and c are points on the curve. As seen in the example above, this can be used once with the x coordinates and a second time with the y coordinates to get the location of a curve at t.

Parameters:

a - coordinate of first control point

b - coordinate of first point on the curve

c - coordinate of second point on the curve

d - coordinate of second control point

t - value between 0 and 1

See Also:

• PGraphics.curve(float, float, float, float, float, float, float, float, float, float, float, float)
• PGraphics.curveVertex(float, float)
• PGraphics.bezierPoint(float, float, float, float, float)

curveTangent

public float curveTangent(float a,
 float b,
 float c,
 float d,
 float t)

Calculates the tangent of a point on a curve. There's a good definition of tangent on Wikipedia.

Advanced

Code thanks to Dave Bollinger (Bug #715)

Parameters:

a - coordinate of first point on the curve

b - coordinate of first control point

c - coordinate of second control point

d - coordinate of second point on the curve

t - value between 0 and 1

See Also:

• PGraphics.curve(float, float, float, float, float, float, float, float, float, float, float, float)
• PGraphics.curveVertex(float, float)
• PGraphics.curvePoint(float, float, float, float, float)
• PGraphics.bezierTangent(float, float, float, float, float)

curveDetail

public void curveDetail(int detail)

Sets the resolution at which curves display. The default value is 20. This function is only useful when using the P3D renderer as the default P2D renderer does not use this information.

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)

curveTightness

public void curveTightness(float tightness)

Modifies the quality of forms created with curve() and curveVertex(). The parameter tightness determines how the curve fits to the vertex points. The value 0.0 is the default value for tightness (this value defines the curves to be Catmull-Rom splines) and the value 1.0 connects all the points with straight lines. Values within the range -5.0 and 5.0 will deform the curves but will leave them recognizable and as values increase in magnitude, they will continue to deform.

Parameters:

tightness - amount of deformation from the original vertices

See Also:

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

curve

public void curve(float x1,
 float y1,
 float x2,
 float y2,
 float x3,
 float y3,
 float x4,
 float y4)

Draws a curved line on the screen. The first and second parameters specify the beginning control point and the last two parameters specify the ending control point. The middle parameters specify the start and stop of the curve. Longer curves can be created by putting a series of curve() functions together or using curveVertex(). An additional function called curveTightness() provides control for the visual quality of the curve. The curve() function is an implementation of Catmull-Rom splines. Using the 3D version requires rendering with P3D (see the Environment reference for more information).

Advanced

As of revision 0070, this function no longer doubles the first and last points. The curves are a bit more boring, but it's more mathematically correct, and properly mirrored in curvePoint().

Identical to typing out:

 beginShape();
 curveVertex(x1, y1);
 curveVertex(x2, y2);
 curveVertex(x3, y3);
 curveVertex(x4, y4);
 endShape();
 

Parameters:

x1 - coordinates for the beginning control point

y1 - coordinates for the beginning control point

x2 - coordinates for the first point

y2 - coordinates for the first point

x3 - coordinates for the second point

y3 - coordinates for the second point

x4 - coordinates for the ending control point

y4 - coordinates for the ending control point

See Also:

• PGraphics.curveVertex(float, float)
• PGraphics.curveTightness(float)
• PGraphics.bezier(float, float, float, float, float, float, float, float, float, float, float, float)

curve

public void curve(float x1,
 float y1,
 float z1,
 float x2,
 float y2,
 float z2,
 float x3,
 float y3,
 float z3,
 float x4,
 float y4,
 float z4)

Parameters:

z1 - coordinates for the beginning control point

z2 - coordinates for the first point

z3 - coordinates for the second point

z4 - coordinates for the ending control point

imageMode

public void imageMode(int mode)

Modifies the location from which images are drawn by changing the way in which parameters given to image() are interpreted.

The default mode is imageMode(CORNER), which interprets the second and third parameters of image() as the upper-left corner of the image. If two additional parameters are specified, they are used to set the image's width and height.

imageMode(CORNERS) interprets the second and third parameters of image() as the location of one corner, and the fourth and fifth parameters as the opposite corner.

imageMode(CENTER) interprets the second and third parameters of image() as the image's center point. If two additional parameters are specified, they are used to set the image's width and height.

The parameter must be written in ALL CAPS because Processing is a case-sensitive language.

Parameters:

mode - either CORNER, CORNERS, or CENTER

See Also:

• loadImage(String, String)
• PImage
• PGraphics.image(PImage, float, float, float, float)
• PGraphics.background(float, float, float, float)

image

public void image(PImage img,
 float a,
 float b)

The image() function draws an image to the display window. Images must be in the sketch's "data" directory to load correctly. Select "Add file..." from the "Sketch" menu to add the image to the data directory, or just drag the image file onto the sketch window. Processing currently works with GIF, JPEG, and PNG images.

The img parameter specifies the image to display and by default the a and b parameters define the location of its upper-left corner. The image is displayed at its original size unless the c and d parameters specify a different size. The imageMode() function can be used to change the way these parameters draw the image.

The color of an image may be modified with the tint() function. This function will maintain transparency for GIF and PNG images.

Advanced

Starting with release 0124, when using the default (JAVA2D) renderer, smooth() will also improve image quality of resized images.

Parameters:

img - the image to display

a - x-coordinate of the image by default

b - y-coordinate of the image by default

See Also:

• loadImage(String, String)
• PImage
• PGraphics.imageMode(int)
• PGraphics.tint(float)
• PGraphics.background(float, float, float, float)
• PGraphics.alpha(int)

image

public void image(PImage img,
 float a,
 float b,
 float c,
 float d)

Parameters:

c - width to display the image by default

d - height to display the image by default

image

public void image(PImage img,
 float a,
 float b,
 float c,
 float d,
 int u1,
 int v1,
 int u2,
 int v2)

Draw an image(), also specifying u/v coordinates. In this method, the u, v coordinates are always based on image space location, regardless of the current textureMode().

shapeMode

public void shapeMode(int mode)

Modifies the location from which shapes draw. The default mode is shapeMode(CORNER), which specifies the location to be the upper left corner of the shape and uses the third and fourth parameters of shape() to specify the width and height. The syntax shapeMode(CORNERS) uses the first and second parameters of shape() to set the location of one corner and uses the third and fourth parameters to set the opposite corner. The syntax shapeMode(CENTER) draws the shape from its center point and uses the third and forth parameters of shape() to specify the width and height. The parameter must be written in "ALL CAPS" because Processing is a case-sensitive language.

Parameters:

mode - either CORNER, CORNERS, CENTER

See Also:

• PShape
• PGraphics.shape(PShape)
• PGraphics.rectMode(int)

shape

public void shape(PShape shape)

shape

public void shape(PShape shape,
 float x,
 float y)

Draws shapes to the display window. Shapes must be in the sketch's "data" directory to load correctly. Select "Add file..." from the "Sketch" menu to add the shape. Processing currently works with SVG, OBJ, and custom-created shapes. The shape parameter specifies the shape to display and the coordinate parameters define the location of the shape from its upper-left corner. The shape is displayed at its original size unless the c and d parameters specify a different size. The shapeMode() function can be used to change the way these parameters are interpreted.

Parameters:

shape - the shape to display

x - x-coordinate of the shape

y - y-coordinate of the shape

See Also:

• PShape
• loadShape(String)
• PGraphics.shapeMode(int)

shape

public void shape(PShape shape,
 float a,
 float b,
 float c,
 float d)

Parameters:

a - x-coordinate of the shape

b - y-coordinate of the shape

c - width to display the shape

d - height to display the shape

textAlign

public void textAlign(int alignX)

textAlign

public void textAlign(int alignX,
 int alignY)

Sets the current alignment for drawing text. The parameters LEFT, CENTER, and RIGHT set the display characteristics of the letters in relation to the values for the x and y parameters of the text() function.

An optional second parameter can be used to vertically align the text. BASELINE is the default, and the vertical alignment will be reset to BASELINE if the second parameter is not used. The TOP and CENTER parameters are straightforward. The BOTTOM parameter offsets the line based on the current textDescent(). For multiple lines, the final line will be aligned to the bottom, with the previous lines appearing above it.

When using text() with width and height parameters, BASELINE is ignored, and treated as TOP. (Otherwise, text would by default draw outside the box, since BASELINE is the default setting. BASELINE is not a useful drawing mode for text drawn in a rectangle.)

The vertical alignment is based on the value of textAscent(), which many fonts do not specify correctly. It may be necessary to use a hack and offset by a few pixels by hand so that the offset looks correct. To do this as less of a hack, use some percentage of textAscent() or textDescent() so that the hack works even if you change the size of the font.

Parameters:

alignX - horizontal alignment, either LEFT, CENTER, or RIGHT

alignY - vertical alignment, either TOP, BOTTOM, CENTER, or BASELINE

See Also:

• loadFont(String)
• PFont
• PGraphics.text(String, float, float)
• PGraphics.textSize(float)
• PGraphics.textAscent()
• PGraphics.textDescent()

textAscent

public float textAscent()

Returns ascent of the current font at its current size. This information is useful for determining the height of the font above the baseline.

See Also:

• PGraphics.textDescent()

textDescent

public float textDescent()

Returns descent of the current font at its current size. This information is useful for determining the height of the font below the baseline.

See Also:

• PGraphics.textAscent()

textFont

public void textFont(PFont which)

Sets the current font that will be drawn with the text() function. Fonts must be created for Processing with createFont() or loaded with loadFont() before they can be used. The font set through textFont() will be used in all subsequent calls to the text() function. If no size parameter is specified, the font size defaults to the original size (the size in which it was created with the "Create Font..." tool) overriding any previous calls to textFont() or textSize().

When fonts are rendered as an image texture (as is the case with the P2D and P3D renderers as well as with loadFont() and vlw files), you should create fonts at the sizes that will be used most commonly. Using textFont() without the size parameter will result in the cleanest type.

Parameters:

which - any variable of the type PFont

See Also:

• createFont(String, float, boolean)
• loadFont(String)
• PFont
• PGraphics.text(String, float, float)
• PGraphics.textSize(float)

textFont

public void textFont(PFont which,
 float size)

Parameters:

size - the size of the letters in units of pixels

textLeading

public void textLeading(float leading)

Sets the spacing between lines of text in units of pixels. This setting will be used in all subsequent calls to the text() function. Note, however, that the leading is reset by textSize(). For example, if the leading is set to 20 with textLeading(20), then if textSize(48) is run at a later point, the leading will be reset to the default for the text size of 48.

Parameters:

leading - the size in pixels for spacing between lines

See Also:

• loadFont(String)
• PFont(java.io.InputStream)
• PGraphics.text(String, float, float)
• PGraphics.textFont(PFont)
• PGraphics.textSize(float)

textMode

public void textMode(int mode)

Sets the way text draws to the screen, either as texture maps or as vector geometry. The default textMode(MODEL), uses textures to render the fonts. The textMode(SHAPE) mode draws text using the glyph outlines of individual characters rather than as textures. This mode is only supported with the PDF and P3D renderer settings. With the PDF renderer, you must call textMode(SHAPE) before any other drawing occurs. If the outlines are not available, then textMode(SHAPE) will be ignored and textMode(MODEL) will be used instead.

The textMode(SHAPE) option in P3D can be combined with beginRaw() to write vector-accurate text to 2D and 3D output files, for instance DXF or PDF. The SHAPE mode is not currently optimized for P3D, so if recording shape data, use textMode(MODEL) until you're ready to capture the geometry with beginRaw().

Parameters:

mode - either MODEL or SHAPE

See Also:

• loadFont(String)
• PFont(java.io.InputStream)
• PGraphics.text(String, float, float)
• PGraphics.textFont(PFont)
• PGraphics.beginRaw(PGraphics)
• createFont(String, float, boolean)

textSize

public void textSize(float size)

Sets the current font size. This size will be used in all subsequent calls to the text() function. Font size is measured in units of pixels.

Parameters:

size - the size of the letters in units of pixels

See Also:

• loadFont(String)
• PFont(java.io.InputStream)
• PGraphics.text(String, float, float)
• PGraphics.textFont(PFont)

textWidth

public float textWidth(char c)

Parameters:

c - the character to measure

textWidth

public float textWidth(String str)

Calculates and returns the width of any character or text string.

Parameters:

str - the String of characters to measure

See Also:

• loadFont(String)
• PFont(java.io.InputStream)
• PGraphics.text(String, float, float)
• PGraphics.textFont(PFont)
• PGraphics.textSize(float)

textWidth

public float textWidth(char[] chars,
 int start,
 int length)

text

public void text(char c,
 float x,
 float y)

Draws text to the screen. Displays the information specified in the first parameter on the screen in the position specified by the additional parameters. A default font will be used unless a font is set with the textFont() function and a default size will be used unless a font is set with textSize(). Change the color of the text with the fill() function. The text displays in relation to the textAlign() function, which gives the option to draw to the left, right, and center of the coordinates.

The x2 and y2 parameters define a rectangular area to display within and may only be used with string data. When these parameters are specified, they are interpreted based on the current rectMode() setting. Text that does not fit completely within the rectangle specified will not be drawn to the screen.

Note that Processing now lets you call text() without first specifying a PFont with textFont(). In that case, a generic sans-serif font will be used instead. (See the third example above.)

Parameters:

c - the alphanumeric character to be displayed

x - x-coordinate of text

y - y-coordinate of text

See Also:

• PGraphics.textAlign(int, int)
• PGraphics.textFont(PFont)
• PGraphics.textMode(int)
• PGraphics.textSize(float)
• PGraphics.textLeading(float)
• PGraphics.textWidth(String)
• PGraphics.textAscent()
• PGraphics.textDescent()
• PGraphics.rectMode(int)
• PGraphics.fill(int, float)

text

public void text(char c,
 float x,
 float y,
 float z)

Parameters:

z - z-coordinate of text

text

public void text(String str,
 float x,
 float y)

Advanced

Draw a chunk of text. Newlines that are \n (Unix newline or linefeed char, ascii 10) are honored, but \r (carriage return, Windows and Mac OS) are ignored.

text

public void text(char[] chars,
 int start,
 int stop,
 float x,
 float y)

Advanced

Method to draw text from an array of chars. This method will usually be more efficient than drawing from a String object, because the String will not be converted to a char array before drawing.

Parameters:

chars - the alphanumeric symbols to be displayed

start - array index at which to start writing characters

stop - array index at which to stop writing characters

text

public void text(String str,
 float x,
 float y,
 float z)

Same as above but with a z coordinate.

text

public void text(char[] chars,
 int start,
 int stop,
 float x,
 float y,
 float z)

text

public void text(String str,
 float x1,
 float y1,
 float x2,
 float y2)

Advanced

Draw text in a box that is constrained to a particular size. The current rectMode() determines what the coordinates mean (whether x1/y1/x2/y2 or x/y/w/h).

Note that the x,y coords of the start of the box will align with the *ascent* of the text, not the baseline, as is the case for the other text() functions.

Newlines that are \n (Unix newline or linefeed char, ascii 10) are honored, and \r (carriage return, Windows and Mac OS) are ignored.

Parameters:

x1 - by default, the x-coordinate of text, see rectMode() for more info

y1 - by default, the y-coordinate of text, see rectMode() for more info

x2 - by default, the width of the text box, see rectMode() for more info

y2 - by default, the height of the text box, see rectMode() for more info

text

public void text(int num,
 float x,
 float y)

text

public void text(int num,
 float x,
 float y,
 float z)

text

public void text(float num,
 float x,
 float y)

This does a basic number formatting, to avoid the generally ugly appearance of printing floats. Users who want more control should use their own nf() command, or if they want the long, ugly version of float, use String.valueOf() to convert the float to a String first.

Parameters:

num - the numeric value to be displayed

text

public void text(float num,
 float x,
 float y,
 float z)

push

public void push()

The push() function saves the current drawing style settings and transformations, while pop() restores these settings. Note that these functions are always used together. They allow you to change the style and transformation settings and later return to what you had. When a new state is started with push(), it builds on the current style and transform information.

push() stores information related to the current transformation state and style settings controlled by the following functions: rotate(), translate(), scale(), fill(), stroke(), tint(), strokeWeight(), strokeCap(), strokeJoin(), imageMode(), rectMode(), ellipseMode(), colorMode(), textAlign(), textFont(), textMode(), textSize(), textLeading().

The push() and pop() functions were added with Processing 3.5. They can be used in place of pushMatrix(), popMatrix(), pushStyles(), and popStyles(). The difference is that push() and pop() control both the transformations (rotate, scale, translate) and the drawing styles at the same time.

See Also:

• PGraphics.pop()

pop

public void pop()

The pop() function restores the previous drawing style settings and transformations after push() has changed them. Note that these functions are always used together. They allow you to change the style and transformation settings and later return to what you had. When a new state is started with push(), it builds on the current style and transform information.

push() stores information related to the current transformation state and style settings controlled by the following functions: rotate(), translate(), scale(), fill(), stroke(), tint(), strokeWeight(), strokeCap(), strokeJoin(), imageMode(), rectMode(), ellipseMode(), colorMode(), textAlign(), textFont(), textMode(), textSize(), textLeading().

The push() and pop() functions were added with Processing 3.5. They can be used in place of pushMatrix(), popMatrix(), pushStyles(), and popStyles(). The difference is that push() and pop() control both the transformations (rotate, scale, translate) and the drawing styles at the same time.

See Also:

• PGraphics.push()

pushMatrix

public void pushMatrix()

Pushes the current transformation matrix onto the matrix stack. Understanding pushMatrix() and popMatrix() requires understanding the concept of a matrix stack. The pushMatrix() function saves the current coordinate system to the stack and popMatrix() restores the prior coordinate system. pushMatrix() and popMatrix() are used in conjunction with the other transformation functions and may be embedded to control the scope of the transformations.

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

Pops the current transformation matrix off the matrix stack. Understanding pushing and popping requires understanding the concept of a matrix stack. The pushMatrix() function saves the current coordinate system to the stack and popMatrix() restores the prior coordinate system. pushMatrix() and popMatrix() are used in conjunction with the other transformation functions and may be embedded to control the scope of the transformations.

See Also:

• PGraphics.pushMatrix()

translate

public void translate(float x,
 float y)

Specifies an amount to displace objects within the display window. The x parameter specifies left/right translation, the y parameter specifies up/down translation, and the z parameter specifies translations toward/away from the screen. Using this function with the z parameter requires using P3D as a parameter in combination with size as shown in the above example.

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

Parameters:

x - left/right translation

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

translate

public void translate(float x,
 float y,
 float z)

Parameters:

z - forward/backward translation

rotate

public void rotate(float angle)

Rotates a shape the amount specified by the angle parameter. Angles should be specified in radians (values from 0 to TWO_PI) or converted to radians with the radians() function.

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

Technically, rotate() multiplies the current transformation matrix by a rotation matrix. This function can be further controlled by the pushMatrix() and popMatrix().

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)
• radians(float)

rotateX

public void rotateX(float angle)

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.

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)

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.

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)

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.

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 x,
 float y,
 float z)

Advanced

Rotate about a vector in space. Same as the glRotatef() function.

scale

public void scale(float s)

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

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

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 x,
 float y)

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.

Parameters:

x - percentage to scale the object in the x-axis

y - percentage to scale the object in the y-axis

scale

public void scale(float x,
 float y,
 float z)

Parameters:

z - percentage to scale the object in the z-axis

shearX

public void shearX(float angle)

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.

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)
• radians(float)

shearY

public void shearY(float angle)

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.

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)
• radians(float)

resetMatrix

public void resetMatrix()

Replaces the current matrix with the identity matrix. The equivalent function in OpenGL is glLoadIdentity().

See Also:

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

applyMatrix

public void applyMatrix(PMatrix source)

Multiplies the current matrix by the one specified through the parameters. This is very slow because it will try to calculate the inverse of the transform, so avoid it whenever possible. The equivalent function in OpenGL is glMultMatrix().

See Also:

• PGraphics.pushMatrix()
• PGraphics.popMatrix()
• PGraphics.resetMatrix()
• PGraphics.printMatrix()

applyMatrix

public void applyMatrix(PMatrix2D source)

applyMatrix

public void applyMatrix(float n00,
 float n01,
 float n02,
 float n10,
 float n11,
 float n12)

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

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)

Parameters:

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

getMatrix

public PMatrix2D getMatrix(PMatrix2D target)

Copy the current transformation matrix into the specified target. Pass in null to create a new matrix.

getMatrix

public PMatrix3D getMatrix(PMatrix3D target)

Copy the current transformation matrix into the specified target. Pass in null to create a new matrix.

setMatrix

public void setMatrix(PMatrix source)

Set the current transformation matrix to the contents of another.

setMatrix

public void setMatrix(PMatrix2D source)

Set the current transformation to the contents of the specified source.

setMatrix

public void setMatrix(PMatrix3D source)

Set the current transformation to the contents of the specified source.

printMatrix

public void printMatrix()

Prints the current matrix to the Console (the text window at the bottom of Processing).

See Also:

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

beginCamera

public void beginCamera()

The beginCamera() and endCamera() functions enable advanced customization of the camera space. The functions are useful if you want to more control over camera movement, however for most users, the camera() function will be sufficient.

The camera functions will replace any transformations (such as rotate() or translate()) that occur before them in draw(), but they will not automatically replace the camera transform itself. For this reason, camera functions should be placed at the beginning of draw() (so that transformations happen afterwards), and the camera() function can be used after beginCamera() if you want to reset the camera before applying transformations.

This function sets the matrix mode to the camera matrix so calls such as translate(), rotate(), applyMatrix() and resetMatrix() affect the camera. beginCamera() should always be used with a following endCamera() and pairs of beginCamera() and endCamera() cannot be nested.

See Also:

• PGraphics.camera()
• PGraphics.endCamera()
• PGraphics.applyMatrix(PMatrix)
• PGraphics.resetMatrix()
• PGraphics.translate(float, float, float)
• PGraphics.scale(float, float, float)

endCamera

public void endCamera()

The beginCamera() and endCamera() functions enable advanced customization of the camera space. Please see the reference for beginCamera() for a description of how the functions are used.

See Also:

• PGraphics.beginCamera()
• PGraphics.camera(float, float, float, float, float, float, float, float, float)

camera

public void camera()

Sets the position of the camera through setting the eye position, the center of the scene, and which axis is facing upward. Moving the eye position and the direction it is pointing (the center of the scene) allows the images to be seen from different angles. The version without any parameters sets the camera to the default position, pointing to the center of the display window with the Y axis as up. The default values are camera(width/2.0, height/2.0, (height/2.0) / tan(PI*30.0 / 180.0), width/2.0, height/2.0, 0, 0, 1, 0). This function is similar to gluLookAt() in OpenGL, but it first clears the current camera settings.

See Also:

• PGraphics.beginCamera()
• PGraphics.endCamera()
• PGraphics.frustum(float, float, float, float, float, float)

camera

public void camera(float eyeX,
 float eyeY,
 float eyeZ,
 float centerX,
 float centerY,
 float centerZ,
 float upX,
 float upY,
 float upZ)

Parameters:

eyeX - x-coordinate for the eye

eyeY - y-coordinate for the eye

eyeZ - z-coordinate for the eye

centerX - x-coordinate for the center of the scene

centerY - y-coordinate for the center of the scene

centerZ - z-coordinate for the center of the scene

upX - usually 0.0, 1.0, or -1.0

upY - usually 0.0, 1.0, or -1.0

upZ - usually 0.0, 1.0, or -1.0

printCamera

public void printCamera()

Prints the current camera matrix to the Console (the text window at the bottom of Processing).

See Also:

• PGraphics.camera(float, float, float, float, float, float, float, float, float)

ortho

public void ortho()

Sets an orthographic projection and defines a parallel clipping volume. All objects with the same dimension appear the same size, regardless of whether they are near or far from the camera. The parameters to this function specify the clipping volume where left and right are the minimum and maximum x values, top and bottom are the minimum and maximum y values, and near and far are the minimum and maximum z values. If no parameters are given, the default is used: ortho(-width/2, width/2, -height/2, height/2).

ortho

public void ortho(float left,
 float right,
 float bottom,
 float top)

Parameters:

left - left plane of the clipping volume

right - right plane of the clipping volume

bottom - bottom plane of the clipping volume

top - top plane of the clipping volume

ortho

public void ortho(float left,
 float right,
 float bottom,
 float top,
 float near,
 float far)

Parameters:

near - maximum distance from the origin to the viewer

far - maximum distance from the origin away from the viewer

perspective

public void perspective()

Sets a perspective projection applying foreshortening, making distant objects appear smaller than closer ones. The parameters define a viewing volume with the shape of truncated pyramid. Objects near to the front of the volume appear their actual size, while farther objects appear smaller. This projection simulates the perspective of the world more accurately than orthographic projection. The version of perspective without parameters sets the default perspective and the version with four parameters allows the programmer to set the area precisely. The default values are: perspective(PI/3.0, width/height, cameraZ/10.0, cameraZ*10.0) where cameraZ is ((height/2.0) / tan(PI*60.0/360.0))

perspective

public void perspective(float fovy,
 float aspect,
 float zNear,
 float zFar)

Parameters:

fovy - field-of-view angle (in radians) for vertical direction

aspect - ratio of width to height

zNear - z-position of nearest clipping plane

zFar - z-position of the farthest clipping plane

frustum

public void frustum(float left,
 float right,
 float bottom,
 float top,
 float near,
 float far)

Sets a perspective matrix as defined by the parameters.

A frustum is a geometric form: a pyramid with its top cut off. With the viewer's eye at the imaginary top of the pyramid, the six planes of the frustum act as clipping planes when rendering a 3D view. Thus, any form inside the clipping planes is rendered and visible; anything outside those planes is not visible.

Setting the frustum has the effect of changing the perspective with which the scene is rendered. This can be achieved more simply in many cases by using perspective().

Note that the near value must be greater than zero (as the point of the frustum "pyramid" cannot converge "behind" the viewer). Similarly, the far value must be greater than the near value (as the "far" plane of the frustum must be "farther away" from the viewer than the near plane).

Works like glFrustum, except it wipes out the current perspective matrix rather than multiplying itself with it.

Parameters:

left - left coordinate of the clipping plane

right - right coordinate of the clipping plane

bottom - bottom coordinate of the clipping plane

top - top coordinate of the clipping plane

near - near component of the clipping plane; must be greater than zero

far - far component of the clipping plane; must be greater than the near value

See Also:

• PGraphics.camera(float, float, float, float, float, float, float, float, float)
• PGraphics.beginCamera()
• PGraphics.endCamera()
• PGraphics.perspective(float, float, float, float)

printProjection

public void printProjection()

Prints the current projection matrix to the Console (the text window at the bottom of Processing).

See Also:

• PGraphics.camera(float, float, float, float, float, float, float, float, float)

screenX

public float screenX(float x,
 float y)

Takes a three-dimensional X, Y, Z position and returns the X value for where it will appear on a (two-dimensional) screen.

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)

Takes a three-dimensional X, Y, Z position and returns the Y value for where it will appear on a (two-dimensional) screen.

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)

Parameters:

z - 3D z-coordinate to be mapped

screenY

public float screenY(float x,
 float y,
 float z)

Parameters:

z - 3D z-coordinate to be mapped

screenZ

public float screenZ(float x,
 float y,
 float z)

Takes a three-dimensional X, Y, Z position and returns the Z value for where it will appear on a (two-dimensional) screen.

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)

modelX

public float modelX(float x,
 float y,
 float z)

Returns the three-dimensional X, Y, Z position in model space. This returns the X value for a given coordinate based on the current set of transformations (scale, rotate, translate, etc.) The X value can be used to place an object in space relative to the location of the original point once the transformations are no longer in use.

In the example, the modelX(), modelY(), and modelZ() functions record the location of a box in space after being placed using a series of translate and rotate commands. After popMatrix() is called, those transformations no longer apply, but the (x, y, z) coordinate returned by the model functions is used to place another box in the same location.

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.modelY(float, float, float)
• PGraphics.modelZ(float, float, float)

modelY

public float modelY(float x,
 float y,
 float z)

Returns the three-dimensional X, Y, Z position in model space. This returns the Y value for a given coordinate based on the current set of transformations (scale, rotate, translate, etc.) The Y value can be used to place an object in space relative to the location of the original point once the transformations are no longer in use.

In the example, the modelX(), modelY(), and modelZ() functions record the location of a box in space after being placed using a series of translate and rotate commands. After popMatrix() is called, those transformations no longer apply, but the (x, y, z) coordinate returned by the model functions is used to place another box in the same location.

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.modelX(float, float, float)
• PGraphics.modelZ(float, float, float)

modelZ

public float modelZ(float x,
 float y,
 float z)

Returns the three-dimensional X, Y, Z position in model space. This returns the Z value for a given coordinate based on the current set of transformations (scale, rotate, translate, etc.) The Z value can be used to place an object in space relative to the location of the original point once the transformations are no longer in use.

In the example, the modelX(), modelY(), and modelZ() functions record the location of a box in space after being placed using a series of translate and rotate commands. After popMatrix() is called, those transformations no longer apply, but the (x, y, z) coordinate returned by the model functions is used to place another box in the same location.

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.modelX(float, float, float)
• PGraphics.modelY(float, float, float)

pushStyle

public void pushStyle()

The pushStyle() function saves the current style settings and popStyle() restores the prior settings. Note that these functions are always used together. They allow you to change the style settings and later return to what you had. When a new style is started with pushStyle(), it builds on the current style information. The pushStyle() and popStyle() functions can be embedded to provide more control (see the second example above for a demonstration.)

The style information controlled by the following functions are included in the style: fill(), stroke(), tint(), strokeWeight(), strokeCap(),strokeJoin(), imageMode(), rectMode(), ellipseMode(), shapeMode(), colorMode(), textAlign(), textFont(), textMode(), textSize(), textLeading(), emissive(), specular(), shininess(), ambient()

See Also:

• PGraphics.popStyle()

popStyle

public void popStyle()

The pushStyle() function saves the current style settings and popStyle() restores the prior settings; these functions are always used together. They allow you to change the style settings and later return to what you had. When a new style is started with pushStyle(), it builds on the current style information. The pushStyle() and popStyle() functions can be embedded to provide more control (see the second example above for a demonstration.)

See Also:

• PGraphics.pushStyle()

style

public void style(PStyle s)

strokeWeight

public void strokeWeight(float weight)

Sets the width of the stroke used for lines, points, and the border around shapes. All widths are set in units of pixels.

Using point() with strokeWeight(1) or smaller may draw nothing to the screen, depending on the graphics settings of the computer. Workarounds include setting the pixel using set() or drawing the point using either circle() or square().

Parameters:

weight - the weight (in pixels) of the stroke

See Also:

• PGraphics.stroke(int, float)
• PGraphics.strokeJoin(int)
• PGraphics.strokeCap(int)

strokeJoin

public void strokeJoin(int join)

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.

Parameters:

join - either MITER, BEVEL, ROUND

See Also:

• PGraphics.stroke(int, float)
• PGraphics.strokeWeight(float)
• PGraphics.strokeCap(int)

strokeCap

public void strokeCap(int cap)

Sets the style for rendering line endings. These ends are either squared, extended, or rounded, each of which specified with the corresponding parameters: SQUARE, PROJECT, and ROUND. The default cap is ROUND.

To make point() appear square, use strokeCap(PROJECT). Using strokeCap(SQUARE) (no cap) causes points to become invisible.

Parameters:

cap - either SQUARE, PROJECT, or ROUND

See Also:

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

noStroke

public void noStroke()

Disables drawing the stroke (outline). If both noStroke() and noFill() are called, nothing will be drawn to the screen.

See Also:

• PGraphics.stroke(int, float)
• PGraphics.fill(float, float, float, float)
• PGraphics.noFill()

stroke

public void stroke(int rgb)

Sets the color used to draw lines and borders around shapes. This color is either specified in terms of the RGB or HSB color depending on the current colorMode(). The default color space is RGB, with each value in the range from 0 to 255.

When using hexadecimal notation to specify a color, use "#" or "0x" before the values (e.g., #CCFFAA or 0xFFCCFFAA). The # syntax uses six digits to specify a color (just as colors are typically specified in HTML and CSS). When using the hexadecimal notation starting with "0x", the hexadecimal value must be specified with eight characters; the first two characters define the alpha component, and the remainder define the red, green, and blue components.

The value for the gray parameter must be less than or equal to the current maximum value as specified by colorMode(). The default maximum value is 255.

When drawing in 2D with the default renderer, you may need hint(ENABLE_STROKE_PURE) to improve drawing quality (at the expense of performance). See the hint() documentation for more details.

Parameters:

rgb - color value in hexadecimal notation

See Also:

• PGraphics.noStroke()
• PGraphics.strokeWeight(float)
• PGraphics.strokeJoin(int)
• PGraphics.strokeCap(int)
• PGraphics.fill(int, float)
• PGraphics.noFill()
• PGraphics.tint(int, float)
• PGraphics.background(float, float, float, float)
• PGraphics.colorMode(int, float, float, float, float)

stroke

public void stroke(int rgb,
 float alpha)

Parameters:

alpha - opacity of the stroke

stroke

public void stroke(float gray)

Parameters:

gray - specifies a value between white and black

stroke

public void stroke(float gray,
 float alpha)

stroke

public void stroke(float v1,
 float v2,
 float v3)

Parameters:

v1 - red or hue value (depending on current color mode)

v2 - green or saturation value (depending on current color mode)

v3 - blue or brightness value (depending on current color mode)

stroke

public void stroke(float v1,
 float v2,
 float v3,
 float alpha)

noTint

public void noTint()

Removes the current fill value for displaying images and reverts to displaying images with their original hues.

See Also:

• PGraphics.tint(float, float, float, float)
• PGraphics.image(PImage, float, float, float, float)

Usage:

web_application

tint

public void tint(int rgb)

Sets the fill value for displaying images. Images can be tinted to specified colors or made transparent by including an alpha value.

To apply transparency to an image without affecting its color, use white as the tint color and specify an alpha value. For instance, tint(255, 128) will make an image 50% transparent (assuming the default alpha range of 0-255, which can be changed with colorMode()).

When using hexadecimal notation to specify a color, use "#" or "0x" before the values (e.g., #CCFFAA or 0xFFCCFFAA). The # syntax uses six digits to specify a color (just as colors are typically specified in HTML and CSS). When using the hexadecimal notation starting with "0x", the hexadecimal value must be specified with eight characters; the first two characters define the alpha component, and the remainder define the red, green, and blue components.

The value for the gray parameter must be less than or equal to the current maximum value as specified by colorMode(). The default maximum value is 255.

The tint() function is also used to control the coloring of textures in 3D.

Parameters:

rgb - color value in hexadecimal notation

See Also:

• PGraphics.noTint()
• PGraphics.image(PImage, float, float, float, float)

Usage:

web_application

tint

public void tint(int rgb,
 float alpha)

Parameters:

alpha - opacity of the image

tint

public void tint(float gray)

Parameters:

gray - specifies a value between white and black

tint

public void tint(float gray,
 float alpha)

tint

public void tint(float v1,
 float v2,
 float v3)

Parameters:

v1 - red or hue value (depending on current color mode)

v2 - green or saturation value (depending on current color mode)

v3 - blue or brightness value (depending on current color mode)

tint

public void tint(float v1,
 float v2,
 float v3,
 float alpha)

noFill

public void noFill()

Disables filling geometry. If both noStroke() and noFill() are called, nothing will be drawn to the screen.

See Also:

• PGraphics.fill(float, float, float, float)
• PGraphics.stroke(int, float)
• PGraphics.noStroke()

Usage:

web_application

fill

public void fill(int rgb)

Sets the color used to fill shapes. For example, if you run fill(204, 102, 0), all subsequent shapes will be filled with orange. This color is either specified in terms of the RGB or HSB color depending on the current colorMode() (the default color space is RGB, with each value in the range from 0 to 255).

When using hexadecimal notation to specify a color, use "#" or "0x" before the values (e.g. #CCFFAA, 0xFFCCFFAA). The # syntax uses six digits to specify a color (the way colors are specified in HTML and CSS). When using the hexadecimal notation starting with "0x", the hexadecimal value must be specified with eight characters; the first two characters define the alpha component and the remainder the red, green, and blue components.

The value for the parameter "gray" must be less than or equal to the current maximum value as specified by colorMode(). The default maximum value is 255.

To change the color of an image (or a texture), use tint().

Parameters:

rgb - color variable or hex value

See Also:

• PGraphics.noFill()
• PGraphics.stroke(int, float)
• PGraphics.noStroke()
• PGraphics.tint(int, float)
• PGraphics.background(float, float, float, float)
• PGraphics.colorMode(int, float, float, float, float)

Usage:

web_application

fill

public void fill(int rgb,
 float alpha)

Parameters:

alpha - opacity of the fill

fill

public void fill(float gray)

Parameters:

gray - number specifying value between white and black

fill

public void fill(float gray,
 float alpha)

fill

public void fill(float v1,
 float v2,
 float v3)

Parameters:

v1 - red or hue value (depending on current color mode)

v2 - green or saturation value (depending on current color mode)

v3 - blue or brightness value (depending on current color mode)

fill

public void fill(float v1,
 float v2,
 float v3,
 float alpha)

ambient

public void ambient(int rgb)

Sets the ambient reflectance for shapes drawn to the screen. This is combined with the ambient light component of environment. The color components set through the parameters define the reflectance. For example in the default color mode, setting v1=255, v2=126, v3=0, would cause all the red light to reflect and half of the green light to reflect. Used in combination with emissive(), specular(), and shininess() in setting the material properties of shapes.

Parameters:

rgb - any value of the color datatype

See Also:

• PGraphics.emissive(float, float, float)
• PGraphics.specular(float, float, float)
• PGraphics.shininess(float)

Usage:

web_application

ambient

public void ambient(float gray)

Parameters:

gray - number specifying value between white and black

ambient

public void ambient(float v1,
 float v2,
 float v3)

Parameters:

v1 - red or hue value (depending on current color mode)

v2 - green or saturation value (depending on current color mode)

v3 - blue or brightness value (depending on current color mode)

specular

public void specular(int rgb)

Sets the specular color of the materials used for shapes drawn to the screen, which sets the color of highlights. Specular refers to light which bounces off a surface in a preferred direction (rather than bouncing in all directions like a diffuse light). Used in combination with emissive(), ambient(), and shininess() in setting the material properties of shapes.

Parameters:

rgb - color to set

See Also:

• PGraphics.lightSpecular(float, float, float)
• PGraphics.ambient(float, float, float)
• PGraphics.emissive(float, float, float)
• PGraphics.shininess(float)

Usage:

web_application

specular

public void specular(float gray)

gray number specifying value between white and black

Parameters:

gray - value between black and white, by default 0 to 255

specular

public void specular(float v1,
 float v2,
 float v3)

Parameters:

v1 - red or hue value (depending on current color mode)

v2 - green or saturation value (depending on current color mode)

v3 - blue or brightness value (depending on current color mode)

shininess

public void shininess(float shine)

Sets the amount of gloss in the surface of shapes. Used in combination with ambient(), specular(), and emissive() in setting the material properties of shapes.

Parameters:

shine - degree of shininess

See Also:

• PGraphics.emissive(float, float, float)
• PGraphics.ambient(float, float, float)
• PGraphics.specular(float, float, float)

Usage:

web_application

emissive

public void emissive(int rgb)

Sets the emissive color of the material used for drawing shapes drawn to the screen. Used in combination with ambient(), specular(), and shininess() in setting the material properties of shapes.

Parameters:

rgb - color to set

See Also:

• PGraphics.ambient(float, float, float)
• PGraphics.specular(float, float, float)
• PGraphics.shininess(float)

Usage:

web_application

emissive

public void emissive(float gray)

gray number specifying value between white and black

Parameters:

gray - value between black and white, by default 0 to 255

emissive

public void emissive(float v1,
 float v2,
 float v3)

Parameters:

v1 - red or hue value (depending on current color mode)

v2 - green or saturation value (depending on current color mode)

v3 - blue or brightness value (depending on current color mode)

lights

public void lights()

Sets the default ambient light, directional light, falloff, and specular values. The defaults are ambientLight(128, 128, 128) and directionalLight(128, 128, 128, 0, 0, -1), lightFalloff(1, 0, 0), and lightSpecular(0, 0, 0). Lights need to be included in the draw() to remain persistent in a looping program. Placing them in the setup() of a looping program will cause them to only have an effect the first time through the loop.

See Also:

• PGraphics.ambientLight(float, float, float, float, float, float)
• PGraphics.directionalLight(float, float, float, float, float, float)
• PGraphics.pointLight(float, float, float, float, float, float)
• PGraphics.spotLight(float, float, float, float, float, float, float, float, float, float, float)
• PGraphics.noLights()

Usage:

web_application

noLights

public void noLights()

Disable all lighting. Lighting is turned off by default and enabled with the lights() function. This function can be used to disable lighting so that 2D geometry (which does not require lighting) can be drawn after a set of lighted 3D geometry.

See Also:

• PGraphics.lights()

Usage:

web_application

ambientLight

public void ambientLight(float v1,
 float v2,
 float v3)

Adds an ambient light. Ambient light doesn't come from a specific direction, the rays of light have bounced around so much that objects are evenly lit from all sides. Ambient lights are almost always used in combination with other types of lights. Lights need to be included in the draw() to remain persistent in a looping program. Placing them in the setup() of a looping program will cause them to only have an effect the first time through the loop. The v1, v2, and v3 parameters are interpreted as either RGB or HSB values, depending on the current color mode.

Parameters:

v1 - red or hue value (depending on current color mode)

v2 - green or saturation value (depending on current color mode)

v3 - blue or brightness value (depending on current color mode)

See Also:

• PGraphics.lights()
• PGraphics.directionalLight(float, float, float, float, float, float)
• PGraphics.pointLight(float, float, float, float, float, float)
• PGraphics.spotLight(float, float, float, float, float, float, float, float, float, float, float)

Usage:

web_application

ambientLight

public void ambientLight(float v1,
 float v2,
 float v3,
 float x,
 float y,
 float z)

Parameters:

x - x-coordinate of the light

y - y-coordinate of the light

z - z-coordinate of the light

directionalLight

public void directionalLight(float v1,
 float v2,
 float v3,
 float nx,
 float ny,
 float nz)

Adds a directional light. Directional light comes from one direction and is stronger when hitting a surface squarely and weaker if it hits at a gentle angle. After hitting a surface, a directional lights scatters in all directions. Lights need to be included in the draw() to remain persistent in a looping program. Placing them in the setup() of a looping program will cause them to only have an effect the first time through the loop. The affect of the v1, v2, and v3 parameters is determined by the current color mode. The nx, ny, and nz parameters specify the direction the light is facing. For example, setting ny to -1 will cause the geometry to be lit from below (the light is facing directly upward).

Parameters:

v1 - red or hue value (depending on current color mode)

v2 - green or saturation value (depending on current color mode)

v3 - blue or brightness value (depending on current color mode)

nx - direction along the x-axis

ny - direction along the y-axis

nz - direction along the z-axis

See Also:

• PGraphics.lights()
• PGraphics.ambientLight(float, float, float, float, float, float)
• PGraphics.pointLight(float, float, float, float, float, float)
• PGraphics.spotLight(float, float, float, float, float, float, float, float, float, float, float)

Usage:

web_application

pointLight

public void pointLight(float v1,
 float v2,
 float v3,
 float x,
 float y,
 float z)

Adds a point light. Lights need to be included in the draw() to remain persistent in a looping program. Placing them in the setup() of a looping program will cause them to only have an effect the first time through the loop. The v1, v2, and v3 parameters are interpreted as either RGB or HSB values, depending on the current color mode. The x, y, and z parameters set the position of the light.

Parameters:

v1 - red or hue value (depending on current color mode)

v2 - green or saturation value (depending on current color mode)

v3 - blue or brightness value (depending on current color mode)

x - x-coordinate of the light

y - y-coordinate of the light

z - z-coordinate of the light

See Also:

• PGraphics.lights()
• PGraphics.directionalLight(float, float, float, float, float, float)
• PGraphics.ambientLight(float, float, float, float, float, float)
• PGraphics.spotLight(float, float, float, float, float, float, float, float, float, float, float)

Usage:

web_application

spotLight

public void spotLight(float v1,
 float v2,
 float v3,
 float x,
 float y,
 float z,
 float nx,
 float ny,
 float nz,
 float angle,
 float concentration)

Adds a spotlight. Lights need to be included in the draw() to remain persistent in a looping program. Placing them in the setup() of a looping program will cause them to only have an effect the first time through the loop. The v1, v2, and v3 parameters are interpreted as either RGB or HSB values, depending on the current color mode. The x, y, and z parameters specify the position of the light and nx, ny, nz specify the direction of light. The angle parameter affects angle of the spotlight cone, while concentration sets the bias of light focusing toward the center of that cone.

Parameters:

v1 - red or hue value (depending on current color mode)

v2 - green or saturation value (depending on current color mode)

v3 - blue or brightness value (depending on current color mode)

x - x-coordinate of the light

y - y-coordinate of the light

z - z-coordinate of the light

nx - direction along the x-axis

ny - direction along the y-axis

nz - direction along the z-axis

angle - angle of the spotlight cone

concentration - exponent determining the center bias of the cone

See Also:

• PGraphics.lights()
• PGraphics.directionalLight(float, float, float, float, float, float)
• PGraphics.pointLight(float, float, float, float, float, float)
• PGraphics.ambientLight(float, float, float, float, float, float)

Usage:

web_application

lightFalloff

public void lightFalloff(float constant,
 float linear,
 float quadratic)

Sets the falloff rates for point lights, spotlights, and ambient lights. Like fill(), it affects only the elements which are created after it in the code. The default value is lightFalloff(1.0, 0.0, 0.0), and the parameters are used to calculate the falloff with the following equation:

d = distance from light position to vertex position
falloff = 1 / (CONSTANT + d * LINEAR + (d*d) * QUADRATIC)

Thinking about an ambient light with a falloff can be tricky. If you want a region of your scene to be ambient lit with one color and another region to be ambient lit with another color, you could use an ambient light with location and falloff. You can think of it as a point light that doesn't care which direction a surface is facing.

Parameters:

constant - constant value or determining falloff

linear - linear value for determining falloff

quadratic - quadratic value for determining falloff

See Also:

• PGraphics.lights()
• PGraphics.ambientLight(float, float, float, float, float, float)
• PGraphics.pointLight(float, float, float, float, float, float)
• PGraphics.spotLight(float, float, float, float, float, float, float, float, float, float, float)
• PGraphics.lightSpecular(float, float, float)

Usage:

web_application

lightSpecular

public void lightSpecular(float v1,
 float v2,
 float v3)

Sets the specular color for lights. Like fill(), it affects only the elements which are created after it in the code. Specular refers to light which bounces off a surface in a preferred direction (rather than bouncing in all directions like a diffuse light) and is used for creating highlights. The specular quality of a light interacts with the specular material qualities set through the specular() and shininess() functions.

Parameters:

v1 - red or hue value (depending on current color mode)

v2 - green or saturation value (depending on current color mode)

v3 - blue or brightness value (depending on current color mode)

See Also:

• PGraphics.specular(float, float, float)
• PGraphics.lights()
• PGraphics.ambientLight(float, float, float, float, float, float)
• PGraphics.pointLight(float, float, float, float, float, float)
• PGraphics.spotLight(float, float, float, float, float, float, float, float, float, float, float)

Usage:

web_application

background

public void background(int rgb)

The background() function sets the color used for the background of the Processing window. The default background is light gray. This function is typically used within draw() to clear the display window at the beginning of each frame, but it can be used inside setup() to set the background on the first frame of animation or if the background need only be set once.

An image can also be used as the background for a sketch, although the image's width and height must match that of the sketch window. Images used with background() will ignore the current tint() setting. To resize an image to the size of the sketch window, use image.resize(width, height).

It is not possible to use the transparency alpha parameter with background colors on the main drawing surface. It can only be used along with a PGraphics object and createGraphics().

Advanced

Clear the background with a color that includes an alpha value. This can only be used with objects created by createGraphics(), because the main drawing surface cannot be set transparent.

It might be tempting to use this function to partially clear the screen on each frame, however that's not how this function works. When calling background(), the pixels will be replaced with pixels that have that level of transparency. To do a semi-transparent overlay, use fill() with alpha and draw a rectangle.

Parameters:

rgb - any value of the color datatype

See Also:

• PGraphics.stroke(float)
• PGraphics.fill(float)
• PGraphics.tint(float)
• PGraphics.colorMode(int)

Usage:

web_application

background

public void background(int rgb,
 float alpha)

Parameters:

alpha - opacity of the background

background

public void background(float gray)

Parameters:

gray - specifies a value between white and black

background

public void background(float gray,
 float alpha)

background

public void background(float v1,
 float v2,
 float v3)

Parameters:

v1 - red or hue value (depending on the current color mode)

v2 - green or saturation value (depending on the current color mode)

v3 - blue or brightness value (depending on the current color mode)

background

public void background(float v1,
 float v2,
 float v3,
 float alpha)

clear

public void clear()

Clears the pixels within a buffer. This function only works on PGraphics objects created with the createGraphics() function. Unlike the main graphics context (the display window), pixels in additional graphics areas created with createGraphics() can be entirely or partially transparent. This function clears everything in a PGraphics object to make all the pixels 100% transparent.

background

public void background(PImage image)

Takes an RGB or ARGB image and sets it as the background. The width and height of the image must be the same size as the sketch. Use image.resize(width, height) to make short work of such a task.

Note that even if the image is set as RGB, the high 8 bits of each pixel should be set opaque (0xFF000000) because the image data will be copied directly to the screen, and non-opaque background images may have strange behavior. Use image.filter(OPAQUE) to handle this easily.

When using 3D, this will also clear the zbuffer (if it exists).

Parameters:

image - PImage to set as background (must be same size as the sketch window)

colorMode

public void colorMode(int mode)

Changes the way Processing interprets color data. By default, the parameters for fill(), stroke(), background(), and color() are defined by values between 0 and 255 using the RGB color model. The colorMode() function is used to change the numerical range used for specifying colors and to switch color systems. For example, calling colorMode(RGB, 1.0) will specify that values are specified between 0 and 1. The limits for defining colors are altered by setting the parameters max, max1, max2, max3, and maxA.

After changing the range of values for colors with code like colorMode(HSB, 360, 100, 100), those ranges remain in use until they are explicitly changed again. For example, after running colorMode(HSB, 360, 100, 100) and then changing back to colorMode(RGB), the range for R will be 0 to 360 and the range for G and B will be 0 to 100. To avoid this, be explicit about the ranges when changing the color mode. For instance, instead of colorMode(RGB), write colorMode(RGB, 255, 255, 255).

Parameters:

mode - Either RGB or HSB, corresponding to Red/Green/Blue and Hue/Saturation/Brightness

See Also:

• PGraphics.background(float)
• PGraphics.fill(float)
• PGraphics.stroke(float)

Usage:

web_application

colorMode

public void colorMode(int mode,
 float max)

Parameters:

max - range for all color elements

colorMode

public void colorMode(int mode,
 float max1,
 float max2,
 float max3)

Parameters:

max1 - range for the red or hue depending on the current color mode

max2 - range for the green or saturation depending on the current color mode

max3 - range for the blue or brightness depending on the current color mode

colorMode

public void colorMode(int mode,
 float max1,
 float max2,
 float max3,
 float maxA)

Parameters:

maxA - range for the alpha

alpha

public final float alpha(int rgb)

Extracts the alpha value from a color.

Parameters:

rgb - any value of the color datatype

See Also:

• PGraphics.red(int)
• PGraphics.green(int)
• PGraphics.blue(int)
• PGraphics.hue(int)
• PGraphics.saturation(int)
• PGraphics.brightness(int)

Usage:

web_application

red

public final float red(int rgb)

Extracts the red value from a color, scaled to match current colorMode(). The value is always returned as a float, so be careful not to assign it to an int value.

The red() function is easy to use and understand, but it is slower than a technique called bit shifting. When working in colorMode(RGB, 255), you can achieve the same results as red() but with greater speed by using the right shift operator (>>) with a bit mask. For example, the following two lines of code are equivalent means of getting the red value of the color value c:

 float r1 = red(c); // Simpler, but slower to calculate
 float r2 = c >> 16 & 0xFF; // Very fast to calculate
 

Parameters:

rgb - any value of the color datatype

See Also:

• PGraphics.green(int)
• PGraphics.blue(int)
• PGraphics.alpha(int)
• PGraphics.hue(int)
• PGraphics.saturation(int)
• PGraphics.brightness(int)

Usage:

web_application

green

public final float green(int rgb)

Extracts the green value from a color, scaled to match current colorMode(). The value is always returned as a float, so be careful not to assign it to an int value.

The green() function is easy to use and understand, but it is slower than a technique called bit shifting. When working in colorMode(RGB, 255), you can achieve the same results as green() but with greater speed by using the right shift operator (>>) with a bit mask. For example, the following two lines of code are equivalent means of getting the green value of the color value c:

 float g1 = green(c); // Simpler, but slower to calculate
 float g2 = c >> 8 & 0xFF; // Very fast to calculate
 

Parameters:

rgb - any value of the color datatype

See Also:

• PGraphics.red(int)
• PGraphics.blue(int)
• PGraphics.alpha(int)
• PGraphics.hue(int)
• PGraphics.saturation(int)
• PGraphics.brightness(int)

Usage:

web_application

blue

public final float blue(int rgb)

Extracts the blue value from a color, scaled to match current colorMode(). The value is always returned as a float, so be careful not to assign it to an int value.

The blue() function is easy to use and understand, but it is slower than a technique called bit masking. When working in colorMode(RGB, 255), you can achieve the same results as blue() but with greater speed by using a bit mask to remove the other color components. For example, the following two lines of code are equivalent means of getting the blue value of the color value c:

 float b1 = blue(c); // Simpler, but slower to calculate
 float b2 = c & 0xFF; // Very fast to calculate
 

Parameters:

rgb - any value of the color datatype

See Also:

• PGraphics.red(int)
• PGraphics.green(int)
• PGraphics.alpha(int)
• PGraphics.hue(int)
• PGraphics.saturation(int)
• PGraphics.brightness(int)

Usage:

web_application

hue

public final float hue(int rgb)

Extracts the hue value from a color.

Parameters:

rgb - any value of the color datatype

See Also:

• PGraphics.red(int)
• PGraphics.green(int)
• PGraphics.blue(int)
• PGraphics.alpha(int)
• PGraphics.saturation(int)
• PGraphics.brightness(int)

Usage:

web_application

saturation

public final float saturation(int rgb)

Extracts the saturation value from a color.

Parameters:

rgb - any value of the color datatype

See Also:

• PGraphics.red(int)
• PGraphics.green(int)
• PGraphics.blue(int)
• PGraphics.alpha(int)
• PGraphics.hue(int)
• PGraphics.brightness(int)

Usage:

web_application

brightness

public final float brightness(int rgb)

Extracts the brightness value from a color.

Parameters:

rgb - any value of the color datatype

See Also:

• PGraphics.red(int)
• PGraphics.green(int)
• PGraphics.blue(int)
• PGraphics.alpha(int)
• PGraphics.hue(int)
• PGraphics.saturation(int)

Usage:

web_application

lerpColor

public static int lerpColor(int c1,
 int c2,
 float amt,
 int mode)

showDepthWarning

public static void showDepthWarning(String method)

Display a warning that the specified method is only available with 3D.

Parameters:

method - The method name (no parentheses)

showDepthWarningXYZ

public static void showDepthWarningXYZ(String method)

Display a warning that the specified method that takes x, y, z parameters can only be used with x and y parameters in this renderer.

Parameters:

method - The method name (no parentheses)

showMethodWarning

public static void showMethodWarning(String method)

Display a warning that the specified method is simply unavailable.

showVariationWarning

public static void showVariationWarning(String str)

Error that a particular variation of a method is unavailable (even though other variations are). For instance, if vertex(x, y, u, v) is not available, but vertex(x, y) is just fine.

showMissingWarning

public static void showMissingWarning(String method)

Display a warning that the specified method is not implemented, meaning that it could be either a completely missing function, although other variations of it may still work properly.

checkAlpha

public void checkAlpha()

Check the alpha on an image, using a really primitive loop.

get

public int get(int x,
 int y)

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

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

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

Advanced

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

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

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

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

Parameters:

x - x-coordinate of the pixel

y - y-coordinate of the pixel

See Also:

• set(int, int, int)
• pixels
• copy(PImage, int, int, int, int, int, int, int, int)

Usage:

web_application

get

public PImage get(int x,
 int y,
 int w,
 int h)

Parameters:

w - width of pixel rectangle to get

h - height of pixel rectangle to get

get

public PImage get()

Returns a copy of this PImage. Equivalent to get(0, 0, width, height). Deprecated, just use copy() instead.

copy

public PImage copy()

set

public void set(int x,
 int y,
 int c)

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.

Parameters:

x - x-coordinate of the pixel

y - y-coordinate of the pixel

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

Usage:

web_application

set

public void set(int x,
 int y,
 PImage img)

Advanced

Efficient method of drawing an image's pixels directly to this surface. No variations are employed, meaning that any scale, tint, or imageMode settings will be ignored.

Parameters:

img - image to copy into the original image

mask

public void mask(PImage img)

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

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

Advanced

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

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

Parameters:

img - image to use as the mask

Usage:

web_application

filter

public void filter(int kind)

filter

public void filter(int kind,
 float param)

Filters the image as defined by one of the following modes:

THRESHOLD
Converts the image to black and white pixels depending on if they are above or below the threshold defined by the level parameter. The parameter must be between 0.0 (black) and 1.0 (white). If no level is specified, 0.5 is used.

GRAY
Converts any colors in the image to grayscale equivalents. No parameter is used.

OPAQUE
Sets the alpha channel to entirely opaque. No parameter is used.

INVERT
Sets each pixel to its inverse value. No parameter is used.

POSTERIZE
Limits each channel of the image to the number of colors specified as the parameter. The parameter can be set to values between 2 and 255, but results are most noticeable in the lower ranges.

BLUR
Executes a Gaussian blur with the level parameter specifying the extent of the blurring. If no parameter is used, the blur is equivalent to Gaussian blur of radius 1. Larger values increase the blur.

ERODE
Reduces the light areas. No parameter is used.

DILATE
Increases the light areas. No parameter is used.

Advanced

Method to apply a variety of basic filters to this image.

• filter(BLUR) provides a basic blur.
• filter(GRAY) converts the image to grayscale based on luminance.
• filter(INVERT) will invert the color components in the image.
• filter(OPAQUE) set all the high bits in the image to opaque
• filter(THRESHOLD) converts the image to black and white.
• filter(DILATE) grow white/light areas
• filter(ERODE) shrink white/light areas

Luminance conversion code contributed by toxi

Gaussian blur code contributed by Mario Klingemann

Parameters:

kind - Either THRESHOLD, GRAY, OPAQUE, INVERT, POSTERIZE, BLUR, ERODE, or DILATE

param - unique for each, see above

Usage:

web_application

copy

public void copy(int sx,
 int sy,
 int sw,
 int sh,
 int dx,
 int dy,
 int dw,
 int dh)

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

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)

Usage:

web_application

copy

public void copy(PImage src,
 int sx,
 int sy,
 int sw,
 int sh,
 int dx,
 int dy,
 int dw,
 int dh)

Parameters:

src - an image variable referring to the source image.

blend

public void blend(int sx,
 int sy,
 int sw,
 int sh,
 int dx,
 int dy,
 int dw,
 int dh,
 int mode)

blend

public void blend(PImage src,
 int sx,
 int sy,
 int sw,
 int sh,
 int dx,
 int dy,
 int dw,
 int dh,
 int mode)

Blends a region of pixels into the image specified by the img parameter. These copies utilize full alpha channel support and a choice of the following modes to blend the colors of source pixels (A) with the ones of pixels in the destination image (B):

BLEND - linear interpolation of colours: C = A*factor + B

ADD - additive blending with white clip: C = min(A*factor + B, 255)

SUBTRACT - subtractive blending with black clip: C = max(B - A*factor, 0)

DARKEST - only the darkest colour succeeds: C = min(A*factor, B)

LIGHTEST - only the lightest colour succeeds: C = max(A*factor, B)

DIFFERENCE - subtract colors from underlying image.

EXCLUSION - similar to DIFFERENCE, but less extreme.

MULTIPLY - Multiply the colors, result will always be darker.

SCREEN - Opposite multiply, uses inverse values of the colors.

OVERLAY - A mix of MULTIPLY and SCREEN. Multiplies dark values, and screens light values.

HARD_LIGHT - SCREEN when greater than 50% gray, MULTIPLY when lower.

SOFT_LIGHT - Mix of DARKEST and LIGHTEST. Works like OVERLAY, but not as harsh.

DODGE - Lightens light tones and increases contrast, ignores darks. Called "Color Dodge" in Illustrator and Photoshop.

BURN - Darker areas are applied, increasing contrast, ignores lights. Called "Color Burn" in Illustrator and Photoshop.

All modes use the alpha information (the highest byte) of source image pixels as the blending factor. If the source and destination regions are different sizes, the image will be automatically resized to match the destination size. If the srcImg parameter is not used, the display window is used as the source image.

As of release 0149, this function ignores imageMode().

Parameters:

src - an image variable referring to the source image

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

mode - Either BLEND, ADD, SUBTRACT, LIGHTEST, DARKEST, DIFFERENCE, EXCLUSION, MULTIPLY, SCREEN, OVERLAY, HARD_LIGHT, SOFT_LIGHT, DODGE, BURN

See Also:

• alpha(int)
• PImage.copy(PImage, int, int, int, int, int, int, int, int)
• PImage.blendColor(int,int,int)