public class Shape2 {

	int NVERTICES,NFACES,NSIDES;
	Matrix3D transfo = new Matrix3D(); 
	double vertices[][];
	material m=new material();
	double tVertices[][];//transformed vertices
	static double epsilon;
	static double foc ;
	static int nlights;
	static light[] lights;
	int faces[][];
	int px[];
	int py[];
	double pz[];
	double rgb[][];
	int ord[];
	static double zBuffer[][];
	static double FrameBuffer[][][];
	
	static void setEps(double e){
		epsilon=e;
	}
	static void setFoc(double f){
		foc=f;

	}
	static void setLights(int nb, double dirs[][], double rgbs[][]){
		lights=new light[nb];
		nlights=nb;
		for (int i=0;i<nlights;i++){
			lights[i]=new light();
			lights[i].setRgb(rgbs[i]);
			lights[i].setDir(dirs[i]);
		}
	}

	static void setBuffers(double zBuf[][], double FrameBuf[][][]){
		zBuffer=zBuf;
		FrameBuffer=FrameBuf;
	}

	void setMaterial(material ms){
		m.copy(ms);
	}

	void transform(){
		for (int i=0; i<NVERTICES; ++i){
			double src[]=new double[4];
			double dst[]=new double[4];
			for (int j=0;j<3;j++){
				src[j]=vertices[i][j];
			}
			src[3]=1;
			transfo.transform(src,dst);
			for (int j=0;j<3;j++){
				tVertices[i][j]=dst[j];
			}

			for (int j=0;j<3;j++){
				src[j]=vertices[i][j+3];
			}
			src[3]=1;
			transfo.transformN(src,dst);
			for (int j=0;j<3;j++){
				tVertices[i][j+3]=dst[j];
			}
		}
	}

	void shade(){
		for (int i=0; i<NVERTICES; ++i){
			for (int j=0;j<3;j++){
				rgb[i][j]=m.ambient[j];
				if (lights!=null){
					for (int k=0;k<lights.length;k++){
						double[] tmp=new double[3];
						tmp[0]=tVertices[i][3];
						tmp[1]=tVertices[i][4];
						tmp[2]=tVertices[i][5];
						double[] normNorm=normalize(tmp);
						double vald=lights[k].dir[0]*normNorm[0]+lights[k].dir[1]*normNorm[1]+lights[k].dir[2]*normNorm[2];
						if (vald>0)
							rgb[i][j]+=lights[k].rgb[j]*m.diffuse[j]*vald;// diffuse
						tmp[0]=tVertices[i][0];
						tmp[1]=tVertices[i][1];
						tmp[2]=tVertices[i][2];
						double[] normPos=normalize(tmp);
						double vals=normPos[0]*(lights[k].dir[0]-2*vald*normNorm[0])+normPos[1]*(lights[k].dir[1]-2*vald*normNorm[1])+normPos[2]*(lights[k].dir[2]-2*vald*normNorm[2]);
						if (vals>0)

							rgb[i][j]+=lights[k].rgb[j]*m.specular[j]*pow(vals,m.p);
					}
				}
			}
		}
	}

	double pow(double f1, int f2){
		double res=1;
		for (int i=0;i<f2+1;i++)
			res*=f1;
		return res;
	}
	
	double[] normalize(double[] src){
		double[] res=new double[src.length];
		double norm=Math.sqrt(pow(src[0],2)+pow(src[1],2)+pow(src[2],2));
		for (int i=0; i<src.length;i++)
			res[i]=src[i]/norm;
		return res;
	}

	void viewPort(int W, int H){
		for (int i=0; i<NVERTICES; ++i){
			px[i]=(int)(W/2 + (int)(tVertices[i][0]*W/4));
			py[i]=(int)(H/2 - (int)(tVertices[i][1]*W/4));
		}

	}

	void paint(int W, int H){
		//setBuffers(zBuf,FrameBuf);
		//only for a triangle
		// split the triangle:
		trapeze trapezia[]=getTrapeze();

		// paint accordingly
		for (int i=0; i<trapezia.length;++i){
			trapezia[i].paintTrapeze(W,H);
		}
	}

	Shape2[] triangularize(){
		int nShapes=0;
		Shape2[] res=new Shape2[NFACES*(NSIDES-2)];
		for (int i=0; i<NFACES; i++){
			double[][] baseVert=new double[3][6];
			double[][] baseTVert=new double[3][6];
			for (int k=0;k<6;k++){
				baseVert[0][k]=vertices[faces[i][0]][k];// first vertex
				baseTVert[0][k]=tVertices[faces[i][0]][k];// first vertex
			}
			for (int j=2; j<NSIDES;j++){
				for (int k=0;k<6;k++){
					baseVert[1][k]=vertices[faces[i][j-1]][k];// second vertex
					baseTVert[1][k]=tVertices[faces[i][j-1]][k];// second vertex
					baseVert[2][k]=vertices[faces[i][j]][k];// third vertex
					baseTVert[2][k]=tVertices[faces[i][j]][k];// third vertex
				}
				res[nShapes]=new Shape2();
				res[nShapes].triangle(baseVert);
				for(int l=0;l<3;l++)
					res[nShapes].setTxyz(baseTVert[l],l);
				res[nShapes].transfo.copy(transfo);
				res[nShapes].m.copy(m);
				nShapes++;
			}
		}
		return res;
	}

	void copy(Shape2 src){
		ord=new int[3];
		NVERTICES=src.NVERTICES;
		NFACES=src.NFACES;
		NSIDES=src.NSIDES;
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		pz=new double [NVERTICES];
		rgb=new double[NVERTICES][3];
		faces = new int[NFACES][NSIDES];
		vertices = new double[NVERTICES][6];
		tVertices = new double[NVERTICES][6];
		transfo.copy(src.transfo); 
		m.copy(src.m); 

		for (int i=0;i<NVERTICES;i++){
			for (int j=0;j<6;j++){
				vertices[i][j] = src.vertices[i][j];
				tVertices[i][j] = src.tVertices[i][j];
			}
			px[i]=src.px[i];
			py[i]=src.py[i];
			pz[i]=src.pz[i];
			for (int j=0;j<3;j++){
				rgb[i][j] = src.rgb[i][j];
			}
		}
		for (int i=0;i<NFACES;i++)
			for (int j=0;j<NSIDES;j++){
				faces[i][j] = src.faces[i][j];
			}

	}

	Shape2[] clip(){//for a transformed triangle
		int ind=0;
		Shape2[] res;
		int[] pow2=new int[] {1,2,4};
		double[] zs=new double[3];
		for (int i=0; i<3; ++i){
			zs[i]=tVertices[i][2]+epsilon-foc;
			if (zs[i]>0)
				ind+=pow2[i];
		}
		switch (ind){
			case (0):
				res = new Shape2[1];
				res[0]=this;	
				return res;
			case(1):
				return get2tr(this,0,1,2);
			case(2):
				return get2tr(this,1,0,2);
			case(3):
				res = new Shape2[1];
				res[0]=get1tr(this,1,0,2);
				return res;
			case(4):
				return get2tr(this,2,0,1);
			case(5):
				res = new Shape2[1];
				res[0]=get1tr(this,0,2,1);
				return res;
			case(6):
				res = new Shape2[1];
				res[0]=get1tr(this,1,2,0);
				return res;
			case(7):
				return null;


		}
		return null;
	}

	Shape2[] get2tr(Shape2 src, int gone, int s1, int s2){
		double[] zs=new double[3];
		for (int i=0; i<3; ++i)
			zs[i]=src.tVertices[i][2]+epsilon-foc;

		Shape2[] res=new Shape2[2];

		res[0]=new Shape2();
		res[0].copy(src);
		double tCross0 = getTcross(zs[gone],zs[s1]);
		double[] rgbz=interpolRgbz(getRgbz(s1),getRgbz(gone),tCross0);
		double[] xyz=interpolXyz(getTxyz(s1),getTxyz(gone),tCross0);
		res[0].setRgbz(rgbz,gone);
		res[0].setTxyz(xyz,gone);

		res[1]=new Shape2();
		res[1].copy(src);
		tCross0 = getTcross(zs[gone],zs[s2]);
		rgbz=interpolRgbz(getRgbz(s2),getRgbz(gone),tCross0);
		xyz=interpolXyz(getTxyz(s2),getTxyz(gone),tCross0);
		res[1].setRgbz(rgbz,gone);
		res[1].setTxyz(xyz,gone);
		return res;
	}

	Shape2 get1tr(Shape2 src, int gone1, int gone2, int s2){
		double[] zs=new double[3];
		for (int i=0; i<3; ++i)
			zs[i]=src.tVertices[i][2]+epsilon-foc;
		Shape2 res=new Shape2();
		res.copy(src);
		double tCross0 = getTcross(zs[gone1],zs[s2]);
		double[] rgbz=interpolRgbz(getRgbz(s2),getRgbz(gone1),tCross0);
		double[] xyz=interpolXyz(getTxyz(s2),getTxyz(gone1),tCross0);
		res.setRgbz(rgbz,gone1);
		res.setTxyz(xyz,gone1);

		tCross0 = getTcross(zs[gone2],zs[s2]);
		rgbz=interpolRgbz(getRgbz(s2),getRgbz(gone2),tCross0);
		xyz=interpolXyz(getTxyz(s2),getTxyz(gone2),tCross0);
		res.setRgbz(rgbz,gone2);
		res.setTxyz(xyz,gone2);
		return res;


	}

	double getTcross(double z1, double z2){ //assumes z1>-epsilon+foc>z2
		return -z2/(z1-z2);
	}

	void persp(){
		for (int j=0; j<NVERTICES; j++){
			tVertices[j][0]=foc*tVertices[j][0]/tVertices[j][2];
			tVertices[j][1]=foc*tVertices[j][1]/tVertices[j][2];
			tVertices[j][2]=foc/tVertices[j][2];
			pz[j]=foc/tVertices[j][2];
		}

	}

	void render(int W, int H){
		//transform();
		//shade();
		Shape2[] res=triangularize();
		for (int i=0;i<res.length;++i){	
			res[i].transform();//should be done by vertex, not like this.
			//Change the triangle method
			res[i].shade();
			if (false){
				Shape2[] res2=res[i].clip();

				if (res2!=null)
					for (int j=0;j<res2.length;++j){	
						if (res2[j]!=null){
							res2[j].persp();
							res2[j].viewPort(W,H);

							res2[j].paint(W,H);
						}
					}
			}
			else{
				res[i].persp();
				res[i].viewPort(W,H);
				res[i].paint(W,H);
			}
		}
	}


	double[] getRgbz(int index){
		double res[]=new double[4];
		res[0]=rgb[index][0];
		res[1]=rgb[index][1];
		res[2]=rgb[index][2];
		res[3]=pz[index];
		return res;
	}

	void setRgbz(double[] res, int index){
		rgb[index][0]=res[0];
		rgb[index][1]=res[1];
		rgb[index][2]=res[2];
		pz[index] =  res[3];
	}
	void setTxyz(double[] res, int index){
		tVertices[index][0]=res[0];
		tVertices[index][1]=res[1];
		tVertices[index][2]=res[2];
	}


	double [] getXyz(int index){
		double res[]=new double[3];
		res[0]=vertices[index][0];
		res[1]=vertices[index][1];
		res[2]=vertices[index][2];
		return res;
	}

	double [] getTxyz(int index){
		double res[]=new double[3];
		res[0]=tVertices[index][0];
		res[1]=tVertices[index][1];
		res[2]=tVertices[index][2];
		return res;
	}


	double [] getNxyz(int index){
		double res[]=new double[3];
		res[0]=vertices[index][3];
		res[1]=vertices[index][4];
		res[2]=vertices[index][5];
		return res;
	}

	double [] getTNxyz(int index){
		double res[]=new double[3];
		res[0]=tVertices[index][3];
		res[1]=tVertices[index][4];
		res[2]=tVertices[index][5];
		return res;
	}

	trapeze[] getTrapeze(){
		int toto=ord.length;
		int min=10000;
		int max=-1000;
		for (int j=0;j<3;j++){
			if (py[j]<min){
				min=py[j];
				ord[0]=j;
			}
			if (py[j]>max){
				max=py[j];
				ord[2]=j;
			}
		}

		for (int j=0;j<3;j++)
			if (j!=ord[0] & j!=ord[2])
				ord[1]=j;

		if (py[ord[0]]==py[ord[1]]){
			trapeze res = new trapeze();
			res.trapeze(this,0);
			trapeze retres[]=new trapeze[1];
			retres[0]=res;
			return retres;
		}

		if (py[ord[1]]==py[ord[2]]){
			trapeze res = new trapeze();
			res.trapeze(this,1);
			trapeze retres[]=new trapeze[1];
			retres[0]=res;
			return retres;
		}

		trapeze retres[]=new trapeze[2];
		double tY= (py[ord[1]]-py[ord[0]]+0.0)/(py[ord[2]]-py[ord[0]]);
		int tmpPx=(int)(px[ord[0]]+tY*(px[ord[2]]-px[ord[0]]));
		double tmpRgbz[]=interpolRgbz(getRgbz(ord[0]),getRgbz(ord[2]),tY);
		retres[0]=new trapeze();
		Shape2 topTriangle=new Shape2();
		topTriangle.triangle(this);
		int tmpVert=ord[0];
		topTriangle.py[tmpVert]=py[ord[1]];
		topTriangle.px[tmpVert]=tmpPx;
		topTriangle.pz[tmpVert]=tmpRgbz[3];
		for (int i=0;i<3;i++)
			topTriangle.rgb[tmpVert][i]=tmpRgbz[i];
		retres[0].trapeze(topTriangle,0);

		retres[1]=new trapeze();
		Shape2 bottomTriangle=new Shape2();
		bottomTriangle.triangle(this);
		tmpVert=ord[2];

		bottomTriangle.py[tmpVert]=py[ord[1]];
		bottomTriangle.px[tmpVert]=tmpPx;
		bottomTriangle.pz[tmpVert]=tmpRgbz[3];
		for (int i=0;i<3;i++)
			bottomTriangle.rgb[tmpVert][i]=tmpRgbz[i];
		retres[1].trapeze(bottomTriangle,1);

		return retres;

	}



	double[] interpolRgbz(double[] inp1, double[] inp2, double t){
		double res[]=new double[4];
		for (int i=0;i<4;i++) 
			res[i]=inp1[i]+t*(inp2[i]-inp1[i]);
		return res;
	}
	double[] interpolXyz(double[] inp1, double[] inp2, double t){
		double res[]=new double[3];
		for (int i=0;i<3;i++) 
			res[i]=inp1[i]+t*(inp2[i]-inp1[i]);
		return res;
	}

	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];
		tVertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		pz=new double[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 triangle(){
		ord=new int[3];
		NVERTICES=3;
		NFACES=1;
		NSIDES=3;
		transfo.identity();
		vertices=new double[3][6];
		tVertices=new double[3][6];
		rgb=new double[NVERTICES][3];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		pz=new double[NVERTICES];
		faces= new int[1][3];
		vertices[0][0]=0;
		vertices[0][1]=0;
		vertices[0][2]=-1;
		vertices[1][0]=1;
		vertices[1][1]=0;
		vertices[1][2]=-1;
		vertices[2][0]=0;
		vertices[2][1]=1;
		vertices[2][2]=-1;
		for (int i=0;i<3;++i){
			vertices[i][3]=0;
			vertices[i][4]=0;
			vertices[i][5]=1;
		}


	}

	void triangle(Shape2 srcTriangle){
		this.triangle();
		NVERTICES=srcTriangle.NVERTICES;
		NFACES=srcTriangle.NFACES;
		NSIDES=srcTriangle.NSIDES;
		transfo.copy(srcTriangle.transfo);
		m.copy(srcTriangle.m);
		//zBuffer=srcTriangle.zBuffer;
		//FrameBuffer=srcTriangle.FrameBuffer;
		for (int i=0;i<3;i++)
			ord[i]=srcTriangle.ord[i];
		for (int i=0;i<NVERTICES;i++){
			px[i]=srcTriangle.px[i];
			py[i]=srcTriangle.py[i];
			pz[i]=srcTriangle.pz[i];
			for (int j=0;j<3;j++)
				rgb[i][j]=srcTriangle.rgb[i][j];
		}


	}

	void triangle(double srcVert[][]){
		this.triangle();
		for (int j=0; j<3; j++)
			for (int k=0; k<6; k++)
				vertices[j][k]=srcVert[j][k];

	}


	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];
		tVertices = new double[NVERTICES][6];
		px=new int[NVERTICES];
		py=new int[NVERTICES];
		pz=new double[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];
		Shape2 tmptube = new Shape2();
		Shape2 cap1 = new Shape2();
		Shape2 cap2 = new Shape2();
		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();
		transfo.translate(0,0,1-Math.cos(Math.PI/N));
		transfo.scale(1,1,1/Math.cos(Math.PI/N));
		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];
		Shape2 base = new Shape2();
		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;
			vertices[N+1+3*n+2][2]=-1+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();
		transfo.translate(0,0,1-Math.cos(Math.PI/N));
		transfo.scale(1,1,1/Math.cos(Math.PI/N));
		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];
		Shape2 base = new Shape2();
		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]=-1+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;
		}







	}



}