diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 000000000..93c4b27b4
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,2 @@
+github: processing
+custom: https://processingfoundation.org/
diff --git a/.gitignore b/.gitignore
index 367672981..27c953a9e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,4 @@ about/
contrib_generate/contribs.txt # File now built on the server side; don't need to track here
contrib_generate/contributions.txt # File now built on the server side; don't need to track here
*~
+/bin/
diff --git a/README.md b/README.md
index c0183179c..60a674da3 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,14 @@
+> ⚠️ This repository is now deprecated and will be archived soon. If you have any issues or want to submit a pull request, please direct them to the [processing-website](https://github.com/processing/processing-website) repo. Make sure to check the [README](https://github.com/processing/processing-website/blob/main/README.md) for information on how to contribute to the documentation.
+
+
+
Processing Documentation
==========
-This is the official source code for the Processing reference, examples, tutorials, and [processing.org](http://processing.org) web site.
+~~This is the official source code for the Processing reference, examples, tutorials, and [processing.org](http://processing.org) web site.~~
-If you have found an error in the Processing reference, examples, tutorials, or website you can file it here under the ["issues" tab](https://github.com/processing/processing-docs/issues).
+~~If you have found an error in the Processing reference, examples, tutorials, or website you can file it here under the ["issues" tab](https://github.com/processing/processing-docs/issues).~~
-The [processing](https://github.com/processing/processing) repository contains the source code for Processing itself. (Please use that link to file issues regarding the Processing software.)
+~~The [processing](https://github.com/processing/processing) repository contains the source code for Processing itself. (Please use that link to file issues regarding the Processing software.)~~
diff --git a/content/api_en/LIB_io/GPIO_digitalRead.xml b/content/api_en/LIB_io/GPIO_digitalRead.xml
index 2efc9fbb1..4a8c8d36d 100755
--- a/content/api_en/LIB_io/GPIO_digitalRead.xml
+++ b/content/api_en/LIB_io/GPIO_digitalRead.xml
@@ -14,20 +14,21 @@
- The new Sound library for Processing 3 provides a simple way to work with audio. It can play, analyze, and synthesize sound. The library comes with a collection of oscillators for basic wave forms, a variety of noise generators, and effects and filters to alter sound files and other generated sounds. The syntax is minimal to make it easy to patch one sound object into another.
-
- The source code is available on the processing-sound GitHub repository. Please report bugs here. This library is only compatible with Processing 3.0+.
-
-
- I/O
-
- AudioDevice
- SoundFile
- Noise
-
- WhiteNoise
- SinOsc
- Env
+ The new Sound library for Processing 3 provides a simple way to work with audio. It can play, analyze, and synthesize sound. It provides a collection of oscillators for basic wave forms, a variety of noise generators, and effects and filters to play and alter sound files and other generated sounds. The syntax is minimal to make it easy to patch one sound object into another. The library also comes with example sketches covering many use cases to help you get started.
+
+ The source code is available on the processing-sound GitHub repository. Please report bugs here. This library is only compatible with Processing 3.0+.
+
+
+ Configuration
+
+ Sound
+ AudioIn
+ SoundFile
+ Noise
+
+ WhiteNoise
+ SinOsc
+ Env The SVG library makes it possible to write SVG files directly from Processing. These vector graphics files can be scaled to any size and output at very high resolutions. The SVG library can flatten 3D data into a 2D vector file, but to export 3D data, use the DXF library. The source code is available on the Processing GitHub repository. Please report bugs here.
+SVG Export (No Screen Display) SVG Export (With Screen Display) Single Frame from an Animation (With Screen Display) SVG Files from 3D Geometry (With Screen Display) When using beginRaw() and endRaw(), it's possible to write to either a 2D or 3D renderer.
+For instance, beginRaw() with the SVG library will write the geometry as flattened triangles
+and lines. Using createGraphics() to Create an SVG File
+Additional notes for the SVG renderer:
+
+
Sketches written in this mode can be exported to run on Android phones and tablets.
- This mode is documented on the
- Processing for Android page of the Processing Wiki. To add this mode, click on
+ This mode is documented on the
+ Processing for Android page. To add this mode, click on
the mode button in the upper-right corner of the PDE and select "Add Mode..."
- The Export information and
+ The Export information and
Tips page on the Processing Wiki covers the details of exporting Applications from Java mode.
Send and receive data over the Internet through simple clients and servers. Create SVG files. Send data between Processing and external hardware through serial communication (RS-232).
Die eigenständige Programmiersprache Processing basiert auf Java und ähnelt diesem sehr, verbirgt aber gleichzeitig viel von dessen Komplexität. Dadurch ist Processing für den Programmieranfänger ideal geeignet, um sich Konzepte des Programmierens zu erschließen und bewahrt gleichzeitig die Möglichkeit eines späteren Umstiegs. Dennoch ist die Sprache keineswegs nur für triviale Anfängeraufgaben geeignet: speziell im Bereich der graphischen Datenverarbeitung spielt Processing seine Stärken aus. Dieses Buch richtet sich in erster Linie an den Einsteiger, den es an die Bewältigung auch komplexerer Aufgaben heranführt, wobei grundlegende Konzepte der imperativen und der objektorientierten Programmierung vorgestellt werden. Auch notwendige theoretische Hintergründe kommen dabei nicht zu kurz. Ausführlich kommentierter Beispielcode erschließt Konzepte und Sprache. Aber auch der routinierte Programmierer, der sich "nur" eine neue Sprache erschließen will, wird fündig! Aus dem Inhalt: Datentypen — Variablen — Arrays (ein- und mehrdiomensional) — Flusssteuerung — Methoden — Objektorientiertes Programmieren — 2D-Graphik — 3D-Graphik — Dateizugriff — PDF — QuickTimeTM — Arduino®-Mikrocontroller — Alphabetischer Index
+ Matthias Wolf. Die eigenständige Programmiersprache Processing basiert auf Java und ähnelt diesem sehr, verbirgt aber gleichzeitig viel von dessen Komplexität. Dadurch ist Processing für den Programmieranfänger ideal geeignet, um sich Konzepte des Programmierens zu erschließen und bewahrt gleichzeitig die Möglichkeit eines späteren Umstiegs. Dennoch ist die Sprache keineswegs nur für triviale Anfängeraufgaben geeignet: speziell im Bereich der graphischen Datenverarbeitung spielt Processing seine Stärken aus. Dieses Buch richtet sich in erster Linie an den Einsteiger, den es an die Bewältigung auch komplexerer Aufgaben heranführt, wobei grundlegende Konzepte der imperativen und der objektorientierten Programmierung vorgestellt werden. Auch notwendige theoretische Hintergründe kommen dabei nicht zu kurz. Ausführlich kommentierter Beispielcode erschließt Konzepte und Sprache. Aber auch der routinierte Programmierer, der sich "nur" eine neue Sprache erschließen will, wird fündig! Aus dem Inhalt: Datentypen — Variablen — Arrays (ein- und mehrdiomensional) — Flusssteuerung — Methoden — Objektorientiertes Programmieren — 2D-Graphik — 3D-Graphik — Dateizugriff — PDF — QuickTimeTM — Arduino®-Mikrocontroller — Alphabetischer Index
+When no period is specified, a default 1 kHz (1000 Hz) is used.
]]>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
-
-
+Sound
- AudioIn
-
-
- PinkNoise
- BrownNoise
-
- SawOsc
- SqrOsc
- TriOsc
- Pulse
-
- Sound
+
+
+ AudioSample
+
+ PinkNoise
+ BrownNoise
+
+ SawOsc
+ SqrOsc
+ TriOsc
+ Pulse
+
+ SVG Export
+
+ This library can be used with the core Processing function size(), or createGraphics(). See the examples below for different techniques.
+
+This example draws a single frame to a SVG file and quits. (Note that no display window will open; this helps when you're trying to create massive SVG images that are far larger than the screen size.)import processing.svg.*;
+
+void setup() {
+ size(400, 400, SVG, "filename.svg");
+}
+
+void draw() {
+ // Draw something good here
+ line(0, 0, width/2, height);
+
+ // Exit the program
+ println("Finished.");
+ exit();
+}
+
+
+
+
+To draw to the screen while also saving an SVG beginRecord()
+and endRecord() functions. Unlike the PDF renderer, the SVG renderer will only save the final frame of a sequence. This is slower, but is useful when you need to
+see what you're working on as it saves.import processing.svg.*;
+
+void setup() {
+ size(400, 400);
+ noLoop();
+ beginRecord(SVG, "filename.svg");
+}
+
+void draw() {
+ // Draw something good here
+ line(0, 0, width/2, height);
+
+ endRecord();
+}
+
+
+
+It's also possible to save one frame from a program with moving elements.
+Create a boolean variable to turn the SVG recording process on and offimport processing.svg.*;
+
+boolean record;
+
+void setup() {
+ size(400, 400);
+}
+
+void draw() {
+ if (record) {
+ // Note that #### will be replaced with the frame number. Fancy!
+ beginRecord(SVG, "frame-####.svg");
+ }
+
+ // Draw something good here
+ background(255);
+ line(mouseX, mouseY, width/2, height/2);
+
+ if (record) {
+ endRecord();
+ record = false;
+ }
+}
+
+// Use a keypress so thousands of files aren't created
+void mousePressed() {
+ record = true;
+}
+
+
+
+
+To create vectors from 3D data, use the beginRaw() and endRaw() commands.
+These commands will grab the shape data just before it is rendered to the screen.
+At this stage, your entire scene is nothing but a long list of 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.import processing.svg.*;
+
+boolean record;
+
+void setup() {
+ size(500, 500, P3D);
+}
+
+void draw() {
+ if (record) {
+ beginRaw(SVG, "output.svg");
+ }
+
+ // Do all your drawing here
+ background(204);
+ translate(width/2, height/2, -200);
+ rotateZ(0.2);
+ rotateY(mouseX/500.0);
+ box(200);
+
+ if (record) {
+ endRaw();
+ record = false;
+ }
+}
+
+// Hit 'r' to record a single frame
+void keyPressed() {
+ if (key == 'r') {
+ record = true;
+ }
+}
+
+
+
+
+To write a SVG file using only the createGraphics() command, rather than as
+part of a sketch, it's necessary to call dispose() on the PGraphicsSVG object.
+This is the same as calling exit(), but it won't quit the sketch.import processing.svg.*;
+
+PGraphics svg = createGraphics(300, 300, SVG, "output.svg");
+svg.beginDraw();
+svg.background(128, 0, 0);
+svg.line(50, 50, 250, 250);
+svg.dispose();
+svg.endDraw();
+
+
+
+
+
+
+
+
+
Limits each channel of the image to the number of colors specified as the parameter. The parameter can be set to values between 2 and 255, but results are most noticeable in the lower ranges.
BLUR
-Executes a Guassian blur with the level parameter specifying the extent of the blurring. If no parameter is used, the blur is equivalent to Guassian blur of radius 1. Larger values increase the blur.
+Executes a Gaussian blur with the level parameter specifying the extent of the blurring. If no parameter is used, the blur is equivalent to Gaussian blur of radius 1. Larger values increase the blur.
ERODE
Reduces the light areas. No parameter is used.
diff --git a/content/api_en/PImage_loadPixels.xml b/content/api_en/PImage_loadPixels.xml
index 23c5f9730..a9c353f84 100644
--- a/content/api_en/PImage_loadPixels.xml
+++ b/content/api_en/PImage_loadPixels.xml
@@ -34,8 +34,6 @@ void draw() {
-Certain renderers may or may not seem to require loadPixels() or updatePixels(). However, the rule is that any time you want to manipulate the pixels[] array, you must have previously called loadPixels(), and after changes have been made, call updatePixels(). Even if the renderer may not seem to use this function in the current Processing release, this will always be subject to change.
]]>
Before accessing this array, the data must loaded with the loadPixels() method. Failure to do so may result in a NullPointerException. After the array data has been modified, the updatePixels() method must be run to update the content of the display window.
]]>
-Certain renderers may or may not seem to require loadPixels() or updatePixels(). However, the rule is that any time you want to manipulate the pixels[] array, you must first call loadPixels(), and after changes have been made, call updatePixels(). Even if the renderer may not seem to use this function in the current Processing release, this will always be subject to change.
-
-Currently, none of the renderers use the additional parameters to updatePixels(), however this may be implemented in the future.
]]>
+Expands a one-dimensional array by one element and adds data to the new position. The datatype of the element parameter must be the same as the datatype of the array.
When using an array of objects, the data returned from the function must be cast to the object array's data type. For example: SomeClass[] items = (SomeClass[]) append(originalArray, element)
]]>
-
-There are three ways to draw an arc; the rendering technique used is defined by the optional seventh parameter. The three options, depicted in the above examples, are PIE, OPEN, and CHORD. The default mode is the OPEN stroke with a PIE fill.
-
+Draws an arc to the screen. Arcs are drawn along the outer edge of an ellipse defined by the a, b, c, and d parameters. The origin of the arc's ellipse may be changed with the ellipseMode() function. Use the start and stop parameters to specify the angles (in radians) at which to draw the arc. The start/stop values must be in clockwise order.
+
+There are three ways to draw an arc; the rendering technique used is defined by the optional seventh parameter. The three options, depicted in the above examples, are PIE, OPEN, and CHORD. The default mode is the OPEN stroke with a PIE fill.
+
In some cases, the arc() function isn't accurate enough for smooth drawing. For example, the shape may jitter on screen when rotating slowly. If you're having an issue with how arcs are rendered, you'll need to draw the arc yourself with beginShape()/endShape() or a PShape.
]]>
The simplified version with only two arguments — arrayCopy(src, dst) — copies an entire array to another of the same size. It is equivalent to arrayCopy(src, 0, dst, 0, src.length).
-Using this function is far more efficient for copying array data than iterating through a for() loop and copying each element individually. This function only copies references, which means that for most purposes it only copies one-dimensional arrays (a single set of brackets). If used with a two (or three or more) dimensional array, it will only copy the references at the first level, because a two dimensional array is simply an "array of arrays". This does not produce an error, however, because this is often the desired behavior. Internally, this function calls Java's System.arraycopy() method, so most things that apply there are inherited.
+Using this function is far more efficient for copying array data than iterating through a for() loop and copying each element individually. This function only copies references, which means that for most purposes it only copies one-dimensional arrays (a single set of brackets). If used with a two (or three or more) dimensional array, it will only copy the references at the first level, because a two dimensional array is simply an "array of arrays". This does not produce an error, however, because this is often the desired behavior. Internally, this function calls Java's System.arraycopy() method, so most things that apply there are inherited.
]]>
diff --git a/content/api_en/attrib.xml b/content/api_en/attrib.xml
new file mode 100644
index 000000000..3d21bc538
--- /dev/null
+++ b/content/api_en/attrib.xml
@@ -0,0 +1,63 @@
+
+
+
-BLEND - linear interpolation of colours: C = A*factor + B
+BLEND - linear interpolation of colors: 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)
+DARKEST - only the darkest color succeeds: C = min(A*factor, B)
-LIGHTEST - only the lightest colour succeeds: C = max(A*factor, B)
+LIGHTEST - only the lightest color succeeds: C = max(A*factor, B)
DIFFERENCE - subtract colors from underlying image.
diff --git a/content/api_en/blendMode.xml b/content/api_en/blendMode.xml
index 26e3285a2..a3c309cb1 100755
--- a/content/api_en/blendMode.xml
+++ b/content/api_en/blendMode.xml
@@ -35,17 +35,17 @@ line(75, 25, 25, 75);
-BLEND - linear interpolation of colours: C = A*factor + B. This is the default blending mode.
+BLEND - linear interpolation of colors: C = A*factor + B. This is the default.
ADD - additive blending with white clip: C = min(A*factor + B, 255)
SUBTRACT - subtractive blending with black clip: C = max(B - A*factor, 0)
-DARKEST - only the darkest colour succeeds: C = min(A*factor, B)
+DARKEST - only the darkest color succeeds: C = min(A*factor, B)
-LIGHTEST - only the lightest colour succeeds: C = max(A*factor, B)
+LIGHTEST - only the lightest color succeeds: C = max(A*factor, B)
DIFFERENCE - subtract colors from underlying image.
diff --git a/content/api_en/circle.xml b/content/api_en/circle.xml
new file mode 100755
index 000000000..0e1d9adfb
--- /dev/null
+++ b/content/api_en/circle.xml
@@ -0,0 +1,23 @@
+
+
+
+Creates and returns a new PGraphics object. Use this class if you need to draw into an off-screen graphics buffer. The first two parameters define the width and height in pixels. The third, optional parameter specifies the renderer. It can be defined as P2D, P3D, PDF, or SVG. If the third parameter isn't used, the default renderer is set. The PDF and SVG renderers require the filename parameter.
-It's important to consider the renderer used with createGraphics() in relation to the main renderer specified in size(). For example, it's only possible to use P2D or P3D with createGraphics() when one of them is defined in size(). Unlike Processing 1.0, P2D and P3D use OpenGL for drawing, and when using an OpenGL renderer it's necessary for the main drawing surface to be OpenGL-based. If P2D or P3D are used as the renderer in size(), then any of the options can be used with createGraphics(). If the default renderer is used in size(), then only the default or PDF can be used with createGraphics().
+It's important to consider the renderer used with createGraphics() in relation to the main renderer specified in size(). For example, it's only possible to use P2D or P3D with createGraphics() when one of them is defined in size(). Unlike Processing 1.0, P2D and P3D use OpenGL for drawing, and when using an OpenGL renderer it's necessary for the main drawing surface to be OpenGL-based. If P2D or P3D are used as the renderer in size(), then any of the options can be used with createGraphics(). If the default renderer is used in size(), then only the default, PDF, or SVG can be used with createGraphics().
-It's important to call any drawing functions between beginDraw() and endDraw() statements. This is also true for any functions that affect drawing, such as smooth() or colorMode().
+It's important to run all drawing functions between the beginDraw() and endDraw(). As the exception to this rule, smooth() should be run on the PGraphics object before beginDraw(). See the reference for smooth() for more detail.
-The createGraphics() function should almost never be used inside draw() because of the memory and time needed to set up the graphics. One-time or occasional use during draw() are acceptable, but code that calls createGraphics() at 60 frames per second will run out of memory or freeze your sketch.
+The createGraphics() function should almost never be used inside draw() because of the memory and time needed to set up the graphics. One-time or occasional use during draw() might be acceptable, but code that calls createGraphics() at 60 frames per second might run out of memory or freeze your sketch.
Unlike the main drawing surface which is completely opaque, surfaces created with createGraphics() can have transparency. This makes it possible to draw into a graphics and maintain the alpha channel. By using save() to write a PNG or TGA file, the transparency of the graphics object will be honored.
]]>Android Mode
When using an array of objects, the data returned from the function must be cast to the object array's data type. For example: SomeClass[] items = (SomeClass[]) expand(originalArray)
]]>
-
+Reads the color of any pixel or grabs a section of an image. If no parameters are specified, the entire image is returned. Use the x and y parameters to get the value of one pixel. Get a section of the display window by specifying additional w and h parameters. When getting an image, the x and y parameters define the coordinates for the upper-left corner of the image, regardless of the current imageMode().
+
If the pixel requested is outside of the image window, black is returned. The numbers returned are scaled according to the current color ranges, but only RGB values are returned by this function. For example, even though you may have drawn a shape with colorMode(HSB), the numbers returned will be in RGB format.
+If a width and a height are specified, get(x, y, w, h) returns a PImage corresponding to the part of the original PImage where the top left pixel is at the (x, y) position with a width of w a height of h.
+
Getting the color of a single pixel with get(x, y) is easy, but not as fast as grabbing the data directly from pixels[]. The equivalent statement to get(x, y) using pixels[] is pixels[y*width+x]. See the reference for pixels[] for more information.
]]>
-float r1 = green(c); // Simpler, but slower to calculate
-float r2 = c >> 8 & 0xFF; // Very fast to calculate
+float g1 = green(c); // Simpler, but slower to calculate
+float g2 = c >> 8 & 0xFF; // Very fast to calculate
]]>
An ArrayList is a resizable-array implementation of the Java List interface. It has many methods used to control and search its contents. For example, the length of the ArrayList is returned by its size() method, which is an integer value for the total number of elements in the list. An element is added to an ArrayList with the add() method and is deleted with the remove() method. The get() method returns the element at the specified position in the list. (See the above example for context.)
-For a list of the numerous ArrayList features, please read the Java reference description.
+For a list of the numerous ArrayList features, please read the Java reference description.
]]>
-For a list of the numerous HashMap features, please read the Java reference description.
+For a list of the numerous HashMap features, please read the Java reference description.
]]>
@@ -46,11 +43,11 @@ println(quoted); // This one has "quotes"
-To compare the contents of two Strings, use the equals() method, as in if (a.equals(b)), instead of if (a == b). A String is an Object, so comparing them with the == operator only compares whether both Strings are stored in the same memory location. Using the equals() method will ensure that the actual contents are compared. (The troubleshooting reference has a longer explanation.)
+To compare the contents of two Strings, use the equals() method, as in if (a.equals(b)), instead of if (a == b). A String is an Object, so comparing them with the == operator only compares whether both Strings are stored in the same memory location. Using the equals() method will ensure that the actual contents are compared. (The troubleshooting reference has a longer explanation.)
Because a String is defined between double quotation marks, to include such marks within the String itself you must use the \ (backslash) character. (See the third example above.) This is known as an escape sequence. Other escape sequences include \t for the tab character and \n for new line. Because backslash is the escape character, to include a single backslash within a String, you must use two consecutive backslashes, as in: \\
-There are more string methods than those linked from this page. Additional documentation is located online in the official Java documentation.
+There are more string methods than those linked from this page. Additional documentation is located online in the official Java documentation.
]]>
Using print() or println() on a color will produce strange results (usually negative numbers) because of the way colors are stored in memory. A better technique is to use the hex() function to format the color data, or use the red(), green(), and blue() functions to get individual values and print those. The hue(), saturation(), and brightness() functions work in a similar fashion. To extract red, green, and blue values more quickly (for instance when analyzing an image or a frame of video), use bit shifting.
diff --git a/content/api_en/include/doccomment.xml b/content/api_en/include/doccomment.xml
index bb4331414..fa036a032 100755
--- a/content/api_en/include/doccomment.xml
+++ b/content/api_en/include/doccomment.xml
@@ -22,7 +22,9 @@ line(50, 0, 50, 100);
+Doc comments may be converted into browseable documentation using external editors and tools such as the command line javadoc, doc generators such as Doxygen, or IDEs such as Eclipse, Netbeans, or IntelliJ IDEA.
]]>
+
+Note that when comparing String objects, you must use the equals() method instead of ==. See the reference for String or the troubleshooting note for more explanation.
-Note that when comparing String objects, you must use the equals() method instead of == to compare their contents. See the reference for String or the troubleshooting note for more explanation.
]]>
Floats are not precise, so adding small values (such as 0.0001) may not always increment precisely due to rounding errors. If you want to increment a value in small intervals, use an int, and divide by a float value before using it. (See the second example above.)
-Floating-point numbers can be as large as 3.40282347E+38 and as low as -3.40282347E+38. They are stored as 32 bits (4 bytes) of information. The float data type is inherited from Java; you can read more about the technical details here and here.
+Floating-point numbers can be as large as 3.40282347E+38 and as low as -3.40282347E+38. They are stored as 32 bits (4 bytes) of information. The float data type is inherited from Java; you can read more about the technical details here and here.
Processing supports the double datatype from Java as well. However, none of the Processing functions use double values, which use more memory and are typically overkill for most work created in Processing. We do not plan to add support for double values, as doing so would require increasing the number of API functions significantly.
]]>
+
+Converts any value of a primitive data type (boolean, byte, char, color, float, int, or long) or String to its integer representation.
When an array of values is passed in, then an int array of the same length is returned.
]]>
+
+There are more features of PSurface documented in the Processing JavaDoc.
+]]>
+
+There are more features of PSurface documented in the Processing JavaDoc.
+]]>
+
+There are more features of PSurface documented in the Processing JavaDoc.
+]]>
The keys included in the ASCII specification (BACKSPACE, TAB, ENTER, RETURN, ESC, and DELETE) do not require checking to see if the key is coded; for those keys, you should simply use the key variable directly (and not keyCode). If you're making cross-platform projects, note that the ENTER key is commonly used on PCs and Unix, while the RETURN key is used on Macs. Make sure your program will work on all platforms by checking for both ENTER and RETURN.
-For those familiar with Java, the values for UP and DOWN are simply shorter versions of Java's KeyEvent.VK_UP and KeyEvent.VK_DOWN. Other keyCode values can be found in the Java KeyEvent reference.
+For those familiar with Java, the values for UP and DOWN are simply shorter versions of Java's KeyEvent.VK_UP and KeyEvent.VK_DOWN. Other keyCode values can be found in the Java KeyEvent reference.
There are issues with how keyCode behaves across different renderers and operating systems. Watch out for unexpected behavior as you switch renderers and operating systems and you are using keys are aren't mentioned in this reference entry.
+
+If you are using P2D or P3D as your renderer, use the NEWT KeyEvent constants.
]]>
diff --git a/content/api_en/libraries/index.html b/content/api_en/libraries/index.html
index 11cc19e54..e507a7c8b 100644
--- a/content/api_en/libraries/index.html
+++ b/content/api_en/libraries/index.html
@@ -16,7 +16,12 @@ PDF Export
Network
SVG Export
+ Serial
-
-Certain renderers may or may not seem to require loadPixels() or updatePixels(). However, the rule is that any time you want to manipulate the pixels[] array, you must have previously called loadPixels(), and after changes have been made, call updatePixels(). Even if the renderer may not seem to use this function in the current Processing release, this will always be subject to change.
+Loads the pixel data of the current display window into the pixels[] array. This function must always be called before reading from or writing to pixels[]. Subsequent changes to the display window will not be reflected in pixels until loadPixels() is called again.
]]>
If the file contains a header row, include "header" in the options parameter. If the file does not have a header row, then simply omit the "header" option.
-When specifying both a header and the file type as the options parameter, separate the options with commas, as in: loadTable("data.csv", "header, tsv")
+Some CSV files contain newline (CR or LF) characters inside cells. This is rare, but adding the "newlines" option will handle them properly. (This is not enabled by default because the parsing code is much slower.)
+
+When specifying multiple options, separate them with commas, as in: loadTable("data.csv", "header, tsv")
All files loaded and saved by the Processing API use UTF-8 encoding.
]]>
diff --git a/content/api_en/match.xml b/content/api_en/match.xml
index 1db3a9f3a..92d1b2fdf 100755
--- a/content/api_en/match.xml
+++ b/content/api_en/match.xml
@@ -51,7 +51,7 @@ To use the function, first check to see if the result is null. If the result is
If there are groups (specified by sets of parentheses) in the regular expression, then the contents of each will be returned in the array. Element [0] of a regular expression match returns the entire matching string, and the match groups start at element [1] (the first group is [1], the second [2], and so on).
-The syntax can be found in the reference for Java's Pattern class. For regular expression syntax, read the Java Tutorial on the topic.
+The syntax can be found in the reference for Java's Pattern class. For regular expression syntax, read the Java Tutorial on the topic.
]]>
diff --git a/content/api_en/matchAll.xml b/content/api_en/matchAll.xml
index 56feb6b5b..4f0345fbe 100644
--- a/content/api_en/matchAll.xml
+++ b/content/api_en/matchAll.xml
@@ -33,7 +33,7 @@ To use the function, first check to see if the result is null. If the result is
If there are groups (specified by sets of parentheses) in the regular expression, then the contents of each will be returned in the array. Assuming a loop with counter variable i, element [i][0] of a regular expression match returns the entire matching string, and the match groups start at element [i][1] (the first group is [i][1], the second [i][2], and so on).
-The syntax can be found in the reference for Java's Pattern class. For regular expression syntax, read the Java Tutorial on the topic.
+The syntax can be found in the reference for Java's Pattern class. For regular expression syntax, read the Java Tutorial on the topic.
]]>
diff --git a/content/api_en/mouseWheel.xml b/content/api_en/mouseWheel.xml
index 02c01cd7a..0a2344176 100755
--- a/content/api_en/mouseWheel.xml
+++ b/content/api_en/mouseWheel.xml
@@ -26,7 +26,7 @@ void mouseWheel(MouseEvent event) {
Mouse and keyboard events only work when a program has draw(). Without draw(), the code is only run once and then stops listening for events.
]]>
As shown in the above example, nf() is used to add zeros to the left and/or right of a number. This is typically for aligning a list of numbers. To remove digits from a floating-point number, use the int(), ceil(), floor(), or round() functions.
+Utility function for formatting numbers into strings. There are two versions: one for formatting floats, and one for formatting ints. The values for the digits and right parameters should always be positive integers. The left parameter should be positive or 0. If it is zero, only the right side is formatted.
As shown in the above example, nf() is used to add zeros to the left and/or right of a number. This is typically for aligning a list of numbers. To remove digits from a floating-point number, use the int(), ceil(), floor(), or round() functions.
]]>
+When the pixel density is set to more than 1, it changes all of the pixel operations including the way get(), set(), blend(), copy(), and updatePixels() all work. See the reference for pixelWidth and pixelHeight for more information.
+
To use variables as the arguments to pixelDensity() function, place the pixelDensity() function within the settings() function. There is more information about this on the settings() reference page.
-
]]>
+
+
+The pixels[] array contains the values for all the pixels in the display window. These values are of the color datatype. This array is defined by the size of the display window. For example, if the window is 100 x 100 pixels, there will be 10,000 values and if the window is 200 x 300 pixels, there will be 60,000 values. When the pixel density is set to higher than 1 with the pixelDensity() function, these values will change. See the reference for pixelWidth or pixelHeight for more information.
+
Before accessing this array, the data must loaded with the loadPixels() function. Failure to do so may result in a NullPointerException. Subsequent changes to the display window will not be reflected in pixels until loadPixels() is called again. After pixels has been modified, the updatePixels() function must be run to update the content of the display window.
]]>
Use stroke() to set the color of a point().
+
+Point appears round with the default strokeCap(ROUND) and square with strokeCap(PROJECT). Points are invisible with strokeCap(SQUARE) (no cap).
+
+Using point() with strokeWeight(1) or smaller may draw nothing to the screen, depending on the graphics settings of the computer. Workarounds include setting the pixel using set() or drawing the point using either circle() or square().
]]>
diff --git a/content/api_en/pop.xml b/content/api_en/pop.xml
new file mode 100644
index 000000000..743748933
--- /dev/null
+++ b/content/api_en/pop.xml
@@ -0,0 +1,51 @@
+
+
+
+
+
+push() stores information related to the current transformation state and style settings controlled by the following functions: rotate(), translate(), scale(), fill(), stroke(), tint(), strokeWeight(), strokeCap(), strokeJoin(), imageMode(), rectMode(), ellipseMode(), colorMode(), textAlign(), textFont(), textMode(), textSize(), textLeading().
+
+The push() and pop() functions were added with Processing 3.5. They can be used in place of pushMatrix(), popMatrix(), pushStyles(), and popStyles(). The difference is that push() and pop() control both the transformations (rotate, scale, translate) and the drawing styles at the same time.
+]]>
+
+
diff --git a/content/api_en/push.xml b/content/api_en/push.xml
new file mode 100644
index 000000000..e926650fb
--- /dev/null
+++ b/content/api_en/push.xml
@@ -0,0 +1,51 @@
+
+
+
+
+
+push() stores information related to the current transformation state and style settings controlled by the following functions: rotate(), translate(), scale(), fill(), stroke(), tint(), strokeWeight(), strokeCap(), strokeJoin(), imageMode(), rectMode(), ellipseMode(), colorMode(), textAlign(), textFont(), textMode(), textSize(), textLeading().
+
+The push() and pop() functions were added with Processing 3.5. They can be used in place of pushMatrix(), popMatrix(), pushStyles(), and popStyles(). The difference is that push() and pop() control both the transformations (rotate, scale, translate) and the drawing styles at the same time.
+]]>
When using an array of objects, the data returned from the function must be cast to the object array's data type. For example: SomeClass[] items = (SomeClass[]) shorten(originalArray)
]]>
+Defines the dimension of the display window width and height in units of pixels. In a program that has the setup() function, the size() function must be the first line of code inside setup(), and the setup() function must appear in the code tab with the same name as your sketch folder.
The built-in variables width and height are set by the parameters passed to this function. For example, running size(640, 480) will assign 640 to the width variable and 480 to the height variable. If size() is not used, the window will be given a default size of 100 x 100 pixels.
@@ -73,6 +73,8 @@ The renderer parameter selects which rendering engine to use. For example
PDF: The PDF renderer draws 2D graphics directly to an Acrobat PDF file. This produces excellent results when you need vector shapes for high-resolution output or printing. You must first use Import Library → PDF to make use of the library. More information can be found in the PDF library reference.
+SVG: The SVG renderer draws 2D graphics directly to an SVG file. This is great for importing into other vector programs or using for digital fabrication. You must first use Import Library → SVG Export to make use of the library.
+
As of Processing 3.0, to use variables as the parameters to size() function, place the size() function within the settings() function (instead of setup()). There is more information about this on the settings() reference page.
]]>
+
-
-With the P2D and P3D renderers, smooth(2) is the default, this is called "2x anti-aliasing." The code smooth(4) is used for 4x anti-aliasing and smooth(8) is specified for 8x anti-aliasing. The maximum anti-aliasing level is determined by the hardware of the machine that is running the software, so smooth(4) and smooth(8) will not work with every computer.
-
-The default renderer uses smooth(3) by default. This is bicubic smoothing. The other option for the default renderer is smooth(2), which is bilinear smoothing.
-
+Draws all geometry with smooth (anti-aliased) edges. This behavior is the default, so smooth() only needs to be used when a program needs to set the smoothing in a different way. The level parameter increases the amount of smoothness. This is the level of over sampling applied to the graphics buffer.
+
+With the P2D and P3D renderers, smooth(2) is the default, this is called "2x anti-aliasing." The code smooth(4) is used for 4x anti-aliasing and smooth(8) is specified for "8x anti-aliasing." The maximum anti-aliasing level is determined by the hardware of the machine that is running the software, so smooth(4) and smooth(8) will not work with every computer.
+
+The default renderer uses smooth(3) by default. This is bicubic smoothing. The other option for the default renderer is smooth(2), which is bilinear smoothing.
+
With Processing 3.0, smooth() is different than before. It was common to use smooth() and noSmooth() to turn on and off antialiasing within a sketch. Now, because of how the software has changed, smooth() can only be set once within a sketch. It can be used either at the top of a sketch without a setup(), or after the size() function when used in a sketch with setup(). The noSmooth() function also follows the same rules.
+
+When smooth() is used with a PGraphics object, it should be run right after the object is created with createGraphics(), as shown in the Reference in the third example.
]]>
+
+
+]]>
+To make point() appear square, use strokeCap(PROJECT). Using strokeCap(SQUARE) (no cap) causes points to become invisible.
]]>
+Using point() with strokeWeight(1) or smaller may draw nothing to the screen, depending on the graphics settings of the computer. Workarounds include setting the pixel using set() or drawing the point using either circle() or square().
]]>
diff --git a/content/api_en/textAscent.xml b/content/api_en/textAscent.xml
index e028c6a16..47de3d52f 100755
--- a/content/api_en/textAscent.xml
+++ b/content/api_en/textAscent.xml
@@ -27,7 +27,7 @@ text("dp", 40, base); // Draw text on baseline
-Certain renderers may or may not seem to require loadPixels() or updatePixels(). However, the rule is that any time you want to manipulate the pixels[] array, you must first call loadPixels(), and after changes have been made, call updatePixels(). Even if the renderer may not seem to use this function in the current Processing release, this will always be subject to change.
-
-Currently, while none of the renderers use the additional parameters to updatePixels(), this may be implemented in the future.
]]>Books. Processing books cove
-
@@ -38,7 +37,7 @@
@@ -12,13 +11,13 @@ 
Books. Processing books cove
Processing: A Programming Handbook for Visual Designers,
Second Edition
Casey Reas and Ben Fry.
Published December 2014, The MIT Press. 720 pages. Hardcover.
- » Order from MIT Press
+ » Order from MIT Press
» Order from Amazon
The second edition of the Handbook has been thoroughly updated, influenced by the seven years of Processing being taught in classrooms, computer labs, and studios since the first edition. Every chapter has been revised, and added chapters introduce new ways to work with data and geometry. New “synthesis” chapters offer discussion and worked examples of such topics as sketching with code, modularity, and algorithms. Interviews have been added that cover a wider range of projects and history. “Extension” chapters are now offered online so they can be updated to keep pace with technological developments in such fields as computer vision and electronics.
- If you are an educator, you can request a desk/exam copy from the MIT Press website.
+ If you are an educator, you can request a desk/exam copy from the MIT Press website.
Books. Processing books cove
» Order Print/EBook from O'Reilly
» Order from Amazon.com
- This casual book is a concise introduction to Processing and interactive computer graphics. Written by the founders of Processing, it takes you through the learning process one step at a time to help you grasp core programming concepts. You'll learn how to sketch with code -- creating a program with a few lines of code, observing the result, and then adding to it. It was written to help reader:
+ This casual book is a concise introduction to Processing and interactive computer graphics. Written by the founders of Processing, it takes you through the learning process one step at a time to help you grasp core programming concepts. You'll learn how to sketch with code -- creating a program with a few lines of code, observing the result, and then adding to it. It was written to help readers:
Books. Processing books cove
If you are an educator, you can request a desk/exam copy from the Elsevier website.
-
+
@@ -120,9 +119,61 @@ Books. Processing books cove
How can we capture the unpredictable evolutionary and emergent properties of nature in software? How can understanding the mathematical principles behind our physical world help us to create digital worlds? This book focuses on a range of programming strategies and techniques behind computer simulations of natural systems, from elementary concepts in mathematics and physics to more advanced algorithms that enable sophisticated visual results. Readers will progress from building a basic physics engine to creating intelligent moving objects and complex systems, setting the foundation for further experiments in generative design. Subjects covered include forces, trigonometry, fractals, cellular automata, self-organization, and genetic algorithms.
-
+
+
+
+
+
+
+
+
+ 
Coding Art: The Four Steps to Creative Programming with the Processing Language
+
+ Yu Zhang, Mathias Funk.
+ Published January 2021, Apress. 280 pages. Paperback.
+ » Order from Apress
+ » Order from Amazon
+
+
+ The authors write, "Finally, a book on creative programming, written directly for artists and designers! Rather than following a computer science curriculum, this book is aimed at creatives who are working in the intersection of design, art, and education. In this book you'll learn to apply computation into the creative process by following a four-step process, and through this, land in the cross section of coding and art, with a focus on practical examples and relevant work structures. You'll follow a real-world use case of computation art and see how it relates back to the four key pillars, and addresses potential pitfalls and challenges in the creative process. All code examples are presented in a fully integrated Processing example library, making it easy for readers to get started."
+
+
+
+
+
+
+
+
+
+ 
Pro Processing for Images and Computer Vision with OpenCV
+
+ Bryan WC Chung.
+ Published 2017, APress. Paperback, eBook.
+ » Order from APress
+
+ The Publisher writes, "Pro Processing for Images and Computer Vision with OpenCV is a step-by-step training tool that guides you through a series of worked examples in linear order. Each chapter begins with a basic demonstration, including the code to recreate it on your own system. Then comes a creative challenge by which to engage and develop mastery of the chapter’s topic. The book also includes hints and tips relating to visual arts, interaction design, and industrial best practices. This book is intended for any developer of artistic and otherwise visual applications, such as in augmented reality and digital effects, with a need to manipulate images, and to recognize and manipulate objects within those images. The book is specifically targeted at those making use of the Processing language that is common in artistic fields, and to Java programmers because of Processing’s easy integration into the Java programming environment."
+
+
+
+
+
+
+
+
+
+ 
Programming 101: The How and Why of Programming Revealed Using the Processing Programming Language
+
+ Jeanine Meyer.
+ Published 2018, APress. Paperback, eBook.
+ » Order from Apress
+
+ The Publisher writes, "Understand the importance of programming, even if you’ve never programmed before! This book will teach you the basics of programming using the Processing programming language. You will create your own Processing sketches, using personal images, themes, or hobbies that you enjoy. The chapters in the book will demonstrate the process of programming, starting with formulating an idea, planning, building on past projects, and refining the work, similar to writing an essay or composing a song. This approach will guide you to make use of logic and mathematics to produce beautiful effects. The term for program in Processing is sketch, though the sketches featured in this book are far more than static drawings; they incorporate interaction, animation, video, audio, and accessing files on the local computer and on the Web. Technical features are introduced and explained in the context of complete examples: games (Snake, Hangman, jigsaw, slingshot), making a collage of family images and video clips, preparing directions for folding an origami model, rotating objects in 3D, and others."
+
@@ -139,10 +190,9 @@ Books. Processing books cove
The O'Reilly website says, "How you can take advantage of data that you might otherwise never use? With the help of a powerful new programming environment [Processing], this book helps you represent data accurately on the Web and elsewhere, complete with user interaction, animation, and more. You'll learn basic visualization principles, how to choose the right kind of display for your purposes, and how to provide interactive features to design entire interfaces around large, complex data sets."
Martin Wattenberg from the IBM Watson Research Center says, "This wonderfully detailed guide, by one of the masters of modern data graphics, tells you everything you need to know to code your own visualizations from scratch. Perhaps most valuable are the many examples where Fry demonstrates how to refine a bare-bones concept into a beautiful, effective finished piece. Read this book, and you'll never again be dependent on someone else's view of your data."
-
+
-
@@ -154,14 +204,14 @@ Books. Processing books cove
Generative Design
+
Hartmut Bohnacker, Benedikt Gross, Julia Laub, and Claudius Lazzeroni.
August 2012, Princeton Architectural Press. 472 pages.
- Originally published in German November 2009, Schmidt Hermann Verlag. 500 pages.
+ Originally published in German November 2009, Schmidt Hermann Verlag. 500 pages.
» Order from Amazon.com
This book is extraordinary; the design is clear and the production quality is fantastic. This is the design book about Processing that we've hoped for. Unlike most other Processing books, it doesn't discuss programming basics so it's free to start with exciting examples. The publisher promotes, "Generative design is a revolutionary new method of creating artwork, models, and animations from sets of rules, or algorithms. By using accessible programming languages such as Processing, artists and designers are producing extravagant, crystalline structures that can form the basis of anything from patterned textiles and typography to lighting, scientific diagrams, sculptures, films, and even fantastical buildings. Opening with a gallery of thirty-five illustrated case studies, Generative Design takes users through specific, practical instructions on how to create their own visual experiments by combining simple-to-use programming codes with basic design principles. A detailed handbook of advanced strategies provides visual artists with all the tools to achieve proficiency. Both a how-to manual and a showcase for recent work in this exciting new field, Generative Design is the definitive study and reference book that designers have been waiting for."
More information about buying this book in German, as well as the complete source code for the examples, are at the book's website.
-
@@ -187,7 +237,7 @@
Books. Processing books cove
@@ -197,14 +247,14 @@
+
Books. Processing books cove
+ alt="Processing: An Introduction to Programming"/>

Processing: An Introduction to Programming
+
Jeffrey L. Nyhoff, Larry R. Nyhoff.
Published May 2017, CRC Press. 544 pages. eBook, Paperback.
» Order from CRC Press
» Order from Amazon.com
-
+
The publisher writes, "The book uses Processing’s capabilities for graphics and interactivity in order to create examples that are simple, illustrative, interesting, and fun. It is designed to appeal to a broad range of readers, including those who want to learn to program to create digital art, as well as those who seek to learn to program to process numerical information or data. It can be used by students and instructors in a first course on programming, as well as by anyone eager to teach them self to program."
The publisher lists:
@@ -215,7 +265,7 @@ Books. Processing books cove
@@ -261,13 +311,11 @@
-
Books. Processing books cove
This book has a different perspective from the others because of Glassner's deep experience in computer graphics. His bio reads, "Dr. Andrew Glassner is a writer-director, and a consultant in story structure, interactive fiction, and computer graphics. He started working in 3D computer graphics in 1978, and has carried out research at the NYIT Computer Graphics Lab, Case Western Reserve University, the IBM TJ Watson Research Lab, the Delft University of Technology, Bell Communications Research, Xerox PARC, and Microsoft Research... He is also a well-known writer, and has published numerous technical papers and books on topics ranging from 3D modeling, rendering, and animation to digital sound synthesis. His book '3D Computer Graphics: A Handbook for Artists and Designers' has taught a generation of artists through two editions and three languages. Glassner created and edited the 'Graphics Gems' series and created and wrote several chapters in the book 'An Introduction to Ray Tracing'. He wrote the two-volume text 'Principles of Digital Image Synthesis'."
-
- 
Processing: Creative Coding and Computational Art (Foundation)
@@ -279,11 +327,10 @@ Books. Processing books cove
The Friends of Ed website says, "This book is written especially for artists, designers, and other creative professionals and students exploring code art, graphics programming, and computational aesthetics. The book provides a solid and comprehensive foundation in programming, including object-oriented principles, and introduces you to the easy-to-grasp Processing language, so no previous coding experience is necessary. The book then goes through using Processing to code lines, curves, shapes, and motion, continuing to the point where you'll have mastered Processing and can really start to unleash your creativity with realistic physics, interactivity, and 3D! In the final chapter, you'll even learn how to extend your Processing skills by working directly with the powerful Java programming language, the language Processing itself is built with." (Quote from the Friends of Ed website)
-
+
-
-
-
+ The O'Reilly website says, "Make cool stuff. If you're a designer or artist without a lot of programming experience, this book will teach you to work with 2D and 3D graphics, sound, physical interaction, and electronic circuitry to create all sorts of interesting and compelling experiences -- online and off. Programming Interactivity explains programming and electrical engineering basics, and introduces three freely available tools created specifically for artists and designers: Processing, Arduino, and OpenFrameworks."
+
+
+
- 
Programming Interactivity
+ Programming Interactivity
-
Joshua Noble.
Published January 2012, O'Reilly. 728 pages. Paperback.
» Order from Amazon.com
- The O'Reilly website says, "Make cool stuff. If you're a designer or artist without a lot of programming experience, this book will teach you to work with 2D and 3D graphics, sound, physical interaction, and electronic circuitry to create all sorts of interesting and compelling experiences -- online and off. Programming Interactivity explains programming and electrical engineering basics, and introduces three freely available tools created specifically for artists and designers: Processing, Arduino, and OpenFrameworks."
-
@@ -348,7 +394,6 @@ Books. Processing books cove
-
-
@@ -369,15 +414,12 @@ Books. Processing books cove
The Wiley website says, "this book offers a series of generic procedures that can function as building blocks and encourages you to then use those building blocks to experiment, explore, and channel your thoughts, ideas, and principles into potential solutions. The book covers such topics as structured shapes, solid geometry, networking and databases, physical computing, image processing, graphic user interfaces, and more."
-
-
-
-
@@ -387,20 +429,16 @@ Books. Processing books cove
Andrew Richardson.
Published January 2016, Bloomsbury. 224 Pages. Paperback.
» Order from Amazon.com
-
+
The book description reads, "Data-driven Graphic Design introduces the creative potential of computational data and how it can be used to inform and create everything from typography, print and moving graphics to interactive design and physical installations. Using code as a creative environment allows designers to step outside the boundaries of commercial software tools, and create a set of unique, digitally informed pieces of work. The use of code offers a new way of thinking about and creating design for the digital environment."
+
-
+
@@ -446,7 +484,7 @@ Books. Processing books cove
-
+
@@ -533,20 +571,40 @@ Books. Processing books cove
-
+
+
+
+
+
+ 
O Código Transcendente: Uma Introdução Prática à Programação e Arte Gerativa
+
+ Mateus Berruezo.
+ Published December 2019. 270 pages. PDF, Web.
+ Text in Portuguese.
+ » Download
+ » Read online
+
+
+ Este livro é um guia de programação com enfoque prático considerando o contexto da arte gerativa e do pensamento computacional. Ele conta com explicações e exemplos visuais cuidadosamente projetados para serem de valor tanto para programadores quanto artistas. As aplicações e estudos de caso foram direcionados para a linguagem Processing cuja própria filosofia segue o princípio da exploração do artístico através do código.
+
+
+
+
+
@@ -564,7 +622,7 @@ 
Einführung ins Programmieren mit Processing
- Matthias Wolf.
- Published August 2013. 178 pages. PDF, Paperback.
- Text in German.
- » Order Print/EBook from lulu.com
-
-
+ Published August 2013. 178 pages. PDF, Paperback.
+ Text in German.
+ » Order Print/EBook from lulu.com
+
+ Books. Processing books cove
Text in German.
The OReilly.de site writes, "Processing ist eine auf Grafik, Simulation und Animation spezialisierte objektorientierte Programmiersprache, die besonders für Menschen mit wenig Programmiererfahrung geeignet ist. Deshalb eignet sie sich vor allem für Künstler, Bastler und Programmiereinsteiger. Die aus Java abgeleitete Sprache wurde geschaffen, um schnell und effektiv mit relativ wenig Aufwand zu beeindruckenden Ergebnissen zu kommen. Processing führt den Leser zügig in die Programmieressentials ein und geht dann unmittelbar zur Programmierung grafisch anspruchsvoller Anwendungen über. Spielerisch wird dem Leser die 2D- und 3D-Programierung, Textrendering, die Bildbearbeitung und sogar die Videomanipulation nahe gebracht."
-
+
@@ -636,7 +694,8 @@ Books. Processing books cove
During the 50‘s ”era of cybernetics“, computer entered into the history of art simultaneously in different parts of the world. Art and science were in great turmoil. Science, with its theories and experiments, was approaching artificially mimicking both natural phenomena, such as light and sound, and the human phenomena of language and communication. Art, with its aesthetic and exhibitions, had transcended the boundaries of the avant-garde. Now, with the computer, it was confronting a reality that challenged ”the where“ and ”the how“ of doing art and the very meaning of ”masterpiece“. Antonio Rollo takes us on a tour of these seminal works from his unique perspective of the artist, through the code!
- There's additional information on the publisher's website.
+ There's additional information on the publisher's website.
+
@@ -656,7 +715,8 @@ Books. Processing books cove
Note from Casey: "I received a copy of this book from the authors on a recent trip to Japan. It's a beautifully produced full-color book with sections introducing Processing, featuring work created with Processing (many are from the Exhibition section of the Processing website), and introducing programming through progressively complicated examples. The majority of the book is an introduction to programming. There are many good examples and the code is color-coded like in the Processing Environment. This book is less comprehensive than the Greenberg and Reas/Fry books, but it appears to be a good, brief introduction."
- There's additional information on the publisher's website.
+ There's additional information on the publisher's website.
+
@@ -686,49 +746,5 @@ Books. Processing books cove
-
-
-
-
-
-
-
-
-
- Processing is also discussed through examples and projects in the following books:
-
-
-
-
-
-
- 10 PRINT CHR$(205.5+RND(1)); : GOTO 10
By Nick Montfort, Patsy Baudoin, John Bell, Ian Bogost, Jeremy Douglass, Mark C. Marino, Michael Mateas, Casey Reas, Mark Sample, Noah Vawter. Examples use Processing to explore a modern interpretation of a 1982 Commodore 64 program.
-
-
-
- Make: Getting Started with Arduino
By Massimo Banzi. Examples use Processing to communicate with an Arduino board.
-
-
-
- Building Wireless Sensor Networks: with ZigBee, XBee, Arduino, and Processing
By Robert Faludi. Network examples use Processing.
-
-
-
- Physical Computing: Sensing and Controlling the Physical World with Computers
- By Dan O'Sullivan and Tom Igoe. Examples using Processing for RS-232 communication and
- computer vision.
-
-
-
- Aesthetic Computing.
- Edited by Paul Fishwick. Casey Reas and Ben Fry contributed a chapter entitled
- "Processing Code: Programming within the Context of Visual Art and Design."
-
-
-
- Hacking Roomba: ExtremeTech
By Tod E. Kurt. Processing is introduced and used to design an application to control a Roomba (a robot vacuum cleaner).
-
-
- Analog In, Digital Out
By Brendan Dawes. Numerous projects created with Processing are illustrated and discussed.
Earlier releases have been removed because we can only support the current versions of the software. To update old code, read the changes page. Changes for each release can be found in revisions.txt. If you have problems with the current release, please file a bug so that we can fix it. Older releases can also be built from the source. Read More about the releases and their numbering. To use Android Mode, Processing 3 or later is required.
@@ -202,170 +270,65 @@The revisions cover incremental changes between releases, and are especially important to read for pre-releases.
+The changes document covers incremental updates between 4.x releases, and is especially important to read for pre-releases.
@@ -28,7 +28,7 @@
- Interviews with SUE.C, Larry Cuba, Mark Hansen, Lynn Hershman Leeson, Jürg Lehni, LettError, Golan Levin and Zachary Lieberman, Benjamin Maus, Manfred Mohr, Ash Nehru, Josh On, Bob Sabiston, Jennifer Steinkamp, Jared Tarbell, Steph Thirion, and Robert Winter. + Interviews with SUE.C, Larry Cuba, Mark Hansen, Lynn Hershman Leeson, Jürg Lehni, LettError, Golan Levin and Zachary Lieberman, Benjamin Maus, Manfred Mohr, Ash Nehru, Josh On, Bob Sabiston, Jennifer Steinkamp, Jared Tarbell, Steph Thirion, and Robert Winter.
diff --git a/content/static/overview.html b/content/static/overview.html index 13349191d..d5d3d30ff 100644 --- a/content/static/overview.html +++ b/content/static/overview.html @@ -6,14 +6,11 @@- For the past fourteen years, Processing has promoted software literacy, particularly within the visual arts, and visual literacy within technology. Initially created to serve as a software sketchbook and to teach programming fundamentals within a visual context, Processing has also evolved into a development tool for professionals. The Processing software is free and open source, and runs on the Mac, Windows, and GNU/Linux platforms. - -
- Processing continues to be an alternative to proprietary software tools with restrictive and expensive licenses, making it accessible to schools and individual students. Its open source status encourages the community participation and collaboration that is vital to Processing’s growth. Contributors share programs, contribute code, and build libraries, tools, and modes to extend the possibilities of the software. The Processing community has written more than a hundred libraries to facilitate computer vision, data visualization, music composition, networking, 3D file exporting, and programming electronics. + For the past sixteen years, Processing has promoted software literacy, particularly within the visual arts, and visual literacy within technology. Initially created to serve as a software sketchbook and to teach programming fundamentals within a visual context, Processing has also evolved into a development tool for professionals. The Processing software is free and open source, and runs on the Mac, Windows, and GNU/Linux platforms.
- Processing is currently developed primarily in Boston (at Fathom Information Design), Los Angeles (at the UCLA Arts Software Studio), and New York City (at NYU’s ITP). + Processing continues to be an alternative to proprietary software tools with restrictive and expensive licenses, making it accessible to schools and individual students. Its open source status encourages the community participation and collaboration that is vital to Processing’s growth. Contributors share programs, contribute code, and build libraries, tools, and modes to extend the possibilities of the software. The Processing community has written more than a hundred libraries to facilitate computer vision, data visualization, music composition, networking, 3D file exporting, and programming electronics.
- The innovations in teaching through Processing have been adapted for the Khan Academy computer science tutorials, offered online for free. The tutorials begin with drawing, using most of the Processing functions for drawing. The Processing approach has also been applied to electronics through the Arduino and Wiring projects. Arduino uses a syntax inspired by that used with Processing, and continues to use a modified version of the Processing programming environment to make it easier for students to learn how to program robots and countless other electronics projects. + The innovations in teaching through Processing have been adapted for the Khan Academy computer science tutorials, offered online for free. The tutorials begin with drawing, using most of the Processing functions for drawing. The Processing approach has also been applied to electronics through the Arduino and Wiring projects. Arduino uses a syntax inspired by that used with Processing, and continues to use a modified version of the Processing programming environment to make it easier for students to learn how to program robots and countless other electronics projects.
-The primary charge of the Foundation is to develop and distribute the Processing software. This includes the original Processing (Java), p5.js (Javascript), and Processing.py (Python). There is more information about the Foundation at http://foundation.processing.org/. +The primary charge of the Foundation is to develop and distribute the Processing software. This includes the original Processing (Java), p5.js (Javascript), and Processing.py (Python). There is more information about the Foundation at https://processingfoundation.org/.
- Processing was started by Ben Fry and Casey Reas in the spring of 2001, while both were graduate students at the MIT Media Lab within John Maeda's Aesthetics and Computation research group. Development continued in their free time while Casey pursued his artistic and teaching career and Ben pursued a Ph.D. and founded Fathom Information Design. Many of the ideas in Processing go back to Muriel Cooper's Visual Language Workshop, and it grew directly out of Maeda's Design By Numbers project, developed at the Media Lab and released in 1999. The Wiring and Arduino projects, in turn, grew out of Processing while Casey was teaching at the Interaction Design Institute Ivrea in Italy. Processing also prompted John Resig (jQuery) to build Processing.js, a JavaScript version that then inspired more related work such as the Khan Academy curriculum in computer science. Versions of Processing that use Python, Ruby, ActionScript, and Scala are also in development. Processing and its sister projects have inspired over twenty educational books. + Processing was started by Ben Fry and Casey Reas in the spring of 2001, while both were graduate students at the MIT Media Lab within John Maeda's Aesthetics and Computation research group. Development continued in their free time while Casey pursued his art and teaching career and Ben pursued a Ph.D. and founded Fathom Information Design. Many of the ideas in Processing go back to Muriel Cooper's Visual Language Workshop, and it grew directly out of Maeda's Design By Numbers project, developed at the Media Lab and released in 1999. The Wiring and Arduino projects, in turn, grew out of Processing while Casey was teaching at the Interaction Design Institute Ivrea in Italy.
+For more information, please write to foundation@processing.org diff --git a/content/static/people.html b/content/static/people.html index 9079900ab..d406b648c 100755 --- a/content/static/people.html +++ b/content/static/people.html @@ -6,78 +6,57 @@
- Lead Developers
+ Project Leads
Ben Fry and Casey Reas
started Processing in Spring 2001 and continue to obsessively work on it. In 2012, they started the Processing Foundation along with Dan Shiffman, who formally joined as a third project lead.
- Senior Developers
- Andres Colubri (Boston), OpenGL / Video
- Florian Jenett (Frankfurt), Forum
- Elie Zananiri (Montreal), Contributed Libraries / Tools
- Scott Murray (San Francisco), Website / Reference / UI
+ Developers
+ Andres Colubri (Boston), OpenGL / Video
+ Elie Zananiri (New York), Contributed Libraries / Tools
+ Samuel Pottinger (San Francisco), Processing Core
+ -
+
Libraries, Tools
- The core Processing software is augmented by libraries and tools contributed through the community.
- These inventive extensions are a bright future for the project. We have a list of
- Contributed Libraries and
+ The core Processing software is augmented by libraries and tools contributed through
+ the community. These inventive extensions are a bright future for the project. We have a
+ list of Contributed Libraries and
Contributed Tools posted online.
- These contributions can't be underestimated. For example, see how
- Karsten Schmidt (London) has transformed Processing
- through the toxiclibs library and how
- Damien Di Fede (Austin) has extended the project
- into programming sound through his minim
- library.
-
- Fellowship Alumni
- Lauren McCarthy (New York), Spring/Summer/Fall 2013
- Greg Borenstein (New York), Spring/Summer 2013
- Wilm Thoben (Los Angeles), Fall 2013/Winter 2014
+ These contributions can't be underestimated. For example, see how Karsten Schmidt (London) has
+ transformed Processing through the toxiclibs library and how Damien Di Fede (Austin) has extended
+ the project into programming sound through his minim library.
- Developer Alumni
+ Alumni
+ Jakub Valtar (Brno), Processing Core
+ Scott Garner (New York), Hello Processing Website
+ Scott Murray (San Francisco), Website / Reference / UI
+ Gottfried Haider (Los Angeles), Processing for Pi
+ Florian Jenett (Frankfurt), Forum
+ Jamie Kosoy (San Francisco), Website
+ Manindra Moharana (San Diego), PDE / Core
+ James Grady (Boston), Visual Design
+
+
Patrick Hebron, Video Library (Summer 2011)
Peter Kalauskas, Library/Tool/Mode Install Utility (Summer, Fall 2011)
Andreas Schlegel, Libraries (Winter 2008 - Summer 2011)
Harshani Nawarathna, Processing Development Environment (Summer 2011)
Cindy Chi, Reference Editing (Summer 2011)
- Jonathan Feinberg, Parsing & Android Hacking (Spring 2011)
+ Jonathan Feinberg, Parsing & Android Hacking (Spring 2011)
Chris Lonnen, Processing Development Environment (Summer 2011)
Eric Jordan, Graphics Weapon (2007 - 2009)
Tom Carden, Processing Hacks Director (Summer 2005 - Fall 2008)
@@ -132,10 +111,6 @@
- -
-We offer a special "Thank You!" to Sami Arola for writing the base of the original P3D and Simon Greenwold for incorporating camera and lights. Tom Carden contributed great diff --git a/content/static/support.html b/content/static/support.html index 91cb0754f..2a8f77f05 100644 --- a/content/static/support.html +++ b/content/static/support.html @@ -1,67 +1,48 @@ -
- One way to donate is to become a Processing Foundation Member. Please become a member today to help us continue to provide access to quality, free, open-source software. +
- The Processing Foundation was founded in 2012 after more than a decade of work with the original Processing software. The Foundation’s mission is to promote software literacy within the visual arts, and visual literacy within technology-related fields — and to make these fields accessible to diverse communities. Our goal is to empower people of all interests and backgrounds to learn how to program and make creative work with code, especially those who might not otherwise have access to these tools and resources. -
+Some helpful tips when you’re working with Processing & Android:
- I know I’ve said this before, but be patient. Canceling a process (ie. the emulator load or a device compile) can cause problems. If you do this inadvertently, you’re best off restarting Processing.
-- Make sure to check out the Processing Android Wiki, where you’ll find some troubleshooting advice, and some tips on how to get your sketches working properly on your device.
+- Make sure to check out the Processing Android Wiki, where you’ll find some troubleshooting advice, and some tips on how to get your sketches working properly on your device.
This tutorial is for Processing version 2.0+. If you see any errors or have comments, please let us know. This tutorial is adapted from 'Processing & Android: Mobile App Development Made (Very) Easy' by Jer Thorp
diff --git a/content/static/tutorials/arraylist/index.html b/content/static/tutorials/arraylist/index.html index 613ffee6a..5f24a6ad5 100644 --- a/content/static/tutorials/arraylist/index.html +++ b/content/static/tutorials/arraylist/index.html @@ -1,4 +1,4 @@ -In truth, we could use a simple array to manage our Particle objects. Some particle systems might have a fixed number of particles, and arrays are magnificently efficient in those instances. Processing also offers expand(), contract(), subset(), splice() and other methods for resizing arrays. However, for these examples, the Java class ArrayList (found in the java.util package: http://download.oracle.com/javase/6/docs/api/java/util/ArrayList.html) will prove to be the best solution. Using an ArrayList is conceptually similar to a standard array, but the syntax is different. Here is some code (that assumes the existence of a generic Particle class) demonstrating identical results: first with an array, and second with an ArrayList. +In truth, we could use a simple array to manage our Particle objects. Some particle systems might have a fixed number of particles, and arrays are magnificently efficient in those instances. Processing also offers expand(), contract(), subset(), splice() and other methods for resizing arrays. However, for these examples, the Java class ArrayList (found in the java.util package: https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html) will prove to be the best solution. Using an ArrayList is conceptually similar to a standard array, but the syntax is different. Here is some code (that assumes the existence of a generic Particle class) demonstrating identical results: first with an array, and second with an ArrayList. // THE STANDARD ARRAY WAY int total = 10; diff --git a/content/static/tutorials/data/index-old.html b/content/static/tutorials/data/index-old.html index 0df744e1b..6221a4a80 100644 --- a/content/static/tutorials/data/index-old.html +++ b/content/static/tutorials/data/index-old.html @@ -17,7 +17,7 @@- In Strings and Drawing Text, we touched on a few of the basic functions available in the Java String class, such as charAt(), toUpperCase(), equals(), and length(). These functions are documented on the Processing reference page for Strings. Nevertheless, in order to perform some more advanced data parsing techniques, we'll need to explore some additional String manipulation functions documented in the Java API. + In Strings and Drawing Text, we touched on a few of the basic functions available in the Java String class, such as charAt(), toUpperCase(), equals(), and length(). These functions are documented on the Processing reference page for Strings. Nevertheless, in order to perform some more advanced data parsing techniques, we'll need to explore some additional String manipulation functions documented in the Java API.
@@ -518,7 +518,7 @@
Two examples that follow this methodology can be found under Topics --> Advanced Data in the Processing examples.
-While using the thread() function is a very simple way of getting an independent thread, it should be noted that it is somewhat limited. Being able to make a thread object is a great deal more powerful, and this can be done by extending the Java Thread class.
+While using the thread() function is a very simple way of getting an independent thread, it should be noted that it is somewhat limited. Being able to make a thread object is a great deal more powerful, and this can be done by extending the Java Thread class.
- In Strings and Drawing Text, we touched on a few of the basic functions available in the Java String, such as charAt(), toUpperCase(), equals(), and length(). These functions are documented on the Processing reference page for Strings. Nevertheless, in order to perform some more advanced data parsing techniques, we'll need to explore some additional String manipulation functions documented in the Java API.
+ In Strings and Drawing Text, we touched on a few of the basic functions available in the Java String, such as charAt(), toUpperCase(), equals(), and length(). These functions are documented on the Processing reference page for Strings. Nevertheless, in order to perform some more advanced data parsing techniques, we'll need to explore some additional String manipulation functions documented in the Java API.
Let's take a closer look at the following two String functions: indexOf() and substring().
indexOf() locates a sequence of characters within a string. It takes one argument — a search string — and returns a numeric value that corresponds to the first occurrence of the search string inside of the String object being searched.
@@ -1404,6 +1404,34 @@
// Read data from the serial port and set the position of a servomotor
// according to the value
+#include <Servo.h>
Servo myservo; // Create servo object to control a servo
-int servoPin = 4; // Connect yellow servo wire to digital I/O pin 4
+int servoPin = 3; // Connect yellow servo wire to digital I/O pin 3 (must be PWM)
int val = 0; // Data received from the serial port
void setup() {
@@ -672,7 +673,12 @@ Code
noStroke();
frameRate(10);
// Open the port that the board is connected to and use the same speed (9600 bps)
- port = new Serial(this, 9600);
+ port = new Serial(this, 9600); // Comment this line if it's not the correct port
+ // If the above does not work uncomment the lines below to choose the correct port
+ // List all the available serial ports, preceded by their index number:
+ //printArray(Serial.list());
+ // Instead of 0 input the index number of the port you are using:
+ //port = new Serial(this, Serial.list()[0], 9600);
}
void draw() {
@@ -918,4 +924,4 @@ Resources
With any luck, the main Processing window will now be visible. Everyone's setup is different, so if the program didn't start, or you're otherwise stuck, visit the troubleshooting page for possible solutions.
+With any luck, the main Processing window will now be visible. Everyone's setup is different, so if the program didn't start, or you're otherwise stuck, visit the troubleshooting page for possible solutions.
diff --git a/content/static/tutorials/index.html b/content/static/tutorials/index.html index 17369c6a1..7434e5bbb 100644 --- a/content/static/tutorials/index.html +++ b/content/static/tutorials/index.html @@ -294,16 +294,21 @@
Level: Advanced
-
-
Anatomy of a Program
- by J David Eisenberg
How do you analyze a problem and break it down into steps that the computer can do?
-Level: Advanced
+
Anatomy of a Program
+ by J David Eisenberg
How do you analyze a problem and break it down into steps that the computer can do?
+Level: Advanced
+- To work with fonts different than the default, more functions are needed to prepare a font to be used with Processing. The createFont() function is used to convert a TrueType font (.ttf) or OpenType font (.otf) so that is can display through text(). The textFont() function is used to define the current font to display. Any compatible font installed on the computer running Processing or stored in the sketch’s data folder may be used. The following short program is used to print the list of the available installed fonts to the console: + To work with fonts different than the default, more functions are needed to prepare a font to be used with Processing. The createFont() function is used to convert a TrueType font (.ttf) or OpenType font (.otf) so that it can display through text(). The textFont() function is used to define the current font to display. Any compatible font installed on the computer running Processing or stored in the sketch’s data folder may be used. The following short program is used to print the list of the available installed fonts to the console:
diff --git a/content/static/tutorials/video/index.html b/content/static/tutorials/video/index.html index fda2a4e29..22ccf759b 100644 --- a/content/static/tutorials/video/index.html +++ b/content/static/tutorials/video/index.html @@ -300,7 +300,7 @@-Although Processing is by no means the most sophisticated environment for displaying and manipulating recorded video, there are some more advanced features available in the video library. There are function sfor obtaining the duration (length measured in seconds) of a video, for speeding it up and slowing it down, and for jumping to a specific point in the video (among others). If you find that performance is sluggish and the video playback is choppy, I would suggest trying the P2D or P3D renderers. +Although Processing is by no means the most sophisticated environment for displaying and manipulating recorded video, there are some more advanced features available in the video library. There are functions for obtaining the duration (length measured in seconds) of a video, for speeding it up and slowing it down, and for jumping to a specific point in the video (among others). If you find that performance is sluggish and the video playback is choppy, I would suggest trying the P2D or P3D renderers.Recorded video
}
- Everything - Site + Everything + Site Nothing
Contributions diff --git a/generate/keywords_base.txt b/generate/keywords_base.txt index a89afdf87..7757bb46f 100755 --- a/generate/keywords_base.txt +++ b/generate/keywords_base.txt @@ -1,17 +1,18 @@ -# THE TEXT BELOW IS HAND WRITTEN AND FOUND IN THE FILE "keywords_base.txt" -# IN THE PROCESSING-DOCS REPO. DON'T EDITS THE keywords.txt FILE DIRECTLY. +# THIS TEXT IS FROM keywords_base.txt IN THE PROCESSING-DOCS REPO: +# https://github.com/processing/processing-docs/blob/master/generate/keywords_base.txt +# MAKE CHANGES THERE: DO NOT EDIT THE keywords.txt FILE DIRECTLY. -# For an explanation of these tags, see Token.java +# For an explanation of these tags, see Token.java # trunk/processing/app/src/processing/app/syntax/Token.java ADD LITERAL2 blend_ -ALIGN_CENTER LITERAL2 -ALIGN_LEFT LITERAL2 -ALIGN_RIGHT LITERAL2 +ALIGN_CENTER LITERAL2 +ALIGN_LEFT LITERAL2 +ALIGN_RIGHT LITERAL2 ALPHA LITERAL2 ALPHA_MASK LITERAL2 ALT LITERAL2 -AMBIENT LITERAL2 +AMBIENT LITERAL2 ARC LITERAL2 createShape_ ARROW LITERAL2 cursor_ ARGB LITERAL2 @@ -24,7 +25,7 @@ BLUR LITERAL2 filter_ BOTTOM LITERAL2 textAlign_ BOX LITERAL2 createShape_ BURN LITERAL2 blend_ -CENTER LITERAL2 +CENTER LITERAL2 CHATTER LITERAL2 CHORD LITERAL2 arc_ CLAMP LITERAL2 @@ -88,7 +89,7 @@ GIF LITERAL2 GRAY LITERAL2 filter_ GREEN_MASK LITERAL2 GROUP LITERAL2 -HALF LITERAL2 +HALF LITERAL2 HALF_PI LITERAL2 HALF_PI HAND LITERAL2 cursor_ HARD_LIGHT LITERAL2 blend_ @@ -97,7 +98,7 @@ HSB LITERAL2 colorMode_ IMAGE LITERAL2 textureMode_ INVERT LITERAL2 filter_ JAVA2D LITERAL2 size_ -JPEG LITERAL2 +JPEG LITERAL2 LEFT LITERAL2 keyCode LIGHTEST LITERAL2 blend_ LINE LITERAL2 createShape_ @@ -105,18 +106,18 @@ LINES LITERAL2 beginShape_ LINUX LITERAL2 MACOSX LITERAL2 MAX_FLOAT LITERAL2 -MAX_INT LITERAL2 +MAX_INT LITERAL2 MIN_FLOAT LITERAL2 MIN_INT LITERAL2 MITER LITERAL2 stokeJoin_ MODEL LITERAL2 textMode_ MOVE LITERAL2 cursor_ MULTIPLY LITERAL2 blend_ -NORMAL LITERAL2 +NORMAL LITERAL2 NORMALIZED LITERAL2 textureMode_ NO_DEPTH_TEST LITERAL2 NTSC LITERAL2 -ONE LITERAL2 +ONE LITERAL2 OPAQUE LITERAL2 filter_ OPEN LITERAL2 ORTHOGRAPHIC LITERAL2 @@ -127,13 +128,13 @@ P2D LITERAL2 size_ P3D LITERAL2 size_ PERSPECTIVE LITERAL2 PI LITERAL2 PI -PIE LITERAL2 +PIE LITERAL2 PIXEL_CENTER LITERAL2 POINT LITERAL2 -POINTS LITERAL2 +POINTS LITERAL2 POSTERIZE LITERAL2 filter_ PRESS LITERAL2 -PROBLEM LITERAL2 +PROBLEM LITERAL2 PROJECT LITERAL2 strokeCap_ QUAD LITERAL2 createShape_ QUAD_STRIP LITERAL2 beginShape_ @@ -146,23 +147,23 @@ RECT LITERAL2 RED_MASK LITERAL2 RELEASE LITERAL2 REPEAT LITERAL2 -REPLACE LITERAL2 +REPLACE LITERAL2 RETURN LITERAL2 RGB LITERAL2 colorMode_ RIGHT LITERAL2 keyCode ROUND LITERAL2 strokeCap_ SCREEN LITERAL2 blend_ -SECAM LITERAL2 +SECAM LITERAL2 SHAPE LITERAL2 textMode_ SHIFT LITERAL2 -SPAN LITERAL2 fullScreen_ +SPAN LITERAL2 fullScreen_ SPECULAR LITERAL2 SPHERE LITERAL2 createShape_ SOFT_LIGHT LITERAL2 blend_ SQUARE LITERAL2 strokeCap_ SUBTRACT LITERAL2 blend_ SVG LITERAL2 -SVIDEO LITERAL2 +SVIDEO LITERAL2 TAB LITERAL2 keyCode TARGA LITERAL2 TAU LITERAL2 TAU @@ -181,17 +182,17 @@ TWO LITERAL2 TWO_PI LITERAL2 TWO_PI UP LITERAL2 keyCode WAIT LITERAL2 cursor_ -WHITESPACE LITERAL2 +WHITESPACE LITERAL2 # Java keywords (void, import, , etc.) - + abstract KEYWORD1 break KEYWORD1 break class KEYWORD1 class continue KEYWORD1 continue -default KEYWORD1 default -enum KEYWORD1 +default KEYWORD1 default +enum KEYWORD1 extends KEYWORD1 extends false KEYWORD1 false final KEYWORD1 final @@ -199,17 +200,17 @@ finally KEYWORD1 implements KEYWORD1 implements import KEYWORD1 import instanceof KEYWORD1 -interface KEYWORD1 +interface KEYWORD1 native KEYWORD1 new KEYWORD1 new null KEYWORD1 null -package KEYWORD1 +package KEYWORD1 private KEYWORD1 private -protected KEYWORD1 +protected KEYWORD1 public KEYWORD1 public static KEYWORD1 static -strictfp KEYWORD1 -throws KEYWORD1 +strictfp KEYWORD1 +throws KEYWORD1 transient KEYWORD1 true KEYWORD1 true void KEYWORD1 void @@ -220,7 +221,7 @@ volatile KEYWORD1 assert KEYWORD6 case KEYWORD6 case -return KEYWORD6 return +return KEYWORD6 return super KEYWORD6 super this KEYWORD6 this throw KEYWORD6 @@ -230,18 +231,17 @@ throw KEYWORD6 Array KEYWORD5 Array ArrayList KEYWORD5 ArrayList -Boolean KEYWORD5 -Byte KEYWORD5 +Boolean KEYWORD5 +Byte KEYWORD5 BufferedReader KEYWORD5 BufferedReader -Character KEYWORD5 +Character KEYWORD5 Class KEYWORD5 class -Double KEYWORD5 -Float KEYWORD5 -Integer KEYWORD5 +Float KEYWORD5 +Integer KEYWORD5 HashMap KEYWORD5 HashMap PrintWriter KEYWORD5 PrintWriter String KEYWORD5 String -StringBuffer KEYWORD5 +StringBuffer KEYWORD5 StringBuilder KEYWORD5 Thread KEYWORD5 boolean KEYWORD5 boolean @@ -252,7 +252,7 @@ double KEYWORD5 double float KEYWORD5 float int KEYWORD5 int long KEYWORD5 long -short KEYWORD5 +var KEYWORD5 # Flow structures @@ -386,7 +386,7 @@ pixelHeight KEYWORD4 pixelHeight # # THE TEXT BELOW IS AUTO-GENERATED # -# SO -# DON'T -# TOUCH +# SO +# DON'T +# TOUCH # IT diff --git a/generate/libraries.php b/generate/libraries.php index ee8bc5652..d34c53ba2 100755 --- a/generate/libraries.php +++ b/generate/libraries.php @@ -19,7 +19,7 @@ //`cd $path && /usr/bin/git pull https://github.com/processing/processing-docs/`; -$libraries = array('net', 'serial', 'video', 'dxf', 'pdf', 'sound', 'io'); +$libraries = array('net', 'serial', 'video', 'dxf', 'pdf', 'sound', 'io', 'svg'); $lib_dir = REFERENCEDIR.'libraries/'; // Create Index @@ -47,7 +47,7 @@ // template and copy index $index = CONTENTDIR.$source.'/index.html'; - if($lib == 'pdf' || $lib == 'dxf') { + if($lib == 'pdf' || $lib == 'dxf' || $lib == 'svg') { //$page = new Page(strtoupper($lib) . ' \\ Libraries', 'Libraries', 'Library-index'); $page = new Page(strtoupper($lib) . ' \\ Libraries', 'Libraries'); } else { diff --git a/generate/libraries_local.php b/generate/libraries_local.php index 7c946d94f..ddaeaff96 100755 --- a/generate/libraries_local.php +++ b/generate/libraries_local.php @@ -8,7 +8,7 @@ $benchmark_start = microtime_float(); -$libraries = array('net', 'serial', 'video', 'dxf', 'pdf', 'sound', 'io'); +$libraries = array('net', 'serial', 'video', 'dxf', 'pdf', 'sound', 'io', 'svg'); $lib_dir = DISTDIR.'libraries'; diff --git a/generate/reference.php b/generate/reference.php index b1a0aeeed..5e2a7532c 100644 --- a/generate/reference.php +++ b/generate/reference.php @@ -38,7 +38,9 @@ function out($output) { out("Pulling in latest changes from processing/processing-sound/..."); $soundRepoPath = "{$path}../processing-sound"; -$shell_output = shell_exec("cd $soundRepoPath && /usr/bin/git pull https://github.com/processing/processing-sound/ 2>&1"); +//$shell_output = shell_exec("cd $soundRepoPath && /usr/bin/git pull https://github.com/processing/processing-sound/ 2>&1"); +// clone new processing-sound library from work-in-progress repository instead +$shell_output = shell_exec("rm -rf $soundRepoPath && mkdir $soundRepoPath && cd $soundRepoPath && /usr/bin/git clone https://github.com/processing/processing-sound.git . 2>&1"); out($shell_output); out("---------------"); @@ -84,4 +86,4 @@ function out($output) { $execution_time = round($benchmark_end - $benchmark_start, 4); out("Generated files in $execution_time seconds."); -?> \ No newline at end of file +?> diff --git a/generate/staticpages.php b/generate/staticpages.php index db3b0422b..1a60b6291 100755 --- a/generate/staticpages.php +++ b/generate/staticpages.php @@ -28,9 +28,9 @@ writeFile('overview/index.html', $page->out()); #copydirr($source.'/images', $path.'/images'); -$page = new Page("Foundation", "Foundation"); -$page->content(file_get_contents($source."foundation.html")); -writeFile('foundation/index.html', $page->out()); +#$page = new Page("Foundation", "Foundation"); +#$page->content(file_get_contents($source."foundation.html")); +#writeFile('foundation/index.html', $page->out()); $page = new Page("People", "People"); $page->content(file_get_contents($source."people.html")); @@ -65,21 +65,21 @@ writeFile('copyright.html', $page->out()); // Copy over the images for the shop index -if (!is_dir($path.'shop')) { - mkdir($path.'shop', 0757); -} +#if (!is_dir($path.'shop')) { +# mkdir($path.'shop', 0757); +#} -if (!is_dir($path.'shop/imgs')) { - mkdir($path.'shop/imgs', 0757); -} +#if (!is_dir($path.'shop/imgs')) { +# mkdir($path.'shop/imgs', 0757); +#} -if (is_dir($path.'shop/imgs')) { - copydirr($source.'shop/imgs', $path.'shop/imgs', null, 0757, false); -} +#if (is_dir($path.'shop/imgs')) { +# copydirr($source.'shop/imgs', $path.'shop/imgs', null, 0757, false); +#} -$page = new Page("Shop", "Shop"); -$page->content(file_get_contents($source.'shop/'."index.html")); -writeFile('shop/index.html', $page->out()); +#$page = new Page("Shop", "Shop"); +#$page->content(file_get_contents($source.'shop/'."index.html")); +#writeFile('shop/index.html', $page->out()); $benchmark_end = microtime_float(); $execution_time = round($benchmark_end - $benchmark_start, 4); diff --git a/img/cc.png b/img/cc.png new file mode 100644 index 000000000..4acf8c4ec Binary files /dev/null and b/img/cc.png differ diff --git a/img/learning/books/coding-art.jpg b/img/learning/books/coding-art.jpg new file mode 100644 index 000000000..79fa91e5a Binary files /dev/null and b/img/learning/books/coding-art.jpg differ diff --git a/img/learning/books/o-codigo.jpg b/img/learning/books/o-codigo.jpg new file mode 100644 index 000000000..e70fad0e9 Binary files /dev/null and b/img/learning/books/o-codigo.jpg differ diff --git a/img/learning/books/pro-processing.jpg b/img/learning/books/pro-processing.jpg new file mode 100644 index 000000000..25e7f6863 Binary files /dev/null and b/img/learning/books/pro-processing.jpg differ diff --git a/img/learning/books/programming-101.jpg b/img/learning/books/programming-101.jpg new file mode 100644 index 000000000..3749c36a2 Binary files /dev/null and b/img/learning/books/programming-101.jpg differ diff --git a/java_generate/templates/class.template.html b/java_generate/templates/class.template.html index 3d715adf9..96634b4c1 100644 --- a/java_generate/templates/class.template.html +++ b/java_generate/templates/class.template.html @@ -23,7 +23,7 @@ -
- - + diff --git a/java_generate/templates/generic.template.html b/java_generate/templates/generic.template.html index dbf060144..d8858a537 100644 --- a/java_generate/templates/generic.template.html +++ b/java_generate/templates/generic.template.html @@ -23,7 +23,6 @@ -- Processing is a flexible software sketchbook and a language for learning how to code within the context of the visual arts. Since 2001, Processing has promoted software literacy within the visual arts and visual literacy within technology. There are tens of thousands of students, artists, designers, researchers, and hobbyists who use Processing for learning and prototyping. - -
+ Processing is a flexible software sketchbook and a language for learning how to code within the context of the visual arts. Since 2001, Processing has promoted software literacy within the visual arts and visual literacy within technology. There are tens of thousands of students, artists, designers, researchers, and hobbyists who use Processing for learning and prototyping. +
Books
- The 2nd edition of Getting Started with Processing is here and it's updated for Processing 3. It's now in full color and there's a new chapter on working with data. The 2nd edition of the Processing Handbook is here too. Every chapter has been revised, and new chapters introduce more ways to work with data and geometry. New “synthesis” chapters offer discussion and worked examples of such topics as sketching with code, modularity, and algorithms.
+ The second edition of Getting Started with Processing is here and it's updated for Processing 3. It's now in full color and there's a new chapter on working with data. The Processing Handbook now has a second edition too. Every chapter has been revised, and new chapters introduce more ways to work with data and geometry. New “synthesis” chapters offer discussions and worked examples of topics such as sketching with code, modularity, and algorithms.
-
To see more of what people are doing with Processing, check out these sites:
- -» CreativeApplications.Net
- » OpenProcessing
- » For Your Processing
- » Processing Subreddit
- » Vimeo
-
- » Studio Sketchpad
+
+ To see more of what people are doing with Processing, check out these sites:
+ » CreativeApplications.Net
+ » OpenProcessing
+ » For Your Processing
+ » Processing Subreddit
+ » Vimeo
+ » Studio Sketchpad
- To contribute to the development, please visit +
+ To contribute to Processing development, please visit Processing on GitHub to read instructions for downloading the code, building from the source, - reporting and tracking bugs, and + reporting and tracking bugs, and creating libraries and tools.
--