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

void setup(){
        	lafonte=loadFont("Slabserif-MediumItalic.vlw.gz");
	       size(750,500);
		angleX=0;
		angleY=0;
		tempo=0;
		trajet0=new Vector();
		trajet1=new Vector();
		bondebut=false;
		binitier=true;
}
void initier(){
	binitier=false;
	trajet0.removeAllElements();
	trajet1.removeAllElements();
	compte=Math.round(random(5,7));
      	coude=new Articulation(compte);
       	hautbord=20000f+30000*compte;
      	eloignement=-200000-400000*compte;
     	largeur=200000+10000*compte;	
       	hauteur=1000+9000*compte;
}
//*******************************************
//*******************************************
void loop(){
	if(!bondebut){
                        background(230,180,255);
                        fill(255);
			textFont(lafonte, 18); 
			text(" clic... ",100,100);

        }else{
                      
	              if(binitier==true)initier();
	              tempo+=0.02f;
	              if(tempo>TWO_PI)tempo=tempo-TWO_PI;
	              background(230+18.0f*cos(tempo),180,235+20.0f*sin(tempo));
	              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 mousePressed(){binitier=true;  bondebut=true;}
//*******************************************
void keyPressed(){
 	 if (key=='+' )eloignement +=50000.0f;
	if(key=='-' )eloignement-=50000.0f;	
println("eloignement =  "+eloignement+  "  compte =  "+compte);
}
//*******************************************

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<(6.4f)*compte){	
	push();//absolu
		repere1();
		coude.appliquer();	
                float larg=(0.2f+1.8f*sq(cos(coude.tempa)))	;	
		Vecteur w=coorabs(hauteur*larg,0,0);
		Vecteur w1=coorabs(hauteur*larg,largeur*larg*1.3f,0);
	 pop();//absolu
	trajetAdd( w,w1);	}
	
	repere1();
	afficherTrajet();

	  }

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


	void afficherTrajet(){
			 Vecteur v0,v1,v,vp,vv,ww,no,coul;
			 float cot=cos(tempo*2);
			 float sit=sin(tempo*2);   
			 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.3f);
			       coul=(new Vecteur(cot,2*sit*cot,1+2*cot*sit)).normalize();
			       float scal=255-255*(abs(Vecteur.dot(no,coul)));
			       fill(150+0.4f*scal,100+0.3f*scal,150+0.4f*scal,160);
			       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(3.7f);
		       coul=(new Vecteur(cot,2*sit*cot,1+2*cot*sit)).normalize();
		       float scal=255-255*(abs(Vecteur.dot(no,coul)));
		       fill(0.4f*scal+130,0.4f*scal+130,0.4f*scal+170,180);		       
		       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();  
   }
//	*******************************************
//	*******************************************  
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;
 		Repere lerepere;
      public Articulation(int n){
      				num=n;
				Vecteur pos=new Vecteur(80000+random(0,30000),30000+random(0,20000),85000);
				Vecteur axex=(new Vecteur(random(-100,100),random(-100,100),random(-100,100))).normalize();
				Vecteur axey;
				do
					{axey=(new Vecteur(random(-200,200),random(-200,200),random(-200,200))).normalize();	
					axey=axey.cross(axex);}
				while(axey.length()<0.001f);
				axey.normalize();
				Vecteur axez=(axex.cross(axey)).normalize();	
			   	lerepere=new Repere(pos,axex,axey,axez);	   	
			 		    
	      }
public void appliquer(){
	tempa+=0.04f;
	rotateX(tempa/num);
	for(int i=0;i<num;i++){
		lerepere.transformerRepere();	
           rotateZ(tempa);	
             translate(0,0,lerepere.pos.z*sin(tempa*2));	
                translate(0,0,-250000-100000*sq(cos(tempa)));
    	
		//rotateX(tempa);
		//rotateY(tempa);		
	}
 
	
}

 
      }	
  //++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++    
      class Repere{
      	Vecteur pos, axex,axey,axez;
      	public Repere(Vecteur p,Vecteur xx,Vecteur yy,Vecteur zz){
      		pos=p;
      		axex=xx;
      		axey=yy;
      		axez=zz;
      	}
  
      
	void transformerRepere(){
		
				 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  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);
}

   
}