float angleX,angleY,bangleX,bangleY,
		phi,psi,theta,rapport1,rapport2,rayon,tmod;
		Quat pp,qq,pq;
		Arc arcp,arcq,arcpq;
		Vecteur bleu,vert,rouge,paxe,qaxe,pqaxe;
		int tempo,incrtempo,etape;
		Tirette barrePhi,barrePsi,barreR1,barreR2;
		BFont gillesans;
		boolean mouvement,montrecercles,montresphere;
//*******************************************
//*******************************************
//*******************************************

void setup(){
	gillesans = loadFont("GillSans.vlw.gz");
	rectMode(CORNER);
	size(700,500);
	background(255);
	initier();
}

void loop(){
	
	clear();
	push();
		modifierparam();
			afficherArc(arcp,50,255,0,0);
			afficherArc(arcq,50,0,0,255);
			afficherArc(arcpq,50,0,255,0);
		if(montresphere)
			{afficherSphere();
		}else{	
			affichercone(arcp.axe,arcp.points[0],200,0,0);
			affichercone(arcq.axe,arcq.points[0],0,0,200);
			affichercone(arcpq.axe,arcpq.points[0],0,200,0);
		}
		if(mouvement) modifierVdepart();		
	pop();
	fill(120,120,140,130);
	rect(550,300,150,200);
	barrePhi.actualiser();
	phi=barrePhi.getValeur();
	barrePsi.actualiser();
	psi=barrePsi.getValeur();
	barreR1.actualiser();
	rapport1=barreR1.getValeur();
	barreR2.actualiser();
	rapport2=barreR2.getValeur();
	/*text("          quaternion rouge= ["+pp.w+","+pp.x+","+pp.y+","+pp.z+"]",50,410);
	text("           quaternion bleu = ["+qq.w+","+qq.x+","+qq.y+","+qq.z+"]",50,440);
	text("quaternion produit vert = ["+pq.w+","+pq.x+","+pq.y+","+pq.z+"]",50,470);
	text("touches actives :  'a' 'c' 's'",370,50);
	text("un clic pour le focus,s'il vous plait, puis clic et drague",370,25);*/
	textFont(gillesans, 20);fill(185);
	text("Les quaternions sont des classes de  chips decoupes sur des cones....",20,40);	
	text("Rouge ,bleu a  la queue leuleu....alors le vert ! C'est comme ca que les chips se multiplent",20,60);					
	text("Quand vous dechirer un lambeau de l'emballage de votre cornet de glace, gardez le precieusement, ",20,80);
	text(" C'est un quaternion! On peut en faire l'elevage....",20,100);
}
//*******************************************
//*******************************************
//*******************************************
void initier(){
	mouvement=true;
	montrecercles=false;
	montresphere=true;
	rayon=2000.0f;
	angleX=0;
	angleY=0;
	tempo=0;
	incrtempo=1;
	etape=0;
	phi=PI-1.9f;
	psi=-0.99f;
	theta=0.0f;
	rapport1=1.3f;
	rapport2=1.4f;
	paxe=(new Vecteur(-20,-10,15)).normalize();
	qaxe=(new Vecteur(40,-30,20)).normalize();
	bleu=Vecteur.comb(1.5f,paxe,1.2f,qaxe);	
	bleu.normalize(rayon);
	vert=(new Vecteur(60,-30,50)).normalize(rayon);
	rouge=(new Vecteur(100,30,-50)).normalize(rayon);

	barrePhi=new Tirette(630,430,60,-6.2f,6.27f,"angle rouge= ",235, 20,gillesans,this);
	barrePsi=new Tirette(630,470,60,-6.2f,6.27f,"angle bleu= ",235, 20,gillesans,this);
	barreR1=new Tirette(630,390,60,0.10f,3.0f,"module rouge= ",235, 20,gillesans,this);
	barreR2=new Tirette(630,350,60,0.10f,3.0f,"module bleu= ",235, 20,gillesans,this);
	barrePhi.setposition(5f);
	barrePsi.setposition(4f);
	barreR1.setposition(2.1f);
	barreR2.setposition(1.3f);	
}
public void keyPressed(){
	if(key=='a')mouvement=!mouvement;
	if(key=='c')montrecercles=!montrecercles;
	if(key=='s')montresphere=!montresphere;
}
//*******************************************
//*******************************************
//*******************************************
void modifierparam(){

//les angles de la position
if(mousePressed && (mouseX<550||mouseY<300)){

	bangleX=(-mouseY+width/2.0f)/100.0f;
	bangleY=(mouseX-width/2.0f)/100.0f;	
	angleX+=(bangleX-angleX)/10.0f;
	angleY+=(bangleY-angleY)/10.0f;}
	translate(200,300,-8000);
	rotateX(angleX);
	rotateY(angleY);
	stroke(255,0,255,100);noFill();


//les objets déformables

	pp=new Quat(cos(phi/2)*rapport1,paxe.mul(sin(phi/2)*rapport1));
	qq=new Quat(cos(psi/2)*rapport2,qaxe.mul(sin(psi/2)*rapport2));
	pq=Quat.mul(qq,pp);
	arcp=pp.donneArc(bleu)	;
	Vecteur dernier=arcp.points[50];
	arcq=qq.donneArc(dernier.mul(arcp.rapport));
	arcpq=pq.donneArc(bleu);
	
	float[] tabl=pq.getValue();
	pqaxe=new Vecteur(tabl[1],tabl[2],tabl[3]);
	theta=tabl[0];
	if(montrecercles){
		fill(255,55,0,100);
		afficherCercle(paxe.x,paxe.y,paxe.z,rayon,0,0,0);	
		fill(55,55,255,100);
		afficherCercle(qaxe.x,qaxe.y,qaxe.z,rayon,0,0,0);	
		fill(255,255,255,100);
		afficherCercle(pqaxe.x,pqaxe.y,pqaxe.z,rayon,0,0,0);
	}
	
	
}
//*******************************************
//*******************************************
//*******************************************
void afficherSphere(){noFill();stroke(150,50);
	for(int i=0;i<8;i++){
		float co=(float)Math.cos(PI/8*i);
		float si=(float)Math.sin(PI/8*i);
		afficherCercle(co,0,si,rayon,0.0f,0.0f,0.0f);
		afficherCercle(0.0f,1.0f,0.0f,rayon*si,0.0f,rayon*co,0.0f);
	}
}
//*******************************************
//*******************************************
//*******************************************

void afficherCercle(float nx,float ny,float nz,float r,float cx,float cy,float cz){
push();

	ellipseMode(CENTER_DIAMETER); 
	translate(cx,cy,cz);
	rotateZ(atan2(ny,nx));
	rotateY(atan2(sqrt(nx*nx+ny*ny),nz));
	ellipse(0, 0, 2*r, 2*r); 
pop();

}
       //****************************************************************
void afficherArc(Arc arc0,int n,int r,int g,int b){
	       float cst=arc0.rapport;
	       float c,cc;
	float rap=rayon/arc0.points[0].length();

       noStroke();
       beginShape(BApplet.QUADS);
	       for(int i=0;i<n;i++){
		       c=1+(cst-1)*i/50;
		       cc=c+(cst-1)/50;
		Vecteur v1=arc0.points[i].mul(rap);
		Vecteur v2=arc0.points[i+1].mul(rap);
		Vecteur v3=arc0.points[i].mul(c);
		Vecteur v4=arc0.points[i+1].mul(cc);					  
		       fill(r/1.5f,g/1.5f,b/1.5f);
		       vertex(v2.x,v2.y,v2.z );
		       vertex(v1.x,v1.y,v1.z );fill(r,g,b);		      
		       vertex(v3.x,v3.y,v3.z );
		vertex(v4.x,v4.y,v4.z );

       }		
       endShape();
	
}
void afficherplans(){
	fill(255,255,0,150);stroke(255);
	float rr=5000;
	beginShape(TRIANGLES);
		vertex(0,0,0);
		vertex(rayon*paxe.x,rayon*paxe.y,rayon*paxe.z);
		vertex(rayon*qaxe.x,rayon*qaxe.y,rayon*qaxe.z);
	fill(255,0,250,150);
		vertex(0,0,0);
		vertex(rayon*paxe.x,rayon*paxe.y,rayon*paxe.z);
		vertex(rayon*pqaxe.x,rayon*pqaxe.y,rayon*pqaxe.z);		
	fill(0,255,255,150);
		vertex(0,0,0);
		vertex(rayon*pqaxe.x,rayon*pqaxe.y,rayon*pqaxe.z);
		vertex(rayon*qaxe.x,rayon*qaxe.y,rayon*qaxe.z);
	endShape();
	stroke(255);
	afficheligne(paxe.mul(-rr),paxe.mul(rr));
	afficheligne(qaxe.mul(-rr),qaxe.mul(rr));	
	afficheligne(pqaxe.mul(-rr),pqaxe.mul(rr));

}
void afficheligne(Vecteur v1,Vecteur v2){
	line(v1.x ,v1.y ,v1.z ,v2.x ,v2.y,v2.z);
}
void modifierVdepart(){
	tmod+=0.03;
	bleu.x=cos(tmod)*sin(3*tmod);
	bleu.y=sin(tmod);
	bleu.z=sin(2*tmod)+cos(tmod);
	bleu.normalize(rayon);	
}
void affichercone(Vecteur axe,Vecteur v,int r,int g,int b){
	v.normalize(5000);
	Vecteur vaxe=axe.mul(v.dot(axe));
	Vecteur vx=v.ajouter(vaxe,-1);
	Vecteur ygrec=axe.cross(v);
	
	stroke(r,g,b,50);
	//noFill();
	fill(r,g,b,30);
	beginShape(TRIANGLE_STRIP);
	Vecteur res=v;
	for(float j=1;j<=31;j++){
		float i=j*TWO_PI/30;

		Vecteur res1= vaxe.ajouter(Vecteur.comb((float)Math.cos(i),vx,(float)Math.sin(i),ygrec),1);	
		vertex(0,0,0);
	
		vertex(res.x,res.y,res.z);
		vertex(res1.x,res1.y,res1.z);
		res=res1;		
	}
	endShape();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////                QUAD                                          //////////////////////////////////////////////////////////////////////////
//------------------------------------------------------------
// Quat class
//------------------------------------------------------------
public static class Quat
{
  float w, x, y, z;

  Quat()
  {
    reset();
  }

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

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

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

  void set(Quat q)
  {
    w = q.w;
    x = q.x;
    y = q.y;
    z = q.z;
  }
public float norme(){
	return (float)Math.sqrt(x * x + y * y + z * z + w * w);
}
  void 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;
  }

  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;
  }
  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;
   }
   
   
  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;
 }
 
  Quat conjugue(){
  	return new Quat(w,-x,-y,-z);
}
 Quat oppose(){
	return new Quat(-w,-x,-y,-z);
}
Quat copie(){
	return new Quat(w,x,y,z);
	}
Quat copieNorme(){
		Quat res=new Quat(w,x,y,z);
		res.normalize();
		return res;
		}	
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);	
	
}
static Quat slerp(Quat d, Quat a,float t){
	d.normalize();
	a.normalize();
	float angle=(float)Math.acos(d.x*a.x+d.y*a.y+d.z*a.z);
	float sina=(float)Math.sin(angle);
	float rd=(float)Math.sin(angle*(1-t))/sina;
	float ra=(float)Math.sin(angle*t)/sina;
	Quat res= Quat.comb(d,rd,a,ra);

	return res;

}
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);
	float sina=(float)Math.sin(angle);
	float rd=(float)Math.sin(angle*(1-t))/sina;
	float ra=(float)Math.sin(angle*t)/sina;
	Quat res= Quat.comb(d,rd,a,ra);

	return res;

}
Vecteur axe(){
return new Vecteur(x,y,z);	
}


Arc donneArc(Vecteur vd){
	

	float[] c=getValue();
	Vecteur vn=new Vecteur(c[1],c[2],c[3]);
	vn.normalize();
	Arc res=new Arc(vn,c[0],this.norme());
	res.calculerPoints(vd);
	return res;
	
	
}


}

///////////////////////////////////////////////////////////////////////////////////////////                           TIRETTE                                             ///////////////////////////////////////////////////////////
public class Tirette {

  int x,y,xpos,xbut,longueur,couleur1,couleur2;
  float valmin,valmax,coef,valeur;
  String titre;
  boolean survol,drag;
  BFont lafonte;
  BApplet apple;
 
  //**********************************************************
  public Tirette(int x,int y,int longueur,float valmin
  ,float valmax,String titre,int couleur1,int couleur2,BFont  lafont,BApplet apple){
    this.x=x;
    this.y=y;
    this.xpos=x;
    this.xbut=x;
    this.survol=false;
    this.drag=false;
    this.longueur=longueur;
    this.valmin=valmin;
    this.valmax=valmax;
    this.coef=(valmax-valmin)/(2*longueur);
    this.titre=titre;
    this.valeur=(valmin+valmax)/2;
    this.couleur1=couleur1;
    this.couleur2=couleur2;
    this.lafonte=lafont;
    this.apple=apple;
  }
 //******************************************************
 public void actualiser(){
    if(!apple.mousePressed && drag) drag=false;
    survol= (apple.mouseX>xpos-10)&&(apple.mouseX<xpos+10)&&(apple.mouseY>y-10)&&(apple.mouseY<y+10);
  if(!drag){drag=survol&&apple.mousePressed;};
    if(drag)    xbut=apple.constrain(apple.mouseX,x-longueur-2,x+longueur+2);
    xpos+=(xbut-xpos)/2;
    this.calculer();
    this.dessinerbarre();
  }
  //****************************************************
 public  void calculer(){
    valeur=valmin+(xpos-x+longueur)*coef;
  }
  public float getValeur(){
  	return valeur;
  }
  public void setValeur(float v){
  	xpos=Math.round((v-valmin)/(float)coef )+x -longueur;apple.println(xpos);
  	xbut=xpos;
  }
  //****************************************************
  public void dessinerbarre(){
  	
	apple.stroke(couleur1);
	apple.noFill();
	apple.line(x-longueur,y-3,x+longueur,y-3);
	apple.line(x-longueur,y-2,x+longueur,y-2);
	apple.stroke(couleur2);
	apple.line(x-longueur,y-1,x+longueur,y-1);
	apple.beginShape(BApplet.TRIANGLES);apple.fill(couleur1);apple.noStroke();
    apple.vertex(xpos,y);apple.vertex(xpos-7,y+9);apple.vertex(xpos+7,y+9); apple.endShape();
    apple.beginShape(BApplet.TRIANGLES);apple.noFill();
    apple.stroke((couleur1+couleur2)/2); apple.vertex(xpos,y-1);apple.vertex(xpos-8,y+10);apple.vertex(xpos+8,y+10);
    apple.endShape();
    apple.fill(couleur1);
   apple.textFont(lafonte, 20);
   float v2=Math.round(valeur*100.0f)/100.0f;
    apple.text(titre+" :  "+v2,x-75,y-15);
  }
public void setposition(float valeur){
	xpos=(int)((valeur-valmin)/coef+x-longueur);
	xbut=xpos;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////                                       VECTEUR                       //////////////////////////////////////////////////////////
//-------------------------------------------------------
//-------------------------------------------------------
public static class Vecteur
{
  float x, y, z;
 
  Vecteur()
  {
  }

  Vecteur(float x, float y, float z)
  {
    this.x = x;
    this.y = y;
    this.z = z;
 
  }
  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;
 
  } 
 void place(float xx, float yy, float zz)
  {
    this.x = xx;
    this.y = yy;
    this.z = zz;
 
  }
 Vecteur normalize()
  {
    float length = length();
    x /= length;
    y /= length;
    z /= length;
    return this;
  }
  Vecteur normalize(float k)
   {
     float length = length();
     x=x/ length*k;
     y =y/ length*k;
     z =z/ length*k;
     return this;
   }
  float length()
  {
    return (float) Math.sqrt(x * x + y * y + z * z);
  }

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

  static float dot(Vecteur v1, Vecteur v2)
  {
    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
  }
float dot(Vecteur v1)
  {
    return v1.x * x + v1.y *y + v1.z *z;
  }
 Vecteur mul( float d)
  {
    Vecteur res = new Vecteur();
    res.x =x * d;
    res.y = y * d;
    res.z = z * d;
    return res;
  }
 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);
  }

   Vecteur ajouter(Vecteur v,float m){
		Vecteur res=new Vecteur(x+v.x*m, y+v.y*m,z+v.z*m);
    return res;
  }
  void afficher(String tex,BApplet ba){
  	ba.println(tex+"x= "+x+" y= "+y+" z= "+z);
  }
  Vecteur projete(Vecteur laxe){
  	laxe.normalize();
  	Vecteur res=laxe.mul(this.dot(laxe));
  	return res;
  }
  float donneAngle(Vecteur vc){
	 return (float) Math.acos(this.dot(vc)/(length()*vc.length()));
  }
  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);
  }
  
}


///////////////////////////////////////////////////////////////                                                        ARC                                                               //////////////////////////////////////////////////////////
//*************************************
 //************************************                                            
 //************************************ 
 public static class Arc{

 	
	 Vecteur axe;
	 float angle,rapport;
	 int r,g,b;
	 Vecteur[] points;

	public Arc( Vecteur  v,float  angle,float rapport){
			v.normalize();
			this.axe=v;
			
			this.angle=angle;
			this.rapport=rapport;
			this.points= new Vecteur[51];


		}
//********************************************************************
	public Vecteur arrivee(Vecteur depart, float ang2){
		Vecteur res;
		float ang=ang2/2;
		Quat q=new Quat((float)Math.cos(ang),axe.mul((float)Math.sin(ang)));
		Quat qv=new Quat(0,depart.x,depart.y,depart.z);	 	
		Quat qc=new Quat((float)Math.cos(ang),axe.mul(-(float)Math.sin(ang)));	
		Quat q1=Quat.mul(qv,qc);
		Quat q2=Quat.mul(q,q1);		
		res=q.tourner(depart);

	return res;
	
	 }
	//**************************************************************
 void calculerPoints(Vecteur depart){
		for(int i=0;i<50;i++){
			points[i]=arrivee(depart,angle*i/50);
					
		}
		points[50]=arrivee(depart,angle);
 }

//**************************************************************
Quat donneQuat(){	
return new Quat((float)Math.cos(angle/2)*rapport,axe.mul((float)Math.sin(angle/2)*rapport));	
}
}