//Alcys_Extrusion 29/09/2004


/////////////////////////////////////////////////////////////////////////
        BImage tampon;
        Vecteur der,deg,ded,mde,mge;
        boolean trajetclos,keyc;
        float angleX,angleY,butx,buty,reducteur,large,haut,coul1,coul2;
        int pas;
        Tirette curseur1,curseur2,regle1,regle2;
        BFont gille;
/////////////////////////////////////////////////////////////////////////       
        
/////////////////////////////////////////////////////////////////////////        
void setup(){

        size(700, 560);
        background(20,0,66);
               
        reducteur=1/150000f;
        gille=loadFont("GillSans.vlw.gz");
        pas=4;
        
        trajetclos=true;keyc=true;
 
              //definir les curseurs
        curseur1=new Tirette(150,350,100,5.0f,35.0f,"largeur",235,120,gille,this);
        curseur2=new Tirette(150,400,100,-126.0f,126.0f,"hauteur",235,120,gille,this);
        regle1=new Tirette(150,450,100,20.0f,253.0f,"couleur 1",235,120,gille,this);
        regle2=new Tirette(150,500,100,20.0f,253.0f,"couleur 2",235,120,gille,this);
        curseur1.setValeur(25f);
       curseur2.setValeur(90f);
       regle1.setValeur(20f);
        regle2.setValeur(200f);
}
/////////////////////////////////////////////////////////////////////////  

/////////////////////////////////////////////////////////////////////////  
void loop() {
  clear();
  actualiserCurseur();
  actualiserTampon();
  angleY+=0.05f;

  if(mousePressed ){
       if(mouseX<300)  {completerTrajet();}else{  modiferLesAngles(); };
  }
  dessinerLextrusion();
}

///////////////////////////////////////////////////////////////
void     modiferLesAngles(){
        butx=-(mouseY-height/2)*0.02f;
            buty=(mouseX-500)*0.02f;
            angleX+=(butx-angleX)/10.0f;
            angleY+=(buty-angleY)/10.0f;
}
////////////////////////////////////////////////////////////////
void dessinerLextrusion(){
  noStroke();
  translate(500, 200,-70);
  rotateX(angleX);
  rotateY(angleY);
  for(int i=0; i<290; i+=pas) {
    beginShape(TRIANGLE_STRIP);
    for(int j=0; j<290; j+=pas) {
      Vecteur v0=(new Vecteur(i-150,j,pixels[i+j*700]*reducteur)).coorabs(this);
      Vecteur v1=(new Vecteur(i-150,j+pas,pixels[i+(j+pas)*700]*reducteur)).coorabs(this);
      Vecteur v2=(new Vecteur(i-150+pas,j,pixels[i+pas+j*700]*reducteur)).coorabs(this);
      Vecteur vxv=((v1.ajouter(v0,-1)).cross(v2.ajouter(v0,-1))).normalize();
      float correc=abs((1*vxv.x-1*vxv.y-0*vxv.z)/1.414f);
      fill(correc*coul1,0,coul2*(1.2f-correc));
      vertex(i-150,j,(8355711-pixels[i+j*700])*reducteur);
      vertex(i-150+pas,j,(8355711-pixels[i+pas+j*700])*reducteur);
    }   endShape();
  }
}
////////////////////////////////////////////////////////////////
void mouseReleased(){
  trajetclos=true;
}
////////////////////////////////////////////////////////////////
void keyPressed(){
  if (key=='c')keyc=true;
}
////////////////////////////////////////////////////////////////
void actualiserTampon(){ if(keyc){
   fill(127);
   noStroke();
  rect(0,0,300,300); 
  tampon=get(0,0,300,300);
  keyc=false;
  }
  set(0,0,tampon);
  }
  ////////////////////////////////////////////////////////////////
void actualiserCurseur(){
 curseur1.actualiser();
  curseur2.actualiser();
  regle1.actualiser();
  regle2.actualiser();
  coul1=regle1.getValeur();
  coul2=regle2.getValeur();
  large=curseur1.getValeur();
  haut=curseur2.getValeur();
}
////////////////////////////////////////////////////////////////
void completerTrajet(){
if(mouseY<300){
  float mx=this.constrain(mouseX,10,300);
  float	my=this.constrain(mouseY,10,300);
  if(trajetclos){trajetclos=false;
    der=new Vecteur(mx,my,0);
    deg=new Vecteur(mx+8,my,0);
    ded=new Vecteur(mx-8,my,0);
    mde=new Vecteur(mx-5,my,0);
    mge=	new Vecteur(mx+5,my,0);
  }else{
    if(distance2(der.x,der.y,mx,my)>9){
      Vecteur nouv=new Vecteur(mx,my,0);
      Vecteur n=(new Vecteur(my-der.y,der.x-mx,0)).normalize(large);
      Vecteur nd=nouv.ajouter(n,1);
      Vecteur ng=nouv.ajouter(n,-1);
      Vecteur mds=nouv.ajouter(n,0.7f);
      Vecteur mgs=nouv.ajouter(n,-0.7f);
      noStroke();
      beginShape(QUAD_STRIP);
      fill(127);vertex(ded.x,ded.y);vertex(nd.x,nd.y);
      fill(127+haut/6);vertex(mds.x,mds.y);vertex(mde.x,mde.y);
      fill(127+haut);vertex(der.x,der.y);vertex(nouv.x,nouv.y);
      fill(127+haut/6);vertex(mgs.x,mgs.y);vertex(mge.x,mge.y);
      fill(127);vertex(deg.x,deg.y);vertex(ng.x,ng.y);
      endShape();
      der=nouv;
      mde=mds;
      mge=mgs;
      ded=nd;
      deg=ng;
      tampon=get(0,0,300,300);
    }
  }
}
}
////////////////////////////////////////////////////////////////
float distance2(float x,float y,float a,float b){
  return ((x-a)*(x-a)+(y-b)*(y-b));
}
//**********************************************************
//**********************************************************
//**********************************************************
//**********************************************************
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;
    xbut=xpos;
  }
  //****************************************************
  public void dessinerbarre(){

    apple.stroke(couleur1);
    apple.strokeWeight(1.0f);
    apple.noFill();
    apple.line(x-longueur,y-2,x+longueur,y-2);

    apple.beginShape(BApplet.TRIANGLES);
    apple.vertex(xpos,y);apple.vertex(xpos-11,y+11);apple.vertex(xpos+11,y+11); apple.endShape();

    apple.fill(couleur1);
    apple.textFont(lafonte, 16);
    float v2=Math.round(valeur*100.0f)/100.0f;
    apple.text(titre+" =  "+v2,x-45,y-15);
  }
}
//**********************************************************
//**********************************************************
//**********************************************************
//**********************************************************
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;
  }
  Vecteur projeteSurAxe(Vecteur laxe){
    laxe.normalize();
    Vecteur res=laxe.mul(this.dot(laxe));
    return res;
  }
  Vecteur projeteSurPlan(Vecteur laxe){
    laxe.normalize();
    Vecteur res=laxe.mul(this.dot(laxe));
    res=this.ajouter(projeteSurAxe(res),-1);
    return res;
  }
  Vecteur projeteSurPlan(Vecteur laxe,Vecteur unpoint){
    laxe.normalize();
    Vecteur res=projeteSurPlan(laxe);
    return  res.ajouter(unpoint.projeteSurAxe(res),1);

  }
  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);
  }
  Vecteur cloner()
  {
    Vecteur res = new Vecteur();
    res.x =x ;
    res.y = y ;
    res.z = z ;
    return res;
  }

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