//Contains common 3D stuff
//clipping, perspective, etc

import java.awt.*;
import graphics.Matrix3D;
import graphics.MatrixStack;
import graphics.ClipPlane;
import graphics.Light;

public class ThreeDApplet extends RasterizerApplet
{
  //perspective value
  private double F = 10;

  private MatrixStack stack;
  private ClipPlane clipper = new ClipPlane(0, 0, 1, 0.001); //Pz + eps

  //can be overridden by child applet
  Light[] lights;
  protected int[] ambient = {0,0,0};

  //EXTEND THIS
  public void initialize()
  {
    super.initialize();
    stack = new MatrixStack();
  }

  public void initFrame(long time)
  {
    super.initFrame(time);

    try {
      animate(time);
    }
    catch (Exception e) {
      e.printStackTrace();
      stop();
      return;
    }

    draw();
  }

  //OVERRIDE THESE
  void draw() {}
  void animate(long time) {}

  protected void applyPerspective(double f, double[][] vertices)
  {
    for (int i = 0; i< vertices.length; i++)
    {
      double[] v = vertices[i];
      double z = v[2];
      double fz = f/z;

      v[0] *= fz; v[1] *= fz; //scale x, y
      v[2] = fz;
    }
  }

  public void drawShape(graphics.Shape s)
  {
    s.shade(lights, ambient); //apply vertex shading

    int vlength = s.getVertex(0).length; //length of each vertex

    //loop through each face
    for (int fi = 0; fi < s.numFaces(); fi++)
    {
      int[] face = s.getFace(fi);

      //copy from vertices to points
      double[][] points = new double[face.length][vlength];
      for (int i = 0; i<face.length; i++)
        System.arraycopy(s.getVertex(face[i]), 0, points[i], 0, vlength);
        //points[i] = (double [])s.getVertex(face[i]).clone();

      if (face.length == 3) drawTriangle(points);
      else if (face.length == 4) drawQuad(points);
    }
  }

  //to get the good old fashioned wireframe look :-)
  public void outlineShape(graphics.Shape s, int[] color)
  {
    for (int fi = 0; fi < s.numFaces(); fi++)
    {
      int[] face = s.getFace(fi);
      double[][] lines = new double[face.length][3];

      for (int i = 0; i < face.length; i++)
      {
        double[] v = s.getVertex(face[i]);
        lines[i][0] = v[0]; lines[i][1] = v[1]; lines[i][2] = v[2];
      }

      drawLine(lines[0], lines[1], color);
      drawLine(lines[1], lines[2], color);
      drawLine(lines[2], lines[0], color);

      if (face.length == 4)
      {
        //(2->3, 3->0, 0->2)
        drawLine(lines[2], lines[3], color);
        drawLine(lines[3], lines[0], color);
        drawLine(lines[0], lines[2], color);
      }
    }
  }

  //draws normals for all a shape's vertices
  public void drawNormals(graphics.Shape s, int[] color) {drawNormals(s, color, 1.0);}
  public void drawNormals(graphics.Shape s, int[] color, double scale)
  {
    for (int vi=0; vi<s.numVertices(); vi++)
    {
      double[] v = s.getVertex(vi);
      double[] p1 = new double[3], p2 = new double[3];

      //set one endpoint of line to where vertex is
      p1[0] = v[0]; p1[1] = v[1]; p1[2] = v[2];

      //move other endpoint along normal
      p2[0] = v[0]+scale*v[3]; p2[1] = v[1]+scale*v[4]; p2[2] = v[2]+scale*v[5];

      drawLine(p1, p2, color);
    }
  }

  public void drawTriangle(double[][] triangle) {drawTriangle(triangle, true);} //clip by default
  public void drawTriangle(double[][] triangle, boolean doClip)
  {
//System.err.println("triangle");
//dumpVertices(triangle);

    if (doClip)
    {
      //clipped polygon may be a quad
      double[][] poly = new double[4][triangle[0].length];

      int numClippedVerts = clipper.clipTriangle(triangle, poly);

      if (numClippedVerts == 0) return; 
      if (numClippedVerts == 4)
      {
        drawQuad(poly, false); //don't re-clip these triangles
        return;
      }

      for (int i = 0; i < 3; i++)
        triangle[i] = poly[i]; //copy new polygon info into triangle
    }

    applyPerspective(F, triangle);

    //viewport transformation
    triangle[0][0] = x(triangle[0][0]); triangle[0][1] = y(triangle[0][1]);
    triangle[1][0] = x(triangle[1][0]); triangle[1][1] = y(triangle[1][1]);
    triangle[2][0] = x(triangle[2][0]); triangle[2][1] = y(triangle[2][1]);

    renderTriangle(triangle); //send to RasterizerApplet
  }

  //draws quad as two triangles
  public void drawQuad(double[][] quad) {drawQuad(quad, true);} //clip by default
  public void drawQuad(double[][] quad, boolean doClip)
  {
    double[][] triangle = new double[3][6]; //3 points with 6 values each

    //(0->1, 1->2, 2->0)
    System.arraycopy(quad[0], 0, triangle[0], 0, 6); //1st point of triangle
    System.arraycopy(quad[1], 0, triangle[1], 0, 6); //2nd point of triangle
    System.arraycopy(quad[2], 0, triangle[2], 0, 6); //3rd point of triangle
    drawTriangle(triangle, doClip);

    //(2->3, 3->0, 0->2)
    System.arraycopy(quad[2], 0, triangle[0], 0, 6); //1st point of triangle
    System.arraycopy(quad[3], 0, triangle[1], 0, 6); //2nd point of triangle
    System.arraycopy(quad[0], 0, triangle[2], 0, 6); //3rd point of triangle
    drawTriangle(triangle, doClip);
  }

  public void drawLine(double[] a, double[] b, int[] color)
  {
//System.err.println("in drawLine:");
//System.err.println("("+a[0]+", "+a[1]+", "+a[2]+")");
//System.err.println("("+b[0]+", "+b[1]+", "+b[2]+")");

    double[][] line = new double[2][a.length];
    System.arraycopy(a, 0, line[0], 0, a.length);
    System.arraycopy(b, 0, line[1], 0, b.length);

    //if clipline returns false it means don't draw the line
    boolean doDraw = clipper.clipLine(line[0], line[1]);
    if (!doDraw) return;

    applyPerspective(F, line);

    //viewport transformation
    line[0][0] = (double)x(line[0][0]); line[0][1] = (double)y(line[0][1]);
    line[1][0] = (double)x(line[1][0]); line[1][1] = (double)y(line[1][1]);

    renderLine(line[0], line[1], color); //send to RasterizerApplet
  }

  //Viewport transformations
  int x(double t) { return W/2 + (int)(t*W/4); }
  int y(double t) { return H/2 - (int)(t*W/4); }

  //applies matrix at the top of the stack to a shape
  public void transform(graphics.Shape shape)
  {
    shape.matrix.copy(stack.peek());
    shape.transform();
  }

  //applies matrix at the top of the stack to a vertex
  public void transform(double[] src, double[] dst)
  {
    stack.peek().transform(src, dst);
  }

  //convenience methods for stack operations
  protected void push()
  {
    stack.push();
  }
  protected Matrix3D pop()
  {
    return stack.pop();
  }

  public void rotateX(double theta)
  {
    stack.peek().rotateX(theta);
  }
  public void rotateY(double theta)
  {
    stack.peek().rotateY(theta);
  }
  public void rotateZ(double theta)
  {
    stack.peek().rotateZ(theta);
  }
  public void translate(double x, double y, double z)
  {
    stack.peek().translate(x, y, z);
  }
  public void scale(double x, double y, double z)
  {
    stack.peek().scale(x, y, z);
  }
}