Processing: Creative Coding and Computational Art

Rather than deal with another flat, undulating surface, I used some trig functions to calculate
the planet surface as an arc. The two expressions that create the arc
px[i] = width-50 + cos(radians(ang))*(width*1.3+peakHeights[i]);
py[i] = height*1.75 + sin(radians(ang))*(height+peakHeights[i]);
are pretty ugly and (dare I say) use magic numbers. I spent way too much time on this
chapter, so I kind of took the easy way out (sorry). Feel free to mess with these values to
change the planet’s shape, or better yet, try to improve the expressions by losing the
magic numbers.
In the draw() function, after drawing the fading background and stars, I created the Earth
(yeah, I’m pretty powerful). Notice after the beginShape() function call, the following line:
texture(p);
This call, in a sense, turns on texture mode, allowing images to be mapped to geometry in
Processing, using beginShape(), endShape(), and vertex() calls. The texture() call needs
to be called between beginShape() and endShape(), and before any vertex() calls. The
argument p should be the image you want to map to the geometry. This image should be
loaded earlier in your sketch (after it has been added to the sketch’s data directory), as I
did in the setup() function.
Image mapping in Processing follows a common approach, used in other 3D environments,
utilizing uv coordinates. u and v represent the coordinate space in which to put an
image. Unlike x, y, and z, which each map to a specific axis, u and v represent a more symbolic
type of space that relates to the object’s vertices. For example, I can specify a point
in xyz space that also has uv components. This structure allows 3D geometry to be plotted
along the x-, y-, and z-axes, while also enabling an image to be attached to the geometry,
with some flexibility; the image can be mapped different ways to the actual vertex geometry
it’s connected to. Once an image is mapped to the geometry using uv coordinates, it
can be deformed along with the geometry, allowing for very realistic morphing effects. For
now, I’ll be focusing on simply mapping the image onto the 2D ground geometry. Later, in
the 3D chapters, we’ll map an image to a 3D object.
After the texture(p) call is made, the vertex calls now require two extra arguments, specifying
how the image should be mapped to the vertices created between beginShape()
and endShape(). By default, the mapping is based on the image’s actual size. However,
Processing comes with a function called textureMode(), allowing you to change the mapping
from IMAGE mode (the default) to NORMALIZED mode. NORMALIZED mode allows
you to specify argument values between 0 and 1.0, instead of the actual image sizes. To learn
more about this option, please refer to the Processing reference at http://processing.
org/reference/textureMode_.html.
The default image mapping is relatively simple to use on rectilinear geometry. For example,
to map a 200 by 200 pixel image onto the same sized geometry, you would do the
following (please note: the following code won’t run as written—you need to specify P3D
in size(), add and then load an image, and finally replace PimageObjectNameGoesHere
with the actual name of your PImage):
MOTION
549
11