The first class we will discuss is Input. It is not really specific for computer graphics, but useful for any programming task that involves reading data from a textfile in a simple way. We will use it to read data for 3D objects, specified in a particular format. There is an Input constructor that accepts the name of an input file as an argument, as well as a constructor without any arguments to read data from the keyboard. To demonstrate how easy it is to use this class, let us suppose we are given a textfile containing only numbers and we want to write a program to read this file and compute the sum of these numbers. For example, this textfile, say, example.txt, may have the following contents:

2.5     6
200     100

Then the desired program is shown below:

// Sum.java: Demonstrating the class Input by computing the sum
//   of all numbers in the textfile example.txt (which contains
//   only numbers and whitespace characters).
public class Sum
{  public static void main(String[] args)
   {  float x, s=0;
      Input inp = new Input("example.txt");
      for (;;)
      {  x = inp.readFloat();
         if (inp.fails())
            break;
         s += x;
      }
      System.out.println("The computed sum is " + s);
   }
}

After compiling and executing this program in a directory that also contains the files Input.java and example.txt, the following output line is displayed:

The computed sum is 308.5

This example demonstrates the use of the Input constructor and of the methods readFloat and fails. The complete class Input, listed below, shows that it contains some other useful methods as well:

// Input.java: A class to read numbers and characters from textfiles.
// Methods of this class, available for other program files:
//   Input(fileName) (constructor; open input file)
//   Input()         (constructor; prepare for input from keyboard)
//   readInt()       (read an integer)
//   readFloat()     (read a float number)
//   readChar()      (read a character)

//   readString()    (read a string between double quotes)
//   skipRest()      (skip all remaining characters of current line)
//   fails()         (input operation failed)
//   eof()           (failure because of end of file)
//   clear()         (reset error flag)
//   close()         (close input file)
//   pushBack(ch)    (push character ch back into the input stream)
import java.io.*;

class Input
{  private PushbackInputStream pbis;
   private boolean ok = true;
   private boolean eoFile = false;

   Input(){pbis = new PushbackInputStream(System.in);}

   Input(String fileName)
   {  try
      {  InputStream is = new FileInputStream(fileName);
         pbis = new PushbackInputStream(is);
      }
      catch(IOException ioe){ok = false;}
   }

   int readInt()
   {  boolean neg = false;
      char ch;
      do {ch = readChar();}while (Character.isWhitespace(ch));
      if (ch == '-') neg = true; ch = readChar();}
      if (!Character.isDigit(ch))
      {  pushBack(ch);
         ok = false;
         return 0;
      }
      int x = ch - '0';
      for (;;)
      {  ch = readChar();
         if (!Character.isDigit(ch)){pushBack(ch); break;}
         x = 10 * x + (ch - '0'),
      }
      return (neg ? -x : x);
   }

float readFloat()
   {  char ch;
      int nDec = −1;
      boolean neg = false;
      do
      {  ch = readChar();
      }  while (Character.isWhitespace(ch));
      if (ch == '-'){neg = true; ch = readChar();}
      if (ch == '.'){nDec = 1; ch = readChar();}
      if (!Character.isDigit(ch)){ok = false; pushBack(ch); return 0;}
      float x = ch - '0';
      for (;;)
      {  ch = readChar();
         if (Character.isDigit(ch))
         {  x = 10 * x + (ch - '0'),
            if (nDec >= 0) nDec++;
         }
         else
         if (ch == '.' && nDec == −1) nDec = 0;
         else break;
      }
      while (nDec > 0){x *= 0.1; nDec--;}
      if (ch == 'e' || ch == 'E')
      {  int exp = readInt();
         if (!fails())
         {  while (exp < 0){x *= 0.1; exp++;}
            while (exp > 0){x *= 10; exp--;}
         }
      }
      else pushBack(ch);
      return (neg ? -x : x);
   }

   char readChar()
   {  int ch=0;
      try
      {  ch = pbis.read();
         if (ch == −1) {eoFile = true; ok = false;}
      }
      catch(IOException ioe){ok = false;
      return (char)ch;
   }

String readString()  // Read first string between quotes (").
   {  String str = " ";
      char ch;
      do ch = readChar(); while (!(eof() || ch == '"'));
                                                // Initial quote
      for (;;)
      {  ch = readChar();
         if (eof() || ch == '"') // Final quote (end of string)
            break;
         str += ch;
      }
      return str;
   }

   void skipRest()  // Skip rest of line
   {  char ch;
      do ch = readChar(); while (!(eof() || ch == '
'));
   }

   boolean fails(){return !ok;}
   boolean eof(){return eoFile;}
   void clear(){ok = true;}

   void close()
   {  if (pbis != null)
      try {pbis.close();}catch(IOException ioe){ok = false;}
   }

   void pushBack(char ch)
   {  try {pbis.unread(ch);}catch(IOException ioe){}
   }
}

Using a call to readChar immediately after readInt or readFloat causes the character immediately after the number to be read. To realize this, we use the standard Java class PushbackInputStream, which enables us to push back, or 'unread' the last character that we have read and that does not belong to the number we are reading.

After an attempt to read a number by using readInt or readFloat, we can call the fails method to check whether that attempt was successful. If fails returns true, a non-numeric character, such as a period in the second part of our input files, may have been read. It is then still possible to read that character by using readChar. The clear method resets the error flag, so that we can resume input, using fails again. The method fails also returns true if an input operation fails because the end of the file is encountered during a call to one of the methods readInt, readFloat and readChar. In that case, the eof method also returns true. We can use the method readString to read a string surrounded by double quotes ("), as we will do in Chapter 8. To skip all remaining characters of the current input line, we use the method skipRest.

Let us now discuss the way the above class Input is used in the method readObject of the class Obj3D. Suppose we have an input file such as the one shown below:

1    0    0      0
2    0  100.5    0
3    0    0    1.5e2
Faces:
1 2 3.
3 2 1.

We will often use files of this type, which will be described in more detail in the next chapter. This example defines a 3D object that has only three vertices, with numbers 1, 2 and 3. The x-, y- and z-coordinates are given after each of these vertex numbers. The object has two faces, which are the two sides of the triangle with these three vertices. The first line following the word Faces indicates the side where we view the vertices 1, 2 and 3, in that order, counter-clockwise, while the last line denotes the other side. Obviously, which of these two triangle sides we can see depends on the point of view.

A simplified version of the Obj3D method readObject is shown below. It shows how the class Input can be used to read data files such as the one shown above. In this fragment three dots (. . .) denote code that is not relevant in this discussion because it does not perform any input operations:

private boolean readObject(Input inp)
{  for (;;)
   { int i = inp.readInt();
     if (inp.fails()){inp.clear(); break;}
     ...
     float x = inp.readFloat(),
           y = inp.readFloat(),
           z = inp.readFloat();

addVertex(i, x, y, z);
   }
   ...
   do   // Skip the line "Faces:"
   {  ch = inp.readChar(); count++;
   }  while (!inp.eof() && ch != '
'),
   ...
   // Build polygon list:
   for (;;)
   {  Vector vnrs = new Vector();
      for (;;)
      {  int i = inp.readInt();
         if (inp.fails()){inp.clear(); break;}
         ...
         vnrs.addElement(new Integer(i));
      }
      ch = inp.readChar();
      if (ch != '.') break;
      // Ignore input lines with only one vertex number:
      if (vnrs.size() >= 2)
         polyList.addElement(new Polygon3D(vnrs));
   }
   inp.close();
   return true;
}

The above fragment is a simplified version of the method readObject of the class Obj3D, which we will now discuss in more detail. We will use this class to store all data of 3D objects, along with their 2D representations, in such a way that this data is easy to use in our programs. We store three representations of vertices:

Recall the classes Point2D and Point3D discussed in Sections 1.5 and 3.9. Since we read the world coordinates from an input file without knowing in advance how many vertices there will be, we use a Java Vector for them. This is different with the eye and screen coordinates. Since we compute these ourselves after we have read the world coordinates of all vertices, we know the size of the arrays e and vScr, so that we can allocate memory for them. We use the vertex numbers to indicate the positions in w, e, and vScr. In other words, with an input line of the form

we can find these world coordinates x, y and z of vertex i in the Point3D object

(Point3D)w.elementAt(i)

We use the Obj3D method eyeAndScreen to compute the corresponding eye coordinates and store them in the Point3D object

e[i]

This method also computes the corresponding screen coordinates and stores them in the Point2D object

vScr[i]

It follows that w.size(), e.length and vScr.length will be one higher than the highest vertex number that is in use.

We will use the accessor methods getE() and getVScr() for access to the arrays e and vScr. The Vector object w will not be used at all outside the class Obj3D.

Another useful method of Obj3D is planeCoeff. For each face (or polygon) of the object, it computes the coefficients a, b, c and h of the equation

Equation 5.10. 

which describes the plane where this face lies. Using the first three vertices A, B and C of a polygon, we compute the normal vector n = (a, b, c) of the plane as the vector product AB × AC (see Section 2.4), scaled such that

Using the inner product (see Section 2.2) of n and a vector x = EP for any point P in the plane, we can write (5.10) as

in which h is positive if the sequence A, B and C is clockwise, that is, if ABC is a back face. On the other hand, if ABC is not a back face, h is negative and the sequence A, B and C is counter-clockwise. Recall that the positive z-axis (in the eye-coordinate system) points towards us, as is more or less the case with the normal vector n of a visible face. However, the vector x points away from us, which implies that the inner product n · x = h will be negative for a visible face and positive for a back face. The absolute value of h is the distance between the eye E and the plane in question (see Exercise 7.1). We will use the coefficients a, b, c and h on several occasions. In the class Obj3D, the method planeCoeff computes these coefficients, after which they are stored in Polygon3D objects, as we will see shortly. This method planeCoeff also computes the maximum and minimum values of an inner product used to determine which color is to be assigned to each face, as we will discuss in Section 7.2.

Since the file Obj3D.java is considerably larger than the program files we have seen so far, it is not listed here but you can find it in Appendix C. Here is a summary of all methods of this class that we can use outside it:

boolean read(String fName) // Reads a 3D object file, if possible.
Vector getPolyList()       // Returns polyList, the list of faces.
String getFName()          // File name of current object.
Point3D[] getE()           // Eye coordinates e of vertices.
Point2D[] getVScr()        // Screen coordinates vScr of vertices.
Point2D getImgCenter()     // Center of image in screen coordinates.
float getRho()             // Rho, the viewing distance.
float getD()               // d, scaling factor, also screen distance.
float eyeAndScreen         // Computes eye and screen coordinates and
                           // returns maximum screen-coordinate range.
void planeCoeff()          // Computes the coefficients a, b, c, h
                           // for all faces.
boolean vp(Canvas cv, float dTheta, float dPhi, float fRho)
                           // Changes the viewpoint.
int colorCode(double a, double b, double c)
                           // Computes the color code of a face.

We will discuss the method colorCode in detail in Section 7.2. The public Obj3D method read calls the private method readObject, discussed above, as the following fragment shows:

boolean read(String fName)
{  Input inp = new Input(fName);
   ...
   return readObject(inp); // Read from inp into obj
}

As we have seen in the simplified version of readObject, this method starts by repeatedly reading four numbers, i, x, y and z, and calls the method addVertex, which keeps track of the minimum and maximum values of x, y and z. The loop in which the four numbers are read terminates when an attempt to read a vertex number i fails because of the word Faces. The minimum and maximum coordinate values just mentioned are required for a call to the private method shiftToOrigin, which reduces all world coordinates such that the origin of the coordinate center will coincide with the center of the bounding box of the object.

After skipping the rest of the line on which we encounter the word Faces, we enter a loop to read vertex-number sequences representing polygons. Vertex numbers in these sequences may be preceded by a minus sign, as we will discuss in Chapter 6, so that the vertex numbers are actually the absolute values of the integers that we read.

Since we will often refer to the class Obj3D, let us have a look at a simplified version of it:

// Obj3D.java: A 3D object and its 2D representation.
// Uses: Point2D (Section 1.5), Point3D (Section 3.9),
//       Polygon3D, Input (Section 5.5).
...
class Obj3D
{  ...
   private Vector w = new Vector();        // World coordinates
   private Point3D[] e;                    // Eye coordinates
   private Point2D[] vScr;                 // Screen coordinates
   private Vector polyList = new Vector(); // Polygon3D objects
   ...
   private void addVertex(int i, float x, float y, float z)
   {  ...
   }
   ...
}

Recall that the complete version is listed in Appendix C.

We will often store large sets of triangles, the vertices of which have numbers in the same way as letters normally used in geometry. Since several triangles may share some vertices, it would not be efficient to store the coordinates of each vertex separately for every triangle. For example, suppose in 3D space we have a triangle with vertices 1, 2 and 3 and another with vertices 1, 4 and 2. It will then be efficient to set up a table with the x-, y- and z-coordinates of the four vertices 1, 2, 3 and 4, and denote the triangles only by their vertex numbers. The following class represents triangles in this way:

// Tria.java: Triangle represented by its vertex numbers.
class Tria
{  int iA, iB, iC;
   Tria(int i, int j, int k){iA = i; iB = j; iC = k;}
}

If there had been no 3D programs in this book other than that for wire-frame models, as discussed in Section 5.6, it would not have been necessary to store polygons, let alone triangles. We could then have restricted ourselves to the edges of 3D objects, that is, to line segments. We will nevertheless store the polygonal faces of the objects even in this chapter, to prepare for some more interesting programs where hidden lines or faces are not displayed.

Almost at the end of the Obj3D method readObject you may have noticed the following statement:

polyList.addElement(new Polygon3D(vnrs));

Here a new Polygon3D object is created to store the vertex numbers of a polygon. This object is then added to the Vector object polyList, a private variable of the class Obj3D. The class Polygon3D contains a number of methods that we will not use in this chapter. These are related to triangles resulting from polygons and will be useful in the next two chapters, in which we will be dealing with algorithms to eliminate hidden lines and faces. Thanks to the above class Tria, the coordinates of the vertices of each triangle are not duplicated. Since they are stored in arrays that are data members of the Obj3D class, we only need to store the numbers iA, iB and iC of the vertices here. Although, in Section 2.13, we have already used a method triangulate to divide a polygon into triangles, we will need a slightly different one that represents vertices by numbers referring to the Obj3D class. This special method for triangulation is part of the class Polygon3D, listed below:

// Polygon3D.java: Polygon in 3D, represented by vertex numbers
//                 referring to coordinates stored in an Obj3D object.
import java.util.*;

class Polygon3D
{  private int[] nrs;
   private double a, b, c, h;
   private Tria[] t;
   Polygon3D(Vector vnrs)
   {  int n = vnrs.size();
      nrs = new int[n];
      for (int i=0; i<n; i++)
         nrs[i] = ((Integer)vnrs.elementAt(i)).intValue();
   }

   int[] getNrs(){return nrs;}
   double getA(){return a;}
   double getB(){return b;}
   double getC(){return c;}
   double getH(){return h;}
   void setAbch(double a, double b, double c, double h)
   {  this.a = a; this.b = b; this.c = c; this.h = h;
   }
   Tria[] getT(){return t;}

   void triangulate(Obj3D obj)
   // Successive vertex numbers (CCW) in vector nrs.
   // Resulting triangles will be put in array t.
   {  int n = nrs.length;         // n > 2 is required
      int[] next = new int[n];
      t = new Tria[n − 2];
      Point2D[] vScr = obj.getVScr();
      int iA=0, iB, iC;
      int j = n − 1;
      for (int i=0; i<n; i++){next[j] = i; j = i;}
      for (int k=0; k<n-2; k++)
      {  // Find a suitable triangle, consisting of two edges
        // and an internal diagonal:
         Point2D a, b, c;
         boolean found = false;
         int count = 0, nA = −1, nB = 0, nC = 0, nj;
         while (!found && ++count < n)
         {  iB = next[iA]; iC = next[iB];
            nA = Math.abs(nrs[iA]); a = vScr[nA];
            nB = Math.abs(nrs[iB]); b = vScr[nB];
            nC = Math.abs(nrs[iC]); c = vScr[nC];

if (Tools2D.area2(a, b, c) >= 0)
            {  // Edges AB and BC; diagonal AC.
               // Test to see if no vertex (other than A,
               // B, C) lies within triangle ABC:
               j = next[iC]; nj = Math.abs(nrs[j]);
               while (j != iA &&
                     (nj == nA || nj == nB || nj == nC ||
                     !Tools2D.insideTriangle(a, b, c, vScr[nj])))
                  {  j = next[j]; nj = Math.abs(nrs[j]);
                  }
               if (j == iA)
               {  // Triangle found:
                  t[k] = new Tria(nA, nB, nC);
                  next[iA] = iC;
                  found = true;
               }
            }
            iA = next[iA];
         }
         if (count == n)
         {  // Degenerated polygon, possibly with all
           // vertices on one line.
            if (nA >= 0) t[k] = new Tria(nA, nB, nC);
            else
            { System.out.println("Nonsimple polygon");
              System.exit(1);
            }
         }
      }
   }
}

The vertex numbers of the given polygon are available in the array nrs, while those of each resulting triangle are stored in an element of the array t. The most difficult part of this class is the method triangulate, which is the 3D equivalent of the Tools2D method with the same name, discussed in Section 2.13 and not used in this chapter.

The canvas classes we will be using will contain the methods getObj and setObj, to retrieve and store a reference to an Obj3D object. In view of a separate frame class, Fr3D, we need to define the following abstract class:

// Canvas3D.java: Abstract class.
import java.awt.*;

abstract class Canvas3D extends Canvas
{  abstract Obj3D getObj();
   abstract void setObj(Obj3D obj);
}

Remember, abstract classes are only useful to create subclasses, not to define objects. Any (non-abstract) subclass of Canvas3D is simply a subclass of the standard class Canvas, except that it is guaranteed to define the methods getObj and setObj. For example, in the next section we will discuss a class CvWireframe of which the first line reads

class CvWireframe extends Canvas3D

By writing here Canvas3D instead of Canvas, we are obliged to define the methods getObj and setObj in this CvWireframe class, and in return we are allowed to call these two methods for any object of class CvWireframe. We will clarify the use of the abstract class Canvas3D further at the end of this section.

The class Fr3D will be used in four non-trivial 3D programs of this book, Wireframe.java (Section 5.6), HLines.java (Chapter 6), Painter.java (Section 7.3) and ZBuf.java (Section 7.4). Since these programs will have the same menus, it makes sense to let them share the file Fr3D.java, listed below, in which much of the code is related to these menus. The Java compiler accepts the calls cv.getObj() and cv.setObj(obj) in this file because, as Canvas3D is an abstract class, the actual type of cv can only be a subclass of it. As we have just seen, this implies that this subclass will define the methods getObj and setObj:

// Fr3D.java: Frame class to deal with menu commands and other
//    user actions.
import java.awt.*;
import java.awt.event.*;
import java.util.*;

class Fr3D extends Frame implements ActionListener
{  protected MenuItem open, exit, eyeUp, eyeDown, eyeLeft, eyeRight,
      incrDist, decrDist;
   protected String sDir;

protected Canvas3D cv;
   protected Menu mF, mV;

   Fr3D(String argFileName, Canvas3D cv, String textTitle)
   { super(textTitle);
     addWindowListener(new WindowAdapter()
        {public void windowClosing(WindowEvent e){System.exit(0);}});
     this.cv = cv;
     MenuBar mBar = new MenuBar();
     setMenuBar(mBar);
     mF = new Menu("File");
     mV = new Menu("View");
     mBar.add(mF); mBar.add(mV);

     open = new MenuItem("Open",
        new MenuShortcut(KeyEvent.VK_O));
     eyeDown = new MenuItem("Viewpoint Down",
        new MenuShortcut(KeyEvent.VK_DOWN));
     eyeUp = new MenuItem("Viewpoint Up",
        new MenuShortcut(KeyEvent.VK_UP));
     eyeLeft = new MenuItem("Viewpoint to Left",
        new MenuShortcut(KeyEvent.VK_LEFT));
     eyeRight = new MenuItem("Viewpoint to Right",
        new MenuShortcut(KeyEvent.VK_RIGHT));

     incrDist = new MenuItem("Increase viewing distance",
        new MenuShortcut(KeyEvent.VK_INSERT));
     decrDist = new MenuItem("Decrease viewing distance",
        new MenuShortcut(KeyEvent.VK_DELETE));
     exit = new MenuItem("Exit",
        new MenuShortcut(KeyEvent.VK_Q));
     mF.add(open); mF.add(exit);
     mV.add(eyeDown); mV.add(eyeUp);
     mV.add(eyeLeft); mV.add(eyeRight);
     mV.add(incrDist); mV.add(decrDist);
     open.addActionListener(this);
     exit.addActionListener(this);
     eyeDown.addActionListener(this);
     eyeUp.addActionListener(this);
     eyeLeft.addActionListener(this);
     eyeRight.addActionListener(this);
     incrDist.addActionListener(this);
     decrDist.addActionListener(this);

add("Center", cv);
     Dimension dim = getToolkit().getScreenSize();
     setSize(dim.width/2, dim.height/2);
     setLocation(dim.width/4, dim.height/4);
     if (argFileName != null)
     {  Obj3D obj = new Obj3D();
        if (obj.read(argFileName)){cv.setObj(obj); cv.repaint();}
     }
     cv.setBackground(new Color (180, 180, 255) );
     show();
   }

   void vp(float dTheta, float dPhi, float fRho) // Viewpoint
   {  Obj3D obj = cv.getObj();
      if (obj == null || !obj.vp(cv, dTheta, dPhi, fRho))
         Toolkit.getDefaultToolkit().beep();
   }

   public void actionPerformed(ActionEvent ae)
   {  if (ae.getSource() instanceof MenuItem)
      {  MenuItem mi = (MenuItem)ae.getSource();
         if (mi == open)
         {  FileDialog fDia = new FileDialog(Fr3D.this,
            "Open", FileDialog.LOAD);
            fDia.setDirectory(sDir);
            fDia.setFile("*.dat");
            fDia.show();
            String sDir1 = fDia.getDirectory();
            String sFile = fDia.getFile();
            String fName = sDir1 + sFile;
            Obj3D obj = new Obj3D();
            if (obj.read(fName))
            {  sDir = sDir1;
               cv.setObj(obj);
               cv.repaint();
            }
         }
         else
         if (mi == exit) System.exit(0); else
         if (mi == eyeDown) vp(0, .1F, 1); else
         if (mi == eyeUp) vp(0, -.1F, 1); else
         if (mi == eyeLeft) vp(-.1F, 0, 1); else
         if (mi == eyeRight) vp(.1F, 0, 1); else

if (mi == incrDist) vp (0, 0, 2); else
         if (mi == decrDist) vp(0, 0, .5F);
      }
   }
}

Notice the use of the abstract class Canvas3D in the line

Fr3D(String argFileName, Canvas3D cv, String textTitle)

almost at the beginning of class Fr3D. We cannot replace Canvas3D with Canvas here because the compiler would not accept the statement

cv.setObj(obj);

in the if-statement near the end of the Fr3D constructor. After all, setObj is not a method of the standard Java class Canvas. Since, in the next section we will actually be using the class CvWireframe, of which setObj is really a method, it is tempting to write CvWireframe instead of Canvas3D. This would indeed work, but then we would not be able to use the class Fr3D also in programs with canvas classes other than CvWireframe, as we will do in Chapters 6 and 7. We now see that the abstract class Canvas3D is very useful. It is general enough to be used in several of our programs and yet less general than the standard Canvas class in that it 'promises' an implementation of the methods setObj and getObj. We will discuss some aspects of the class Fr3D in Chapter 7 when using it.

It is now time to see the program Wireframe.java in action. For example, let us use the object with vertices 1, 2, . . ., 6, shown in Figure 5.12.

Figure 5.12. Object and vertex numbers

With dimensions 1, 3 and 5 for the thickness, the width and the height, respectively, the following data file specifies this object:

1   1 0 0
2   1 3 0
3   0 3 0
4   0 0 0
5   1 0 5
6   0 0 5
Faces:
1 2 5.
3 4 6.
2 3 6 5.
1 5 6 4.
1 4 3 2.

When running program Wireframe.java and opening the above input file, a window as shown in Figure 5.13 appears.

Figure 5.13. Default view of object

Figure 5.14. Same object viewed from the back

By moving the point of view, using the Viewpoint to Right command from the View menu or its shortcut Ctrl+Arrow right a number of times, we obtain a different view of the same object, as shown in Figure 5.14.

Note that the program chooses a default viewing distance which is quite reasonable. If desired we can increase or decrease this distance using two commands from the View menu.

EXERCISES

5.1 Modify program CubePers.java of Section 5.4 in such a way that, with the given viewpoint, only the visible edges are drawn as solid black lines; draw the other, invisible lines in a different color, or, as usually in mechanical engineering, as dashed lines (see Exercise 1.5).

5.2 Use a fillPolygon method to display only the top, right and front faces of Figure 5.10 as filled polygons of different colors.

5.3 To prepare for Exercise 5.5, extend program CubePers.java of Section 5.4 so that two cubes beside each other are generated.

Figure 5.15. Snapshot of two cubes rotating about vertical axes

5.4 Use the class Rota3D of Section 3.9 to apply animation with double buffering to the cube of Section 5.4, using a rotation about some line, say, 0–6 (see Figure 5.11) through some small angle. If you are unfamiliar with animation in Java or with the Java class Image, required for double buffering, you will find the program Anim.java in Appendix F helpful.

5.5 As Exercise 5.4, but the rotation is to be applied to the two cubes of Exercise 5.3. Use different axes of rotation and increase the rotation angles for the two cubes by different amounts, so that the cubes seem to rotate independently of each other, with different speeds. Figure 5.15 shows a snapshot of the two cubes, each rotating about one of its vertical edges.