/**
 *A class to store a matrix and perform basic linear transformation on that matrix
 *
 *
 *
 *
 */
public class Matrix4x4{
/**
 *Public (callable from the outside)
 *methods
 */
 
   /**
    *Puts an identity matrix into data
    */
   public void identity(){
     doIdentity(data);
   }
   /**
    *Rotate about Z axis
    **/
   public void rotateZ( double theta) {
      doMakeRotationZ(theta, temp);
      doMultiply(data, temp, temp2);              // postMultiply
      copyData(temp2, data);
   }

   /**
    *Rotate about Y axis
    **/
   public void rotateY( double theta) {
      doMakeRotationY(theta, temp);
      doMultiply(data, temp, temp2);              // postMultiply
      copyData(temp2, data);
   }
   /**
    *Rotate about X axis
    **/
   public void rotateX( double theta) {
      doMakeRotationX(theta, temp);
      doMultiply(data, temp, temp2);              // postMultiply
      copyData(temp2, data);
   }
   
   public void makeRotationZ(double theta) {
      doMakeRotationZ(theta, data);
   }
   
   public void makeRotationY(double theta) {
      doMakeRotationY(theta, data);
   }
   public void makeRotationX(double theta) {
      doMakeRotationX(theta, data);
   }
   public void scale(double sx, double sy, double sz) {
      doMakeScale(sx, sy, sz, temp);
      doMultiply(data, temp, temp2);              // postMultiply
      copyData(temp2, data);
   }

   public void perspective(double f) {
      doMakePerspective(f, temp);
      doMultiply(data, temp, temp2);              // postMultiply
      copyData(temp2, data);
   }

   public void makeScale(double sx, double sy, double sz) {
      doMakeScale(sx, sy, sz, data);
   }

   public void makePerspective(double f) {
      doMakePerspective(f, data);
   }

   public void translate(double dx, double dy, double dz) {
      doMakeTranslation(dx, dy, dz, temp);
      doMultiply(data, temp, temp2);              // postMultiply
      copyData(temp2, data);
   }

   public void makeTranslation(double dx, double dy, double dz) {
      doMakeTranslation(dx, dy, dz, data);
   }

   public void postMultiply(Matrix4x4 src) {
      doMultiply(data, src.data, temp);
      copyData(temp, data);
   }

   public void preMultiply(Matrix4x4 src) {
      doMultiply(src.data, data, temp);
      copyData(temp, data);
   }

   public void transform(double x, double y, double z, double dst[]) {
      dst[0] = data[0][0] * x + data[0][1] * y + data[0][2]*z+data[0][3];
      dst[1] = data[1][0] * x + data[1][1] * y + data[1][2]*z+data[1][3];
      dst[2] = data[2][0] * x + data[2][1] * y + data[2][2]*z+data[2][3];
   }
   
   protected boolean setData(double src[][]){
        if(src.length!=4) return false;
        if(src[1].length!=4) return false;
        for(int i=0; i< 4;i++)
          for(int j = 0; j < 4;j++)
              data[i][j] = src[i][j];
       return true;//only return true if success;
    }
   
   public Matrix4x4 getCopy(){
        Matrix4x4 m = new Matrix4x4();
        m.setData(this.data);
        return m;
    }
    
    public void printData(){
        for(int i=0; i< 4;i++){
          for(int j = 0; j < 4;j++){
              System.out.print (" "+data[i][j]);
                }
                System.out.println();
        }
    }



/**
 *Internal workhorse methods
 */

   /**
    *Set given matrix to the identity
    */
   protected static void doIdentity(double data[][]) {
     for (int i = 0 ; i <4  ; i++)
        for (int j = 0 ; j < 4 ; j++)
            data[i][j] = i == j ? 1 : 0;//only one if on the diagonal, otherwise 0
   }
   
   protected static void doMakeRotationZ(double theta, double data[][]) {
      doIdentity(data);
      data[0][0] = Math.cos(theta);
      data[0][1] = -Math.sin(theta);
      data[1][0] = Math.sin(theta);
      data[1][1] = Math.cos(theta);
   }
   
   protected static void doMakeRotationY(double theta, double data[][]) {
      doIdentity(data);
      data[2][2] = Math.cos(theta);
      data[2][0] = -Math.sin(theta);
      data[0][2] = Math.sin(theta);
      data[0][0] = Math.cos(theta);
   }
   
   protected static void doMakeRotationX(double theta, double data[][]) {
      doIdentity(data);
      data[1][1] = Math.cos(theta);
      data[1][2] = -Math.sin(theta);
      data[2][1] = Math.sin(theta);
      data[2][2] = Math.cos(theta);
   }
   
    protected static void doMakePerspective(double f, double data[][]) {
      doIdentity(data);
      data[2][2] = 0;
      data[2][3] = 1/f;
      data[3][2] = 1/f;
      data[3][3] = 1;
   }
   
   protected static void doMakeScale(double sx, double sy, double sz, double data[][]) {
      doIdentity(data);
      data[0][0] = sx;
      data[1][1] = sy;
      data[2][2] = sz;
   }
   protected static void doMakeTranslation(double dx, double dy, double dz, double data[][]) {
      doIdentity(data);
      data[0][3] = dx;
      data[1][3] = dy;
      data[2][3] = dz;
  }

   protected static void doMultiply(double a[][], double b[][], double c[][]) {
      for (int i = 0 ; i < 4  ; i++)
      for (int j = 0 ; j < 4  ; j++)
         c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j] + a[i][3] * b[3][j];
   }

   protected static void copyData(double src[][], double dst[][]) {
      for (int i = 0 ; i < 4 ; i++)
      for (int j = 0 ; j < 4 ; j++)
         dst[i][j] = src[i][j];
   }
  
/**
 *Global variables
 */
  protected double data[][] = new double[4][4];//matrix is 4x4
  private   double temp[][] = new double[4][4];//temp matrix for moving things around in internal workhorse methods
  private   double temp2[][]= new double[4][4];//another temp for the same reason
}