float angleX,angleY,bangleX,bangleY,tempo;
	Vecteur coul,origine1;
        float nbor=(-1+sqrt(5))/2;
	Dodecaedre leDodecaedre;
//	++++++++++++++++++++++++++++++++++++++++
//	++++++++++++++++++++++++++++++++++++++++	
void setup(){
	size(750,500);
	coul=new Vecteur(-1f,0.3f,-1.8f);
	origine1=new Vecteur(0,500,-14000);
	Vecteur lecentre=new Vecteur(0,0,2670);
	leDodecaedre=new Dodecaedre(lecentre,2000);
	this.ellipseMode(CENTER_DIAMETER);
	tempo=0;
}
//	++++++++++++++++++++++++++++++++++++++++
//	++++++++++++++++++++++++++++++++++++++++
void loop(){
	tempo+=0.05f;
	background(155+50*cos(tempo),20+20*sin(tempo),200+55*sin(2*tempo));
	modifierparam();
	push();
		translate(0,0,-30);
		dessinerPentagone();
	pop();
	leDodecaedre.evoluer();
}
//	++++++++++++++++++++++++++++++++++++++++
//	++++++++++++++++++++++++++++++++++++++++
void modifierparam(){

	translate(origine1.x,origine1.y,origine1.z);
	bangleX=(mouseY)/500.0f;
	bangleY=(mouseX)/150.0f;//	
	angleX+=(bangleX-angleX)/10.0f;
	angleY+=(bangleY-angleY)/10.0f;
	rotateX(0.6f+angleX);
	
		
}
//	++++++++++++++++++++++++++++++++++++++++
//	++++++++++++++++++++++++++++++++++++++++
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();	
}
void dessinerPentagone(){
	//Vecteur no=vecteurNormal(pts[faces[k].liste[0]],pts[faces[k].liste[1]],pts[faces[k].liste[2]]);
	float scal=1;
	float pi5=TWO_PI/5,rr=13000;
	beginShape();
	for(int i=0;i<5;i++){
			fill(195+75*cos(tempo*5+i*pi5),180+70*cos(tempo+(i+1.5f)*i*pi5),200+75*sin(tempo+(i+3)*i*pi5));
			Vecteur v=new Vecteur(rr*cos(i*pi5),rr*sin(i*pi5),0);
			vertex(v.x,v.y,v.z);
	}
	endShape();
}
//	++++++++++++++++++++++++++++++++++++++++
//				CLASSE Face
//	++++++++++++++++++++++++++++++++++++++++
class Face{
		int[] liste;
		
	
	public Face(int[] listeDesSommets){
		this.liste=listeDesSommets;
		
	}
}
//	++++++++++++++++++++++++++++++++++++++++
//				CLASSE Arete
//	++++++++++++++++++++++++++++++++++++++++
class Arete{
	Vecteur axe;
	int d,a;
	public Arete(int d,int a){
		this.d=d;
		this.a=a;
	}
}
//	++++++++++++++++++++++++++++++++++++++++
//				CLASSE Dodecaedre
//	++++++++++++++++++++++++++++++++++++++++
class Dodecaedre{
	float x,y,z,c,angle;
	float d=(1+sqrt(5))/2;
	float d2=d*d;
	float diedre0=(float)Math.acos(1/sqrt(5));
	float diedre=diedre0;
	boolean enmouvement;
	Vecteur centre;
	Vecteur[] sommets;
	Arete areteRot;
	Vecteur axeRot;
	Vector empreintes;
	int faceSol;
	Arete[] aretes=new Arete[30];
	Face[] faces=new Face[]{
	new Face(new int[]{7,9,2,3,8}),		//
	new Face(new int[]{5,6,0,1,4}),		//
	new Face(new int[]{1,17,12,11,4}),	//
	new Face(new int[]{1,0,13,18,17}),	//
	new Face(new int[]{0,6,10,14,13}),	//
	new Face(new int[]{7,8,10,6,5}),	//
	new Face(new int[]{5,4,11,9,7}),	//        
	new Face(new int[]{11,12,16,2,9}),	//
	new Face(new int[]{16,19,15,3,2}),	//
	new Face(new int[]{14,10,8,3,15}),	//
	new Face(new int[]{17,18,19,16,12}),	//	
	new Face(new int[]{18,13,14,15,19})	//
	
	};
public Dodecaedre(Vecteur lecentr,float cote)
	{
		centre=lecentr;
		c=cote/2;
		empreintes=new Vector();
		sommets=new Vecteur[20];
		sommets[0]=new Vecteur(0,-c,c*d2);
		sommets[1]=new Vecteur(0,c,c*d2);
		sommets[2]=new Vecteur(0,c,-c*d2);
		sommets[3]=new Vecteur(0,-c,-c*d2);
		sommets[7]=new Vecteur(c*d2,0,-c);
		sommets[5]=new Vecteur(c*d2,0,c);
		sommets[18]=new Vecteur(-c*d2,0,c);
		sommets[19]=new Vecteur(-c*d2,0,-c);
		sommets[10]=new Vecteur(c,-c*d2,0);
		sommets[11]=new Vecteur(c,c*d2,0);
		sommets[12]=new Vecteur(-c,c*d2,0);
		sommets[14]=new Vecteur(-c,-c*d2,0);					
		sommets[4]=new Vecteur(c*d,c*d,c*d);
		sommets[6]=new Vecteur(c*d,-c*d,c*d);
		sommets[8]=new Vecteur(c*d,-c*d,-c*d);
		sommets[9]=new Vecteur(c*d,c*d,-c*d);
		sommets[13]=new Vecteur(-c*d,-c*d,c*d);
		sommets[15]=new Vecteur(-c*d,-c*d,-c*d );	
		sommets[16]=new Vecteur(-c*d,c*d,-c*d);
		sommets[17]=new Vecteur(-c*d,c*d,c*d);
	
		for(int i=0;i<sommets.length;i++){
			sommets[i] = sommets[i].ajouter(centre,1);			
		}
		
	
		areteRot=new Arete(3,2);
		axeRot=calculAxe(3,2);			
		sommets=pivoter(diedre0/2);
		faceSol=8;
		axeRot=calculAxe(3,2);	
		enmouvement=false;
	}
Vecteur calculAxe(int u,int v){
	return sommets[v].ajouter(sommets[u],-1).normalize();
}

//	++++++++++++++++++++++++++++++++++++++++	
public void dessiner(Vecteur[] pts){
	DessinerEmpreintes();
		noStroke();
		for(int k=0;k<12;k++){
			Vecteur no=vecteurNormal(pts[faces[k].liste[0]],pts[faces[k].liste[1]],pts[faces[k].liste[2]]);
			float scal=1-abs(Vecteur.dot(no,coul));
			beginShape();
			fill(150+100*scal,80+scal*175,55*scal+10*k);
				Vecteur v=pts[faces[k].liste[0]];
				vertex(v.x,v.y,v.z);
			fill(130+120*scal,10*k+scal*55,105*scal+130);
				v=pts[faces[k].liste[1]];
				vertex(v.x,v.y,v.z);
				v=pts[faces[k].liste[2]];
			fill(10*k+50*scal,80+scal*175,150+105*scal);
				vertex(v.x,v.y,v.z);
				v=pts[faces[k].liste[3]];
				vertex(v.x,v.y,v.z);
				v=pts[faces[k].liste[4]];
				vertex(v.x,v.y,v.z);
			endShape();
		}
	}
//	++++++++++++++++++++++++++++++++++++++++	
void evoluer(){
		if(!enmouvement)	{
				faceSol=calculerSol();
				areteRot=calculerNouvelAxe();
				axeRot=sommets[areteRot.a].ajouter(sommets[areteRot.d],-1).normalize();
				angle=0;
				enmouvement=true;	
				dessiner(sommets);
			stokerEmpreinte(faceSol);
		}
		else
		{	
			if(abs(angle)>abs(diedre))
			{
				angle=diedre;
				enmouvement=false;
			}
			Vecteur[] temppts=pivoter(angle);
			if(abs(angle-diedre)<0.00001f){
				sommets=temppts;
				enmouvement=false;
				}
			dessiner(temppts);
			angle+=diedre/10;
			
		}
	}
//	++++++++++++++++++++++++++++++++++++++++
int calculerSol(){
	int res=0;
	for(int i=0;i<faces.length;i++){
	
		for(int j=0;j<5;j++){
			int k=(j+1)%5;
			if(faces[i].liste[j]==areteRot.a&&faces[i].liste[k]==areteRot.d){
			res=i;
			break;
			}
		}
	}
	return res;
	}

//	++++++++++++++++++++++++++++++++++++++++
Vecteur baryCentre(int i){
		Vecteur bar=new Vecteur(0,0,0);	
		for(int k=0;k<5;k++){
			bar.ajouter(sommets[faces[i].liste[k]],0.2f);
		}
		return bar;
}	
//	++++++++++++++++++++++++++++++++++++++++
Arete calculerNouvelAxe(){
	Arete res;
	int u1=0,u2=1;
	float mes;
	Vecteur vs;
	Vecteur bary=baryCentre(faceSol);
		int debut=Math.round(random(-0.45f,4.45f));
		for(int i=debut;i<debut+5;i++){
		
			u1=faces[faceSol].liste[i%5];
			u2=faces[faceSol].liste[(i+1)%5];
			vs=symetrique(bary,u1,u2);
		 	mes=vs.length();
			 if (mes<8000)	break; 
		}
		return new Arete(u1,u2);
}
//	++++++++++++++++++++++++++++++++++++++++
Vecteur symetrique(Vecteur v, int d,int a){
	Vecteur axx=sommets[a].ajouter(sommets[d],-1).normalize();
	Vecteur vv=v.ajouter(sommets[d],-1);
	Vecteur proj=axx.mul(axx.dot(vv)).mul(2);
	return proj.ajouter(vv,-1).ajouter(sommets[d],1);

}


//	++++++++++++++++++++++++++++++++++++++++	
Vecteur[] pivoter(float angl){
	Quat q=new Quat(cos(angl/2),axeRot.mul(sin(angl/2)));	
				Vecteur[] temppts=new Vecteur[20];
				for(int i=0;i<sommets.length;i++)temppts[i]=(q.tourner(sommets[i].ajouter(sommets[areteRot.d],-1))).ajouter(sommets[areteRot.d],1);
return temppts;
}

//	++++++++++++++++++++++++++++++++++++++++
void stokerEmpreinte(int n){
	if(empreintes.size()>200){for(int i=0;i<5;i++)empreintes.removeElementAt(0);
        }
	for(int i=0;i<5;i++){
		empreintes.addElement(sommets[faces[n].liste[i]].cloner());
	}
}
//	++++++++++++++++++++++++++++++++++++++++
void DessinerEmpreintes(){
       
	for(int i=0;i<empreintes.size();i+=5){
		float cc=255*i/(empreintes.size()+1);             
               	Vecteur barycentr=new Vecteur(0,0,0);	
		for(int u=0;u<5;u++){
                        Vecteur v=(Vecteur)empreintes.elementAt(i+u);
			barycentr=barycentr.ajouter(v,0.2f);
		}       
		for(int k=0;k<5;k++){
                        int j=(k+2)%5;
 			Vecteur v0=(Vecteur)empreintes.elementAt(i+k);                       
			Vecteur v1=(Vecteur)empreintes.elementAt(i+j);
			fill(50*k+25*j+cc*1.8f,20*k+20*j+cc*2.7f,0,cc*0.75f);
                        beginShape(TRIANGLES);
			  vertex(v0.x,v0.y,v0.z);
                          vertex(v1.x,v1.y,v1.z);
                          vertex(barycentr.x,barycentr.y,barycentr.z);
                       	endShape();
              }
	
	}

}
}
//-------------------------------------------------------
//-------------------------------------------------------
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  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);
}

   
}
//------------------------------------------------------------
// Quat class
//------------------------------------------------------------
public static class Quat
{
  float w, x, y, z;

 public Quat()
  {
    reset();
  }

 public  Quat(float w, float x, float y, float z)
  {
    this.w = w;
    this.x = x;
    this.y = y;
    this.z = z;
  }
   public Quat(float w, Vecteur v)
  {
    this.w = w;
    this.x =v. x;
    this.y = v.y;
    this.z = v.z;
  }
public  Quat(Quat q)
  {
    set(q);
  }

 public  void reset()
  {
    w = 1.0f;
    x = 0.0f;
    y = 0.0f;
    z = 0.0f;
  }

  public void set(float w, Vecteur v)
  {
    this.w = w;
    x = v.x;
    y = v.y;
    z = v.z;
  }

  public void set(Quat q)
  {
    w = q.w;
    x = q.x;
    y = q.y;
    z = q.z;
  }
  public Quat(Vecteur v,float angle,float rapport){
   v.normalize(rapport);
   float sinus=(float)Math.sin(angle/2);	
   this.w = rapport*(float)Math.cos(angle/2);
     this.x =v.x*sinus;
     this.y = v.y*sinus;
     this.z = v.z*sinus;
   }
public float norme(){
	return (float)Math.sqrt(x * x + y * y + z * z + w * w);
}

 public  Quat normalize()
  {
    float square = x * x + y * y + z * z + w * w;
    float dist = (square > 0.0f) ? (1.0f / (float) Math.sqrt(square)) : 1.0f;

    x *= dist;
    y *= dist;
    z *= dist;
    w *= dist;
    return this;
  }
  public  Quat normalize(float c)
   {
     float square = x * x + y * y + z * z + w * w;
     float dist = (square > 0.0f) ? (c / (float) Math.sqrt(square)) : c;
	
     x *= dist;
     y *= dist;
     z *= dist;
     w *= dist;
     return this;
   }
 public static Quat mul(Quat q1, Quat q2)
  {
    Quat res = new Quat();
    res.w = q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z;
    res.x = q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y;
    res.y = q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z;
    res.z = q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x;
    return res;
  }
 public static Quat comb(Quat q1,float r1, Quat q2,float r2)
   {
     Quat res = new Quat();
     res.w = q1.w *r1 +  q2.w*r2;
     res.x = q1.x * r1+  q2.x * r2;
     res.y = q1.y * r1+  q2.y * r2;
     res.z = q1.z * r1+  q2.z * r2;
     return res;
   }
   public Quat ajouter(Quat q1,float r1)
     {
       Quat res = new Quat();
       res.w = q1.w *r1;
       res.x = q1.x * r1;
       res.y = q1.y * r1;
       res.z = q1.z * r1;
       return res;
     } 
      
     public   float Angle()
  {	
   
    float nq=norme();
	return (float) Math.acos(w/nq)* 2.0f;
 }  
     public   float[] getValue()
 {	
   float[] res = new float[4];
   float nq=norme();
	 res[0] = (float) Math.acos(w/nq)* 2.0f;
  	 
	 float nV= (float) Math.sqrt(x*x+y*y+z*z);
  if ( nV< 0.00001f*nq)
   {
	res[1] = x ;
	res[2] = y;
	res[3] = z ;   
   }else{
	 res[1] = x /nV;
	 res[2] = y/nV ;
	 res[3] = z/nV;  }
   return res;
 }
 
 public   Quat conjugue(){
	return new Quat(w,-x,-y,-z);
}
public  Quat oppose(){
	return new Quat(-w,-x,-y,-z);
}
public Quat copie(){
	return new Quat(w,x,y,z);
	}
	public Quat copieNorme(){
		Quat res=new Quat(w,x,y,z);
		res.normalize();
		return res;
		}	
	public Vecteur tourner(Vecteur v){
	Quat qv=new Quat(0.0f,v.x,v.y,v.z);
	Quat qc=this.conjugue();
	Quat q1=Quat.mul(qv,qc);	
	Quat q= Quat.mul(this,q1);
	return new Vecteur(q.x,q.y,q.z);	
	
}
public static Quat slerp(Quat d, Quat a,float t){
	Quat res;
	d.normalize();
	a.normalize();
	float costheta=d.x*a.x+d.y*a.y+d.z*a.z;
	
	if(costheta<0.99f){
		float theta=(float)Math.acos(costheta);
		float sintheta=(float)Math.sin(theta);
		float rd=(float)Math.sin(theta*(1-t))/sintheta;
		float ra=(float)Math.sin(theta*t)/sintheta;
		 res= Quat.comb(d,rd,a,ra);}
	else{
		res=Quat.comb(d,1-t,a,t);
	}
	return res;

}
public static Quat slerp1(Quat d, Quat a,float tt){
	
	d.normalize();
	a.normalize();
	float t=(tt-1)*(tt-1)*(tt-1)+1;
	float angle=(float)Math.acos(d.x*a.x+d.y*a.y+d.z*a.z);
	if(angle>0.05f){	
	float sina=(float)Math.sin(angle);
	float rd=(float)Math.sin(angle*(1-t))/sina;
	float ra=(float)Math.sin(angle*t)/sina;
	return Quat.comb(d,rd,a,ra);}
	else{return Quat.comb(d,1-t,a,t);
	}
}
public Vecteur axe(){
return new Vecteur(x,y,z);	
}
public static Quat slerp2(Quat d, Quat a,float tt){
	Quat res;
	d.normalize();
	a.normalize();
	float costheta=d.x*a.x+d.y*a.y+d.z*a.z;
	float t=(tt-1)*(tt-1)+1;
	if(costheta<0.9999f){
		float theta=(float)Math.acos(costheta);
		float sintheta=(float)Math.sin(theta);
		float rd=(float)Math.sin(theta*(1-t))/sintheta;
		float ra=(float)Math.sin(theta*t)/sintheta;
		 res= Quat.comb(d,rd,a,ra);
		}
	else{
		res=Quat.comb(d,1-t,a,t);
	}
	return  Quat.mul(res,new Quat((float)Math.cos(t*6.2832f),(float)Math.sin(t*6.2832f),(float)Math.sin(t*6.2832f),0));

}

public static Quat euler2quat(float psi,float theta,float phi){
	/* psi      :angle de la rotation autour de 0z    :precession
	 * theta   :angle de la rotation autour de 0x1  :nutation
	 * phi      :angle de la rotation autoue de 0z2  : rotation propre
	 */
		float w,x,y,z,th,psiMphi,psiPphi;
		th=theta/2;
		psiMphi=(psi-phi)/2;
		psiPphi=(psi+phi)/2;		
		w=(float)Math.cos(th)*(float)Math.cos(psiPphi);
		x=(float)Math.sin(th)*(float)Math.cos(psiMphi);
		y=(float)Math.sin(th)*(float)Math.sin(psiMphi);
		z=(float)Math.cos(th)*(float)Math.sin(psiPphi);		
	return new Quat(w,x,y,z);
}

}