Wrappers and extensions around the core Processing.org API.
Wrappers and extensions around the core Processing.org API.
(abs n)
Calculates the absolute value (magnitude) of a number. The
absolute value of a number is always positive. Dynamically casts to
an int
or float
appropriately for Clojure.
Calculates the absolute value (magnitude) of a number. The absolute value of a number is always positive. Dynamically casts to an `int` or `float` appropriately for Clojure.
(acos n)
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 Math/PI
(3.1415927).
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 `Math/PI` (3.1415927).
(alpha color)
Extracts the alpha value from a color.
Extracts the alpha value from a color.
(ambient gray)
(ambient r g b)
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 r=255, g=126, b=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.
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 `r=255, g=126, b=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.
(ambient-light red green blue)
(ambient-light red green blue x y z)
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 effect of the
parameters is determined by the current color-mode
.
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 effect of the parameters is determined by the current [[color-mode]].
(angle-mode mode)
Sets the current mode of p5 to given mode
.
Options are:
:radians
(default):degrees
Sets the current mode of p5 to given `mode`. Options are: * `:radians` **(default)** * `:degrees`
(apply-matrix n00 n01 n02 n10 n11 n12)
(apply-matrix n00 n01 n02 n03 n10 n11 n12 n13 n20 n21 n22 n23 n30 n31 n32 n33)
(apply-matrix a b c d e f)
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()
.
Note that cljs has only 2d version and arguments differ see https://p5js.org/reference/#/p5/applyMatrix
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()`. Note that cljs has only 2d version and arguments differ see https://p5js.org/reference/#/p5/applyMatrix
(arc x y width height start stop)
(arc x y width height start stop mode)
Draws an arc in the display window. Arcs are drawn along the outer
edge of an ellipse defined by the x
, y
, width
and height
parameters. The origin or the arc's ellipse may be changed with the
ellipse-mode
function. The start
and stop
parameters specify the
angles at which to draw the arc. The mode
is either :open
, :chord
or :pie
.
Draws an arc in the display window. Arcs are drawn along the outer edge of an ellipse defined by the `x`, `y`, `width` and `height` parameters. The origin or the arc's ellipse may be changed with the [[ellipse-mode]] function. The `start` and `stop` parameters specify the angles at which to draw the arc. The `mode` is either `:open`, `:chord` or `:pie`.
(asin n)
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
.
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`.
(atan n)
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
.
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`.
(atan2 y 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 to the structure of
calculating the tangent.
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 to the structure of calculating the tangent.
(available-fonts)
A sequence of strings representing the fonts on this system available for use.
Because of limitations in Java, 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.
A sequence of strings representing the fonts on this system available for use. Because of limitations in Java, 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.
(background gray)
(background gray alpha)
(background r g b)
(background r g b a)
Sets the color used for the background of the Processing window. The default background is light gray. In the draw function, the background color is used to clear the display window at the beginning of each frame.
It is not possible to use transparency (alpha) in background colors
with the main drawing surface, however they will work properly with
create-graphics
. Converts args to floats
.
Sets the color used for the background of the Processing window. The default background is light gray. In the draw function, the background color is used to clear the display window at the beginning of each frame. It is not possible to use transparency (alpha) in background colors with the main drawing surface, however they will work properly with [[create-graphics]]. Converts args to `floats`.
(background-image img)
Specify an image to be used as the background for a sketch. Its
width and height must be the same size as the sketch window. Images
used as background will ignore the current tint
setting.
Specify an image to be used as the background for a sketch. Its width and height must be the same size as the sketch window. Images used as background will ignore the current [[tint]] setting.
(begin-contour)
Use the begin-contour
and end-contour
function to create negative
shapes within shapes. These functions can only be used within a
begin-shape
/end-shape
pair and they only work with the :p2d
and :p3d
renderers.
Use the [[begin-contour]] and [[end-contour]] function to create negative shapes within shapes. These functions can only be used within a [[begin-shape]]/[[end-shape]] pair and they only work with the `:p2d` and `:p3d` renderers.
(begin-raw renderer filename)
Enables the creation of vectors from 3D data. Requires
corresponding end-raw
command. 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 method 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.
Enables the creation of vectors from 3D data. Requires corresponding [[end-raw]] command. 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 method 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.
(begin-shape)
(begin-shape mode)
Enables the creation of complex forms. begin-shape
begins recording
vertices for a shape and end-shape
stops recording. Use the mode
keyword to specify which shape to create from the provided
vertices. With no mode specified, the shape can be any irregular
polygon.
The available mode keywords are :points
, :lines
, :triangles
,
:triangle-fan
, :triangle-strip
,
:quads
, :quad-strip
.
After calling the begin-shape
function, a series of vertex commands
must follow. To stop drawing the shape, call end-shape
. 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 begin-shape
. It is also not possible to use other shapes,
such as ellipse
or rect
within begin-shape
.
Enables the creation of complex forms. [[begin-shape]] begins recording vertices for a shape and [[end-shape]] stops recording. Use the `mode` keyword to specify which shape to create from the provided vertices. With no mode specified, the shape can be any irregular polygon. The available mode keywords are `:points`, `:lines`, `:triangles`, `:triangle-fan`, `:triangle-strip`, `:quads`, `:quad-strip`. After calling the [[begin-shape]] function, a series of vertex commands must follow. To stop drawing the shape, call [[end-shape]]. 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 [[begin-shape]]. It is also not possible to use other shapes, such as [[ellipse]] or [[rect]] within [[begin-shape]].
(bezier x1 y1 cx1 cy1 cx2 cy2 x2 y2)
(bezier x1 y1 z1 cx1 cy1 cz1 cx2 cy2 cz2 x2 y2 z2)
Draws a Bezier 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.
Draws a Bezier 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.
(bezier-detail detail)
Sets the resolution at which Beziers display. The default value is
20. This function is only useful when using the :p3d
or :opengl
renderer as the default (:java2d
) renderer does not use this
information.
Sets the resolution at which Beziers display. The **default** value is 20. This function is only useful when using the `:p3d` or `:opengl` renderer as the default (`:java2d`) renderer does not use this information.
(bezier-point a b c d 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 bezier curve at 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 bezier curve at `t`.
(bezier-tangent a b c d t)
Calculates the tangent of a point on a Bezier curve. (See http://en.wikipedia.org/wiki/Tangent)
Calculates the tangent of a point on a Bezier curve. (See http://en.wikipedia.org/wiki/Tangent)
(bezier-vertex cx1 cy1 cx2 cy2 x y)
(bezier-vertex cx1 cy1 cz1 cx2 cy2 cz2 x y z)
Specifies vertex coordinates for Bezier curves. Each call to
bezier-vertex
defines the position of two control points and one
anchor point of a Bezier curve, adding a new segment to a line or
shape. The first time bezier-vertex
is used within a begin-shape
call, it must be prefaced with a call to vertex
to set the first
anchor point. This function must be used between begin-shape
and
end-shape
and only when there is no parameter specified to
begin-shape
.
Specifies vertex coordinates for Bezier curves. Each call to [[bezier-vertex]] defines the position of two control points and one anchor point of a Bezier curve, adding a new segment to a line or shape. The first time [[bezier-vertex]] is used within a [[begin-shape]] call, it must be prefaced with a call to [[vertex]] to set the first anchor point. This function must be used between [[begin-shape]] and [[end-shape]] and only when there is no parameter specified to [[begin-shape]].
(binary val)
(binary val num-digits)
Returns a string
representing the binary value of an int
, char
or
byte
. When converting an int
to a string
, it is possible to specify
the number of digits used.
Returns a `string` representing the binary value of an `int`, `char` or `byte`. When converting an `int` to a `string`, it is possible to specify the number of digits used.
(blend x y width height dx dy dwidth dheight mode)
(blend src-img x y width height dx dy dwidth dheight mode)
(blend src-img dest-img x y width height dx dy dwidth dheight mode)
Blends a region of pixels from one image into another with full alpha
channel support. If src
is not specified it defaults to current-graphics
.
If dest is not specified it defaults to current-graphics
.
Note: it is recommended to use the blend-mode
function instead of this one.
Available blend modes are:
:blend
- linear interpolation of colours: C = A*factor + B:add
- additive blending with white clip:
C = min(A*factor + B, 255):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.In clj the following blend modes are also supported:
:subtract
- subtractive blending with black clip:
C = max(B - A*factor, 0)
In cljs the following blend modes are also supported:
:replace
- the pixels entirely replace the others and don't utilize
alpha (transparency) values.
Blends a region of pixels from one image into another with full alpha channel support. If `src` is not specified it defaults to [[current-graphics]]. If dest is not specified it defaults to [[current-graphics]]. Note: it is recommended to use the [[blend-mode]] function instead of this one. Available blend modes are: * `:blend` - linear interpolation of colours: C = A*factor + B * `:add` - additive blending with white clip: C = min(A*factor + B, 255) * `: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. In clj the following blend modes are also supported: `:subtract` - subtractive blending with black clip: C = max(B - A*factor, 0) In cljs the following blend modes are also supported: `:replace` - the pixels entirely replace the others and don't utilize alpha (transparency) values.
(blend-color c1 c2 mode)
Blends two color values together based on the blending mode given specified with the mode keyword.
Available blend modes are:
: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.Blends two color values together based on the blending mode given specified with the mode keyword. Available blend modes are: * `: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.
(blend-mode mode)
Blends the pixels in the display window according to the 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):
: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.:replace
- the pixels entirely replace the others and don't utilize
alpha (transparency) values.:overlay
- 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.:burn
- darker areas are applied, increasing contrast, ignores
lights.Note: in clj :hard-light
, :soft-light
, :overlay
, :dodge
, :burn
modes are not supported. In cljs :subtract
mode is not supported.
factor is the alpha value of the pixel being drawn
Blends the pixels in the display window according to the 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): * `: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. * `:replace` - the pixels entirely replace the others and don't utilize alpha (transparency) values. * `:overlay` - 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. * `:burn` - darker areas are applied, increasing contrast, ignores lights. Note: in clj `:hard-light`, `:soft-light`, `:overlay`, `:dodge`, `:burn` modes are not supported. In cljs `:subtract` mode is not supported. factor is the alpha value of the pixel being drawn
(blue color)
Extracts the blue value from a color, scaled to match current color-mode.
Returns a float
.
Extracts the blue value from a color, scaled to match current color-mode. Returns a `float`.
(box size)
(box width height depth)
Creates an extruded rectangle.
Creates an extruded rectangle.
(brightness color)
Extracts the brightness value from a color. Returns a float
.
Extracts the brightness value from a color. Returns a `float`.
(camera)
(camera eyeX eyeY eyeZ centerX centerY centerZ upX upY upZ)
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:
eyeX
- (/ (width) 2.0)
eyeY
- (/ (height) 2.0)
eyeZ
- (/ (/ (height) 2.0) (tan (/ (* Math/PI 60.0) 360.0)))
centerX
- (/ (width) 2.0)
centerY
- (/ (height) 2.0)
centerZ
- 0
upX
- 0
upY
- 1
upZ
- 0
Similar to gluLookAt()
in OpenGL, but it first clears the
current camera settings.
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: * `eyeX` - `(/ (width) 2.0)` * `eyeY` - `(/ (height) 2.0)` * `eyeZ` - `(/ (/ (height) 2.0) (tan (/ (* Math/PI 60.0) 360.0)))` * `centerX` - `(/ (width) 2.0)` * `centerY` - `(/ (height) 2.0)` * `centerZ` - `0` * `upX` - `0` * `upY` - `1` * `upZ` - `0` Similar to `gluLookAt()` in OpenGL, but it first clears the current camera settings.
(ceil 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.
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.
(clear)
Clears the pixels within a buffer. This function only works on
graphics objects created with the create-graphics
function meaning
that you should call it only inside with-graphics
macro. Unlike
the main graphics context (the display window), pixels in additional
graphics areas created with create-graphics
can be entirely or
partially transparent. This function clears everything in a graphics
object to make all of the pixels 100% transparent.
Clears the pixels within a buffer. This function only works on graphics objects created with the [[create-graphics]] function meaning that you should call it only inside [[with-graphics]] macro. Unlike the main graphics context (the display window), pixels in additional graphics areas created with [[create-graphics]] can be entirely or partially transparent. This function clears everything in a graphics object to make all of the pixels 100% transparent.
(clip x y w h)
Limits the rendering to the boundaries of a rectangle defined by
the parameters. The boundaries are drawn based on the state of
the image-mode
function, either :corner
, :corners
, or :center
.
To disable use no-clip
.
Limits the rendering to the boundaries of a rectangle defined by the parameters. The boundaries are drawn based on the state of the [[image-mode]] function, either `:corner`, `:corners`, or `:center`. To disable use [[no-clip]].
(color gray)
(color gray alpha)
(color r g b)
(color r g b a)
Creates an integer representation of a color. The parameters are
interpreted as RGB or HSB values depending on the current
color-mode
. The default mode is RGB values from 0 to 255 and
therefore, the function call (color 255 204 0)
will return a bright
yellow. Args are cast to floats.
Creates an integer representation of a color. The parameters are interpreted as RGB or HSB values depending on the current [[color-mode]]. The default mode is RGB values from 0 to 255 and therefore, the function call `(color 255 204 0)` will return a bright yellow. Args are cast to floats. * r - red or hue value * g - green or saturation value * b - blue or brightness value * a - alpha value
(color-mode mode)
(color-mode mode max)
(color-mode mode max-x max-y max-z)
(color-mode mode max-x max-y max-z max-a)
Changes the way Processing interprets color data. Available modes
are :rgb
and :hsb
(and :hsl
in clojurescript).
By default, the parameters for fill
, stroke
,
background
, and color
are defined by values between 0 and 255 using
the :rgb
color model. The color-mode
function is used to change the
numerical range used for specifying colors and to switch color
systems. For example, calling
(color-mode :rgb 1.0)
will specify that values are specified between
0 and 1. The limits for defining colors are altered by setting the
parameters range1, range2, range3, and range 4.
Changes the way Processing interprets color data. Available modes are `:rgb` and `:hsb` (and `:hsl` in clojurescript). By default, the parameters for [[fill]], [[stroke]], [[background]], and [[color]] are defined by values between 0 and 255 using the `:rgb` color model. The [[color-mode]] function is used to change the numerical range used for specifying colors and to switch color systems. For example, calling `(color-mode :rgb 1.0)` will specify that values are specified between 0 and 1. The limits for defining colors are altered by setting the parameters range1, range2, range3, and range 4.
(cone radius height)
(cone radius height detail-x)
(cone radius height detail-x detail-y)
(cone radius height detail-x detail-y cap)
Draw a cone with given radius
and height
.
Optional parameters:
detail-x
- number of segments, the more segments the smoother geometry default is 24detail-y
- number of segments, the more segments the smoother geometry default is 24cap
- whether to draw the base of the coneDraw a cone with given `radius` and `height`. Optional parameters: * `detail-x` - number of segments, the more segments the smoother geometry default is 24 * `detail-y` - number of segments, the more segments the smoother geometry default is 24 * `cap` - whether to draw the base of the cone
(constrain amt low high)
Constrains a value to not exceed a maximum and minimum value.
Constrains a value to not exceed a maximum and minimum value.
(copy [sx sy swidth sheight] [dx dy dwidth dheight])
(copy src-img [sx sy swidth sheight] [dx dy dwidth dheight])
(copy src-img dest-img [sx sy swidth sheight] [dx dy dwidth dheight])
Copies a region of pixels from one image to another. If src-img
is not specified it defaults to current-graphics
. If dest-img
is not
specified - it defaults to current-graphics
. If the source
and destination regions aren't the same size, it will automatically
resize the 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.
Copies a region of pixels from one image to another. If `src-img` is not specified it defaults to [[current-graphics]]. If `dest-img` is not specified - it defaults to [[current-graphics]]. If the source and destination regions aren't the same size, it will automatically resize the 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.
(cos 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 Math/PI*2). Values are returned in the range -1 to 1.
Calculates the cosine of an angle. This function expects the values of the angle parameter to be provided in radians (values from 0 to Math/PI*2). Values are returned in the range -1 to 1.
(create-font name size)
(create-font name size smooth)
(create-font name size smooth charset)
Dynamically converts a font to the format used by Processing (a
PFont
) from either a font name that's installed on the computer, or
from a .ttf
or .otf
file inside the sketches 'data' folder. This
function is an advanced feature for precise control.
Use available-fonts
to obtain the names for the fonts recognized by
the computer and are compatible with this function.
The size
parameter states the font size you want to generate. The
smooth
parameter specifies if the font should be antialiased or not,
and the charset
parameter is an array of chars that specifies the
characters to generate.
This function creates a bitmapped version of a font. It loads a font
by name, and converts it to a series of images based on the size of
the font. When possible, the text function will use a native font
rather than the bitmapped version created behind the scenes with
create-font. For instance, when using the default renderer
setting (JAVA2D), the actual native version of the font will be
employed by the sketch, improving drawing quality and
performance. With the :p2d
, :p3d
, and :opengl
renderer settings, the
bitmapped version will be used. While this can drastically improve
speed and appearance, results are poor when exporting of the sketch
does not include the .otf
or .ttf
file, and the requested font is
not available on the machine running the sketch.
Dynamically converts a font to the format used by Processing (a `PFont`) from either a font name that's installed on the computer, or from a `.ttf` or `.otf` file inside the sketches 'data' folder. This function is an advanced feature for precise control. Use [[available-fonts]] to obtain the names for the fonts recognized by the computer and are compatible with this function. The `size` parameter states the font size you want to generate. The `smooth` parameter specifies if the font should be antialiased or not, and the `charset` parameter is an array of chars that specifies the characters to generate. This function creates a bitmapped version of a font. It loads a font by name, and converts it to a series of images based on the size of the font. When possible, the text function will use a native font rather than the bitmapped version created behind the scenes with create-font. For instance, when using the default renderer setting (JAVA2D), the actual native version of the font will be employed by the sketch, improving drawing quality and performance. With the `:p2d`, `:p3d`, and `:opengl` renderer settings, the bitmapped version will be used. While this can drastically improve speed and appearance, results are poor when exporting of the sketch does not include the `.otf` or `.ttf` file, and the requested font is not available on the machine running the sketch.
(create-graphics w h)
(create-graphics w h renderer)
(create-graphics w h renderer path)
(create-graphics w h)
(create-graphics w h renderer)
Creates and returns a new PGraphics
object of the types :p2d
, :p3d
,
:java2d
, :pdf
. By default :java2d
is used. Use this class if you
need to draw into an off-screen graphics buffer. It's not possible
to use create-graphics
with the :opengl
renderer, because it doesn't
allow offscreen use. The :pdf
renderer requires the filename parameter.
Note: don't use create-graphics
in draw in clojurescript, it leaks memory.
You should create graphic in setup and reuse it in draw instead of creating
a new one.
It's important to call any drawing commands between (.beginDraw graphics)
and
(.endDraw graphics)
statements or use with-graphics
macro. This is also true
for any commands that affect drawing, such as smooth
or color-mode
.
If you're using :pdf
renderer - don't forget to call (.dispose graphics)
as last command inside with-graphics
macro, otherwise graphics won't be
saved.
Unlike the main drawing surface which is completely opaque, surfaces
created with create-graphics
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.
Creates and returns a new `PGraphics` object of the types `:p2d`, `:p3d`, `:java2d`, `:pdf`. By default `:java2d` is used. Use this class if you need to draw into an off-screen graphics buffer. It's not possible to use [[create-graphics]] with the `:opengl` renderer, because it doesn't allow offscreen use. The `:pdf` renderer requires the filename parameter. Note: don't use [[create-graphics]] in draw in clojurescript, it leaks memory. You should create graphic in setup and reuse it in draw instead of creating a new one. It's important to call any drawing commands between `(.beginDraw graphics)` and `(.endDraw graphics)` statements or use [[with-graphics]] macro. This is also true for any commands that affect drawing, such as [[smooth]] or [[color-mode]]. If you're using `:pdf` renderer - don't forget to call `(.dispose graphics)` as last command inside [[with-graphics]] macro, otherwise graphics won't be saved. Unlike the main drawing surface which is completely opaque, surfaces created with [[create-graphics]] 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.
(create-image w h format)
(create-image w h)
Creates a new datatype for storing images (PImage
for clj and
Image
for cljs). This provides a fresh buffer of pixels to play
with. Set the size of the buffer with the width
and height
parameters.
In clj the format
parameter defines how the pixels are stored.
See the PImage reference for more information.
Possible formats: :rgb
, :argb
, :alpha
(grayscale alpha channel)
Prefer using create-image
over initialising new PImage
(or Image
)
instances directly.
Creates a new datatype for storing images (`PImage` for clj and `Image` for cljs). This provides a fresh buffer of pixels to play with. Set the size of the buffer with the `width` and `height` parameters. In clj the `format` parameter defines how the pixels are stored. See the PImage reference for more information. Possible formats: `:rgb`, `:argb`, `:alpha` (grayscale alpha channel) Prefer using [[create-image]] over initialising new `PImage` (or `Image`) instances directly.
(current-fill)
Return the current fill color.
Return the current fill color.
(current-frame-rate)
Returns the current framerate
Returns the current framerate
(current-graphics)
Graphics currently used for drawing. By default it is sketch graphics,
but if called inside with-graphics
macro - graphics passed to the macro
is returned. This method should be used if you need to call some methods
that are not implemented by quil.
Example:
(.beginDraw (current-graphics))
Graphics currently used for drawing. By default it is sketch graphics, but if called inside [[with-graphics]] macro - graphics passed to the macro is returned. This method should be used if you need to call some methods that are not implemented by quil. Example: ``` (.beginDraw (current-graphics)) ```
(current-stroke)
Return the current stroke color.
Return the current stroke color.
(cursor)
(cursor cursor-mode)
Sets the cursor to a predefined symbol or makes it
visible if already hidden (after no-cursor
was called).
Available modes: :arrow
, :cross
, :hand
, :move
, :text
, :wait
See cursor-image
for specifying a generic image as the cursor
symbol (clj only).
Sets the cursor to a predefined symbol or makes it visible if already hidden (after [[no-cursor]] was called). Available modes: `:arrow`, `:cross`, `:hand`, `:move`, `:text`, `:wait` See [[cursor-image]] for specifying a generic image as the cursor symbol (clj only).
(cursor-image img)
(cursor-image img hx hy)
Set the cursor to a predefined image. The horizontal and vertical
active spots of the cursor may be specified with hx
and hy
.
It is recommended to make the size 16x16 or 32x32 pixels.
Set the cursor to a predefined image. The horizontal and vertical active spots of the cursor may be specified with `hx` and `hy`. It is recommended to make the size 16x16 or 32x32 pixels.
(curve x1 y1 x2 y2 x3 y3 x4 y4)
(curve x1 y1 z1 x2 y2 z2 x3 y3 z3 x4 y4 z4)
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 curve-vertex
. An additional
function called curve-tightness
provides control for the visual quality
of the curve. The curve
function is an implementation of Catmull-Rom
splines.
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 [[curve-vertex]]. An additional function called [[curve-tightness]] provides control for the visual quality of the curve. The [[curve]] function is an implementation of Catmull-Rom splines.
(curve-detail detail)
Sets the resolution at which curves display. The default value is
20. This function is only useful when using the :p3d
or :opengl
renderer as the default (:java2d
) renderer does not use this
information.
Sets the resolution at which curves display. The default value is 20. This function is only useful when using the `:p3d` or `:opengl` renderer as the default (`:java2d`) renderer does not use this information.
(curve-point a b c d t)
Evaluates the curve 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 curve at t
.
Evaluates the curve 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 curve at `t`.
(curve-tangent a b c d t)
Calculates the tangent of a point on a curve. See: http://en.wikipedia.org/wiki/Tangent
Calculates the tangent of a point on a curve. See: http://en.wikipedia.org/wiki/Tangent
(curve-tightness tightness)
Modifies the quality of forms created with curve and
curve-vertex
. 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.
Modifies the quality of forms created with curve and [[curve-vertex]]. 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.
(curve-vertex x y)
(curve-vertex x y z)
Specifies vertex coordinates for curves. This function may only be
used between begin-shape
and end-shape
and only when there is no
mode
keyword specified to begin-shape
. The first and last points in a
series of curve-vertex
lines will be used to guide the beginning and
end of a 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 curve-vertex
will draw the curve between the second, third, and
fourth points. The curve-vertex
function is an implementation of
Catmull-Rom splines.
Specifies vertex coordinates for curves. This function may only be used between [[begin-shape]] and [[end-shape]] and only when there is no `mode` keyword specified to [[begin-shape]]. The first and last points in a series of [[curve-vertex]] lines will be used to guide the beginning and end of a 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 [[curve-vertex]] will draw the curve between the second, third, and fourth points. The [[curve-vertex]] function is an implementation of Catmull-Rom splines.
(cylinder radius height)
(cylinder radius height detail-x detail-y bottom-cap top-cap)
Draw a cylinder with given radius
and height
.
Draw a cylinder with given `radius` and `height`.
(day)
Get the current day of the month (1 through 31).
Get the current day of the month (1 through 31).
(debug msg)
(debug msg delay-ms)
Prints msg
and then sleeps the current thread for delay-ms
. Useful
for debugging live running sketches. delay-ms
defaults to 300.
Prints `msg` and then sleeps the current thread for `delay-ms`. Useful for debugging live running sketches. `delay-ms` defaults to 300.
(defsketch app-name & options)
(defsketch &form &env app-name & options)
Define and start a sketch and bind it to a var with the symbol
app-name
. If any of the options to the various callbacks are
symbols, it wraps them in a call to var to ensure they aren't
inlined and that redefinitions to the original functions are reflected in
the visualisation.
:size
- A vector of width and height for the sketch or :fullscreen.
Defaults to [500 300]
. If you're using :fullscreen you may
want to enable present mode - :features [:present].
:fullscreen size works only in Clojure. In ClojureScript
all sketches are support fullscreen when you press F11.:renderer
- Specifies the renderer type. One of :p2d
, :p3d
, :java2d
,
:opengl
, :pdf
, :svg
). Defaults to :java2d
. :dxf
renderer
can't be used as sketch renderer. Use begin-raw
method
instead. In clojurescript only :p2d
and :p3d
renderers
are supported.:output-file
- Specifies an output file path. Only used in :pdf
and :svg
modes. Not supported in clojurescript. When writing to a
file, call exit
at the end of the draw call to end
the sketch and not write repeatedly to the file.:title
- A string which will be displayed at the top of
the sketch window. Not supported in clojurescript.:features
- A vector of keywords customizing sketch behaviour.
Supported features:
:keep-on-top
- Sketch window will always be above other windows.
Note: some platforms might not support always-on-top windows.
Not supported in clojurescript.:exit-on-close
- Shutdown JVM when sketch is closed.
Not supported in clojurescript.:resizable
- Makes sketch resizable. Not supported in clojurescript.:no-safe-fns
- Do not catch and print exceptions thrown inside functions
provided to sketch (like draw, [[mouse-click]],
[[key-pressed]] and others). By default all exceptions
thrown inside these functions are caught. This prevents
sketch from breaking when bad function was provided and
allows you to fix it and reload it on fly. You can
disable this behaviour by enabling :no-safe-fns
feature. Not supported in clojurescript.:present
- Switch to present mode (fullscreen without borders, OS
panels). You may want to use this feature together with
:size :fullscreen
. Not supported in ClojureScript. In
ClojureScript fullscreen is enabled by pressing F11 and
it's enabled on all sketches automatically.:no-start
- Disables autostart if sketch was created using defsketch
macro. To start sketch you have to call function created
defsketch. Supported only in ClojureScript.
Usage example: :features [:keep-on-top :present]
:bgcolor
- Sets background color for unused space in present mode.
Color is specified in hex format for example
:bgcolor "#00FFFF"
(cyan background)
Not supported in ClojureScript.:display
- Sets what display should be used by this sketch.
Displays are numbered starting from 0. Example: :display 1
.
Not supported in ClojureScript.:setup
- A function to be called once when setting the sketch up.:draw
- A function to be repeatedly called at most n times per
second where n is the target frame-rate
set for
the visualisation.:host
- String id of canvas element or DOM element itself.
Specifies host for the sketch. Must be specified in sketch,
may be omitted in defsketch. If omitted in defsketch,
:host is set to the name of the sketch. If element with
specified id is not found on the page and page is empty -
new canvas element will be created. Used in ClojureScript.:focus-gained
- Called when the sketch gains focus.
Not supported in ClojureScript.:focus-lost
- Called when the sketch loses focus.
Not supported in ClojureScript.:mouse-entered
- Called when the mouse enters the sketch window.:mouse-exited
- Called when the mouse leaves the sketch window:mouse-pressed
- Called every time a mouse button is pressed.:mouse-released
- Called every time a mouse button is released.:mouse-clicked
- Called once after a mouse button has been pressed
and then released.:mouse-moved
- Called every time the mouse moves and a button is
not pressed.:mouse-dragged
- Called every time the mouse moves and a button is
pressed.:mouse-wheel
- Called every time mouse wheel is rotated.
Takes 1 argument - wheel rotation, an int.
Negative values if the mouse wheel was rotated
up/away from the user, and positive values
if the mouse wheel was rotated down/ towards the user:key-pressed
- Called every time any key is pressed.:key-released
- Called every time any key is released.:key-typed
- Called once every time non-modifier keys are
pressed.:on-close
- Called once, when sketch is closed.
Not supported in ClojureScript.:middleware
- Vector of middleware to be applied to the sketch.
Middleware will be applied in the same order as in comp
function: [f g] will be applied as (f (g options))
.:settings
- Cousin of :setup
. A function to be called once when
setting sketch up. Should be used only for smooth
and
no-smooth
. Due to Processing limitations these functions
cannot be used neither in :setup
nor in :draw
.Define and start a sketch and bind it to a var with the symbol `app-name`. If any of the options to the various callbacks are symbols, it wraps them in a call to var to ensure they aren't inlined and that redefinitions to the original functions are reflected in the visualisation. * `:size` - A vector of width and height for the sketch or :fullscreen. Defaults to `[500 300]`. If you're using :fullscreen you may want to enable present mode - :features [:present]. :fullscreen size works only in Clojure. In ClojureScript all sketches are support fullscreen when you press F11. * `:renderer` - Specifies the renderer type. One of `:p2d`, `:p3d`, `:java2d`, `:opengl`, `:pdf`, `:svg`). Defaults to `:java2d`. `:dxf` renderer can't be used as sketch renderer. Use [[begin-raw]] method instead. In clojurescript only `:p2d` and `:p3d` renderers are supported. * `:output-file` - Specifies an output file path. Only used in `:pdf` and `:svg` modes. Not supported in clojurescript. When writing to a file, call [[exit]] at the end of the draw call to end the sketch and not write repeatedly to the file. * `:title` - A string which will be displayed at the top of the sketch window. Not supported in clojurescript. * `:features` - A vector of keywords customizing sketch behaviour. Supported features: - `:keep-on-top` - Sketch window will always be above other windows. Note: some platforms might not support always-on-top windows. Not supported in clojurescript. - `:exit-on-close` - Shutdown JVM when sketch is closed. Not supported in clojurescript. - `:resizable` - Makes sketch resizable. Not supported in clojurescript. - `:no-safe-fns` - Do not catch and print exceptions thrown inside functions provided to sketch (like draw, [[mouse-click]], [[key-pressed]] and others). By default all exceptions thrown inside these functions are caught. This prevents sketch from breaking when bad function was provided and allows you to fix it and reload it on fly. You can disable this behaviour by enabling `:no-safe-fns` feature. Not supported in clojurescript. - `:present` - Switch to present mode (fullscreen without borders, OS panels). You may want to use this feature together with `:size :fullscreen`. Not supported in ClojureScript. In ClojureScript fullscreen is enabled by pressing F11 and it's enabled on all sketches automatically. - `:no-start` - Disables autostart if sketch was created using defsketch macro. To start sketch you have to call function created defsketch. Supported only in ClojureScript. Usage example: `:features [:keep-on-top :present]` * `:bgcolor` - Sets background color for unused space in present mode. Color is specified in hex format for example `:bgcolor "#00FFFF"` (cyan background) Not supported in ClojureScript. * `:display` - Sets what display should be used by this sketch. Displays are numbered starting from 0. Example: `:display 1`. Not supported in ClojureScript. * `:setup` - A function to be called once when setting the sketch up. * `:draw` - A function to be repeatedly called at most n times per second where n is the target [[frame-rate]] set for the visualisation. * `:host` - String id of canvas element or DOM element itself. Specifies host for the sketch. Must be specified in sketch, may be omitted in defsketch. If omitted in defsketch, :host is set to the name of the sketch. If element with specified id is not found on the page and page is empty - new canvas element will be created. Used in ClojureScript. * `:focus-gained` - Called when the sketch gains focus. Not supported in ClojureScript. * `:focus-lost` - Called when the sketch loses focus. Not supported in ClojureScript. * `:mouse-entered` - Called when the mouse enters the sketch window. * `:mouse-exited` - Called when the mouse leaves the sketch window * `:mouse-pressed` - Called every time a mouse button is pressed. * `:mouse-released` - Called every time a mouse button is released. * `:mouse-clicked` - Called once after a mouse button has been pressed and then released. * `:mouse-moved` - Called every time the mouse moves and a button is not pressed. * `:mouse-dragged` - Called every time the mouse moves and a button is pressed. * `:mouse-wheel` - Called every time mouse wheel is rotated. Takes 1 argument - wheel rotation, an int. Negative values if the mouse wheel was rotated up/away from the user, and positive values if the mouse wheel was rotated down/ towards the user * `:key-pressed` - Called every time any key is pressed. * `:key-released` - Called every time any key is released. * `:key-typed` - Called once every time non-modifier keys are pressed. * `:on-close` - Called once, when sketch is closed. Not supported in ClojureScript. * `:middleware` - Vector of middleware to be applied to the sketch. Middleware will be applied in the same order as in comp function: [f g] will be applied as `(f (g options))`. * `:settings` - Cousin of `:setup`. A function to be called once when setting sketch up. Should be used only for [[smooth]] and [[no-smooth]]. Due to Processing limitations these functions cannot be used neither in `:setup` nor in `:draw`.
(degrees 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 Math/PI)
radians
in a circle. For example, (= 90° (/ Math/PI 2) 1.5707964)
. All
trigonometric methods in Processing require their parameters to be
specified in 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 Math/PI)` radians in a circle. For example, `(= 90° (/ Math/PI 2) 1.5707964)`. All trigonometric methods in Processing require their parameters to be specified in radians.
(delay-frame freeze-ms)
Forces the program to stop running for a specified time. Delay
times are specified in thousandths of a second, therefore the
function call (delay 3000)
will stop the program for three
seconds. Because the screen is updated only at the end of draw
,
the program may appear to 'freeze', because the screen will not
update when the delay-frame
function is used. This function
has no effect inside setup
.
Forces the program to stop running for a specified time. Delay times are specified in thousandths of a second, therefore the function call `(delay 3000)` will stop the program for three seconds. Because the screen is updated only at the end of `draw`, the program may appear to 'freeze', because the screen will not update when the [[delay-frame]] function is used. This function has no effect inside `setup`.
(directional-light r g b nx ny 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
function to remain persistent in a looping
program. Placing them in the setup
function of a looping program will cause
them to only have an effect the first time through the loop. The
affect of the r
, g
, and b
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).
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` function to remain persistent in a looping program. Placing them in the `setup` function of a looping program will cause them to only have an effect the first time through the loop. The affect of the `r`, `g`, and `b` 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).
(display-density)
(display-density display)
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. Can be used in conjunction with pixel-density
.
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. Can be used in conjunction with [[pixel-density]].
(display-filter mode)
(display-filter mode level)
Originally named filter in Processing Language. Filters the display window with the specified mode and level. Level defines the quality of the filter and mode may be one of the following keywords:
:threshold
- converts the image to black and white pixels depending
if they are above or below the threshold defined by
the level parameter. The level 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. Doesn't work with level.:invert
- sets each pixel to its inverse value. Doesn't work with
level.:posterize
- limits each channel of the image to the number of
colors specified as the level 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 level
parameter is used, the blur is equivalent to Gaussian
blur of radius 1.:opaque
- sets the alpha channel to entirely opaque. Doesn't work
with level.:erode
- reduces the light areas. Doesn't work with level.:dilate
- increases the light areas. Doesn't work with level.Originally named filter in Processing Language. Filters the display window with the specified mode and level. Level defines the quality of the filter and mode may be one of the following keywords: * `:threshold` - converts the image to black and white pixels depending if they are above or below the threshold defined by the level parameter. The level 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. Doesn't work with level. * `:invert` - sets each pixel to its inverse value. Doesn't work with level. * `:posterize` - limits each channel of the image to the number of colors specified as the level 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 level parameter is used, the blur is equivalent to Gaussian blur of radius 1. * `:opaque` - sets the alpha channel to entirely opaque. Doesn't work with level. * `:erode` - reduces the light areas. Doesn't work with level. * `:dilate` - increases the light areas. Doesn't work with level.
(dist x1 y1 x2 y2)
(dist x1 y1 z1 x2 y2 z2)
Calculates the distance between two points.
Calculates the distance between two points.
(do-record graphics & body)
(do-record &form &env graphics & body)
Macro for drawing on graphics which saves result in the file at the end.
Similar to with-graphics
macro. do-record
assumed to be used with :pdf
graphics.
Example:
(q/do-record (q/create-graphics 200 200 :pdf "output.pdf")
(q/fill 250 0 0)
(q/ellipse 100 100 150 150))
Macro for drawing on graphics which saves result in the file at the end. Similar to [[with-graphics]] macro. [[do-record]] assumed to be used with `:pdf` graphics. Example: ``` (q/do-record (q/create-graphics 200 200 :pdf "output.pdf") (q/fill 250 0 0) (q/ellipse 100 100 150 150)) ```
(ellipse x y width height)
Draws an ellipse (oval) in the display window. An ellipse with an
equal width
and height
is a circle. The origin may be changed with
the ellipse-mode
function.
Draws an ellipse (oval) in the display window. An ellipse with an equal `width` and `height` is a circle. The origin may be changed with the [[ellipse-mode]] function.
(ellipse-mode mode)
Modifies the origin of the ellipse according to the specified mode
:
:center
- specifies the location of the ellipse as
the center of the shape (default).:radius
- similar to center, but the width and height parameters to
ellipse specify the radius of the ellipse, rather than the
diameter.:corner
- draws the shape from the upper-left corner of its bounding
box.:corners
- uses the four parameters to ellipse to set two opposing
corners of the ellipse's bounding box.Modifies the origin of the ellipse according to the specified `mode`: * `:center` - specifies the location of the ellipse as the center of the shape **(default)**. * `:radius` - similar to center, but the width and height parameters to ellipse specify the radius of the ellipse, rather than the diameter. * `:corner` - draws the shape from the upper-left corner of its bounding box. * `:corners` - uses the four parameters to ellipse to set two opposing corners of the ellipse's bounding box.
(ellipsoid radius-x radius-y radius-z)
(ellipsoid radius-x radius-y radius-z detail-x)
(ellipsoid radius-x radius-y radius-z detail-x detail-y)
Draws an ellipsoid with given radius
Optional parameters:
detail-x
- number of segments, the more segments the smoother geometry default is 24detail-y
- number of segments, the more segments the smoother geometry default is 16Draws an ellipsoid with given radius Optional parameters: * `detail-x` - number of segments, the more segments the smoother geometry default is 24 * `detail-y` - number of segments, the more segments the smoother geometry default is 16
(emissive gray)
(emissive r g b)
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.
If passed one arg it is assumed to be an int
(i.e. a color),
multiple args are converted to floats
.
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. If passed one arg it is assumed to be an `int` (i.e. a color), multiple args are converted to `floats`.
(end-contour)
Use the begin-contour
and end-contour
function to create negative
shapes within shapes. These functions can only be within a
begin-shape
/end-shape
pair and they only work with the :p2d
and :p3d
renderers.
Use the [[begin-contour]] and [[end-contour]] function to create negative shapes within shapes. These functions can only be within a [[begin-shape]]/[[end-shape]] pair and they only work with the `:p2d` and `:p3d` renderers.
(end-shape)
(end-shape mode)
May only be called after begin-shape
. When end-shape
is called,
all of image data defined since the previous call to begin-shape
is
written into the image buffer. The keyword :close
may be passed to
close the shape (to connect the beginning and the end).
May only be called after [[begin-shape]]. When [[end-shape]] is called, all of image data defined since the previous call to [[begin-shape]] is written into the image buffer. The keyword `:close` may be passed to close the shape (to connect the beginning and the end).
(exit)
Quits/stops/exits the program. Rather than terminating
immediately, exit
will cause the sketch to exit after draw
has
completed (or after setup
completes if called during the setup
method).
Quits/stops/exits the program. Rather than terminating immediately, [[exit]] will cause the sketch to exit after `draw` has completed (or after `setup` completes if called during the `setup` method).
(exp val)
Returns Euler's number e
(2.71828...) raised to the power of the
val
parameter.
Returns Euler's number `e` (2.71828...) raised to the power of the `val` parameter.
(fill gray)
(fill gray alpha)
(fill r g b)
(fill r g b alpha)
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 function casts all
input as a float
. If nil is passed it removes any fill color; equivalent to
calling no-fill
.
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 function casts all input as a `float`. If nil is passed it removes any fill color; equivalent to calling [[no-fill]].
(filter-shader shader-obj)
Originally named filter in Processing Language.
Filters the display window with given shader (only in :p2d
and :p3d
modes).
Originally named filter in Processing Language. Filters the display window with given shader (only in `:p2d` and `:p3d` modes).
(floor n)
Calculates the closest int
value that is less than or equal to the
value of the parameter. For example, (floor 9.03)
returns the value 9.
Calculates the closest `int` value that is less than or equal to the value of the parameter. For example, `(floor 9.03)` returns the value 9.
(focused)
Returns true
if the applet has focus, false
otherwise.
Returns `true` if the applet has focus, `false` otherwise.
(font-available? font-str)
Returns true
if font (specified as a string) is available on this
system, false
otherwise
Returns `true` if font (specified as a string) is available on this system, `false` otherwise
(frame-count)
The system variable frameCount contains the number of frames displayed since the program started. Inside setup() the value is 0 and after the first iteration of draw it is 1, etc.
The system variable frameCount contains the number of frames displayed since the program started. Inside setup() the value is 0 and after the first iteration of draw it is 1, etc.
(frame-rate new-rate)
Specifies a new target framerate (number of frames to be displayed every
second). If the processor is not fast enough to maintain the
specified rate, it will not be achieved. For example, the function
call (frame-rate 30)
will attempt to refresh 30 times a second. It
is recommended to set the frame rate within setup. The default rate
is 60 frames per second.
Specifies a new target framerate (number of frames to be displayed every second). If the processor is not fast enough to maintain the specified rate, it will not be achieved. For example, the function call `(frame-rate 30)` will attempt to refresh 30 times a second. It is recommended to set the frame rate within setup. The default rate is 60 frames per second.
(frustum left right bottom top near far)
Sets a perspective matrix defined through the parameters. Works like glFrustum, except it wipes out the current perspective matrix rather than multiplying itself with it. https://en.wikipedia.org/wiki/Frustum
Sets a perspective matrix defined through the parameters. Works like glFrustum, except it wipes out the current perspective matrix rather than multiplying itself with it. https://en.wikipedia.org/wiki/Frustum
(get-pixel)
(get-pixel img)
(get-pixel x y)
(get-pixel img x y)
(get-pixel x y w h)
(get-pixel img x y w h)
Reads the color of any pixel or grabs a section of an image. If no
parameters are specified, a copy of entire image is returned. Get the
value of one pixel by specifying an x
,y
coordinate. Get a section of
the image by specifying an additional width
and height
parameter.
If the pixel requested is outside of the image window, black is returned.
The numbers returned are scaled according to the current color ranges,
but only RGB values are returned by this function. For example, even though
you may have drawn a shape with (color-mode :hsb)
, the numbers returned
will be in RGB.
Getting the color of a single pixel with (get x y)
is easy, but not
as fast as grabbing the data directly using the pixels
function.
If no img
specified - current-graphics
is used.
Reads the color of any pixel or grabs a section of an image. If no parameters are specified, a copy of entire image is returned. Get the value of one pixel by specifying an `x`,`y` coordinate. Get a section of the image by specifying an additional `width` and `height` parameter. If the pixel requested is outside of the image window, black is returned. The numbers returned are scaled according to the current color ranges, but only RGB values are returned by this function. For example, even though you may have drawn a shape with `(color-mode :hsb)`, the numbers returned will be in RGB. Getting the color of a single pixel with `(get x y)` is easy, but not as fast as grabbing the data directly using the [[pixels]] function. If no `img` specified - [[current-graphics]] is used.
(get-sketch-by-id id)
Returns sketch object by id of canvas element of sketch.
Returns sketch object by id of canvas element of sketch.
(green col)
Extracts the green value from a color, scaled to match current
color-mode
. This value is always returned as a float
so be careful
not to assign it to an int
value.
Extracts the green value from a color, scaled to match current [[color-mode]]. This value is always returned as a `float` so be careful not to assign it to an `int` value.
(height)
Height of the display window. The value of height is zero until size is called.
Height of the display window. The value of height is zero until size is called.
(hex val)
(hex val num-digits)
Converts a byte, char, int, or color to a String containing the equivalent hexadecimal notation. For example color(0, 102, 153) will convert to the String "FF006699". This function can help make your geeky debugging sessions much happier.
Converts a byte, char, int, or color to a String containing the equivalent hexadecimal notation. For example color(0, 102, 153) will convert to the String "FF006699". This function can help make your geeky debugging sessions much happier.
(hint hint-type)
Set various hints and hacks for the renderer. This is used to handle obscure rendering features that cannot be implemented in a consistent manner across renderers. Many options will often graduate to standard features instead of hints over time.
Options:
:enable-native-fonts
- Use the native version fonts when they are
installed, rather than the bitmapped version from a .vlw
file. This is useful with the default (or JAVA2D) renderer
setting, as it will improve font rendering speed. This is not
enabled by default, because it can be misleading while testing
because the type will look great on your machine (because you have
the font installed) but lousy on others' machines if the identical
font is unavailable. This option can only be set per-sketch, and
must be called before any use of text-font.
:disable-native-fonts
- Disables native font support.
:disable-depth-test
- Disable the zbuffer, allowing you to draw on
top of everything at will. When depth testing is disabled, items
will be drawn to the screen sequentially, like a painting. This
hint is most often used to draw in 3D, then draw in 2D on top of
it (for instance, to draw GUI controls in 2D on top of a 3D
interface). Starting in release 0149, this will also clear the
depth buffer. Restore the default with :enable-depth-test
but note that with the depth buffer cleared, any 3D drawing that
happens later in draw will ignore existing shapes on the screen.
:enable-depth-test
- Enables the zbuffer.
:enable-depth-sort
- Enable primitive z-sorting of triangles and
lines in :p3d and :opengl rendering modes. This can slow
performance considerably, and the algorithm is not yet perfect.
:disable-depth-sort
- Disables hint :enable-depth-sort
:disable-opengl-errors
- Speeds up the OPENGL renderer setting
by not checking for errors while running.
:enable-opengl-errors
- Turns on OpenGL error checking
:enable-depth-mask
:disable-depth-mask
:enable-optimized-stroke
:disable-optimized-stroke
:enable-retina-pixels
:disable-retina-pixels
:enable-stroke-perspective
:disable-stroke-perspective
:enable-stroke-pure
:disable-stroke-pure
:enable-texture-mipmaps
:disable-texture-mipmaps
Set various hints and hacks for the renderer. This is used to handle obscure rendering features that cannot be implemented in a consistent manner across renderers. Many options will often graduate to standard features instead of hints over time. Options: * `:enable-native-fonts` - Use the native version fonts when they are installed, rather than the bitmapped version from a .vlw file. This is useful with the default (or JAVA2D) renderer setting, as it will improve font rendering speed. This is not enabled by default, because it can be misleading while testing because the type will look great on your machine (because you have the font installed) but lousy on others' machines if the identical font is unavailable. This option can only be set per-sketch, and must be called before any use of text-font. * `:disable-native-fonts` - Disables native font support. * `:disable-depth-test` - Disable the zbuffer, allowing you to draw on top of everything at will. When depth testing is disabled, items will be drawn to the screen sequentially, like a painting. This hint is most often used to draw in 3D, then draw in 2D on top of it (for instance, to draw GUI controls in 2D on top of a 3D interface). Starting in release 0149, this will also clear the depth buffer. Restore the default with :enable-depth-test but note that with the depth buffer cleared, any 3D drawing that happens later in draw will ignore existing shapes on the screen. * `:enable-depth-test` - Enables the zbuffer. * `:enable-depth-sort` - Enable primitive z-sorting of triangles and lines in :p3d and :opengl rendering modes. This can slow performance considerably, and the algorithm is not yet perfect. * `:disable-depth-sort` - Disables hint :enable-depth-sort * `:disable-opengl-errors` - Speeds up the OPENGL renderer setting by not checking for errors while running. * `:enable-opengl-errors` - Turns on OpenGL error checking * `:enable-depth-mask` * `:disable-depth-mask` * `:enable-optimized-stroke` * `:disable-optimized-stroke` * `:enable-retina-pixels` * `:disable-retina-pixels` * `:enable-stroke-perspective` * `:disable-stroke-perspective` * `:enable-stroke-pure` * `:disable-stroke-pure` * `:enable-texture-mipmaps` * `:disable-texture-mipmaps`
(hour)
Returns the current hour as a value from 0 - 23.
Returns the current hour as a value from 0 - 23.
(hue col)
Extracts the hue value from a color.
Extracts the hue value from a color.
(image img x y)
(image img x y c d)
Displays images to the screen. Processing currently works with GIF,
JPEG, and Targa images. The color of an image may be modified with
the tint
function and if a GIF has transparency, it will maintain
its transparency. The img
parameter specifies the image to display
and the x
and y
parameters define the location of the image from its
upper-left corner. The image is displayed at its original size
unless the width and height parameters specify a different size. The
image-mode
function changes the way the parameters work. A call to
(image-mode :corners)
will change the width
and height
parameters to
define the x and y values of the opposite corner of the image.
Displays images to the screen. Processing currently works with GIF, JPEG, and Targa images. The color of an image may be modified with the [[tint]] function and if a GIF has transparency, it will maintain its transparency. The `img` parameter specifies the image to display and the `x` and `y` parameters define the location of the image from its upper-left corner. The image is displayed at its original size unless the width and height parameters specify a different size. The [[image-mode]] function changes the way the parameters work. A call to `(image-mode :corners)` will change the `width` and `height` parameters to define the x and y values of the opposite corner of the image.
(image-filter img mode)
(image-filter img mode level)
Originally named filter in Processing Language.
Filters given image with the specified mode
and level
.
level
defines the quality of the filter and mode
may be one of
the following keywords:
:threshold
- converts the image to black and white pixels depending
if they are above or below the threshold defined by
the level parameter. The level 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. Doesn't work with level.:invert
- sets each pixel to its inverse value. Doesn't work with
level.:posterize
- limits each channel of the image to the number of
colors specified as the level 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 level
parameter is used, the blur is equivalent to Gaussian
blur of radius 1.:opaque
- sets the alpha channel to entirely opaque. Doesn't work
with level.:erode
- reduces the light areas. Doesn't work with level
.:dilate
- increases the light areas. Doesn't work with level
.Originally named filter in Processing Language. Filters given image with the specified `mode` and `level`. `level` defines the quality of the filter and `mode` may be one of the following keywords: * `:threshold` - converts the image to black and white pixels depending if they are above or below the threshold defined by the level parameter. The level 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. Doesn't work with level. * `:invert` - sets each pixel to its inverse value. Doesn't work with level. * `:posterize` - limits each channel of the image to the number of colors specified as the level 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 level parameter is used, the blur is equivalent to Gaussian blur of radius 1. * `:opaque` - sets the alpha channel to entirely opaque. Doesn't work with level. * `:erode` - reduces the light areas. Doesn't work with `level`. * `:dilate` - increases the light areas. Doesn't work with `level`.
(image-mode mode)
Modifies the location from which images draw. The default mode
is :corner
.
Available modes are:
:corner
- specifies the location to be the upper left corner and
uses the fourth and fifth parameters of image to set the
image's width and height.:corners
- uses the second and third parameters of image to set the
location of one corner of the image and uses the fourth
and fifth parameters to set the opposite corner.:center
- draw images centered at the given x and y position.Modifies the location from which images draw. The default `mode` is `:corner`. Available modes are: * `:corner` - specifies the location to be the upper left corner and uses the fourth and fifth parameters of image to set the image's width and height. * `:corners` - uses the second and third parameters of image to set the location of one corner of the image and uses the fourth and fifth parameters to set the opposite corner. * `:center` - draw images centered at the given x and y position.
(key-as-keyword)
Returns a keyword representing the currently pressed key. Modifier
keys are represented as: :up
, :down
, :left
, :right
, :alt
, :control
,
:shift
, :command
, :f1-24
Returns a keyword representing the currently pressed key. Modifier keys are represented as: `:up`, `:down`, `:left`, `:right`, `:alt`, `:control`, `:shift`, `:command`, `:f1-24`
(key-code)
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's first necessary to check and see if the key is
coded. This is done with the conditional (= (key) CODED)
.
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
key-code
. 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.
For users 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.
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's first necessary to check and see if the key is coded. This is done with the conditional `(= (key) CODED)`. 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 [[key-code]]. 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. For users 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.
(key-coded? c)
Returns true if char c
is a coded
char i.e. it is necessary to
fetch the key-code
as an integer and use that to determine the
specific key pressed. See key-as-keyword
.
Returns true if char `c` is a `coded` char i.e. it is necessary to fetch the [[key-code]] as an integer and use that to determine the specific key pressed. See [[key-as-keyword]].
(key-modifiers)
Set of key modifiers that were pressed when event happened.
Possible modifiers :ctrl
, :alt
, :shift
, :meta
. Not available in
ClojureScript.
Set of key modifiers that were pressed when event happened. Possible modifiers `:ctrl`, `:alt`, `:shift`, `:meta`. Not available in ClojureScript.
(key-pressed?)
true if any key is currently pressed, false otherwise.
true if any key is currently pressed, false otherwise.
(lerp start stop 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.
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.
(lerp-color c1 c2 amt)
Calculates a color or colors between two color 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.
Calculates a color or colors between two color 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.
(light-falloff constant linear quadratic)
Sets the falloff rates for point lights, spot lights, and ambient lights. The parameters are used to determine the falloff with the following equation:
d = distance from light position to vertex position falloff = 1 / (CONSTANT + d * LINEAR + (d*d) * QUADRATIC)
Like fill, it affects only the elements which are created after it
in the code. The default value is (light-falloff 1.0 0.0 0.0)
.
Thinking about an ambient light with a falloff can be tricky. It is
used, for example, if you wanted a region of your scene to be lit
ambiently by one color and another region to be lit ambiently by
another color, you would 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 it is facing.
Sets the falloff rates for point lights, spot lights, and ambient lights. The parameters are used to determine the falloff with the following equation: d = distance from light position to vertex position falloff = 1 / (CONSTANT + d * LINEAR + (d*d) * QUADRATIC) Like fill, it affects only the elements which are created after it in the code. The default value is `(light-falloff 1.0 0.0 0.0)`. Thinking about an ambient light with a falloff can be tricky. It is used, for example, if you wanted a region of your scene to be lit ambiently by one color and another region to be lit ambiently by another color, you would 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 it is facing.
(light-specular r g b)
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.
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.
(lightness c)
Extracts the HSL lightness value from a color or pixel array.
Extracts the HSL lightness value from a color or pixel array.
(lights)
Sets the default ambient light, directional light, falloff, and specular values. The defaults are:
(ambient-light 128 128 128)
(directional-light 128 128 128 0 0 -1)
(light-falloff 1 0 0)
(light-specular 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.
Sets the default ambient light, directional light, falloff, and specular values. The defaults are: `(ambient-light 128 128 128)` `(directional-light 128 128 128 0 0 -1)` `(light-falloff 1 0 0)` `(light-specular 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.
(line p1 p2)
(line x1 y1 x2 y2)
(line x1 y1 z1 x2 y2 z2)
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 method 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 stroke-weight
function. The version with six parameters
allows the line to be placed anywhere within XYZ space.
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 method 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 [[stroke-weight]] function. The version with six parameters allows the line to be placed anywhere within XYZ space.
(load-font filename)
Loads a font into a variable of type PFont
. To load correctly,
fonts must be located in the data directory of the current sketch.
To create a font to use with Processing use the create-font
function.
Like load-image
and other methods that load data, the load-font
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.
For most renderers, Processing displays fonts using the .vlw
font
format, which uses images for each letter, rather than defining them
through vector data. When hint :enable-native-fonts
is used with the
JAVA2D renderer, the native version of a font will be used if it is
installed on the user's machine.
Using create-font
(instead of load-font
) enables vector data to be
used with the JAVA2D (default) renderer setting. This can be helpful
when many font sizes are needed, or when using any renderer based on
JAVA2D, such as the PDF library.
Loads a font into a variable of type `PFont`. To load correctly, fonts must be located in the data directory of the current sketch. To create a font to use with Processing use the [[create-font]] function. Like [[load-image]] and other methods that load data, the [[load-font]] 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. For most renderers, Processing displays fonts using the `.vlw` font format, which uses images for each letter, rather than defining them through vector data. When hint `:enable-native-fonts` is used with the JAVA2D renderer, the native version of a font will be used if it is installed on the user's machine. Using [[create-font]] (instead of [[load-font]]) enables vector data to be used with the JAVA2D (default) renderer setting. This can be helpful when many font sizes are needed, or when using any renderer based on JAVA2D, such as the PDF library.
(load-image filename)
Loads an image into a variable of type PImage
. Four types of
images (.gif
, .jpg
, .tga
, .png
) 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.
The filename parameter can also be a URL to a file found online.
Image is loaded asynchronously. In order to check whether image
finished loading use loaded?
.
Loads an image into a variable of type `PImage`. Four types of images (`.gif`, `.jpg`, `.tga`, `.png`) 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. The filename parameter can also be a URL to a file found online. Image is loaded asynchronously. In order to check whether image finished loading use [[loaded?]].
(load-shader fragment-filename)
(load-shader fragment-filename vertex-filename)
Loads a shader into the PShader
object for clj and Shader
object for
cljs. In clj mode shaders are
compatible with the P2D and P3D renderers, but not with the default
renderer. In cljs mode shaders are compatible with the P3D renderer.
Loads a shader into the `PShader` object for clj and `Shader` object for cljs. In clj mode shaders are compatible with the P2D and P3D renderers, but not with the default renderer. In cljs mode shaders are compatible with the P3D renderer.
(load-shape filename)
Load a geometry from a file as a PShape
in clj, and a Geometry
in cljs.
Load a geometry from a file as a `PShape` in clj, and a `Geometry` in cljs.
(loaded? object)
Returns true if object is loaded.
Returns true if object is loaded.
(log val)
Calculates the natural logarithm (the base-e logarithm) of a number. This function expects the values greater than 0.0.
Calculates the natural logarithm (the base-e logarithm) of a number. This function expects the values greater than 0.0.
(looping?)
Returns whether the sketch is looping.
Returns whether the sketch is looping.
(mag a b)
(mag a b c)
(mag a b)
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)
.
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)`.
(map-range val low1 high1 low2 high2)
Re-maps a number from one range to another.
Numbers outside the range are not clamped to 0 and 1, because out-of-range values are often intentional and useful.
Re-maps a number from one range to another. Numbers outside the range are not clamped to 0 and 1, because out-of-range values are often intentional and useful.
(mask-image mask)
(mask-image img mask)
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. The mask image needs to be the same size as the image to which it is applied.
If single argument function is used - masked image is sketch itself
or graphics if used inside with-graphics
macro. If you're passing
graphics to this function - it works only with :p3d
and :opengl
renderers.
This method is useful for creating dynamically generated alpha masks.
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. The mask image needs to be the same size as the image to which it is applied. If single argument function is used - masked image is sketch itself or graphics if used inside [[with-graphics]] macro. If you're passing graphics to this function - it works only with `:p3d` and `:opengl` renderers. This method is useful for creating dynamically generated alpha masks.
(millis)
Returns the number of milliseconds (thousandths of a second) since starting the sketch. This information is often used for timing animation sequences.
Returns the number of milliseconds (thousandths of a second) since starting the sketch. This information is often used for timing animation sequences.
(minute)
Returns the current minute as a value from 0 - 59
Returns the current minute as a value from 0 - 59
(month)
Returns the current month as a value from 1 - 12.
Returns the current month as a value from 1 - 12.
(mouse-button)
The value of the system variable mouseButton is either :left
, :right
,
or :center
depending on which button is pressed. nil
if no button pressed
The value of the system variable mouseButton is either `:left`, `:right`, or `:center` depending on which button is pressed. `nil` if no button pressed
(mouse-pressed?)
true if a mouse button is pressed, false otherwise.
true if a mouse button is pressed, false otherwise.
(mouse-x)
Current horizontal coordinate of the mouse.
Current horizontal coordinate of the mouse.
(mouse-y)
Current vertical coordinate of the mouse.
Current vertical coordinate of the mouse.
(no-clip)
Disables the clipping previously started by the clip
function.
Disables the clipping previously started by the [[clip]] function.
(no-cursor)
Hides the cursor from view. Will not work when running in full screen (Present) mode.
Hides the cursor from view. Will not work when running in full screen (Present) mode.
(no-lights)
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.
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.
(no-loop)
Stops Processing from continuously executing the code within
draw
. If start-loop
is called, the code in draw
will begin to run
continuously again. If using no-loop
in setup, it should be the last
line inside the block.
When no-loop
is used, it's not possible to manipulate or access the
screen inside event handling functions such as [[mouse-pressed]] or
[[key-pressed]]. Instead, use those functions to call redraw
or
loop which will run draw
, which can update the screen
properly. This means that when no-loop
has been called, no drawing
can happen, and functions like save-frame
may not be used.
Note that if the sketch is resized, redraw
will be called to
update the sketch, even after no-loop
has been
specified. Otherwise, the sketch would enter an odd state until
loop was called.
Stops Processing from continuously executing the code within `draw`. If [[start-loop]] is called, the code in `draw` will begin to run continuously again. If using [[no-loop]] in setup, it should be the last line inside the block. When [[no-loop]] is used, it's not possible to manipulate or access the screen inside event handling functions such as [[mouse-pressed]] or [[key-pressed]]. Instead, use those functions to call [[redraw]] or loop which will run `draw`, which can update the screen properly. This means that when [[no-loop]] has been called, no drawing can happen, and functions like [[save-frame]] may not be used. Note that if the sketch is resized, [[redraw]] will be called to update the sketch, even after [[no-loop]] has been specified. Otherwise, the sketch would enter an odd state until loop was called.
(no-smooth)
Draws all geometry with jagged (aliased) edges. Must be called inside
:settings
handler.
Draws all geometry with jagged (aliased) edges. Must be called inside `:settings` handler.
(no-tint)
Removes the current fill value for displaying images and reverts to displaying images with their original hues.
Removes the current fill value for displaying images and reverts to displaying images with their original hues.
(noise x)
(noise x y)
(noise x y z)
Returns the Perlin noise value at specified coordinates. Perlin noise is a random sequence generator producing a more natural ordered, harmonic succession of numbers compared to the standard random function. It was invented by Ken Perlin in the 1980s and been used since in graphical applications to produce procedural textures, natural motion, shapes, terrains etc.
The main difference to the random function is that Perlin noise is defined in an infinite n-dimensional space where 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 and the 2nd and 3rd dimensions can also be interpreted as time.
The actual noise is structured similar to 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 does (eg. when using noise within a loop). As a general rule the smaller the difference between coordinates, the smoother the resulting noise sequence will be. Steps of 0.005-0.03 work best for most applications, but this will differ depending on use.
Returns the Perlin noise value at specified coordinates. Perlin noise is a random sequence generator producing a more natural ordered, harmonic succession of numbers compared to the standard random function. It was invented by Ken Perlin in the 1980s and been used since in graphical applications to produce procedural textures, natural motion, shapes, terrains etc. The main difference to the random function is that Perlin noise is defined in an infinite n-dimensional space where 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 and the 2nd and 3rd dimensions can also be interpreted as time. The actual noise is structured similar to 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 does (eg. when using noise within a loop). As a general rule the smaller the difference between coordinates, the smoother the resulting noise sequence will be. Steps of 0.005-0.03 work best for most applications, but this will differ depending on use.
(noise-detail octaves)
(noise-detail octaves falloff)
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 1st octave. This falloff amount can be changed by adding an additional function parameter. Eg. a falloff factor of 0.75 means each octave will now have 75% impact (25% less) of the previous lower octave. Any value between 0.0 and 1.0 is valid, however note that values greater than 0.5 might result in greater than 1.0 values returned by noise.
By changing these parameters, the signal created by the noise function can be adapted to fit very specific needs and characteristics.
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 1st octave. This falloff amount can be changed by adding an additional function parameter. Eg. a falloff factor of 0.75 means each octave will now have 75% impact (25% less) of the previous lower octave. Any value between 0.0 and 1.0 is valid, however note that values greater than 0.5 might result in greater than 1.0 values returned by noise. By changing these parameters, the signal created by the noise function can be adapted to fit very specific needs and characteristics.
(noise-seed val)
Sets the seed value for noise. By default, noise produces different
results each time the program is run. Set the val
parameter to a
constant to return the same pseudo-random numbers each time the
software is run.
Sets the seed value for noise. By default, noise produces different results each time the program is run. Set the `val` parameter to a constant to return the same pseudo-random numbers each time the software is run.
(norm val start stop)
Normalize a value to exist between 0 and 1 (inclusive).
Normalize a value to exist between 0 and 1 (inclusive).
(orbit-control)
Allows the camera to orbit around a target using mouse.
Allows the camera to orbit around a target using mouse.
(ortho)
(ortho left right bottom top)
(ortho left right bottom top near far)
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 0 width 0 height -10 10)
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 0 width 0 height -10 10)`
(perspective)
(perspective fovy aspect z-near z-far)
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))
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))`
(pixel-density density)
It makes it possible for Processing to render using all of the pixels
on high resolutions screens like Apple Retina displays and Windows
High-DPI displays. Possible values 1 or 2. Must be called only from
:settings handler. To get density of the current screen you can use
the display-density
function.
It makes it possible for Processing to render using all of the pixels on high resolutions screens like Apple Retina displays and Windows High-DPI displays. Possible values 1 or 2. Must be called only from :settings handler. To get density of the current screen you can use the [[display-density]] function.
(pixels)
(pixels img)
Array containing the values for all the pixels in the display
window or image. This array is therefore the size of the display window. If
this array is modified, the update-pixels
function must be called to
update the changes. Calls .loadPixels
before obtaining the pixel array.
Array containing the values for all the pixels in the display window or image. This array is therefore the size of the display window. If this array is modified, the [[update-pixels]] function must be called to update the changes. Calls `.loadPixels` before obtaining the pixel array.
(plane width height)
Draw a plane with given width
and height
.
Draw a plane with given `width` and `height`.
(pmouse-x)
Horizontal coordinate of the mouse in the previous frame
Horizontal coordinate of the mouse in the previous frame
(pmouse-y)
Vertical coordinate of the mouse in the previous frame
Vertical coordinate of the mouse in the previous frame
(point x y)
(point x y z)
Draws a point, a coordinate in space at the dimension of one pixel.
Parameters:
x
- the horizontal value for the pointy
- the vertical value for the pointz
- the depth value (optional)Drawing this shape in 3D using the z
parameter requires the :p3d
or :opengl
renderer to be used.
Draws a point, a coordinate in space at the dimension of one pixel. Parameters: * `x` - the horizontal value for the point * `y` - the vertical value for the point * `z` - the depth value (optional) Drawing this shape in 3D using the `z` parameter requires the `:p3d` or `:opengl` renderer to be used.
(point-light r g b x y 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 affect of the r
, g
, and b
parameters is determined by the current color-mode
. The x
, y
, and z
parameters set the position of the light
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 affect of the `r`, `g`, and `b` parameters is determined by the current [[color-mode]]. The `x`, `y`, and `z` parameters set the position of the light
(pop-matrix)
Pops the current transformation matrix off the matrix
stack. Understanding pushing and popping requires understanding the
concept of a matrix stack. The push-matrix
function saves the current
coordinate system to the stack and pop-matrix
restores the prior
coordinate system. push-matrix
and pop-matrix
are used in conjunction
with the other transformation methods and may be embedded to control
the scope of the transformations.
Pops the current transformation matrix off the matrix stack. Understanding pushing and popping requires understanding the concept of a matrix stack. The [[push-matrix]] function saves the current coordinate system to the stack and [[pop-matrix]] restores the prior coordinate system. [[push-matrix]] and [[pop-matrix]] are used in conjunction with the other transformation methods and may be embedded to control the scope of the transformations.
(pop-style)
Restores the prior settings on the 'style stack'. Used in
conjunction with push-style
. Together they allow you to change the
style settings and later return to what you had. When a new style is
started with push-style
, it builds on the current style information.
The push-style
and pop-style
functions can be nested to provide more
control
Restores the prior settings on the 'style stack'. Used in conjunction with [[push-style]]. Together they allow you to change the style settings and later return to what you had. When a new style is started with [[push-style]], it builds on the current style information. The [[push-style]] and [[pop-style]] functions can be nested to provide more control
(pow num exponent)
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))
.
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))`.
(print-camera)
Prints the current camera matrix to std out. Useful for debugging.
Prints the current camera matrix to std out. Useful for debugging.
(print-matrix)
Prints the current matrix to std out. Useful for debugging.
Prints the current matrix to std out. Useful for debugging.
(print-projection)
Prints the current projection matrix to std out. Useful for debugging
Prints the current projection matrix to std out. Useful for debugging
(push-matrix)
Pushes the current transformation matrix onto the matrix
stack. Understanding [push-matrix
and pop-matrix
requires
understanding the concept of a matrix stack. The push-matrix
function saves the current coordinate system to the stack and
pop-matrix
restores the prior coordinate system. push-matrix
and
pop-matrix
are used in conjunction with the other transformation
methods and may be embedded to control the scope of the
transformations.
Pushes the current transformation matrix onto the matrix stack. Understanding [[[push-matrix]] and [[pop-matrix]] requires understanding the concept of a matrix stack. The [[push-matrix]] function saves the current coordinate system to the stack and [[pop-matrix]] restores the prior coordinate system. [[push-matrix]] and [[pop-matrix]] are used in conjunction with the other transformation methods and may be embedded to control the scope of the transformations.
(push-style)
Saves the current style settings onto a 'style stack'. Use with
pop-style
which 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 push-style
, it builds on the current style
information. The push-style
and pop-style
functions can be
embedded to provide more control.
The style information controlled by the following functions are
included in the style: fill
, stroke
, tint
, stroke-weight
,
stroke-cap
, stroke-join
, image-mode
, rect-mode
, ellipse-mode
,
shape-mode
, color-mode
, text-align
, text-font
, text-mode
, text-size
,
text-leading
, emissive
, specular
, shininess
, and ambient
.
Saves the current style settings onto a 'style stack'. Use with [[pop-style]] which 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 [[push-style]], it builds on the current style information. The [[push-style]] and [[pop-style]] functions can be embedded to provide more control. The style information controlled by the following functions are included in the style: [[fill]], [[stroke]], [[tint]], [[stroke-weight]], [[stroke-cap]], [[stroke-join]], [[image-mode]], [[rect-mode]], [[ellipse-mode]], [[shape-mode]], [[color-mode]], [[text-align]], [[text-font]], [[text-mode]], [[text-size]], [[text-leading]], [[emissive]], [[specular]], [[shininess]], and [[ambient]].
(quad x1 y1 x2 y2 x3 y3 x4 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
be 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.
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 be 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.
(quadratic-vertex cx cy x3 y3)
(quadratic-vertex cx cy cz x3 y3 z3)
Specifies vertex coordinates for quadratic Bezier curves. Each call to
quadratic-vertex
defines the position of one control points and one
anchor point of a Bezier curve, adding a new segment to a line or shape.
The first time quadratic-vertex
is used within a begin-shape
call, it
must be prefaced with a call to vertex
to set the first anchor point.
This function must be used between begin-shape
and end-shape
and only
when there is no MODE parameter specified to begin-shape. Using the 3D
version requires rendering with :p3d
.
Specifies vertex coordinates for quadratic Bezier curves. Each call to [[quadratic-vertex]] defines the position of one control points and one anchor point of a Bezier curve, adding a new segment to a line or shape. The first time [[quadratic-vertex]] is used within a [[begin-shape]] call, it must be prefaced with a call to [[vertex]] to set the first anchor point. This function must be used between [[begin-shape]] and [[end-shape]] and only when there is no MODE parameter specified to begin-shape. Using the 3D version requires rendering with `:p3d`.
(radians 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 methods require their parameters to be specified in radians.
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 methods require their parameters to be specified in radians.
(random max)
(random min max)
Generates random numbers. Each time the random function is called,
it returns an unexpected value within the specified range. If one
parameter is passed to the function it will return a float
between
zero and the value of the high parameter. The function call (random 5)
returns values between 0 and 5 (starting at zero, up to but not
including 5). If two parameters are passed, it will return a float
with a value between the parameters. The function call
(random -5 10.2)
returns values starting at -5 up to (but not
including) 10.2.
Generates random numbers. Each time the random function is called, it returns an unexpected value within the specified range. If one parameter is passed to the function it will return a `float` between zero and the value of the high parameter. The function call `(random 5)` returns values between 0 and 5 (starting at zero, up to but not including 5). If two parameters are passed, it will return a `float` with a value between the parameters. The function call `(random -5 10.2)` returns values starting at -5 up to (but not including) 10.2.
(random-2d)
Returns a new 2D unit vector with a random direction
Returns a new 2D unit vector with a random direction
(random-3d)
Returns a new 3D unit vector with a random direction
Returns a new 3D unit vector with a random direction
(random-gaussian)
Returns a float
from a random series of numbers having a mean of 0 and
standard deviation of 1. Each time the random-gaussian
function is called,
it returns a number fitting a Gaussian, or normal, distribution.
There is theoretically no minimum or maximum value that random-gaussian
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.
Returns a `float` from a random series of numbers having a mean of 0 and standard deviation of 1. Each time the [[random-gaussian]] function is called, it returns a number fitting a Gaussian, or normal, distribution. There is theoretically no minimum or maximum value that [[random-gaussian]] 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.
(random-seed w)
Sets the seed value for random. By default, random 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.
Sets the seed value for random. By default, random 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.
(raw-key)
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.
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.
(rect x y width height)
(rect x y width height r)
(rect x y width height top-left-r top-right-r bottom-right-r bottom-left-r)
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. These parameters
may be changed with rect-mode
.
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.
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. These parameters may be changed with [[rect-mode]]. 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.
(rect-mode mode)
Modifies the location from which rectangles draw. The default mode
is :corner
. Available modes are:
:corner
- Specifies the location to be the upper left corner of the
shape and uses the third and fourth parameters of rect
to
specify the width and height.:corners
- Uses the first and second parameters of rect
to set the
location of one corner and uses the third and fourth
parameters to set the opposite corner.:center
- Draws the image from its center point and uses the third
and fourth parameters of rect
to specify the image's width
and height.:radius
- Draws the image from its center point and uses the third
and forth parameters of rect
to specify half of the
image's width and height.Modifies the location from which rectangles draw. The default `mode` is `:corner`. Available modes are: * `:corner` - Specifies the location to be the upper left corner of the shape and uses the third and fourth parameters of [[rect]] to specify the width and height. * `:corners` - Uses the first and second parameters of [[rect]] to set the location of one corner and uses the third and fourth parameters to set the opposite corner. * `:center` - Draws the image from its center point and uses the third and fourth parameters of [[rect]] to specify the image's width and height. * `:radius` - Draws the image from its center point and uses the third and forth parameters of [[rect]] to specify half of the image's width and height.
(red c)
Extracts the red value from a color, scaled to match the current
color-mode
.
Extracts the red value from a color, scaled to match the current [[color-mode]].
(redraw)
(redraw)
(redraw n)
Executes the code within the draw
function one time (or n times in cljs).
This function allows the program to update the display window only
when necessary, for example when an event registered by [[mouse-pressed]] or
[[key-pressed]] occurs.
In structuring a program, it only makes sense to call redraw
within events such as [[mouse-pressed]]. This is because redraw
does
not run draw immediately (it only sets a flag that indicates an
update is needed).
Calling redraw
within draw
has no effect because draw
is
continuously called anyway.
Executes the code within the `draw` function one time (or n times in cljs). This function allows the program to update the display window only when necessary, for example when an event registered by [[mouse-pressed]] or [[key-pressed]] occurs. In structuring a program, it only makes sense to call [[redraw]] within events such as [[mouse-pressed]]. This is because [[redraw]] does not run draw immediately (it only sets a flag that indicates an update is needed). Calling [[redraw]] within `draw` has no effect because `draw` is continuously called anyway.
(reset-matrix)
Replaces the current matrix with the identity matrix. The
equivalent function in OpenGL is glLoadIdentity()
Replaces the current matrix with the identity matrix. The equivalent function in OpenGL is `glLoadIdentity()`
(reset-shader)
(reset-shader kind)
Restores the default shaders. Code that runs after reset-shader
will
not be affected by previously defined shaders. Optional kind
parameter -
type of shader, either :points
, :lines
, or :triangles
Restores the default shaders. Code that runs after [[reset-shader]] will not be affected by previously defined shaders. Optional `kind` parameter - type of shader, either `:points`, `:lines`, or `:triangles`
(resize img w h)
Resize the image to a new width and height.
To make the image scale proportionally, use 0 as the value for the wide or
high parameter. For instance, to make the width of an image 150 pixels,
and change the height using the same proportion, use (resize 150 0)
.
Even though a PGraphics
is technically a PImage
, it is not possible
to rescale the image data found in a PGraphics
.
(It's simply not possible to do this consistently across renderers:
technically infeasible with P3D, or what would it even do with PDF?)
If you want to resize PGraphics
content, first get a copy of its image data
using the get() method, and call resize() on the PImage
that is returned.
Resize the image to a new width and height. To make the image scale proportionally, use 0 as the value for the wide or high parameter. For instance, to make the width of an image 150 pixels, and change the height using the same proportion, use `(resize 150 0)`. Even though a `PGraphics` is technically a `PImage`, it is not possible to rescale the image data found in a `PGraphics`. (It's simply not possible to do this consistently across renderers: technically infeasible with P3D, or what would it even do with PDF?) If you want to resize `PGraphics` content, first get a copy of its image data using the get() method, and call resize() on the `PImage` that is returned.
(resize-sketch width height)
Resizes sketch.
Note about ClojureScript version: if the div
element is resized externally
(for example from js on a page then you still need to call this
method in order to tell Quil that size has changed. Currently there is no
good way to automatically detect that size of the <div>
element changed.
Resizes sketch. Note about ClojureScript version: if the `div` element is resized externally (for example from js on a page then you still need to call this method in order to tell Quil that size has changed. Currently there is no good way to automatically detect that size of the `<div>` element changed.
(rotate angle)
(rotate angle vx vy vz)
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
push-matrix
and pop-matrix
functions.
When 4 arguments are provided it produces a rotation of angle
degrees
around the vector vx
vy
vz
. Check examples to better understand.
This rotation follows the right-hand rule, so if the vector x y z points
toward the user, the rotation will be counterclockwise.
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 [[push-matrix]] and [[pop-matrix]] functions. When 4 arguments are provided it produces a rotation of `angle` degrees around the vector `vx` `vy` `vz`. Check examples to better understand. This rotation follows the right-hand rule, so if the vector x y z points toward the user, the rotation will be counterclockwise.
(rotate-x 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 (rotate-x HALF-PI)
and then (rotate-x HALF-PI)
is
the same as (rotate-x PI)
. If rotate-x
is called within the draw
function, the transformation is reset when the loop begins again. This
function requires either the :p3d
or :opengl
renderer.
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 `(rotate-x HALF-PI)` and then `(rotate-x HALF-PI)` is the same as `(rotate-x PI)`. If [[rotate-x]] is called within the draw function, the transformation is reset when the loop begins again. This function requires either the `:p3d` or `:opengl` renderer.
(rotate-y 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 (rotate-y HALF-PI)
and then (rotate-y HALF-PI)
is
the same as (rotate-y PI)
. If rotate-y
is called within the draw
function, the transformation is reset when the loop begins again. This
function requires either the :p3d
or :opengl
renderer.
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 `(rotate-y HALF-PI)` and then `(rotate-y HALF-PI)` is the same as `(rotate-y PI)`. If [[rotate-y]] is called within the draw function, the transformation is reset when the loop begins again. This function requires either the `:p3d` or `:opengl` renderer.
(rotate-z 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 (rotate-z HALF-PI)
and then (rotate-z HALF-PI)
is
the same as (rotate-z PI)
. If rotate-y
is called within the draw
function, the transformation is reset when the loop begins again. This
function requires either the :p3d
or :opengl
renderer.
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 `(rotate-z HALF-PI)` and then `(rotate-z HALF-PI)` is the same as `(rotate-z PI)`. If [[rotate-y]] is called within the draw function, the transformation is reset when the loop begins again. This function requires either the `:p3d` or `:opengl` renderer.
(round val)
Calculates the integer closest to the value parameter. For example,
(round 9.2)
returns the value 9.
Calculates the integer closest to the value parameter. For example, `(round 9.2)` returns the value 9.
(saturation c)
Extracts the saturation value from a color.
Extracts the saturation value from a color.
(save filename)
Saves an image from the display window. Images are saved in TIFF,
TARGA, JPEG, and PNG format depending on the extension within the
filename parameter. For example, image.tif will have a TIFF image
and image.png will save a PNG image. If no extension is included in
the filename, the image will save in TIFF format and .tif will be
added to the name. All images saved from the main drawing window
will be opaque. To save images without a background, use
create-graphics
.
Saves an image from the display window. Images are saved in TIFF, TARGA, JPEG, and PNG format depending on the extension within the filename parameter. For example, image.tif will have a TIFF image and image.png will save a PNG image. If no extension is included in the filename, the image will save in TIFF format and .tif will be added to the name. All images saved from the main drawing window will be opaque. To save images without a background, use [[create-graphics]].
(save-frame name)
Saves an image identical to the current display window as a file. May be called multiple times - each file saved will have a unique name. Name and image format may be modified by passing a string parameter of the form "foo-####.ext" where foo- can be any arbitrary string, #### will be replaced with the current frame id and .ext is one of .tiff, .targa, .png, .jpeg or .jpg
Examples:
(save-frame "pretty-pic-####.jpg")
Saves an image identical to the current display window as a file. May be called multiple times - each file saved will have a unique name. Name and image format may be modified by passing a string parameter of the form "foo-####.ext" where foo- can be any arbitrary string, #### will be replaced with the current frame id and .ext is one of .tiff, .targa, .png, .jpeg or .jpg Examples: ``` (save-frame "pretty-pic-####.jpg") ```
(scale s)
(scale sx sy)
(scale sx sy sz)
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)
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)
and then
(scale 1.5)
is the same as (scale 3)
. If scale is called within
draw, the transformation is reset when the loop begins again. Using
this function with the sz
parameter requires specifying :p3d
or :opengl
as the renderer. This function can be further controlled by
push-matrix
and pop-matrix
.
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)` 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)` and then `(scale 1.5)` is the same as `(scale 3)`. If scale is called within draw, the transformation is reset when the loop begins again. Using this function with the `sz` parameter requires specifying `:p3d` or `:opengl` as the renderer. This function can be further controlled by [[push-matrix]] and [[pop-matrix]].
(screen-height)
Returns the height of the main screen in pixels.
Returns the height of the main screen in pixels.
(screen-width)
Returns the width of the main screen in pixels.
Returns the width of the main screen in pixels.
(seconds)
Returns the current second as a value from 0 - 59.
Returns the current second as a value from 0 - 59.
(set-image x y src)
Writes an image directly into the display window. The x
and y
parameters define the coordinates for the upper-left corner of the
image.
Writes an image directly into the display window. The `x` and `y` parameters define the coordinates for the upper-left corner of the image.
(set-pixel x y c)
(set-pixel img x y c)
Changes the color of any pixel in the display window. The x
and y
parameters specify the pixel to change and the c
parameter
specifies the color value. The color parameter is affected by the
current color-mode
(the default is RGB values from 0 to 255).
Setting the color of a single pixel with (set-pixel x y)
is easy, but not
as fast as putting the data directly into pixels
.
This function ignores image-mode
.
Due to what appears to be a bug in Apple's Java implementation, the
point
and set-pixel
methods are extremely slow in some circumstances
when used with the default renderer. Using :p2d
or :p3d
will fix the
problem. Grouping many calls to point
or set-pixel
together can also
help. (Bug 1094)
Changes the color of any pixel in the display window. The `x` and `y` parameters specify the pixel to change and the `c` parameter specifies the color value. The color parameter is affected by the current [[color-mode]] (the default is RGB values from 0 to 255). Setting the color of a single pixel with `(set-pixel x y)` is easy, but not as fast as putting the data directly into [[pixels]]. This function ignores [[image-mode]]. Due to what appears to be a bug in Apple's Java implementation, the [[point]] and [[set-pixel]] methods are extremely slow in some circumstances when used with the default renderer. Using `:p2d` or `:p3d` will fix the problem. Grouping many calls to [[point]] or [[set-pixel]] together can also help. (Bug 1094)
(set-state! & state-vals)
Set sketch-specific state. May only be called once (ideally in the setup function). Subsequent calls have no effect.
Example:
(set-state! :foo 1 :bar (atom true) :baz (/ (width) 2))
Set sketch-specific state. May only be called once (ideally in the setup function). Subsequent calls have no effect. Example: ``` (set-state! :foo 1 :bar (atom true) :baz (/ (width) 2)) ```
(set-uniform shader uniform-name data)
Set a uniform variables inside a shader to modify the effect while the program is running.
Set a uniform variables inside a shader to modify the effect while the program is running.
(shader shader)
(shader shader kind)
(shader shader)
Applies the shader specified by the parameters. It's compatible with the :p2d
and :p3d
renderers, but not with the default :java2d
renderer.
In clj mode you can pass an optional kind
parameter that specifies
the type of shader, either :points
, :lines
, or :triangles
Applies the shader specified by the parameters. It's compatible with the `:p2d` and `:p3d` renderers, but not with the default `:java2d` renderer. In clj mode you can pass an optional `kind` parameter that specifies the type of shader, either `:points`, `:lines`, or `:triangles`
(shape sh)
(shape sh x y)
(shape sh x y width height)
(shape sh)
Displays shapes to the screen. The shapes must have been loaded
with load-shape
. Processing currently works with SVG shapes
only. The sh
parameter specifies the shape to display and the x
and
y
parameters define the location of the shape from its upper-left
corner. The shape is displayed at its original size unless the width
and height
parameters specify a different size. The shape-mode
function changes the way the parameters work. A call to
(shape-mode :corners)
for example, will change the width and height
parameters to define the x and y values of the opposite corner of
the shape.
Note complex shapes may draw awkwardly with the renderers :p2d
, :p3d
, and
:opengl
. Those renderers do not yet support shapes that have holes
or complicated breaks.
Displays shapes to the screen. The shapes must have been loaded with [[load-shape]]. Processing currently works with SVG shapes only. The `sh` parameter specifies the shape to display and the `x` and `y` parameters define the location of the shape from its upper-left corner. The shape is displayed at its original size unless the `width` and `height` parameters specify a different size. The [[shape-mode]] function changes the way the parameters work. A call to `(shape-mode :corners)` for example, will change the width and height parameters to define the x and y values of the opposite corner of the shape. Note complex shapes may draw awkwardly with the renderers `:p2d`, `:p3d`, and `:opengl`. Those renderers do not yet support shapes that have holes or complicated breaks.
(shape-mode mode)
Modifies the location from which shapes draw. Available modes are:
:corner
- 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. (default):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.:center
- draws the shape from its center point and uses the third
and forth parameters of shape to specify the width and
height.Modifies the location from which shapes draw. Available modes are: * `:corner` - 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. **(default)** * `: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. * `:center` - draws the shape from its center point and uses the third and forth parameters of shape to specify the width and height.
(shear-x 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 (shear-x (/ PI 2))
and then (shear-x (/ PI 2))
is
the same as (shear-x PI)
. If shear-x
is called within the draw
function, the transformation is reset when the loop begins again. This
function works in P2D or JAVA2D mode.
Technically, shear-x
multiplies the current transformation matrix
by a rotation matrix. This function can be further controlled by the
push-matrix
and pop-matrix
functions.
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 `(shear-x (/ PI 2))` and then `(shear-x (/ PI 2))` is the same as `(shear-x PI)`. If [[shear-x]] is called within the draw function, the transformation is reset when the loop begins again. This function works in P2D or JAVA2D mode. Technically, [[shear-x]] multiplies the current transformation matrix by a rotation matrix. This function can be further controlled by the [[push-matrix]] and [[pop-matrix]] functions.
(shear-y 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 (shear-y (/ PI 2))
and then (shear-y (/ PI 2))
is
the same as (shear-y PI)
. If shear-y
is called within the draw
function, the transformation is reset when the loop begins again. This
function works in P2D or JAVA2D mode.
Technically, shear-y
multiplies the current transformation matrix
by a rotation matrix. This function can be further controlled by the
push-matrix
and pop-matrix
functions.
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 `(shear-y (/ PI 2))` and then `(shear-y (/ PI 2))` is the same as `(shear-y PI)`. If [[shear-y]] is called within the draw function, the transformation is reset when the loop begins again. This function works in P2D or JAVA2D mode. Technically, [[shear-y]] multiplies the current transformation matrix by a rotation matrix. This function can be further controlled by the [[push-matrix]] and [[pop-matrix]] functions.
(shininess 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.
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.
(show-cats)
Print out a list of all the categories and subcategories, associated index nums and fn count (in parens).
Print out a list of all the categories and subcategories, associated index nums and fn count (in parens).
(show-fns q)
If given a number, print all the functions within category or
subcategory specified by the category index (use show-cats
to see a
list of index nums).
If given a string or a regular expression, print all the functions whose name or category name contains that string.
If a category is specified, it will not print out the fns in any of cat's subcategories.
If given a number, print all the functions within category or subcategory specified by the category index (use [[show-cats]] to see a list of index nums). If given a string or a regular expression, print all the functions whose name or category name contains that string. If a category is specified, it will not print out the fns in any of cat's subcategories.
(show-meths orig-name)
Takes a string representing the start of a method name in the original Processing API and prints out all matches alongside the Processing-core equivalent.
Takes a string representing the start of a method name in the original Processing API and prints out all matches alongside the Processing-core equivalent.
(sin 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). A float
within the range -1 to 1 is returned.
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). A `float` within the range -1 to 1 is returned.
(sketch & opts)
Create and start a new visualisation applet. Can be used to create
new sketches programmatically. See documentation for defsketch
for
list of available options.
Create and start a new visualisation applet. Can be used to create new sketches programmatically. See documentation for [[defsketch]] for list of available options.
(smooth)
(smooth level)
Draws all geometry with smooth (anti-aliased) edges. This will slow down the frame rate of the application, but will enhance the visual refinement.
Must be called inside :settings
handler.
The level
parameter (int) increases the level of smoothness with the
:p2d
and :p3d
renderers. This is the level of over sampling applied to
the graphics buffer. The value 2
will double the rendering size
before scaling it down to the display size. This is called 2x anti-aliasing
. The value 4
is used for 4x anti-aliasing
and 8
is
specified for 8x anti-aliasing
. If level is set to 0
, it will disable
all smoothing; it's the equivalent of the function no-smooth
.
The maximum anti-aliasing level is determined by the hardware of the
machine that is running the software.
Note that smooth will also improve image quality of resized images.
Draws all geometry with smooth (anti-aliased) edges. This will slow down the frame rate of the application, but will enhance the visual refinement. Must be called inside `:settings` handler. The `level` parameter (int) increases the level of smoothness with the `:p2d` and `:p3d` renderers. This is the level of over sampling applied to the graphics buffer. The value `2` will double the rendering size before scaling it down to the display size. This is called `2x anti-aliasing`. The value `4` is used for `4x anti-aliasing` and `8` is specified for `8x anti-aliasing`. If level is set to `0`, it will disable all smoothing; it's the equivalent of the function [[no-smooth]]. The maximum anti-aliasing level is determined by the hardware of the machine that is running the software. Note that smooth will also improve image quality of resized images.
(specular gray)
(specular x y z)
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.
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.
(sphere radius)
Generates a hollow ball made from tessellated triangles.
Generates a hollow ball made from tessellated triangles.
(sphere-detail res)
(sphere-detail ures vres)
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 sphere-detail
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.
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 [[sphere-detail]] 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.
(spot-light [r g b] [x y z] [nx ny nz] angle concentration)
(spot-light r g b x y z nx ny nz angle concentration)
Adds a spot 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 affect of the r
, g
, and b
parameters is determined by the current color-mode
. The x
, y
, and z
parameters specify the position of the light and nx
, ny
, nz
specify
the direction or light. The angle parameter affects the angle of the
spotlight cone.
Adds a spot 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 affect of the `r`, `g`, and `b` parameters is determined by the current [[color-mode]]. The `x`, `y`, and `z` parameters specify the position of the light and `nx`, `ny`, `nz` specify the direction or light. The angle parameter affects the angle of the spotlight cone.
(sq a)
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.
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.
(sqrt a)
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 (= a (* s s)). It is the opposite of squaring.
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 (= a (* s s)). It is the opposite of squaring.
(start-loop)
Causes Processing to continuously execute the code within
draw. If no-loop
is called, the code in draw stops executing.
Causes Processing to continuously execute the code within draw. If [[no-loop]] is called, the code in draw stops executing.
(state)
(state key)
Retrieve sketch-specific state by key. Must initially call set-state! to store state. If no parameter passed whole state map is returned.
(set-state! :foo 1) (state :foo) ;=> 1 (state) ;=> {:foo 1}
Retrieve sketch-specific state by key. Must initially call set-state! to store state. If no parameter passed whole state map is returned. (set-state! :foo 1) (state :foo) ;=> 1 (state) ;=> {:foo 1}
(state-atom)
Retrieve sketch-specific state-atom. All changes to the atom will be reflected in the state.
(set-state! :foo 1) (state :foo) ;=> 1 (swap! (state-atom) update-in [:foo] inc) (state :foo) ;=> 2
Retrieve sketch-specific state-atom. All changes to the atom will be reflected in the state. (set-state! :foo 1) (state :foo) ;=> 1 (swap! (state-atom) update-in [:foo] inc) (state :foo) ;=> 2
(stroke gray)
(stroke gray alpha)
(stroke x y z)
(stroke x y z alpha)
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 color-mode
(the default color space is RGB, with
each value in the range from 0 to 255).
If nil is passed it removes any fill color; equivalent to no-stroke
.
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 [[color-mode]] (the default color space is RGB, with each value in the range from 0 to 255). If nil is passed it removes any fill color; equivalent to [[no-stroke]].
(stroke-cap cap-mode)
Sets the style for rendering line endings. These ends are either
squared, extended, or rounded and specified with the corresponding
parameters :square
, :project
, and :round
. The default cap is :round
.
Sets the style for rendering line endings. These ends are either squared, extended, or rounded and specified with the corresponding parameters `:square`, `:project`, and `:round`. The default cap is `:round`.
(stroke-join join-mode)
Sets the style of the joints which connect line
segments. These joints are either mitered, beveled, or rounded and
specified with the corresponding parameters :miter
, :bevel
, and
:round
. The default joint is :miter
.
This function is not available with the :p2d
, :p3d
, or :opengl
renderers.
Sets the style of the joints which connect line segments. These joints are either mitered, beveled, or rounded and specified with the corresponding parameters `:miter`, `:bevel`, and `:round`. The default joint is `:miter`. This function is not available with the `:p2d`, `:p3d`, or `:opengl` renderers.
(stroke-weight weight)
Sets the width of the stroke used for lines, points, and the border around shapes. All widths are set in units of pixels.
Sets the width of the stroke used for lines, points, and the border around shapes. All widths are set in units of pixels.
(tan 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.
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.
(target-frame-rate)
Returns the target framerate specified with the function frame-rate
Returns the target framerate specified with the function [[frame-rate]]
(text s x y)
(text s x y z)
(text s x1 y1 x2 y2)
(text s x y)
(text s x1 y1 x2 y2)
Draws text to the screen in the position specified by the x
and y
parameters (and the optional z
parameter in clj). A default font will be used
unless a font is set with the text-font
function. Change the color of the
text with the fill
function. The text displays in relation to the
text-align
function, which gives the option to draw to the left, right, and
center of the coordinates.
The x1
, y1
, x2
and y2
parameters define a
rectangular area to display within and may only be used with string
data. For text drawn inside a rectangle, the coordinates are
interpreted based on the current rect-mode
setting.
Draws text to the screen in the position specified by the `x` and `y` parameters (and the optional `z` parameter in clj). A default font will be used unless a font is set with the [[text-font]] function. Change the color of the text with the [[fill]] function. The text displays in relation to the [[text-align]] function, which gives the option to draw to the left, right, and center of the coordinates. The `x1`, `y1`, `x2` and `y2` parameters define a rectangular area to display within and may only be used with string data. For text drawn inside a rectangle, the coordinates are interpreted based on the current [[rect-mode]] setting.
(text-align align)
(text-align align-x align-y)
Sets the current alignment for drawing text. Available modes are:
horizontal - :left
, :center
, and :right
vertical - :top
, :bottom
, :center
, and :baseline
An optional second parameter specifies the vertical alignment
mode. :baseline
is the default. The :top
and :center
parameters are
straightforward. The :bottom
parameter offsets the line based on the
current text-descent
. 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 text-ascent
, 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
text-ascent
or text-descent
so that the hack works even if you
change the size of the font.
Sets the current alignment for drawing text. Available modes are: horizontal - `:left`, `:center`, and `:right` vertical - `:top`, `:bottom`, `:center`, and `:baseline` An optional second parameter specifies the vertical alignment mode. `:baseline` is the default. The `:top` and `:center` parameters are straightforward. The `:bottom` parameter offsets the line based on the current [[text-descent]]. 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 [[text-ascent]], 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 [[text-ascent]] or [[text-descent]] so that the hack works even if you change the size of the font.
(text-ascent)
Returns the ascent of the current font at its current size. This
information is useful for determining the height of the font above
the baseline. For example, adding the text-ascent
and text-descent
values will give you the total height of the line.
Returns the ascent of the current font at its current size. This information is useful for determining the height of the font above the baseline. For example, adding the [[text-ascent]] and [[text-descent]] values will give you the total height of the line.
(text-char c x y)
(text-char c x y z)
Draws a char to the screen in the specified position. See the
text
function for more details.
Draws a char to the screen in the specified position. See the [[text]] function for more details.
(text-descent)
Returns descent of the current font at its current size. This
information is useful for determining the height of the font below
the baseline. For example, adding the text-ascent
and text-descent
values will give you the total height of the line.
Returns descent of the current font at its current size. This information is useful for determining the height of the font below the baseline. For example, adding the [[text-ascent]] and [[text-descent]] values will give you the total height of the line.
(text-font font)
(text-font font size)
Sets the current font that will be drawn with the text
function. Fonts must be loaded with load-font
before it can be
used. This font will be used in all subsequent calls to the text
function. If no size
parameter is input, the font will appear at its
original size until it is changed with text-size
.
Because fonts are usually bitmaped, you should create fonts at the
sizes that will be used most commonly. Using text-font
without the
size
parameter will result in the cleanest-looking text.
With the default (JAVA2D) and PDF renderers, it's also possible to
enable the use of native fonts via the command
(hint :enable-native-fonts)
. This will produce vector text in JAVA2D
sketches and PDF output in cases where the vector data is available:
when the font is still installed, or the font is created via the
create-font
function.
Sets the current font that will be drawn with the text function. Fonts must be loaded with [[load-font]] before it can be used. This font will be used in all subsequent calls to the [[text]] function. If no `size` parameter is input, the font will appear at its original size until it is changed with [[text-size]]. Because fonts are usually bitmaped, you should create fonts at the sizes that will be used most commonly. Using [[text-font]] without the `size` parameter will result in the cleanest-looking text. With the default (JAVA2D) and PDF renderers, it's also possible to enable the use of native fonts via the command `(hint :enable-native-fonts)`. This will produce vector text in JAVA2D sketches and PDF output in cases where the vector data is available: when the font is still installed, or the font is created via the [[create-font]] function.
(text-leading 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.
Sets the spacing between lines of text in units of pixels. This setting will be used in all subsequent calls to the [[text]] function.
(text-mode mode)
Sets the way text draws to the screen - available modes
are :model
and :shape
In the default configuration (the :model
mode), it's possible to
rotate, scale, and place letters in two and three dimensional space.
The :shape
mode draws text using the glyph outlines of individual
characters rather than as textures. This mode is only supported with
the PDF and OPENGL renderer settings. With the PDF renderer, you
must specify the :shape
text-mode
before any other drawing occurs.
If the outlines are not available, then :shape
will be ignored and
:model
will be used instead.
The :shape
option in OPENGL mode can be combined with begin-raw
to
write vector-accurate text to 2D and 3D output files, for instance
DXF or PDF. :shape
is not currently optimized for OPENGL, so if
recording shape data, use :model
until you're ready to capture the
geometry with begin-raw
.
Sets the way text draws to the screen - available modes are `:model` and `:shape` In the default configuration (the `:model` mode), it's possible to rotate, scale, and place letters in two and three dimensional space. The `:shape` mode draws text using the glyph outlines of individual characters rather than as textures. This mode is only supported with the PDF and OPENGL renderer settings. With the PDF renderer, you must specify the `:shape` [[text-mode]] before any other drawing occurs. If the outlines are not available, then `:shape` will be ignored and `:model` will be used instead. The `:shape` option in OPENGL mode can be combined with [[begin-raw]] to write vector-accurate text to 2D and 3D output files, for instance DXF or PDF. `:shape` is not currently optimized for OPENGL, so if recording shape data, use `:model` until you're ready to capture the geometry with [[begin-raw]].
(text-num num x y)
(text-num num x y z)
Draws a number to the screen in the specified position. See the
text
function for more details.
Draws a number to the screen in the specified position. See the [[text]] function for more details.
(text-size 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.
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.
(text-style style)
Sets/gets the style of the text for system fonts to :normal
, :italic
,
or :bold
. Note: this may be is overridden by CSS styling. For
non-system fonts (opentype, truetype, etc.) please load styled fonts
instead.
Sets/gets the style of the text for system fonts to `:normal`, `:italic`, or `:bold`. Note: this may be is overridden by CSS styling. For non-system fonts (opentype, truetype, etc.) please load styled fonts instead.
(text-width data)
Calculates and returns the width of any text string.
Calculates and returns the width of any text string.
(texture img)
Sets a texture to be applied to vertex points. The texture
function must
be called between begin-shape
and end-shape
and before any calls to
vertex
.
When textures are in use, the fill color is ignored. Instead, use
tint
to specify the color of the texture as it is applied to the
shape.
Sets a texture to be applied to vertex points. The [[texture]] function must be called between [[begin-shape]] and [[end-shape]] and before any calls to [[vertex]]. When textures are in use, the fill color is ignored. Instead, use [[tint]] to specify the color of the texture as it is applied to the shape.
(texture-mode mode)
Sets the coordinate space for texture mapping. There are two
options, :image
and :normal
.
:image
refers to the actual coordinates of the image and :normal
refers to a normalized space of values ranging from 0 to 1. The
default mode
is :image
. In :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) (0,100) (100,200) (0,200)
. The same mapping in
NORMAL_SPACE is (0,0) (0,1) (1,1) (0,1)
.
Sets the coordinate space for texture mapping. There are two options, `:image` and `:normal`. `:image` refers to the actual coordinates of the image and `:normal` refers to a normalized space of values ranging from 0 to 1. The default `mode` is `:image`. In `: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) (0,100) (100,200) (0,200)`. The same mapping in NORMAL_SPACE is `(0,0) (0,1) (1,1) (0,1)`.
(texture-wrap mode)
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.
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.
(tint gray)
(tint gray alpha)
(tint r g b)
(tint r g b a)
Sets the fill value for displaying images. Images can be tinted to
specified colors or made transparent by setting the alpha
.
To make an image transparent, but not change it's color, use white
as the tint color and specify an alpha
value. For instance,
(tint 255 128)
will make an image 50% transparent (unless
color-mode
has been used).
The value for the parameter gray must be less than or equal to the
current maximum value as specified by color-mode
. The default
maximum value is 255.
Also used to control the coloring of textures in 3D.
Sets the fill value for displaying images. Images can be tinted to specified colors or made transparent by setting the `alpha`. To make an image transparent, but not change it's color, use white as the tint color and specify an `alpha` value. For instance, `(tint 255 128)` will make an image 50% transparent (unless [[color-mode]] has been used). The value for the parameter gray must be less than or equal to the current maximum value as specified by [[color-mode]]. The default maximum value is 255. Also used to control the coloring of textures in 3D.
(torus radius tube-radius)
(torus radius tube-radius detail-x)
(torus radius tube-radius detail-x detail-y)
Draw a torus with given radius
and tube-radius
.
Optional parameters:
detail-x
- number of segments, the more segments the smoother geometry default is 24detail-y
- number of segments, the more segments the smoother geometry default is 16Draw a torus with given `radius` and `tube-radius`. Optional parameters: * `detail-x` - number of segments, the more segments the smoother geometry default is 24 * `detail-y` - number of segments, the more segments the smoother geometry default is 16
(translate v)
(translate tx ty)
(translate tx ty tz)
Specifies an amount to displace objects within the display
window. The tx
parameter specifies left/right translation, the ty
parameter specifies up/down translation, and the tz
parameter
specifies translations toward/away from the screen. Transformations
apply to everything that happens after and subsequent calls to the
function accumulates the effect. For example, calling (translate 50 0)
and then (translate 20, 0)
is the same as (translate 70, 0)
. If
translate
is called within draw, the transformation is reset when
the loop begins again. This function can be further controlled by
the push-matrix
and pop-matrix
functions.
Specifies an amount to displace objects within the display window. The `tx` parameter specifies left/right translation, the `ty` parameter specifies up/down translation, and the `tz` parameter specifies translations toward/away from the screen. Transformations apply to everything that happens after and subsequent calls to the function accumulates the effect. For example, calling `(translate 50 0)` and then `(translate 20, 0)` is the same as `(translate 70, 0)`. If [[translate]] is called within draw, the transformation is reset when the loop begins again. This function can be further controlled by the [[push-matrix]] and [[pop-matrix]] functions.
(triangle x1 y1 x2 y2 x3 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.
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.
(unbinary str-val)
Unpack a binary string to an integer. See binary
for converting
integers to strings.
Unpack a binary string to an integer. See [[binary]] for converting integers to strings.
(unhex hex-str)
Converts a String representation of a hexadecimal number to its equivalent integer value.
Converts a String representation of a hexadecimal number to its equivalent integer value.
(update-pixels)
(update-pixels img)
Updates the display window or image with the data in the pixels array.
Use in conjunction with pixels
. If you're only reading pixels from
the array, there's no need to call update-pixels
unless there are
changes.
Certain renderers may or may not seem to require pixels
or
update-pixels
. However, the rule is that any time you want to
manipulate the pixels
array, you must first call pixels
, and
after changes have been made, call update-pixels
. Even if the
renderer may not seem to use this function in the current Processing
release, this will always be subject to change.
Updates the display window or image with the data in the pixels array. Use in conjunction with [[pixels]]. If you're only reading pixels from the array, there's no need to call [[update-pixels]] unless there are changes. Certain renderers may or may not seem to require [[pixels]] or [[update-pixels]]. However, the rule is that any time you want to manipulate the `pixels` array, you must first call [[pixels]], and after changes have been made, call [[update-pixels]]. Even if the renderer may not seem to use this function in the current Processing release, this will always be subject to change.
(vertex x y)
(vertex x y z)
(vertex x y u v)
(vertex x y z u 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 and is used
exclusively within the begin-shape
and end-shape
functions.
Drawing a vertex in 3D using the z
parameter requires the :p3d
or
:opengl
renderers to be used.
This function is also used to map a texture onto the geometry. The
texture
function declares the texture to apply to the geometry and the u
and v
coordinates set define the mapping of this texture to the
form. By default, the coordinates used for u
and v
are specified in
relation to the image's size in pixels, but this relation can be
changed with texture-mode
.
All shapes are constructed by connecting a series of vertices. [[vertex]] is used to specify the vertex coordinates for points, lines, triangles, quads, and polygons and is used exclusively within the [[begin-shape]] and [[end-shape]] functions. Drawing a vertex in 3D using the `z` parameter requires the `:p3d` or `:opengl` renderers to be used. This function is also used to map a texture onto the geometry. The [[texture]] function declares the texture to apply to the geometry and the `u` and `v` coordinates set define the mapping of this texture to the form. By default, the coordinates used for `u` and `v` are specified in relation to the image's size in pixels, but this relation can be changed with [[texture-mode]].
(width)
Width of the display window. The value of width is zero until size is called.
Width of the display window. The value of width is zero until size is called.
(with-fill fill & body)
(with-fill &form &env fill & body)
Temporarily set the fill color for the body of this macro.
The code outside of the with-fill
form will have the previous
fill color set.
A fill argument of nil disables the fill.
Examples:
(with-fill 255 ...)
(with-fill [10 80 98] ...)
(with-fill nil ...)
Temporarily set the fill color for the body of this macro. The code outside of the [[with-fill]] form will have the previous fill color set. A fill argument of nil disables the fill. Examples: ``` (with-fill 255 ...) (with-fill [10 80 98] ...) (with-fill nil ...) ```
(with-graphics graphics & body)
(with-graphics &form &env graphics & body)
All subsequent calls of any drawing function will draw on given
graphics. with-graphics
cannot be nested (you can draw simultaneously
only on 1 graphics)
All subsequent calls of any drawing function will draw on given graphics. [[with-graphics]] cannot be nested (you can draw simultaneously only on 1 graphics)
(with-rotation rotation & body)
(with-rotation &form &env rotation & body)
Performs body with rotation, restores current transformation on exit.
Accepts a vector [angle]
or [angle x y z]
.
When 4 arguments provides it produces a rotation of angle degrees around the vector x y z. Check examples to better understand. This rotation follows the right-hand rule, so if the vector x y z points toward the user, the rotation will be counterclockwise.
Example:
(with-rotation [angle]
(vertex 1 2))
Performs body with rotation, restores current transformation on exit. Accepts a vector `[angle]` or `[angle x y z]`. When 4 arguments provides it produces a rotation of angle degrees around the vector x y z. Check examples to better understand. This rotation follows the right-hand rule, so if the vector x y z points toward the user, the rotation will be counterclockwise. Example: ``` (with-rotation [angle] (vertex 1 2)) ```
(with-sketch applet & body)
(with-sketch &form &env applet & body)
(with-stroke stroke & body)
(with-stroke &form &env stroke & body)
Temporarily set the stroke color for the body of this macro.
The code outside of the with-stroke
form will have the previous
stroke color set.
A stroke argument of nil disables the stroke.
Examples:
(with-stroke 255 ...)
(with-stroke [10 80 98] ...)
(with-stroke nil ...)
Temporarily set the stroke color for the body of this macro. The code outside of the [[with-stroke]] form will have the previous stroke color set. A stroke argument of nil disables the stroke. Examples: ``` (with-stroke 255 ...) (with-stroke [10 80 98] ...) (with-stroke nil ...) ```
(with-translation translation-vector & body)
(with-translation &form &env translation-vector & body)
Performs body with translation, restores current transformation on exit.
Performs body with translation, restores current transformation on exit.
(year)
Returns the current year as an integer (2003, 2004, 2005, etc).
Returns the current year as an integer (2003, 2004, 2005, etc).
cljdoc is a website building & hosting documentation for Clojure/Script libraries
× close