Volume levolume;
    		Vecteur origine1;
		float angleX,angleY,bangleX,bangleY,tempo;
//===================================================		
    void setup(){
        size(750,400);
      
        levolume=new Volume(800);
        origine1=new Vecteur(-40000,-12200,-18000);
    } 
//===================================================    
    void loop(){
  	tempo+=0.05f;
  	float si=abs(sin(0.1f*tempo));//background(0);
  	background(85+150*si*si*si,140*si,150*si*si);
      modifierparam();
      levolume.dessiner();
    }
//===================================================
    void mousePressed(){
        levolume.ligne.creerControles();
    
    }
 
//  ==================================================   
    void modifierparam(){

  	translate(origine1.x,origine1.y,origine1.z);
  	bangleX=(mouseY)/100.0f;
  	bangleY=(mouseX)/100.0f;//	
  	angleX+=(bangleX-angleX)/10.0f;
  	angleY+=(bangleY-angleY)/10.0f;
  	//rotateX(angleX);
	//rotateY(angleY);		
  }
    void afficherRepere(float lon){  
 	 stroke(255,0,0);
 	line(0,0,0,lon,0,0);
 	stroke(0,255,0);    
 	line(0,0,0,0,lon,0);
 	stroke(0,0,255);   
 	line(0,0,0,0,0,lon);          
    } 
    //===================================================
    class Volume{    		
        		
        		float  diag;
        		PBezier ligne;
        		
        public Volume(float diag){
            	this.diag=diag;
            	ligne=new PBezier();       
        }
     
    //====================================================
        void dessiner(){  
    
            ligne.calculerTout();
            for(float i=0;i<400;i++){
                	push();
                	translate(i*200,0,0);
                	scale(diag);
                	stroke(220+35*abs(sin(0.05f*i)),200+55*sin(0.04f*i),200+55*cos(0.1f*i));
                	ligne.dessiner();
                	scale(1);
                	pop();}
           
         
  
        }
    }
    //===================================================

    //===================================================
    class PBezier{ 
        

        int ordre;
        Vecteur[][] table;
        Vecteur[] courbe,controles;
        
        public PBezier(){
          ordre=14 ; 
          courbe=new Vecteur[101];
          controles=new Vecteur[ordre];
          creerControles(); 
          table=new Vecteur[ordre+1][ordre+1];
          calculerTout();
        }
        
        void creerControles(){
            for(int i=0;i<ordre-1;i++){
                controles[i]=new Vecteur();
                controles[i].x= random(-10f,10f);
                controles[i].y+=random(5f)*i;
                controles[i].z*=random(-1,1);
            }
            controles[13]=controles[0];
        }
        //=================================================================
       
        Vecteur calculer(float t){
 
  
            Vecteur res;
            int fin=ordre-1;
            for(int k=1;k<ordre;k++)
            	{for(int j=0;j<fin;j++){
            	    table[j][k]=Vecteur.comb(1-t, table[j][k-1], t, table[j+1][k-1]);
            	 
            	}
               fin=fin-1; 
            }     
            return table[0][ordre-1];
        }
        //=================================================================
      
        void calculerTout(){
            //reglages des controles
            for(int i=0;i<ordre;i++) table[i][0]=controles[i];
            float temp=5+2f*cos(1.1f*tempo);
            table[4][0]= Vecteur.comb(temp, controles[4],temp-1, controles[5]); 
            temp=(3f+4f*sin(tempo*0.4f));
            table[0][0]= Vecteur.comb(temp, controles[0],temp-1, controles[5]);
            temp=(-4f+4f*sin(0.2f*tempo));
            table[8][0]= Vecteur.comb(temp, controles[8],temp-1, controles[5]);           
            temp=(4f+3.5f*cos(0.3f*tempo));
            table[7][0]= Vecteur.comb(temp, controles[7],temp-1, controles[6]); 
            temp=(3.8f+3.2f*sin(0.1f*tempo))*cos(0.2f*tempo);
            table[11][0]= Vecteur.comb(temp, controles[11],temp-1, controles[1]);            
            for(int i=0;i<101;i++) {
                courbe[i] = calculer(0.01f*i);
           
            }
        } 
        //=================================================================
     
        void dessiner(){
         beginShape(LINE_STRIP);
            for(int i=0;i<101;i++) {
                vertex(courbe[i].x,courbe[i].y,courbe[i].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);
}

   
}