Creating graphic animations with Processing

Entering the Third Dimension

It is quite easy to enter the third dimension with Processing. To demonstrate this, Listing 4 draws a simple cube. The great thing about it is that it reacts to mouse movements – you can push or drag it through the defined workspace (Figure 5). Unfortunately the screenshot tool on Gnome doesn't show you where the mouse is, but you can take my word for it that the mouse was at the center of the cube in all three figures.

Figure 5: The cube follows your mouse movements and can be moved easily across the screen.

Listing 4

A Simple Cube

01 void setup() {
02   size(400, 400, P3D);
03   frameRate(30);
04 }
06 void draw() {
07   background(200);
08   pushMatrix();
09   translate(mouseX,mouseY,10);
10   color c1 = color(180);
11   fill(c1);
12   stroke(128);
13   box(150);
14   popMatrix();
15 }

The code comprises two basic functions: setup() and draw(), which contain other functions. The setup function defines the basic parameters for the program, and the draw function draws a specific object and executes the commands inside the curly brackets before restarting.

The first function in line 2 initializes the workspace; the extent is followed by an ominous looking P3D keyword, which initializes Processing's internal, software-based 3D engine. The engine calculates 3D graphics and sends them to the graphics card, which renders them on screen. To use OpenGL to render the graphic with the use of the faster hardware-based 3D graphics card support, just add the following line at the start of the code:

import processing. opengl.*;

Then replace P3D with OPENGL in Listing 4. On faster machines you will not notice any difference for simple figures.

To see improved performance with more complex figures, you will need a graphics card with 3D acceleration; in other words, you have to install the Nvidia, ATI, or Intel drivers.

Line 3 specifies the frame rate. A value of 30 should be fine, and you will not notice any jerky movements.

The next step relates to the properties of the cube. The example here uses light gray as the background color (background(200)).

The functions pushMatrix() and popMatrix() in lines 8 and 14 draw a framework around the figure. Whereas pushMatrix() creates a new coordinate system and loads it onto the Matrix Stack [4] (see the box titled "What is the Matrix?"), popMatrix() restores the matrix used previously.

Although the program will work without these two functions, they do make sense, as the next example shows.

Inside the matrix, the first function is translate(). It reads the three parameters and positions the cube on the intersection of the x-, y-, and z-axes – that is, in virtual space.

The function assumes a value of 0, 0 for the top left of the workspace and sets the center of the figure to these coordinates.

Any further translate functions that follow inside the draw function will use the previous translation coordinates as their reference point. This means that you can move the cube easily with the mouse because mouseX, mouseY will always relate to the mouse pointer's previous x/y coordinates.

The next trick is to define a color in the variable c1 – light gray in this case, although you can use sRGB values here, too. The script fills the cube with this color in line 11 and colors the edges dark gray by calling stroke().

The cube isn't actually assembled until line 13; the edge length is set to 150 pixels. To draw a cuboid, you need to enter three values for the length, width, and height.

What is the Matrix?

The following example will give you a rough idea of the Matrix Stack. If you create a series of three sequences, each comprising multiple movements, each sequence starts with the pushMatrix() function, which creates a new coordinate system. To return to the previous sequence, with the previously used coordinates, you just do a popMatrix(). The whole thing works like a kind of return marker, but you can't jump forward.

The Death Star

Finally, Listing 5 presents a more complex script. It displays two counter-rotating green cubes (see Figure 6).

Figure 6: Two counter-rotating cubes lit by a virtual spotlight.

Listing 5

Counter-Rotating Cubes

01 import processing.opengl.*;
03 float ydirection1 = 1;
04 float xdirection1 = 1;
06 float ydirection2 = -1;
07 float xdirection2 = -1;
09 void setup() {
10   size(400, 400, OPENGL);
11   frameRate(30);
12 }
14 void draw() {
15   background(0);
16   directionalLight(255,255,128, 0,0,-1);
18 /* Cube 1 */
19   pushMatrix();
21   translate(200,200,100);
22   color c1 = color(102, 102, 0);
23   fill(c1);
24   stroke(204,102,0);
26   rotateY(radians(ydirection1));
27   rotateX(radians(xdirection1));
29   box(100);
30   popMatrix();
32 /* Cube 2 */
33   pushMatrix();
35   translate(200,200,100);
36   color c2 = color(102, 102, 0);
37   fill(c2);
38   stroke(204,102,0);
40   rotateY(radians(ydirection2));
41   rotateX(radians(xdirection2));
43   box(100);
44   popMatrix();
46 /* cube 1 clockwise */
47   ydirection1 = ydirection1 + 1;
48   xdirection1 = xdirection1 + 1;
50 /* cube 2 counterclockwise */
51   ydirection2 = ydirection2 - 1;
52   xdirection2 = xdirection2 - 1;
54 }

Short comments make the code more intelligible, but the most important features are the use of pushMatrix() and popMatrix() and the commands for rotating the figures.

In lines 3 to 7, I start by initializing two variables for each cube – an xdirection and a ydirection – with values of 1 and -1, respectively. The setup function is already familiar, but the draw function changes.

The script calls directionalLight() to shed some light on the cube. The function has six parameters, the first three of which are for an sRGB or HSV value, and the last three of which are positions on the x-, y-, and z-axes of a spatial coordinate system. The first three values specify the color of the light, and the last three define the direction from which the light comes.

The script defines the size, color, and rotation of the two cubes between the pushMatrix() and popMatrix() functions. The functions are the same for both cubes apart from one detail: The rotateX() and rotateY functions use opposite directions of rotation.

Lines 40 and 41 rotate cube 2 one degree counterclockwise on the x- and y-axes. Both variables start with a value of -1. Cube 1 rotates in the opposite direction. Because they are centered on the same position, they counter-rotate. After this minimal rotation, new values are assigned to the variables in lines 46 to 52.

The torque is incremented for cube 1 and decremented for cube 2. Processing executes the draw function again, and both cubes counter-rotate another degree. Because the draw function uses a frame rate of 30 frames per second, the cubes rotate smoothly.

One other interesting aspect might interest you: If you remove the pushMatrix() and popMatrix() functions in the sample code, the second cube suddenly orbits the first like a planet. Each cube would need a separate coordinate system – unless you want to design a virtual planetarium.

Publish on the Web

By default, Processing stores your efforts in a folder titled sketchbook below your home directory. If you save your creation as experiment_0815, you would find it later in ~/sketchbook/experiment_0815/.

To show off your programming skills to friends, colleagues, and acquaintances, you might want to publish your figures on the web. Selecting File | Export lets you do so. Processing will then create an applet subfolder below the above-mentioned directory and drop the required files into it. If you open the index.html file in your browser, you should see the figure.

To publish the figure on your homepage, just use an FTP client to push the applet folder onto the server with your website and add a link to index.html to your homepage.

If you want to access the file directly, just go to http://www.mydomain.com/applet/index.html.


sRGB Color Space

An additive color space in which each color is defined by the red, green, and blue components with a depth of 8 bits per channel.


A color space that defines the color with reference to the hue, saturation, and value.


  1. The Code Swarm project uses Processing: http://code.google.com/p/codeswarm/
  2. Download page for Processing: http://processing.org/download/index.html
  3. Greenberg, Ira A. Processing: Creative Coding and Computational Art. Computer Bookshops, New York, 2007.
  4. pushMatrix() and popMatrix() explained: http://processing.org/discourse/yabb_beta/YaBB.cgi?board=Syntax;action=display;num=1177279317

The Author

Kristian officially studied german philology, history and social science in Berlin but wasted a lot of his time with computers. He got hooked on Linux in the 90ies and works now as editor for LinuxUser.

Buy this article as PDF

Express-Checkout as PDF
Price $2.95
(incl. VAT)

Buy Linux Magazine

Get it on Google Play

US / Canada

Get it on Google Play

UK / Australia

Related content

  • Flash Alternative: Processing Version 1.0


  • Tcl3D


  • Introduction


  • 3D with Three.js


  • Blender 3D Modeling


comments powered by Disqus

Direct Download

Read full article as PDF:

068-071_processing.pdf (530.87 kB)


njobs Europe