BImage acc;
	int compteur,compteur2,incr;
	float xc, yc, zc;
	boolean grandCycle;
	float tempo;
	DoubleTriedre triedre;
	void setup() {
		size(600, 500);
		xc= width/2.0f;
		yc=height/2.0f;
		zc=347;
		noStroke();//background(125);
		background(75,27,79);
		triedre= new DoubleTriedre(500.0f);
		ellipseMode(CENTER_DIAMETER);
		acc=loadImage("tete.jpg");
		compteur=4;compteur2=8;incr=-1;
	}
	void loop() {
		clear();

		translate(xc, yc, zc);
		rotateY(0.01f * (mouseX - width/2));
		rotateZ(0.01f * (mouseY - height/2));
		scale(55.0f/compteur);		
		tempo += 0.1f;
		triedre.calculer(tempo,PI/compteur2);
		grandCycle=true;
		triedre.dessinerCycle(grandCycle);
		
	}
void mousePressed(){incremente();println(compteur);
}
void incremente(){
		if(compteur==15||compteur==2) incr*=-1;
		 compteur=compteur+incr;
		compteur2=2*compteur;
	}	
	
	
class DoubleTriedre{
Vecteur ab,cd,ac;
Vecteur[] v,w;
float cote;
public DoubleTriedre(float lacote){
	v=new Vecteur[8];
	w=new Vecteur[8];	
	cote=lacote;
	
}
public void  calculer(float t,float alph){
	 ab=new Vecteur(cos(t),0.0f,sin(t));
	float	norm=1.0f/sqrt(1.0f+sq(sin(t)*tan(alph)));
	cd=new Vecteur(norm*sin(t),norm*sin(t)*tan(alph),-norm*cos(t));
	ac=ab.cross(cd);
	Vecteur cc=new Vecteur(ac.y/tan(alph),ac.y,ac.z);
	Vecteur aa=new Vecteur(cc.x-ac.x,0,0);
	
	v[0]=aa;//A
	v[1]=aa.ajouter(ab,1);//B
	v[2]=ac.ajouter(v[1],1);//E
	v[3]=cc;//C
	v[4]=cc.ajouter(cd,1);//D
	v[5]=aa.ajouter(cd,1);//F
	v[6]=v[2].ajouter(cd,1);//G
	v[7]=v[1].ajouter(cd,1);//H	
	Vecteur norplan=new Vecteur(-sin(alph),cos(alph),0);
	for(int i=0;i<8;i++){
	w[i]=v[i].symetrique(norplan);}
		
}


public void  dessiner(){
fill(55,255,0);	
noStroke();

	fill(255,255,255);
	beginShape(QUADS);
	texture(acc);	
		vertex(v[0].x,v[0].y,v[0].z,0,0);
		 vertex(v[1].x,v[1].y,v[1].z, acc.width,0);
		 vertex(v[2].x,v[2].y,v[2].z, acc.width,acc.height);
		vertex(v[3].x,v[3].y,v[3].z,0, acc.height);
	endShape(); 
	
	fill(255,200,100);		
	beginShape(QUADS);
	texture(acc);	
		vertex(v[2].x,v[2].y,v[2].z, acc.width,acc.height);
		vertex(v[3].x,v[3].y,v[3].z,0, acc.height);	
		vertex(v[4].x,v[4].y,v[4].z,0,0);		 
		vertex(v[6].x,v[6].y,v[6].z,acc.width, 0);
	endShape(); 
	
	fill(255,150,150);		
	beginShape(QUADS);
	texture(acc);	
		vertex(v[4].x,v[4].y,v[4].z,0,0);		 
		vertex(v[6].x,v[6].y,v[6].z,acc.width, 0);		
		vertex(v[7].x,v[7].y,v[7].z, acc.width, acc.height);		 
		vertex(v[5].x,v[5].y,v[5].z,0, acc.height);
	endShape();
	 
	fill(255,50,50);		
	beginShape(QUADS);
	texture(acc);	
		vertex(v[7].x,v[7].y,v[7].z, acc.width, acc.height);		 
		vertex(v[5].x,v[5].y,v[5].z,0, acc.height);	
		vertex(v[0].x,v[0].y,v[0].z,0,0);		 
		vertex(v[1].x,v[1].y,v[1].z,acc.width, 0);				
       endShape();
 /////////////////////////////////
       fill(255);
	       beginShape(QUADS);
	       texture(acc);	
		       vertex(w[0].x,w[0].y,w[0].z,0,0);
			vertex(w[1].x,w[1].y,w[1].z, acc.width,0);
			vertex(w[2].x,w[2].y,w[2].z, acc.width,acc.height);
		       vertex(w[3].x,w[3].y,w[3].z,0, acc.height);
	       endShape(); 
	
	       fill(255,200,200);		
	       beginShape(QUADS);
	       texture(acc);	
		       vertex(w[2].x,w[2].y,w[2].z, acc.width,acc.height);
		       vertex(w[3].x,w[3].y,w[3].z,0, acc.height);	
		       vertex(w[4].x,w[4].y,w[4].z,0,0);		 
		       vertex(w[6].x,w[6].y,w[6].z,acc.width, 0);
	       endShape(); 
	
	       fill(255,155,195);		
	       beginShape(QUADS);
	       texture(acc);	
		       vertex(w[4].x,w[4].y,w[4].z,0,0);		 
		       vertex(w[6].x,w[6].y,w[6].z,acc.width, 0);		
		       vertex(w[7].x,w[7].y,w[7].z, acc.width, acc.height);		 
		       vertex(w[5].x,w[5].y,w[5].z,0, acc.height);
	       endShape();
	 
	       fill(255,205,155);		
	       beginShape(QUADS);
	       texture(acc);	
		       vertex(w[7].x,w[7].y,w[7].z, acc.width, acc.height);		 
		       vertex(w[5].x,w[5].y,w[5].z,0, acc.height);	
		       vertex(w[0].x,w[0].y,w[0].z,0,0);		 
		       vertex(w[1].x,w[1].y,w[1].z,acc.width, 0);				
	      endShape();	
		
}
public void dessinerCycle(boolean bool){

	for(int i=0;i<compteur2;i++){	
	push();
		rotateZ(PI*i/compteur);
		triedre.dessiner();
		if(bool) dessinerCycleSecondaire();
	pop();
	}
	}
	public void dessinerCycleSecondaire(){
		Vecteur centre=Vecteur.comb(0.5f,v[0],0.5f,v[4]);
		push();
			
		transform(
		ac.x,ab.x,cd.x,centre.x,
		ac.y,	ab.y,cd.y,centre.y,		
		ac.z,	ab.z,cd.z,centre.z,		
			0,            0,               0,            1);
		scale(0.5f);
		dessinerCycle(false);	
		pop();
	}
}

//-------------------------------------------------------
//-------------------------------------------------------
public static class Vecteur
{
public  float x, y, z;
 
public  Vecteur()
  {
  }

public  Vecteur(float x, float y, float z)
  {
    this.x = x;
    this.y = y;
    this.z = z;
 
  }
  
public  Vecteur(float x, float y, float z,float lon)
  { float no=(float) Math.sqrt(x * x + y * y + z * z);
  	no=lon/no;
    this.x = x*no;
    this.y = y*no;
    this.z = z*no;
 
  } 
  public void place(float xx, float yy, float zz)
  {
    this.x = xx;
    this.y = yy;
    this.z = zz;
 
  }
 public Vecteur normalize()
  {
    float length = length();
    x /= length;
    y /= length;
    z /= length;
    return this;
  }
  public  Vecteur normalize(float k)
   {
     float length = length();
     x=x/ length*k;
     y =y/ length*k;
     z =z/ length*k;
     return this;
   }
   public  float length()
  {
    return (float) Math.sqrt(x * x + y * y + z * z);
  }

  public  Vecteur cross(Vecteur v2)
  {
    Vecteur res = new Vecteur();
    res.x = y * v2.z - z * v2.y;
    res.y =z * v2.x - x * v2.z;
    res.z = x * v2.y - y * v2.x;
    return res;
  }

  public  static float dot(Vecteur v1, Vecteur v2)
  {
    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
  }
  public float dot(Vecteur v1)
  {
    return v1.x * x + v1.y *y + v1.z *z;
  }
  public Vecteur mul( float d)
  {
    Vecteur res = new Vecteur();
    res.x =x * d;
    res.y = y * d;
    res.z = z * d;
    return res;
  }
  public static Vecteur comb(float a,Vecteur v1,float b, Vecteur v2)
  {
   float  rx =a* v1.x + b*v2.x;
   float ry =a* v1.y + b*v2.y;
    float rz =a* v1.z + b*v2.z;
    return new Vecteur(rx,ry,rz);
  }

  public  Vecteur ajouter(Vecteur v,float m){
		Vecteur res=new Vecteur(x+v.x*m, y+v.y*m,z+v.z*m);
    return res;
  }
  public  Vecteur ajouter(float ax,float ay,float az){
		 Vecteur res=new Vecteur(x+ax, y+ay,z+az);
     return res;
   }
  
  public  void afficher(String tex,BApplet ba){
  	ba.println(tex+"x= "+x+" y= "+y+" z= "+z);
  }
  public  Vecteur projete(Vecteur laxe){
  	laxe.normalize();
  	Vecteur res=laxe.mul(this.dot(laxe));
  	return res;
  }
  public Vecteur projeteSurAxe(Vecteur laxe){
	 laxe.normalize();
	 Vecteur res=laxe.mul(this.dot(laxe));
	 return res;
   }
   public  Vecteur projeteSurPlan(Vecteur laxe){
	  laxe.normalize();
	  Vecteur res=projeteSurAxe(laxe);
	  res=this.ajouter(res,-1);
	  return res;
    } 
    public  Vecteur symetrique(Vecteur laxe){
	    laxe.normalize();
	    Vecteur res=projeteSurAxe(laxe);
	    res=this.ajouter(res,-2);
	    return res;
      } 
    /*projection sur le plan vectoriel de normale "laxe"
    public   Vecteur projeteSurPlan(Vecteur laxe,Vecteur unpoint){
	    laxe.normalize();
	    Vecteur res=projeteSurPlan(laxe);	   
	return  res.ajouter(unpoint.projeteSurAxe(res),1);
	   
      }*/
        
      public  float donneAngle(Vecteur vc){
	 return (float) Math.acos(this.dot(vc)/(length()*vc.length()));
  }
  public  Vecteur tourner(Vecteur axe,float angle){//axe est normé et orthogonal à this
  	Vecteur vaxe=axe.mul(this.dot(axe));
  	Vecteur vx=this.ajouter(vaxe,-1);
  	Vecteur ygrec=axe.cross(this);
  	return vaxe.ajouter(Vecteur.comb((float)Math.cos(angle),this,(float)Math.sin(angle),ygrec),1);
  }
  public Vecteur cloner()
    {
      Vecteur res = new Vecteur();
      res.x =x ;
      res.y = y ;
      res.z = z ;
      return res;
    } 
   
    public  Vecteur coorabs(BApplet ba) {
	    float xa = ba.objectX(x,y,z);
	    float ya = ba.objectY(x,y,z);
	    float za = ba.objectZ(x,y,z);
	    return new Vecteur(xa, ya, za);
    }
//  *******************************************
//  *******************************************
//  *******************************************

public static  void afficherRepere(BApplet ba){
       
	 ba.stroke(255,0,0);
	ba.line(0,0,0,500,0,0);
	ba.stroke(0,255,0);    
	ba.line(0,0,0,0,500,0);
	ba.stroke(0,0,255);   
	ba.line(0,0,0,0,0,500);          
   } 
 
//  *******************************************
//  *******************************************
//  *******************************************
    public  void afficherLigne(float k,BApplet ba){
    	ba.line(x*k,y*k,z*k,-x*k,-y*k,-z*k);
}

    }