float angleX,angleY,bangleX,bangleY,tempo,rayon,epais,cote,cost,sint;
	Triangle letriangle;
        boolean  arret;
//	++++++++++++++++++++++++++++++++++++++++
//	++++++++++++++++++++++++++++++++++++++++	
void setup(){
	size(750,500);
	epais=200;
	tempo=0;
        arret=false;
	rayon=800;
	cote=2*rayon*cos(PI/6);
	letriangle=new Triangle(new Vecteur(0,0,rayon),
			new Vecteur(rayon*cos(-5*PI/6),0,rayon*sin(-5*PI/6)),
			new Vecteur(rayon*cos(-PI/6),0,rayon*sin(-PI/6))
		
			);
}
//	++++++++++++++++++++++++++++++++++++++++
//	++++++++++++++++++++++++++++++++++++++++
void loop(){
    if(!arret){
	if(abs((tempo-PI)%PI)<0.1) {tempo+=0.005f;}else{tempo+=0.05f;}}
	cost=cos(tempo);
	sint=sin(tempo);
	clear();
	background(50+30*cost,25,85+sint*40);
	modifierparam();
	for(int i=0;i<4;i++){
		push();
		rotateY(i*PI/2);
		translate(0,0,cote/2+rayon/3+150);
		letriangle.evoluer(tempo);
		pop();
	}
	
}
void mousePressed(){arret=!arret;}
//	++++++++++++++++++++++++++++++++++++++++
//	++++++++++++++++++++++++++++++++++++++++
void modifierparam(){

	bangleX=-0.4f+(-mouseY+100)/50.0f;
	bangleY=(mouseX-width/2.0f)/50.0f;//	
	angleX+=(bangleX-angleX)/10.0f;
	angleY+=(bangleY-angleY)/10.0f;
	translate(200,200,-1700);
	rotateX(angleX);
	rotateY(angleY);	
}
//	++++++++++++++++++++++++++++++++++++++++
//	++++++++++++++++++++++++++++++++++++++++
class Triangle{
	
	Figure[] pieces;
	Vecteur aa,bb,cc,gg,ii,jj,kk,nn,mm,rr,ss;
	
public Triangle(Vecteur a,Vecteur b,Vecteur c){
	aa=a;
	bb=b;
	cc=c;
	gg=Vecteur.centregravite(aa,bb,cc);
	ii=Vecteur.comb(0.5f,aa,0.5f,cc);
	jj=Vecteur.comb(0.5f,aa,0.5f,bb);
	kk=Vecteur.comb(0.5f,bb,0.5f,cc);
	nn=Vecteur.comb(0.5f,ii,0.5f,cc);	
	mm=Vecteur.comb(0.5f,bb,0.5f,jj);	
	ss=Vecteur.centregravite(kk,cc,ii);	
	rr=Vecteur.centregravite(kk,bb,jj);
	pieces=new Figure[5];
	//piece 0
	Vecteur a0,j0,r0,g0,s0,i0;
	a0=new Vecteur(0,0,rayon*3/4);
	j0=new Vecteur(cote/4,0,0);
	r0=new Vecteur(cote/4,0,-rayon/2); 
	g0=new Vecteur(0,0,-rayon/4);
	s0=new Vecteur(-cote/4,0,-rayon/2);
	i0=new Vecteur(-cote/4,0,0);
	Vecteur[]  v0={a0,j0,r0,g0,s0,i0};
	Repere rep=new Repere( Vecteur.comb(0.5f,ii,0.5f,jj),  jj.ajouter(ii,-1), aa.ajouter(kk,-1) );		
	pieces[0]=new Figure(v0,rep);	
	//piece 1
	Vecteur j1,m1,r1;
		j1=new Vecteur(0,0,0);
		m1=new Vecteur(cote/4,0,0);
		r1=new Vecteur(cote/4,0,-rayon/4); 
	Vecteur[]  v1={j1,m1,r1};
	Repere rep1=new Repere(jj,   bb.ajouter(aa,-1), jj.ajouter(cc,-1) );		
	pieces[1]=new Figure(v1,rep1);	
	//piece 2
	Vecteur i2,n2,s2;
		i2=new Vecteur(0,0,0);
		n2=new Vecteur(cote/4,0,0);
		s2=new Vecteur(cote/4,0,-rayon/4); 
	Vecteur[]  v2={i2,n2,s2};
	Repere rep2=new Repere(ii,   cc.ajouter(aa,-1), ii.ajouter(bb,-1) );		
	pieces[2]=new Figure(v2,rep2);
	//piece 3
	Vecteur k3,g3,r3,m3,b3;
		k3=new Vecteur(0,0,0);
		g3=new Vecteur(rayon/4,0,-cote/4);
		r3=new Vecteur(rayon/2,0,0); 
		m3=new Vecteur(rayon*3/4,0,0); 
		b3=new Vecteur(rayon*3/4,0,cote/4); 
	Vecteur[]  v3={k3,g3,r3,m3,b3};
	Repere rep3=new Repere(kk,   jj.ajouter(cc,-1), bb.ajouter(aa,-1) );		
	pieces[3]=new Figure(v3,rep3);
	//piece 4
	Vecteur k4,g4,s4,n4,c4;
		k4=new Vecteur(0,0,0);
		g4=new Vecteur(rayon/4,0,-cote/4);
		s4=new Vecteur(rayon/2,0,0); 
		n4=new Vecteur(rayon*3/4,0,0); 
		c4=new Vecteur(rayon*3/4,0,cote/4); 
	Vecteur[]  v4={k4,g4,s4,n4,c4};
	Repere rep4=new Repere(kk,   ii.ajouter(bb,-1), cc.ajouter(aa,-1) );		
	pieces[4]=new Figure(v4,rep4);					
}
public void evoluer(float t){
	for(int i=0;i<pieces.length;i++){
		pieces[i].tourner(t);
	}
}
}
//	++++++++++++++++++++++++++++++++++++++++
//	++++++++++++++++++++++++++++++++++++++++
class  Figure{
	
	Vecteur[] points;
	Repere lerepere;
	Vecteur lumiere;
	
public Figure(Vecteur[] pts,Repere lereper){
	points = pts;
	lerepere=lereper;
	lumiere=(new Vecteur(1,-1,-1)).normalize();
}
public void tourner(float t){
	push();
	lerepere.deplaceRepere();

	rotateX(t);
	Vecteur no=vecteurNormal(points[0],points[1],points[2]);

	Vecteur coul=(new Vecteur(cost,2*sint,2*sint)).normalize();
	float scal=1-(Vecteur.dot(no,coul));
	scal=sqrt(abs(scal));
	noStroke();
	beginShape(POLYGON);
		for(int i=0;i<points.length;i++)
			{
			fill(100+80*scal,80+i*10,150+12*i*scal);
			vertex( points[i].x, points[i].y-epais ,points[i].z );
			}
	endShape(); 
	beginShape(POLYGON);
		for(int i=0;i<points.length;i++)
			{fill(120+80*scal,80+i*10,150+18*i*scal);
			vertex( points[i].x, points[i].y+epais ,points[i].z );
			} 
	endShape();
	beginShape(QUAD_STRIP);
	int j;
		for(int i=0;i<points.length;i++)
			{	
			 if(i<points.length-1)no=points[i].ajouter(points[i+1],-1).normalize();
			 coul=(new Vecteur(cost,cost,2*sint)).normalize();
			scal=1-(Vecteur.dot(no,coul));
			
			fill(scal*105+50,scal*35+50,50+30*i*scal);
			 j=(i%2)*2-1;
			vertex( points[i].x, points[i].y+j*epais ,points[i].z );	
			fill(scal*45+60,60*scal,80+10*i*scal);
			vertex( points[i].x, points[i].y-j*epais ,points[i].z );
			} 
	j=(points.length%2)*2-1;
	vertex( points[0].x, points[0].y+j*epais ,points[0].z );	
	vertex( points[0].x, points[0].y-j*epais ,points[0].z );
	endShape();
	pop();		
}

Vecteur vecteurNormal(Vecteur v1,Vecteur v2,Vecteur v3){
	Vecteur w1=v2.ajouter(v1,-1);
	Vecteur w2=v3.ajouter(v1,-1);	
	Vecteur res=(w1.cross(w2));
	return res.normalize();
	
}

}
//	++++++++++++++++++++++++++++++++++++++++
//	++++++++++++++++++++++++++++++++++++++++
 
   	
 public   class Repere{
      Vecteur pos, axex,axey,axez;
      public Repere(Vecteur p,Vecteur xx,Vecteur zz){
	      pos=p;
	      axex=xx.normalize();
	      axez=zz.normalize();
	      axey=new Vecteur(0,1,0);
      }
      void deplaceRepere(){
		
			       transform(
			      axex.x,axey.x,axez.x,pos.x,
			      axex.y,axey.y,axez.y,pos.y,		
			      axex.z,axey.z,axez.z,pos.z,		
			      0,              0,               0,                1);
       }

    }
//  ++++++++++++++++++++++++++++++++++++++++
//  ++++++++++++++++++++++++++++++++++++++++
//  ++++++++++++++++++++++++++++++++++++++++
//  ++++++++++++++++++++++++++++++++++++++++
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 void set(Vecteur v)
   {
     this.x = v.x;
     this.y =v.y;
     this.z = v.z;
 
   }
 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 static Vecteur barycentre(float a,Vecteur v1,float b, Vecteur v2)
   {
   Vecteur res=comb(a,v1,b,v2);
   res=res.mul(1/(a+b));
     return res;
   }
     public static Vecteur centregravite(Vecteur v1, Vecteur v2,Vecteur v3)
     {
     	float xx=(v1.x+v2.x+v3.x)/3f;
	float yy=(v1.y+v2.y+v3.y)/3f; 
	float zz=(v1.z+v2.z+v3.z)/3f; 	
       return new Vecteur(xx,yy,zz);
     }
  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.0f);
	    return res;
      }
     public float distancePointDroite(Vecteur d, Vecteur v){
		v.normalize();
	     	Vecteur pd=d.ajouter(this,-1);
	      	Vecteur hd=v.mul(v.dot(pd));
	    	 Vecteur ph=pd.ajouter(hd,-1);
	     	 return ph.length();
      } 
        
      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,float lon){
       
	     ba.stroke(255,0,0);
	    ba.line(0,0,0,lon,0,0);
	    ba.stroke(0,255,0);    
	    ba.line(0,0,0,0,lon,0);
	    ba.stroke(0,0,255);   
	    ba.line(0,0,0,0,0,lon);          
       } 
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);
}

   
}