Processing: Creative Coding and Computational Art

Lights
The Lights section includes functions for controlling subtle, yet very important, aspects of
3D rendering. In general, lighting in 3D is modeled on the real world and the concept of
placing real lights in a space. The virtual camera is a similar such construct. Of course, in
Processing, all the lights are virtual, and really just a bunch of pixel color calculations. That
being said, just as in the real world, virtual lights can have direction, falloff (how far and
intensely they illuminate), color, cone angles (in the case of spotlights), and overall spatial
illumination (in the case of ambient light). Lighting is one of the key research areas in 3D,
and has an enormous impact on the overall quality of rendering.
Camera
Camera functions control the virtual camera that you view the virtual world through. This
might sound like an odd concept if you haven’t played with any 3D applications. A “real”
3D projection is impossible on a flat 2D monitor, so ultimately all the 3D spatial calculations
need to be converted, or projected, back to the 2D Cartesian system. This translation
is one of the aspects that makes 3D complicated. During this geometric flattening (which
usually happens in real time), different algorithms can be applied that control how we
view the implied 3D space. For example, one of the most common approaches is to try to
simulate the effects of perspective, similar to how we, with our binocular vision, experience
the real world.
Based on the rules of perspective, objects get smaller as they go back in space, and in a
one-point perspective system, lines going into the distance converge. When objects get
close to us and appear very large, distortions such as a fish-eye effect can occur. We can
easily simulate these types of effects in 3D—that is, with a lot of math. Conversely, we can
also create a more synthetic, or orthogonal, projection, in which there is no perspective.
This is quite useful for precisely modeling geometry, where you might need to work with a
set of undistorted 2D projections—for example, in an engineering application. Perspective
looks good, but it is often hard to know precisely where you are (actually, where the cursor
is) when working in this mode.
Virtual cameras also utilize a viewing volume and clipping planes that specify minimum
and maximum values for the x-, y-, and z-axes. Normally, only stuff within the camera’s
viewing volume, called the frustum, can be seen. The boundaries of the frustum are called
the clipping planes. If the clipping planes are not set correctly, imagery can disappear and
appear unexpectedly. However, without any clipping, geometry not visible within the camera’s
view can get rendered, which is obviously a waste of memory. Finally, as the virtual
camera is not bound by the physics of the real world, it has the ability to produce highly
distorted and strange effects. This can be an interesting thing to experiment with, but also
a potential source of frustration—especially when you don’t want it to happen (or can’t
track down the problem).
Coordinates
The Coordinates section includes six (conceptually) advanced functions that return coordinate
values. The six functions are modelZ(), modelX(), modelY(), screenZ(), screenX(),
PROCESSING LANGUAGE API
719
A