import java.applet.AudioClip;
import java.awt.*;

public class hw6 extends BufferedApplet
{
	AudioClip sound;
	double epsilon= 0.001;
	int ns=0;
	long time;
	int counterTranslate = 0;
	int maxTranslate = 3;
	int flipEyes = 0;

	int len=100;
	Matrix3D S[]=new Matrix3D[len];
	Matrix3D pushz = new Matrix3D();

	public void rotateX(double theta){
		S[ns].rotateX(theta);
	}
	public void rotateY(double theta){
		S[ns].rotateY(theta);
	}
	public void rotateZ(double theta){
		S[ns].rotateZ(theta);
	}
	public void translate(double a, double b, double c){
		S[ns].translate(a,b,c);
	}
	public void scale(double a, double b, double c){
		S[ns].scale(a,b,c);
	}

	void push(){
		if ((ns+1)>len){
			Matrix3D S1[]=new Matrix3D[len + 1];
			for (int i=0; i<len; i++)
				S1[i]=S[i];
			S=S1;
			System.out.println("Increasing matrix size\n");
		}
		S[ns+1]=new Matrix3D();
		S[ns+1].copy(S[ns]);
		ns++;
	}

	void pop(){
		if (ns>0)
			--ns;
		else
			System.out.println("Cannot pop very first matrix\n");
	}


	void transform2(Shape shape){
		shape.transfo=new Matrix3D();
		shape.transfo.copy(S[ns]);
	}

	double eval(double[][] keyData, double t){
		int i=0;
		while (t>=keyData[i+1][0]){
			i++;
		}
		return (keyData[i][1] + (keyData[i+1][1] - keyData[i][1])*(t-keyData[i][0])/(keyData[i+1][0] - keyData[i][0]));
	}

	double hermite[][]={
		{2, -2, 1, 1},
		{-3, 3, -2, -1},
		{0, 0, 1, 0},
		{1, 0, 0, 0}
	};

	double bezier[][]={
		{-1, 3, -3, 1},
		{3, -6, 3, 0},
		{-3, 3, 0, 0},
		{1, 0, 0, 0}
	};



	double eval2(double [][] keyData, double t){
		int i=0;
		while (t>=keyData[i+1][0]){
			i++;
		}
		double tmp = (t-keyData[i][0])/(keyData[i+1][0] - keyData[i][0]);
		double tvect[] = {tmp*tmp*tmp, tmp*tmp, tmp, 1};
		double coeff[] = new double[4];
		for (int j=0; j<4; j++)
			coeff[j]=hermite[j][0]*keyData[i][1] + hermite[j][1]*keyData[i+1][1] + hermite[j][2]*keyData[i][2] + hermite[j][3]*keyData[i+1][2];
		return tvect[0]*coeff[0]+tvect[1]*coeff[1]+tvect[2]*coeff[2]+tvect[3]*coeff[3];


	}

	double eval3(double [][] keyData, double t){
		int i=0;
		while (t>=keyData[i+1][0]){
			i++;
		}
		double tmp = (t-keyData[i][0])/(keyData[i+1][0] - keyData[i][0]);
		double tvect[] = {tmp*tmp*tmp, tmp*tmp, tmp, 1};
		double coeff[] = new double[4];
		for (int j=0; j<4; j++)
			coeff[j]=bezier[j][0]*keyData[i][1] + bezier[j][1]*keyData[i][2] + bezier[j][2]*keyData[i][3] + bezier[j][3]*keyData[i+1][1];
		return tvect[0]*coeff[0]+tvect[1]*coeff[1]+tvect[2]*coeff[2]+tvect[3]*coeff[3];


	}




	int w, h, count = 0;
	int colr, colg,colb,currcol = 255;
	double t = 0;
	long time0;
	double elapsed;

	double headData[][] = {
		{0.0, 0.0},
		{3.0, Math.PI/4},
		{6.0, 0.0},
		{16.0, 0.0}
	};

	double headData2[][] = {
		{0.0, 0.0, 0.0},
		{9.0, Math.PI/3, 0.0},
		{11.0, 0.0, 0.0},
		{14.0, -Math.PI/3, 0.0},
		{16.0, 0.0, 0.0},
	};



	double bodyDataX[][] = {
		{0.0, -1.0},
		{4.0, 1.0},
		{5.0, 1.0},
		{9.0, -1.0},
		{10.0, -1.0},
	};
	double bodyDataY[][] = {
		{0.0, -1.0},
		{4.0, -1.0},
		{5.0, -0.5},
		{9.0, -0.5},
		{10.0, 0.0},
		{14.0, 0.0},
		{15.0, -0.5},
		{19.0, -0.5},
		{20.0, -1.0},
	};

	double bodyDataX2[][] = {
		{0.0, 0.0, 1.0, 1.0},
		{5.0, 0.0, -1.0, -1.0},
		{10.0, 0.0, 1.0, 1.0},
	};
	double bodyDataY2[][] = {
		{0.0, -1.0, -0.6, -0.3},
		{10.0, 0.0, -0.3, -0.6},
		{20.0, -1.0, -0.6, -0.3},
	};

	double footData[][] = {
	{0.0, 0.0},
	{1.0, Math.PI/6},
	{3.0, -Math.PI/6},
	{4.0, 0.0}};

	double onCubeMove[][] = {
	{0.0, 0.0},
	{2.0, 0.25},
	{6.0, -0.25},
	{8.0, 0.0}};
	
	double onCubeMove2[][] = {
	{0.0, 0.0, 0.5},
	{2.0, 0.25, 0.0},
	{4.0, 0.0, -0.5},
	{6.0, -0.25,0.0},
	{8.0, 0.0, 0.5}};

	double onCubeMoveZ[][] = {
		{0.0,-3.0},
		{2.0,-1.0},
		{10.0,-1.0},
		{12.0,3.0},
		{14.0,-1.0},
		{18.0,-1.0},
		{24.0,-3.0},
	};
	
	double onCubeRotation[][] = {
	{0.0, 0.0},
	{1.75, 0.0},
	{2.0, Math.PI/2},
	{2.25, Math.PI},
	{5.75, Math.PI},
	{6.0, 3*Math.PI/2},
	{6.25, 2*Math.PI},
	{8.0, 2*Math.PI}};

	double onCubeRotation2[][] = {
	{0.0, 0.0, 0.0},
	{2.0, Math.PI/2, 2.0},
	{4.0, Math.PI, 0.0},
	{6.0, 3*Math.PI/2, 2.0},
	{8.0, 2*Math.PI, 0.0}};



	Shape body = new Shape();
	Shape head = new Shape();
	Shape beak = new Shape();
	Shape leftEye = new Shape();
	Shape rightEye = new Shape();
	Shape leftEyeBlack = new Shape();
	Shape rightEyeBlack = new Shape();
	Shape leftFoot = new Shape();
	Shape rightFoot = new Shape();
	Shape base = new Shape();
	Shape duck[]= new Shape[10];
	Matrix3D baseTransfo[] = new Matrix3D[10];
	Matrix3D shapeTransfo[] = new Matrix3D[10];
	Matrix3D placeTransfo[] = new Matrix3D[10];

	Matrix3D persp = new Matrix3D();

	public void init() {
		super.init();


	}

	public void render(Graphics g) {
		if (w == 0) {
		
			initialize();
			w = bounds().width;
			h = bounds().height;
			g.setColor(Color.black);    
			g.fillRect(0,0,w,h);
			time0 = System.currentTimeMillis();

		}


		g.setColor(Color.black);    
		g.fillRect(0,0,w,h);
		time = System.currentTimeMillis();
		elapsed = (double)(time - time0) / 1000.0;

		animate();                



		count ++;
		g.setColor(Color.blue);
		trace(base,g);
		if (flipEyes==0){
			g.setColor(Color.red);
			trace(leftFoot,g);
			trace(rightFoot,g);
			g.setColor(Color.red);
			trace(beak,g);

			g.setColor(Color.white);
			trace(leftEye,g);
			trace(rightEye,g);
			g.setColor(Color.black);
			trace(leftEyeBlack,g);
			trace(rightEyeBlack,g);
			g.setColor(Color.yellow);
			trace(body,g);
			trace(head,g);
		}
		else{
			g.setColor(Color.yellow);
			trace(body,g);
			trace(head,g);
			g.setColor(Color.red);
			trace(leftFoot,g);
			trace(rightFoot,g);
			g.setColor(Color.red);
			trace(beak,g);

			g.setColor(Color.white);
			trace(leftEye,g);
			trace(rightEye,g);
			g.setColor(Color.black);
			trace(leftEyeBlack,g);
			trace(rightEyeBlack,g);
		}


	}

	void animate() {
		Matrix3D tmp=new Matrix3D();


		double t1 = Math.sin(elapsed/2);
		
		S[ns].identity();
		S[ns].translate(0,0.3,0);
		S[ns].translate(eval3(bodyDataX2,(count/20.0)%10),eval3(bodyDataY2,(count/20.0)%20),0);
		//S[ns].translate(eval(bodyDataX,(count/20.0)%10),eval(bodyDataY,(count/20.0)%20),0);
		transform2(base);
		base.transfo.multiplyRight(baseTransfo[9]);
		push();//base
		S[ns].translate(eval2(onCubeMove2,(count/20.0)%8),0,0);
		//S[ns].translate(eval(onCubeMove,(count/20.0)%8),0,0);
		S[ns].translate(0,0,eval(onCubeMoveZ,(count/20.0)%24));
		if ((count/20.0)%24>18)
			flipEyes=0;
		else
			flipEyes=1;
		S[ns].rotateYRight(-1*eval2(onCubeRotation2,(count/20.0)%8));
		//S[ns].rotateYRight(-1*eval(onCubeRotation,(count/20.0)%8));
	
		for (int i=0; i<9; i++){
			transform2(duck[i]);
			duck[i].transfo.multiplyRight(baseTransfo[i]);

		}
		push();//left foot
		tmp.copy(baseTransfo[7]);
		tmp.rotateZ(eval(footData,(count/3.0)%4));
		S[ns].multiplyRight(tmp);
		transform2(leftFoot);
		pop();//left foot
		push();//right foot
		tmp.copy(baseTransfo[8]);
		tmp.rotateZ(-1.0*eval(footData,(count/3.0)%4));
		S[ns].multiplyRight(tmp);
		transform2(rightFoot);
		pop();//right foot

		push();//head
		double tmpAngle = eval(headData,((double)count/10.0)%16);
		S[ns].scaleRight(0.1,0.1,0.1);
		S[ns].translateRight(1.2*Math.sin(Math.PI/6+tmpAngle),1.2*Math.cos(Math.PI/6+tmpAngle),0);
		S[ns].rotateYRight(eval2(headData2,((double)count/10.0)%16));
		for (int l=1; l<7; l++){
			push();//head item
			S[ns].multiplyRight(shapeTransfo[l]);
			transform2(duck[l]);
			pop();//head item
		}

		pop();//head
		pop();//base


		///////////////////////////////////////////////////////////////////////////////////////
	}

	int px(double t) { return (int)(w/2 + (int)(t*w/4)); }
	int py(double t) { return (int) (h/2 - (int)(t*w/4)); } 

	void traceBak(Shape s, Graphics g ){
		transform(s);


		for (int i=0; i<s.NFACES; i++)
			for (int j=0; j<s.NSIDES; j++){
				int index1= s.faces[i][j];
				int index2= s.faces[i][(j+1)%s.NSIDES];
				double[] pt1=s.vertices[index1];
				double[] pt2=s.vertices[index2];

				g.drawLine(s.px[index1],s.py[index1],s.px[index2],s.py[index2]);
			}

	}

	void trace(Shape s, Graphics g ){
		//transformNopersp(s);
		double dstxyz[]=new double[4];
		double dstxyzTmp[]=new double[4];
		double srcxyz[]=new double[4];
		s.transfo.multiplyLeft(pushz);


		for (int i=0; i<s.NFACES; i++){
			int indexPenult= s.faces[i][s.NSIDES - 1];
			
			double[] ptPenult=new double[4];
			srcxyz[0]=s.vertices[indexPenult][0];
			srcxyz[1]=s.vertices[indexPenult][1];
			srcxyz[2]=s.vertices[indexPenult][2];
			srcxyz[3]=1;
			s.transfo.transform(srcxyz,ptPenult);

			for (int j=0; j<(s.NSIDES - 2); j++){
				int countVert = 0;
				double[][] currVert = new double[4][4];
				int index1= s.faces[i][j];
				int index2= s.faces[i][(j+1)%s.NSIDES];
				
				double[] pt1=new double[4];
				srcxyz[0]=s.vertices[index1][0];
				srcxyz[1]=s.vertices[index1][1];
				srcxyz[2]=s.vertices[index1][2];
				srcxyz[3]=1;
				s.transfo.transform(srcxyz,pt1);

				double[] pt2=new double[4];
				srcxyz[0]=s.vertices[index2][0];
				srcxyz[1]=s.vertices[index2][1];
				srcxyz[2]=s.vertices[index2][2];
				srcxyz[3]=1;
				s.transfo.transform(srcxyz,pt2);

				double z1 = pt1[2] + epsilon;
				double z2 = pt2[2] + epsilon;
				double z3 = ptPenult[2] + epsilon;

				if (z1<=0){
					currVert[countVert]=pt1;
					++countVert;
				}
				if (z1*z2 < 0){
					double tCross = z1/(z1-z2);
					for (int zu=0; zu<3; zu++){
						currVert[countVert][zu]=pt1[zu]+tCross*(pt2[zu]-pt1[zu]);

					}
					++countVert;
				}

				if (z2<=0){
					currVert[countVert]=pt2;
					++countVert;
				}
				if (z2*z3 < 0){
					double tCross = z2/(z2-z3);
					for (int zu=0; zu<3; zu++){
						currVert[countVert][zu]=pt2[zu]+tCross*(ptPenult[zu]-pt2[zu]);

					}
					++countVert;
				}

				if (z3<=0){
					currVert[countVert]=ptPenult;
					++countVert;
				}
				if (z3*z1 < 0){
					double tCross = z3/(z3-z1);
					for (int zu=0; zu<3; zu++){
						currVert[countVert][zu]=ptPenult[zu]+tCross*(pt1[zu]-ptPenult[zu]);

					}
					++countVert;
				}
				int[][] thisPol = new int[countVert][2];
				for (int zui=0; zui<countVert ; zui++){
					srcxyz[0]=currVert[zui][0];
					srcxyz[1]=currVert[zui][1];
					srcxyz[2]=currVert[zui][2];
					srcxyz[3]=1;
					persp.transform(srcxyz,dstxyz);
					thisPol[zui][0]=px(dstxyz[0]/dstxyz[3]);
					thisPol[zui][1]=py(dstxyz[1]/dstxyz[3]);
				}


				for (int zui=0; zui<(countVert - 2); zui++){


					g.drawLine(thisPol[zui][0],thisPol[zui][1],thisPol[zui+1][0], thisPol[zui+1][1]);
					g.drawLine(thisPol[zui+1][0],thisPol[zui+1][1],thisPol[countVert-1][0], thisPol[countVert-1][1]);
					g.drawLine(thisPol[countVert-1][0], thisPol[countVert-1][1],thisPol[zui][0],thisPol[zui][1]);
				}
			}
		}

	}




	void transform(Shape s){
		double dstxyz[]=new double[4];
		double dstxyzTmp[]=new double[4];
		double srcxyz[]=new double[4];
		//	s.transfo.multiplyLeft(persp);
		for (int i=0; i<s.NVERTICES; i++){
			double currvertex[]=s.vertices[i];
			srcxyz[0]=currvertex[0];
			srcxyz[1]=currvertex[1];
			srcxyz[2]=currvertex[2];
			srcxyz[3]=1;
			s.transfo.transform(srcxyz,dstxyzTmp);
			persp.transform(dstxyzTmp,dstxyz);
			/*s.px[i]=px(dstxyz[0]);
			  s.py[i]=py(dstxyz[1]);*/
			s.px[i]=px(dstxyz[0]/dstxyz[3]);
			s.py[i]=py(dstxyz[1]/dstxyz[3]);
		}


	}
	void transformNopersp(Shape s){
		double dstxyz[]=new double[4];
		double srcxyz[]=new double[4];
		for (int i=0; i<s.NVERTICES; i++){
			double currvertex[]=s.vertices[i];
			srcxyz[0]=currvertex[0];
			srcxyz[1]=currvertex[1];
			srcxyz[2]=currvertex[2];
			srcxyz[3]=1;
			s.transfo.transform(srcxyz,dstxyz);
			s.px[i]=px(dstxyz[0]);
			s.py[i]=py(dstxyz[1]);
		}


	}

	void transformBak(Shape s){
		double dstxyz[]=new double[4];
		double srcxyz[]=new double[4];
		s.transfo.multiplyLeft(persp);
		for (int i=0; i<s.NVERTICES; i++){
			double currvertex[]=s.vertices[i];
			srcxyz[0]=currvertex[0];
			srcxyz[1]=currvertex[1];
			srcxyz[2]=currvertex[2];
			srcxyz[3]=1;
			s.transfo.transform(srcxyz,dstxyz);
			/*s.px[i]=px(dstxyz[0]);
			  s.py[i]=py(dstxyz[1]);*/
			s.px[i]=px(dstxyz[0]/dstxyz[3]);
			s.py[i]=py(dstxyz[1]/dstxyz[3]);
		}


	}

	void initialize(){
		sound = getAudioClip(getCodeBase(), "poulenc2.wav"); 
		//sound.loop();                                   
		sound.play();                                   
		persp.scaleMatrix(-10.0,-10.0,0);
		persp.set(3,2,1);
		persp.set(3,3,0);
		persp.set(2,3,-10.0);
		pushz.scaleMatrix(.1,0.1,1);
		//pushz.translationMatrix(0.0,0.0,-2.0);
		//persp.multiplyRight(pushz);

		S[0]=new Matrix3D();
		S[0].identity();
		for (int i=0;i<10;i++){
			baseTransfo[i] = new Matrix3D();
			shapeTransfo[i] = new Matrix3D();
			placeTransfo[i] = new Matrix3D();
		}
		duck[0]=body;
		duck[1]=head;
		duck[2]=beak;
		duck[3]=leftEye;
		duck[4]=rightEye;
		duck[5]=leftEyeBlack;
		duck[6]=rightEyeBlack;
		duck[7]=leftFoot;
		duck[8]=rightFoot;
		duck[9]=base;

		body.sphere(20,20);
		body.transfo.rotateX(Math.PI/2);
		body.transfo.scale(0.8,1,1);
		shapeTransfo[0].copy(body.transfo);
		placeTransfo[0].identity();

		head.sphere(20,20);
		head.transfo.rotateX(Math.PI/2);
		head.transfo.scale(0.6,0.6,0.6);
		shapeTransfo[1].copy(head.transfo);
		head.transfo.translate(1.2*Math.sin(Math.PI/6),1.2*Math.cos(Math.PI/6),0);
		placeTransfo[1].translate(1.2*Math.sin(Math.PI/6),1.2*Math.cos(Math.PI/6),0);


		beak.cone(20);
		beak.transfo.rotateY(Math.PI/2);
		beak.transfo.scale(0.25,0.12,0.12);
		beak.transfo.translate(0.8,0,0);
		beak.transfo.rotateZ(-Math.PI/9);
		shapeTransfo[2].copy(beak.transfo);
		beak.transfo.translate(1.2*Math.sin(Math.PI/6),1.2*Math.cos(Math.PI/6),0);
		placeTransfo[2].copy(placeTransfo[1]);

		leftEye.cone(20);
		leftEye.transfo.scale(0.08,0.1,0.05);
		leftEye.transfo.rotateY(Math.PI/2);
		leftEye.transfo.translate(0.6*Math.cos(Math.PI/6)*Math.cos(Math.PI/10),0.6*Math.sin(Math.PI/10),-0.6*Math.cos(Math.PI/10)*Math.sin(Math.PI/6));
		shapeTransfo[3].copy(leftEye.transfo);
		leftEye.transfo.translate(1.2*Math.sin(Math.PI/6),1.2*Math.cos(Math.PI/6),0);
		placeTransfo[3].copy(placeTransfo[1]);

		rightEye.cone(20);
		rightEye.transfo.scale(0.08,0.1,0.05);
		rightEye.transfo.rotateY(Math.PI/2);
		rightEye.transfo.translate(0.6*Math.cos(Math.PI/6)*Math.cos(Math.PI/10),0.6*Math.sin(Math.PI/10),0.6*Math.cos(Math.PI/6)*Math.sin(Math.PI/6));
		shapeTransfo[4].copy(rightEye.transfo);
		rightEye.transfo.translate(1.2*Math.sin(Math.PI/6),1.2*Math.cos(Math.PI/6),0);
		placeTransfo[4].copy(placeTransfo[1]);


		leftEyeBlack.cone(20);
		leftEyeBlack.transfo.scale(0.08,0.1,0.05);
		leftEyeBlack.transfo.scale(0.7,0.7,0.7);
		leftEyeBlack.transfo.rotateY(Math.PI/2);

		leftEyeBlack.transfo.translate(0.6*Math.cos(Math.PI/6)*Math.cos(Math.PI/15),0.6*Math.sin(Math.PI/15),-0.6*Math.cos(Math.PI/15)*Math.sin(Math.PI/6));
		shapeTransfo[5].copy(leftEyeBlack.transfo);
		leftEyeBlack.transfo.translate(1.2*Math.sin(Math.PI/6),1.2*Math.cos(Math.PI/6),0);
		placeTransfo[5].copy(placeTransfo[1]);

		rightEyeBlack.cone(20);
		rightEyeBlack.transfo.scale(0.08,0.1,0.05);
		rightEyeBlack.transfo.scale(0.7,0.7,0.7);
		rightEyeBlack.transfo.rotateY(Math.PI/2);
		rightEyeBlack.transfo.translate(0.6*Math.cos(Math.PI/7)*Math.cos(Math.PI/15),0.6*Math.sin(Math.PI/15),0.6*Math.cos(Math.PI/15)*Math.sin(Math.PI/7));
		shapeTransfo[6].copy(rightEyeBlack.transfo);
		rightEyeBlack.transfo.translate(1.2*Math.sin(Math.PI/6),1.2*Math.cos(Math.PI/6),0);
		placeTransfo[6].copy(placeTransfo[1]);

		leftFoot.cube();
		leftFoot.transfo.scale(0.3,0.1,0.1);
		leftFoot.transfo.translate(0,-0.1,0);
		leftFoot.transfo.rotateZ(Math.PI/6);
		shapeTransfo[7].copy(leftFoot.transfo);
		leftFoot.transfo.translate(-1*Math.sin(Math.PI/15),-1*Math.cos(Math.PI/15),-0.1);
		placeTransfo[7].translate(-1*Math.sin(Math.PI/15),-1*Math.cos(Math.PI/15),-0.1);
		/*leftFoot.transfo.translate(-1*Math.sin(Math.PI/5),-1*Math.cos(Math.PI/5),-0.1);
		  placeTransfo[7].translate(-1*Math.sin(Math.PI/5),-1*Math.cos(Math.PI/5),-0.1);*/

		rightFoot.cube();
		rightFoot.transfo.scale(0.3,0.1,0.1);
		rightFoot.transfo.translate(0,-0.1,0);
		rightFoot.transfo.rotateZ(-Math.PI/6);
		shapeTransfo[8].copy(rightFoot.transfo);
		rightFoot.transfo.translate(-1*Math.sin(Math.PI/15),-1*Math.cos(Math.PI/15),0.1);
		placeTransfo[8].translate(-1*Math.sin(Math.PI/15),-1*Math.cos(Math.PI/15),0.1);
		/*rightFoot.transfo.translate(-1*Math.sin(Math.PI/5),-1*Math.cos(Math.PI/5),0.1);
		  placeTransfo[8].translate(-1*Math.sin(Math.PI/5),-1*Math.cos(Math.PI/5),0.1);*/

		base.cube();
		base.transfo.scale(3,3,30);
		shapeTransfo[9].copy(base.transfo);
		base.transfo.translate(0,-4,0);
		placeTransfo[9].translate(0,-4,0);

		for (int i=0; i<10; i++){
			duck[i].transfo.scale(0.1,0.1,0.1);
			//	placeTransfo[i].scale(0.1,0.1,0.1);
			baseTransfo[i].copy(duck[i].transfo);
		}



	}


}