int compte;
		float angleX,angleY,bangleX,bangleY,tempo;
		float eloignement,largeur,hauteur,hautbord,pox,poy,poz;
		Articulation coude,coude0;
		Vector trajet0,trajet1;
                BFont lafonte;
                boolean bondebut;
                BImage lefond;
//*******************************************
//*******************************************

void setup(){
	lafonte=loadFont("Slabserif-MediumItalic.vlw.gz");
        lefond=loadImage("fond.jpg");
	rectMode(CORNER);
	ellipseMode(CENTER_DIAMETER);	
	size(750,500);
	background(lefond);
		Vecteur pos=new Vecteur(0,0,0);
		Vecteur axex=(new Vecteur(1,0,0));
		Vecteur axey=(new Vecteur(0,1,0));
		coude0=new Articulation(1,pos,axex,axey);
		angleX=0;
		angleY=0;
		tempo=0;
	        trajet0=new Vector();
	        trajet1=new Vector();
                bondebut=false;
		initier();
}
void initier(){
	trajet0.removeAllElements();
	trajet1.removeAllElements();
	pox=500+random(-1500,1500);
	poy=random(-2000,2000);		
	poz=random(-1500,1500);
	Vecteur pos=new Vecteur(pox,poy,poz);
	Vecteur axex=(new Vecteur(1,random(-20,20),random(-20,20))).normalize();
	Vecteur axey=new Vecteur(0,1,0);
	axey=(axey.cross(axex)).normalize();
       coude=new Articulation(1,pos,axex,axey);
       compte=Math.round(random(2,10));
       hautbord=500f+250*compte;
       eloignement=-8000-6000*compte;
       largeur=700+300*compte;	
       hauteur=1000+400*compte;
}
//*******************************************
//*******************************************
void loop(){if(!bondebut){
                        fill(255);
			textFont(lafonte, 18); 
			text(" clic... ",100,100);}else{
	
		background(lefond);
	tempo+=0.05f;
	if(tempo>TWO_PI)tempo=tempo-TWO_PI;
	dessinerTout();}
}
//*******************************************
//*******************************************
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;
	
}
//*******************************************
void repere1(){
	translate(200,0,eloignement);
	rotateX(angleX);
	rotateY(angleY);	
}
//*******************************************
void keyPressed(){
 	 if (key=='+' )eloignement +=300.0f;
	if(key=='-' )eloignement-=300.0f;	
}
//*******************************************
void mousePressed(){bondebut=true;initier();}
//*******************************************

void afficherRepere(float l){
	stroke(255,0,0);
	line(0,0,0,l,0,0);
	stroke(0,255,0);    
	line(0,0,0,0,l,0);
	stroke(0,0,255);   
	line(0,0,0,0,0,l);          
  }


//*******************************************

void dessinerTout(){
	modifierparam();
	if(coude.tempa<TWO_PI*compte+0.1f){	
	push();//absolu
	repere1();

		afficherRepere(500);
		coude0.applique(0);
		for(int i=0;i<compte;i++)	coude.applique(i);			
		Vecteur w=coorabs(hauteur,0,0);
		Vecteur w1=coorabs(hauteur,largeur,0);
	 pop();//absolu

		trajetAdd( w,w1);	}
	repere1();
	afficherTrajet();

	  }

///	+++++++++++++++++++++++++++++++++++


	void afficherTrajet(){
			 Vecteur v0,v1,v,vp,vv,ww,no,coul;
			 float cot=cos(tempo);
			 float sit=sin(tempo);   
			 noStroke();
			beginShape(QUAD_STRIP);
			 for(int i=trajet0.size()-1;i>0;i--){
				v0=(Vecteur)trajet0.elementAt(i-1);	 	
			       v=(Vecteur)trajet0.elementAt(i);
			       vp=(Vecteur)trajet1.elementAt(i);
				vv=vp.ajouter(v,-1);
			       ww=v.ajouter(v0,-1);
				no=(vv.cross(ww)).normalize(1.8f);
			       coul=(new Vecteur(cot,2*sit*cot,1+2*cot*sit)).normalize();
			       float scal=255-255*(abs(Vecteur.dot(no,coul)));
			       fill(scal+205,scal+90,scal+90);
			       if(i%2==0){
					vertex(v.x,v.y,v.z); 
				       vertex(vp.x,vp.y,vp.z);}
			       else{
				       vertex(vp.x,vp.y,vp.z);
				       vertex(v.x,v.y,v.z); 	 
			       }
			 }
		 endShape(); 
		beginShape(QUAD_STRIP);
		 for(int i=trajet0.size()-1;i>0;i--){
			v0=(Vecteur)trajet0.elementAt(i-1);	 	
		       v=(Vecteur)trajet0.elementAt(i);
		       vp=(Vecteur)trajet1.elementAt(i);
			vv=vp.ajouter(v,-1);
		       ww=v.ajouter(v0,-1);
			no=(vv.cross(ww)).normalize(2.7f);
		       coul=(new Vecteur(cot,2*sit*cot,1+2*cot*sit)).normalize();
		       float scal=255-255*(abs(Vecteur.dot(no,coul)));
		       fill(scal+200,scal+100,scal+100);
		       no=no.normalize(hautbord);
		       if(i%2==0){
				vertex(v.x,v.y,v.z); 
			       vertex(v.x+no.x,v.y+no.y,v.z+no.z);}
		       else{
			vertex(v.x+no.x,v.y+no.y,v.z+no.z);
			       vertex(v.x,v.y,v.z); 	 
		       }
		 }
	       endShape();  
	       beginShape(QUAD_STRIP);
		for(int i=trajet0.size()-1;i>0;i--){
		       v0=(Vecteur)trajet0.elementAt(i-1);	 	
		      v=(Vecteur)trajet0.elementAt(i);
		      vp=(Vecteur)trajet1.elementAt(i);
		       vv=vp.ajouter(v,-1);
		      ww=v.ajouter(v0,-1);
		       no=(vv.cross(ww)).normalize(-1.7f);
		      coul=(new Vecteur(cot,2*sit*cot,1+2*cot*sit)).normalize();
		      float scal=255-255*(abs(Vecteur.dot(no,coul)));
		      fill(scal+190,scal+100,scal+110);
		      no=no.normalize(hautbord);
		      if(i%2==0){
			       vertex(vp.x,vp.y,vp.z); 
			      vertex(vp.x+no.x,vp.y+no.y,vp.z+no.z);}
		      else{
		       vertex(vp.x+no.x,vp.y+no.y,vp.z+no.z);
			      vertex(vp.x,vp.y,vp.z); 	 
		      }
		}
	      endShape();   
		    }
   
//	*******************************************
//	*******************************************  
void trajetAdd(Vecteur w,Vecteur w1){
		  push();
			 rotateY(-angleY);
			 rotateX(-angleX);
			 translate(-200,0,-eloignement);
		w=coorabs(w.x,w.y,w.z);
		w1=coorabs(w1.x,w1.y,w1.z);			  
		 pop();
		trajet0.addElement(w);
		trajet1.addElement(w1);		     
		   
	
	     }
   
   
 Vecteur coorabs(float x,float y,float z) {
		     float xa = objectX(x, y, z);
		     float ya = objectY(x, y, z);
		     float za = objectZ(x, y, z);
		     return new Vecteur(xa, ya, za);
	     }
   
//++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++
class Articulation{
	      Vecteur pos;
	      Vecteur XX,YY;
	      int num;
	      float tempa=0;
      public Articulation(Articulation pl){
			      pos=pl.pos;
			      XX=pl.XX;
			      YY=pl.YY;
			      num=pl.num;
			    
      }
      public Articulation(int n,Vecteur position,Vecteur XXp,Vecteur YYp){
			      pos=position;
			      XX=XXp;
			      YY=YYp;
			      num=n;	
	      }


      public void applique(int i){
	     // afficherRepere(1500);
	      fill(205,70,90);noStroke();
	     beginShape(QUADS);
	    		vertex(0,0,0);
			vertex(0,largeur,0);
			vertex(pos.x,pos.y+largeur,pos.z);
			vertex(pos.x,pos.y,pos.z);	      
	      endShape();
	     fill(250,100,155);	
	    Vecteur veq=YY.mul(largeur);
		beginShape(TRIANGLES);
	  		vertex(pos.x,pos.y+largeur,pos.z);
	 		 vertex(pos.x,pos.y,pos.z);
	  		vertex(pos.x+veq.x,pos.y+veq.y,pos.z+veq.z);	      
		endShape();
	      transformerRepere();
	      line(0,-1000,0,0,1000,0);
	     tempa+=0.01f;
	      rotateY(tempa);
	      fill(255,155,100);
	     rect(0,0,hauteur,largeur);
	if(i!=compte-1)translate(hauteur,0,0);
      }
      void transformerRepere(){
	      Vecteur ZZ;
	      ZZ=XX.cross(YY);
			      transform(
			      XX.x,YY.x,ZZ.x,pos.x,
			      XX.y,YY.y,ZZ.y,pos.y,		
			      XX.z,YY.z,ZZ.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  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 tourner(float a,Vecteur ax){
	    Quat qv=new Quat(0.0f,x,y,z);
	    Quat q0=new Quat((float)Math.cos(a/2),ax.mul((float)Math.sin(a/2)));
	    Quat qc=q0.conjugue();
	    Quat q1=Quat.mul(qv,qc);	
	    Quat q= Quat.mul(q0,q1);
	    return new Vecteur(q.x,q.y,q.z);	
	
    } */
    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);
}

    }