Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
646
contains this array. The SpinnyCube constructor accepts the same three arguments as the
Cube class, for the width, height, and depth of the cube. The first line of the SpinnyCube
constructor
super(w, h, d);
passes the arguments through to the superclass (Cube) constructor. This is a very efficient
structure that allows you to build upon base and component classes. One little reminder—
if there had been any other code in the SpinnyCube constructor, it would need to be put
after the super() call, which (when included) must always be the first line in the subclass
constructor. (However, you are not required to include a call to super() in a subclass constructor.)
I recommend always adding a default no-argument constructor to any class that will
be extended, since the superclass constructor is always invoked, even without an
explicit call to super(). To learn more about this and related (albeit geeky and lowlevel)
issues, check out www.beginner-java-tutorial.com/ and http://java.sun.
com/docs/books/jls/second_edition/html/classes.doc.html.
Following the constructors is the spinnyRotateXYZ() method. This method works practically
identically to the rotateVertices() function in the previous example. To keep things
organized, I declared and initialized all the temporary vertices arrays locally within this
method. As in the last example, the transformed vertices need to be plugged into the next
set of expressions. Finally, at the end of the method, I assigned the updated vertices to the
transformedVertices[] array used to draw the cube. Following this method are three
simple utility methods (spinnyRotateX(), spinnyRotateY(), and spinnyRotateZ()) that
update rotation angles, used by the expressions in the spinnyRotateXYZ() method.
The last methods in the SpinnyCube class are two overloaded create() methods, just as in
the Cube class. Creating two more methods with the same name may seem confusing and
unnecessary, since the subclass has access to the superclass’s create() methods. I wanted
to call the spinnyRotate() method internally from within the create() methods, and I
didn’t want to make that change to the cube’s original create() methods. Since the create()
methods in the SpinnyCube subclass have the same method signatures (parameter
lists) as the create() methods in the Cube superclass, the methods in the subclass will
override the same named ones in the superclass. In other words, when I call
c1.create(quadBG);
and c1 is of type SpinnyCube, the create() method in the SpinnyCube subclass is executed,
not the one with the identical signature in the Cube class. The SpinnyCube create()
methods are implemented nearly identically to the ones in the Cube class, except that they
have additional lines for calling the spinnyRotateXYZ() method.