Homework 6, due Wednesday, Oct 16.

Your assignment is to write a java applet that makes some sort of interactively animated person, creature, machine, dancing tree, hopping vehicle, or whatever. The only rules are:

1. You need to implement a kinematic machine whose API is as described below.

2. You need to build your content on top of this kinematic machine.

• Implement a motion curve editor, so that the user can draw time-varying curves to specify joint rotation angles over time (somewhat hard).

• Implement a simple GUI that lets users interactively construct their own creatures, or build their own creature out of simple components. (hard).

• Make your creature respond to the user's mouse movement in some interesting way. (easy).

• Render the scene using perspective (ie: farther away objects appear smaller than nearer objects). Here's how: Assume your "camera" is at point (0,0,focal_length), and is gazing at the origin, so that the origin (0,0,0) should appear at the center of the image. You can implement perspective by modifying your Viewport transformation as follows:
  1. x = focal_length * x / (focal_length - z);
  2. y = focal_length * y / (focal_length - z);
  3. Convert (x,y) to pixels exactly as you did in the Viewport transform of earlier assignments, so that (0,0) is drawn at the center pixel of the image, and (-0.5,0.5*H/W) is drawn at the upper-left corner of the image. (easy).

• Implement two-link inverse kinematics, as described here. (somewhat hard).

API for a kinematic motion machine:

   void initFrame();
   void push();
   void pop();
   void translate(double x,double y,double z);
   void rotateX(double theta);
   void rotateY(double theta);
   void rotateZ(double theta);
   void scale(double x,double y,double z);
   void transform(double src[], double dst[])

Then you call the other routines in any sequence you want, with the the caveat that calls to km.push() and km.pop() must occur in matching pairs (like the rules for parentheses).

Remember that the translate, rotate and scale methods operate only on the top item in the matrix stack S[sp].

The km.push() method duplicates the top entry in the stack, thereby making the stack grow.

The km.pop() method just decrements the stack pointer.

When you implement km.push() and km.pop(), be sure to put in code that checks for stack overflow and underflow errors.

The method km.transform(src,dst) allows you to query the kinematic machine so that you can draw things. For example, if you want to draw the square:

   double A[][] = {{0,0,0},{.1,0,0},{.1,.1,0},{0,.1,0}};

   drawPolygon(double A);

Below is a really simple example of an applet that uses the API that I described above. It just draws two cubes, an inner cube spinning inside an outer cube. Don't hand this in as your homework, but go ahead and use it for reference:

import java.awt.*;

public class testKM extends GenericApplet
{
   int width, height, x = 100, y = 100;
   KM km = new KM();                    // ALLOCATE THE KINEMATIC MACHINE

   // DEFINE 8 VERTICES AND 6 FACES OF A CUBE

   double aaa[] = {-1,-1,-1}, baa[] = { 1,-1,-1}, aba[] = {-1, 1,-1}, bba[] = { 1, 1,-1},
          aab[] = {-1,-1, 1}, bab[] = { 1,-1, 1}, abb[] = {-1, 1, 1}, bbb[] = { 1, 1, 1};
   double a[][][] = {
      { aaa, baa, bba, aba }, { aab, bab, bbb, abb }, { aaa, aba, abb, aab },
      { baa, bba, bbb, bab }, { aaa, baa, bab, aab }, { aba, bba, bbb, abb },
   };

   double L[][] = new double[100][3];
   int count = 0;

   public void render(Graphics g) {
      if (width == 0) {
         width  = bounds().width;
         height = bounds().height;
      }
      if (damage) {
         g.setColor(Color.white);
         g.fillRect(0, 0, width, height);
         g.setColor(Color.black);

	 km.initFrame();           // INIT FRAME
	 km.scale(.2,.2,.2);
	 km.rotateY(.1 * x);       // RESPOND TO MOUSE
	 km.rotateX(.1 * y);

	 // DRAW THE OUTER CUBE

         for (int n = 0 ; n < a.length; n++)
            drawPolygon(g, a[n]);

	 km.scale(.5,.5,.5);       // SCALE DOWN
	 km.rotateX(.11 * count);
	 km.rotateY(.12 * count);  // SPIN
	 km.rotateZ(.13 * count);

	 // DRAW THE INNER CUBE

         for (int n = 0 ; n < a.length; n++)
            drawPolygon(g, a[n]);

         count++;
      }
   }

   void drawPolygon(Graphics g, double A[][]) {

      // DECLARE A TEMPORARY ARRAY

      double B[][] = new double[A.length][3];

      // TRANSFORM ALL VERTICES OF POLYGON INTO TEMPORARY ARRAY

      for (int i = 0 ; i < A.length ; i++)
         km.transform(A[i], B[i]);

      // DRAW LINES BETWEEN SUCCESSIVE TRANSFORMED VERTICES

      for (int i = 0 ; i < A.length ; i++) {
         int j = (i + 1) % A.length;
         g.drawLine(viewportX(B[i]),viewportY(B[i]),
                    viewportX(B[j]),viewportY(B[j]));
      }
   }

   double F = 3.5;  // FOCAL LENGTH

   int viewportX(double V[]) {
      // HERE'S WHERE YOU MIGHT IMPLEMENT PERSPECTIVE
      return (int)(width/2 + V[0] * width);
   }

   int viewportY(double V[]) {
      // HERE'S WHERE YOU MIGHT IMPLEMENT PERSPECTIVE
      return (int)(height/2 - V[1] * width);
   }

   public boolean mouseDown(Event e, int x, int y) { moveXY(x, y); return true; }
   public boolean mouseDrag(Event e, int x, int y) { moveXY(x, y); return true; }
   void moveXY(int x, int y) { this.x = x; this.y = y; damage = true; }
}