// the figure to render on the screen
Figure figure;
// viewpoint from which we look at the 3D scene
Point3D EYE = new Point3D(0,0,-3);
// angle by which to rotate
double ANGLE = 0.1;
// amount by which to translate
double TRANS = 0.5;
// this number denotes the plane z = ZOOM on which the scene
// is going to be projected
double ZOOM = -2;
// factor by which to zoom in or out
double ZOOM_DIST = 0.5;

void setup() {
  size(350,350); // set the size of the canvas
  noLoop(); // we do not need animations
  
  figure = makeCube();
  //figure = makeTetrahedron();
}

void draw() {
  background(255); // clear the screen first
  figure.draw(EYE, ZOOM);
}

// make a cube based on 6 quadrilaterals
Figure makeCube() {
  // TODO: fill in the points and the side planes
  Point3D a = new Point3D(0,0,0);
  Point3D b = new Point3D(0,0,0);
  Point3D c = new Point3D(0,0,0);
  Point3D d = new Point3D(0,0,0);
  Point3D e = new Point3D(0,0,0);
  Point3D f = new Point3D(0,0,0);
  Point3D g = new Point3D(0,0,0);
  Point3D h = new Point3D(0,0,0);

  Polygon[] faces = new Polygon[6];
  faces[0] = makeQuad(a,a,a,a);
  faces[1] = makeQuad(a,a,a,a);
  faces[2] = makeQuad(a,a,a,a);
  faces[3] = makeQuad(a,a,a,a);
  faces[4] = makeQuad(a,a,a,a);
  faces[5] = makeQuad(a,a,a,a);
  return new Figure(faces);
}

// make a tetrahedron based on 4 triangle sides
Figure makeTetrahedron() {
  // TODO: fill in points and plane coordinates
  Point3D a = new Point3D(0,0,0);
  Point3D b = new Point3D(0,0,0);
  Point3D c = new Point3D(0,0,0);
  Point3D d = new Point3D(0,0,0);

  Polygon[] faces = new Polygon[4];
  faces[0] = makeTriangle(a,a,a);
  faces[1] = makeTriangle(a,a,a);
  faces[2] = makeTriangle(a,a,a);
  faces[3] = makeTriangle(a,a,a);
  return new Figure(faces);
}

Polygon makeQuad(Point3D a, Point3D b, Point3D c, Point3D d) {
  return new Polygon(new Point3D[] { a,b,c,d });
}

Polygon makeTriangle(Point3D a, Point3D b, Point3D c) {
  return new Polygon(new Point3D[] { a,b,c });
}

// called when we want to zoom in
void zoomIn(double distance) {
  // TODO: zoom in code
  println("zoom in");
}

// called when we want to zoom out
void zoomOut(double distance) {
  // TODO: zoom out code
  println("zoom out");
}

// called when we want to rotate
void rotateX(double angle) {
  figure.rotateX(angle);
  println("rotateX");
}

void rotateY(double angle) {
  figure.rotateY(angle);
  println("rotateY");
}

void rotateZ(double angle) {
  figure.rotateZ(angle);
  println("rotateZ");
}

// called when we want to translate
public void translate(double x, double y, double z) {
  figure.translate(x,y,z);
  println("translate");
}

/**
 * A figure is a 3D polyhedron consisting of a number of faces,
 * each being a polygon in 3-space
 */
class Figure {
   Polygon[] faces;
    
   Figure(Polygon[] faces) {
       this.faces = faces;
   }
    
   /* Translate the figure using offsets along the three principal axes  */
   void translate(double xofs, double yofs, double zofs) {
        for (int i=0; i<faces.length; i++) {
            faces[i].translate(xofs,yofs,zofs);
        }   
   }

   /* Rotate the figure around one of the principal axes. Angle is in radians */
   void rotateX(double angle) {
        for (int i=0; i<faces.length; i++) {
            faces[i].rotateX(angle);
        }
   }
   
   void rotateY(double angle) {
        for (int i=0; i<faces.length; i++) {
            faces[i].rotateY(angle);
        }
   }
   
   void rotateZ(double angle) {
        for (int i=0; i<faces.length; i++) {
            faces[i].rotateZ(angle);
        }
   }

   /* Draws the figure in the proper perspective projection
    * @param g the graphics context to draw in
    * @param eye the coordinates of the point from where the scene is viewed
    * @param zoom the scaling factor / defines the plane on which the scene is projected
    */
   void draw(Point3D eye, double zoom) {
        for (int i=0; i<faces.length; i++) {
            faces[i].draw(eye,zoom);
        }   
   }
}

class Point3D {

  double x, y, z;
	
  Point3D(double x, double y, double z) {
    this.x=x;
    this.y=y;
    this.z=z;
  }
	
  // project a point (x1,y1,z1) on the plane z = zoom,
  // from viewpoint (eye.x,eye.y,eye.z)
  Point3D project(Point3D eye, double zoom) {
    // TODO: projection-code
    return new Point3D(0,0,0);
  }
	
  Point3D translate(double xofs, double yofs, double zofs) {
    // TODO: translation-code
    return new Point3D(0,0,0);
  }

  // use the following methods to rotate the point across the X, Y or Z axis

  Point3D rotateX(double angle) {
    // TODO: X-rotation code
    return new Point3D(0,0,0);
  }

  Point3D rotateY(double angle) {
    // TODO: Y-rotation code
    return new Point3D(0,0,0);
  }
	
  Point3D rotateZ(double angle) {
    // TODO: Z-rotation code
    return new Point3D(0,0,0);
  }
}

class Polygon {

  Point3D[] vertices;
   
  Polygon(Point3D[] vertices) {
    this.vertices = vertices;
  }
	
  /* Draws the figure in the proper perspective projection
   * @param g the graphics context to draw in
   * @param eye the coordinates of the point from where the scene is viewed
   * @param zoom the scaling factor / defines the plane on which the scene is projected
   * @param width the screen width 
   * @param height the screen height 
   */
  void draw(Point3D eye, double zoom) {
    noFill();
    beginShape();	
      // TODO: calculate projected x and y coords based on vertices[i]
      for (int i=0; i < vertices.length; i++) {
        int x = 0;
        int y = 0;
        vertex(x, y);
      }
    endShape(CLOSE);
  }

  /* Translate the figure using offsets along the three principal axes  */
  void translate(double xofs, double yofs, double zofs) {
    for(int i=0; i<vertices.length; i++) {
      vertices[i] = vertices[i].translate(xofs,yofs,zofs);
    }
  }
	
  /* Rotate the figure around one of the principal axes. Angle is in radians */
  void rotateX(double angle) {
    for(int i=0; i<vertices.length; i++) {
      vertices[i] = vertices[i].rotateX(angle);
    }
  }

  void rotateY(double angle) {
    for(int i=0; i<vertices.length; i++) {
      vertices[i] = vertices[i].rotateY(angle);
    }
  }

  void rotateZ(double angle) {
    for(int i=0; i<vertices.length; i++) {
      vertices[i] = vertices[i].rotateZ(angle);
    }
  }

}

// this function is called each time a key is released on the keyboard
void keyReleased() {
  switch (key) {
    case '+' : zoomIn(ZOOM_DIST); break;
    case '-' : zoomOut(ZOOM_DIST); break;
  }
  switch(keyCode) {
    case KeyEvent.VK_LEFT  : rotateY(-ANGLE); break;
    case KeyEvent.VK_RIGHT : rotateY(+ANGLE); break;
    case KeyEvent.VK_UP    : rotateX(-ANGLE); break;
    case KeyEvent.VK_DOWN  : rotateX(+ANGLE); break;
    case KeyEvent.VK_PAGE_UP   : rotateZ(-ANGLE); break;
    case KeyEvent.VK_PAGE_DOWN : rotateZ(+ANGLE); break;
    case KeyEvent.VK_NUMPAD8 : translate(0,+TRANS,0); break;
    case KeyEvent.VK_NUMPAD6 : translate(+TRANS,0,0); break;
    case KeyEvent.VK_NUMPAD2 : translate(0,-TRANS,0); break;
    case KeyEvent.VK_NUMPAD4 : translate(-TRANS,0,0); break;
    case KeyEvent.VK_NUMPAD0 : translate(0,0,+TRANS); break;
    case KeyEvent.VK_NUMPAD5 : translate(0,0,-TRANS); break;
  }
  redraw();
}