public class Shape {

	int NVERTICES,NFACES,NSIDES;
	Matrix3D transfo = new Matrix3D(); 
	double vertices[][];
	int faces[][];
	int px[];
	int py[];



	void sphere(int M, int N){
		transfo.identity();
		double theta, phi;
		double xyz[]= new double[3];
		int index, index1;
		NVERTICES = M*(N+1);
		NFACES = M*N;
		NSIDES = 4;
		vertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		faces = new int[NFACES][NSIDES];
		for (int n=0; n<=N ; n++)
			for (int m=0;m<M; m++){
				theta=2*Math.PI*m/M;
				phi=Math.PI*n/N-Math.PI/2;
				xyz[0]=Math.cos(theta)*Math.cos(phi);
				xyz[1]=Math.sin(theta)*Math.cos(phi);
				xyz[2]=Math.sin(phi);
				index=n*M+m;
				for (int k=0;k<3; k++){
					vertices[index][k]=xyz[k];
					vertices[index][k+3]=xyz[k];
				}
				if (n>0){
					index1=(n-1)*M+m;
					faces[index1][0]=(n-1)*M+m;
					faces[index1][1]=(n-1)*M+((m+1)%M);
					faces[index1][2]=n*M+((m+1)%M);
					faces[index1][3]=n*M+m;
				}
			}
	}

	void torus(int M, int N, double a, double b){
		transfo.identity();
		double theta, phi;
		double xyz[]= new double[6];
		int index, index1;
		NVERTICES = M*(N+1);
		NFACES = M*N;
		NSIDES = 4;
		vertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		faces = new int[NFACES][NSIDES];
		for (int n=0; n<=N ; n++)
			for (int m=0;m<M; m++){
				theta=2*Math.PI*m/M;
				phi=2*Math.PI*n/N;
				xyz[0]=(a+b*Math.cos(phi))*Math.cos(theta);
				xyz[1]=(a+b*Math.cos(phi))*Math.sin(theta);
				xyz[2]=b*Math.sin(phi);
				xyz[3]=Math.cos(theta)*Math.cos(phi);
				xyz[4]=Math.sin(theta)*Math.cos(phi);
				xyz[5]=Math.sin(phi);

				index=n*M+m;
				for (int k=0;k<6; k++){
					vertices[index][k]=xyz[k];
				}
				if (n>0){
					index1=(n-1)*M+m;
					faces[index1][0]=(n-1)*M+m;
					faces[index1][1]=(n-1)*M+((m+1)%M);
					faces[index1][2]=n*M+((m+1)%M);
					faces[index1][3]=n*M+m;
				}
			}
	}


	void cube(){
		transfo.identity();
		int index, index1;
		NVERTICES = 24;
		NFACES = 6;
		NSIDES = 4;
		vertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		faces = new int[NFACES][NSIDES];
		


		for (int xyz=0;xyz<3;xyz++)
			for (int j=0;j<=1;j++){
				index1 = 2*xyz+j;
				index = 2*NSIDES*xyz + NSIDES*j ;
				for (int k=0;k<NSIDES;k++){
					faces[index1][k]=index+k;
				}


			}
		for (int xyz=0;xyz<3;xyz++){
			for (int j=0; j<2; j++){
				int val=2*j-1;
				for (int k=0; k<4; k++){
					vertices[2*4*xyz+k+j*4][3]=0;
					vertices[2*4*xyz+k+j*4][4]=0;
					vertices[2*4*xyz+k+j*4][5]=0;
					vertices[2*4*xyz+k+j*4][xyz]=val;
					vertices[2*4*xyz+k+j*4][xyz+3]=val;
				}
				vertices[j*4+2*4*xyz][(xyz+1)%3]=val;
				vertices[j*4+2*4*xyz][(xyz+2)%3]=-1;
				vertices[j*4+2*4*xyz+1][(xyz+1)%3]=val;
				vertices[j*4+2*4*xyz+1][(xyz+2)%3]=1;
				vertices[j*4+2*4*xyz+2][(xyz+1)%3]=-val;
				vertices[j*4+2*4*xyz+2][(xyz+2)%3]=1;
				vertices[j*4+2*4*xyz+3][(xyz+1)%3]=-val;
				vertices[j*4+2*4*xyz+3][(xyz+2)%3]=-1;
			}
		}

	}

	void tube(int N){
		transfo.identity();
		double theta;
		double xyz[]= new double[3];
		int index;
		NVERTICES = 2*N;
		NFACES = N;
		NSIDES = 4;
		vertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		faces = new int[NFACES][NSIDES];
		for (int n=0; n<N ; n++){
			theta=2*Math.PI*n/N;
			for (int l=0; l<2; l++){
				xyz[0]=Math.cos(theta);
				xyz[1]=Math.sin(theta);
				xyz[2]=2*l-1;
				index=l*N+n;
				for (int k=0;k<3; k++){
					vertices[index][k]=xyz[k];
					vertices[index][k+3]=xyz[k];
				}
				vertices[index][5]=0;
				faces[n][0]=n;
				faces[n][1]=(n+1)%N;
				faces[n][2]=(n+1)%N+N;
				faces[n][3]=n+N;
			}
		}
	}

	void cap(int N, double z){
		transfo.identity();
		double theta;
		double xyz[]= new double[3];
		NVERTICES = N + 1;
		NFACES = N;
		NSIDES = 3;
		vertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		faces = new int[NFACES][NSIDES];
		if (z>0){
			double tmppt[]={0,0,z,0,0,1};
			vertices[N]=tmppt;
		}
		else{
			double tmppt[]={0,0,z,0,0,-1};
			vertices[N]=tmppt;
		}
		for (int n=0; n<N ; n++){
			theta=2*Math.PI*n/N;
			xyz[0]=Math.cos(theta);
			xyz[1]=Math.sin(theta);
			for (int k=0;k<2; k++){
				vertices[n][k]=xyz[k];
				vertices[n][k+3]=xyz[k];

			}
			vertices[n][2]=z;
			if (z>0){
				vertices[n][5]=1;
				faces[n][0]=n;
				faces[n][1]=(n+1)%N;
			}

			else{
				vertices[n][5]=-1;
				faces[n][1]=n;
				faces[n][0]=(n+1)%N;
			}
			faces[n][2]=N;
		}
	}

	void cap2(int N, double z){
		transfo.identity();
		double theta;
		double xyz[]= new double[3];
		NVERTICES = N + 1;
		NFACES = N;
		NSIDES = 4;
		vertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		faces = new int[NFACES][NSIDES];
		if (z>0){
			double tmppt[]={0,0,z,0,0,1};
			vertices[N]=tmppt;
		}
		else{
			double tmppt[]={0,0,z,0,0,-1};
			vertices[N]=tmppt;
		}
		for (int n=0; n<N ; n++){
			theta=2*Math.PI*n/N;
			xyz[0]=Math.cos(theta);
			xyz[1]=Math.sin(theta);
			for (int k=0;k<2; k++){
				vertices[n][k]=xyz[k];
				vertices[n][k+3]=xyz[k];

			}
			vertices[n][2]=z;
			if (z>0){
				vertices[n][5]=1;
				faces[n][0]=n;
				faces[n][1]=(n+1)%N;
			}

			else{
				vertices[n][5]=-1;
				faces[n][1]=n;
				faces[n][0]=(n+1)%N;
			}
			faces[n][2]=N;
			faces[n][3]=N;
		}
	}


	void cylinder(int N){
		transfo.identity();
		NVERTICES = 4*N+2;
		NFACES = 3*N;
		NSIDES = 4;
		vertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		faces = new int[NFACES][NSIDES];
		Shape tmptube = new Shape();
		Shape cap1 = new Shape();
		Shape cap2 = new Shape();
		tmptube.tube(N);
		cap1.cap(N,1);
		cap2.cap(N,-1);
		for (int i=0;i<tmptube.NVERTICES;i++)
			vertices[i]=tmptube.vertices[i];
		for (int i=0;i<cap1.NVERTICES; i++)
			vertices[tmptube.NVERTICES+i]=cap1.vertices[i];
		for (int i=0;i<cap2.NVERTICES; i++)
			vertices[tmptube.NVERTICES+cap1.NVERTICES+i]=cap2.vertices[i];
		for (int i=0;i<tmptube.NFACES;i++)
			faces[i]=tmptube.faces[i];
		for (int i=0;i<cap1.NFACES; i++)
			for (int j=0; j<NSIDES; j++)
				if (j<cap1.NSIDES)
					faces[tmptube.NFACES+i][j]=cap1.faces[i][j]+tmptube.NVERTICES;
				else
					faces[tmptube.NFACES+i][j]=cap1.faces[i][cap1.NSIDES-1]+tmptube.NVERTICES;
		for (int i=0;i<cap2.NFACES; i++)
			for (int j=0; j<NSIDES; j++)
				if (j<cap2.NSIDES)
					faces[tmptube.NFACES+cap1.NFACES+i][j]=cap2.faces[i][j] + tmptube.NVERTICES + cap1.NVERTICES;
				else
					faces[tmptube.NFACES+cap1.NFACES+i][j]=cap2.faces[i][cap2.NSIDES-1]+ tmptube.NVERTICES + cap1.NVERTICES;

/*		for (int i=0;i<cap1.NFACES; i++)
			faces[tmptube.NFACES+i]=cap1.faces[i];
		for (int i=0;i<cap2.NFACES; i++)
			faces[tmptube.NFACES+cap1.NFACES+i]=cap2.faces[i];*/

	}

	void carre(){
		transfo.identity();
		int index, index1;
		NVERTICES = 4;
		NFACES = 1;
		NSIDES = 4;
		vertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		faces = new int[NFACES][NSIDES];
		double tmpvertices[][]={{1,-1,1,0,0,1},
			{1,1,1,0,0,1},
			{-1,1,1,0,0,1},
			{-1,-1,1,0,0,1}};
		vertices=tmpvertices;
		int tmpfaces[]={0,1,2,3};
		faces[0]=tmpfaces;
	}

	void pyramid(int N){
		double theta;
		double phi0 = Math.PI/4;
		double h = Math.cos(Math.PI/N);
		double Nxyz[]= new double[3];
		transfo.identity();
		NVERTICES = 4*N+1;
		NFACES = 2*N;
		NSIDES = 3;
		vertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		faces = new int[NFACES][NSIDES];
		Shape base = new Shape();
		base.cap(N,-1);
		vertices[N]=base.vertices[N];
		for (int n=0; n<N ; n++){
			vertices[n]=base.vertices[n];
			theta=2*Math.PI*n/N + Math.PI/N;
			Nxyz[0]=Math.cos(theta)*Math.cos(phi0);
			Nxyz[1]=Math.sin(theta)*Math.cos(phi0);
			Nxyz[2]=Math.sin(phi0);

			vertices[N+1+3*n+2][0]=0;
			vertices[N+1+3*n+2][1]=0;
			vertices[N+1+3*n+2][2]=h;
			for (int tr=0; tr<3; tr++){
				vertices[N+1+3*n][tr]=base.vertices[n][tr];
				vertices[N+1+3*n+1][tr]=base.vertices[(n+1)%N][tr];
				vertices[N+1+3*n][tr+3]=Nxyz[tr];
				vertices[N+1+3*n+1][tr+3]=Nxyz[tr];
				vertices[N+1+3*n+2][tr+3]=Nxyz[tr];

			}
		}
		for (int i=0 ; i<N; i++){
			faces[i]=base.faces[i];
			for (int tr=0; tr<3; tr++)
				faces[i+N][tr]=N+1+3*i+tr;
		}







	}
	void cone(int N){
		double theta;
		double phi0 = Math.PI/4;
		double h = Math.cos(Math.PI/N);
		double Nxyz[]= new double[3];
		transfo.identity();
		NVERTICES = 3*N+1;
		NFACES = 2*N;
		NSIDES = 3;
		vertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		faces = new int[NFACES][NSIDES];
		Shape base = new Shape();
		base.cap(N,-1);
		vertices[N]=base.vertices[N];
		for (int n=0; n<N ; n++){
			vertices[n]=base.vertices[n];
			theta=2*Math.PI*n/N;
			Nxyz[0]=Math.cos(theta)*Math.cos(phi0);
			Nxyz[1]=Math.sin(theta)*Math.cos(phi0);
			Nxyz[2]=Math.sin(phi0);

			vertices[N+1+2*n+1][0]=0;
			vertices[N+1+2*n+1][1]=0;
			vertices[N+1+2*n+1][2]=h;
			for (int tr=0; tr<3; tr++){
				vertices[N+1+2*n][tr]=base.vertices[n][tr];
				vertices[N+1+2*n][tr+3]=Nxyz[tr];
				vertices[N+1+2*n+1][tr+3]=Nxyz[tr];

			}
		}
		for (int i=0 ; i<N; i++){
			faces[i]=base.faces[i];
			faces[i+N][0]=N+1+2*i;
			faces[i+N][1]=N+1+2*((i+1)%N);
			faces[i+N][2]=N+1+2*i+1;
		}







	}



}