//Alcys_Karting version du 9/05/2004
///////////////////////////////////////////////////////////////////
//SETUP
///////////////////////////////////////////////////////////////////
Systeme sys;

void setup(){
  size(700,400);

  sys=new Systeme();
  ellipseMode(CENTER_DIAMETER);

}
///////////////////////////////////////////////////////////////////
//LOOP
///////////////////////////////////////////////////////////////////


void loop(){
   background(55);
  push();
  if (mousePressed == true) {sys.voiture.vitesse+=20; };
  if (keyPressed==true){
  if(key==UP){sys.voiture.vitesse+=10;};
  if(key==DOWN){if(sys.voiture.coords.x/2000>sys.ch.t) sys.voiture.vitesse-=10;};
  if(key==RIGHT){sys.voiture.anglevoiture-=0.05;};
  if(key==LEFT){sys.voiture.anglevoiture+=0.05;};
  }
  sys.afficher();
  pop();
}
////////////////////////////////////////////////////
//CLASSE SYSTEME
////////////////////////////////////////////////////
class Systeme {

  Mobile voiture;
  Trajectoire trajet;
  Camera lacamera;
 Chemins ch;
  
  public Systeme(){

  this.ch=new Chemins();
       this.lacamera=new Camera(ch);
    this.trajet=new Trajectoire(lacamera,ch);
    Vecteur c=new Vecteur(800,700,0);
    this.voiture=new Mobile(c,ch);
   
  }
  
  void afficher(){
     ch.t+=((voiture.coords.x-2200)/2000-ch.t)/4;//la camera suit  la voiture souplement,avec retard
    ch.actualiser();
    lacamera.placercamera();
    trajet.dessinerlaroute();
     voiture.dessinerlavoiture();

  }
}


////////////////////////////////////////////////////
//CLASSE MOBILE
////////////////////////////////////////////////////

class Mobile {
  Vecteur coords ,ancCoords;
  float angleroue,vitesse,anglevoiture;
  Chemins ch;
  Mobile(Vecteur c,Chemins ch){
  this.ch=ch;
    this.coords=c;
    this.vitesse=20;
    this.ancCoords=new Vecteur(0,0,0);
    this.angleroue=0;
    this.anglevoiture=0;
  }

void dessinerlavoiture(){
float anglz=ch.routeT(coords.x/2000).z;
    vitesse*=0.99;
    //calculs dans le repere absolu:choc avec les bords
    Vecteur posbords=ch.route(coords.x/2000);
    float lim=posbords.y;
  if(coords.y<lim+120 ){modifiervitesse(anglz);coords.y=lim+120;};
  if( coords.y>lim+1380){modifiervitesse(anglz);coords.y=lim+1380;};
    coords.x+=vitesse*cos(anglevoiture);
    coords.y+=vitesse*sin(anglevoiture);
    posbords=ch.route(coords.x/2000);
    coords.z=posbords.z;
    Vecteur  posbordsT=ch.routeT(coords.x/2000);
    Vecteur angls=posbordsT.anguler();
    //les angles pour la voiture
    push();fill(75,80,180);translate(coords.x,coords.y,coords.z-100);
    rotateY(-angls.y);rotateZ(anglevoiture); box(500,180,100);
    translate(0,100,90);fill(0,0,0,10);box(600,500,2);translate(0,-100,-90);//ombre
    push();fill(130,130,250);translate(-200,0,-150);rotateY(-0.4);box(300,500,20);fill(0);pop();//aileron
    push();
    translate(200,180,-30);rotateY(angleroue-=vitesse/50);box(150,80,150);translate(0,-360,0);box(150,80,150);
    pop();
    translate(-200,200,-30);rotateY(angleroue-=vitesse/50);box(150,100,150);translate(0,-400,0);box(150,100,150);
    pop();
  }
  
void modifiervitesse(float anglez){
    anglevoiture=2*anglez-anglevoiture;
   coords.x+=vitesse*cos(anglevoiture);
    coords.y+=vitesse*sin(anglevoiture);
    vitesse/=2;
  }

}
////////////////////////////////////////////////////
//CLASSE TRAJECTOIRE
////////////////////////////////////////////////////
class Trajectoire{
 Camera lacamera; 
 Chemins ch;
public Trajectoire(Camera lacamera,Chemins ch){
   this.lacamera=lacamera;
   this.ch=ch;
  }

void dessinerlaroute(){
    Vecteur ancp=ch.route(ch.t);//init pour entrer dans la boucle de dessin
    for(float i=ch.t+0.03;i<ch.t+6.25;i+=0.03){
      Vecteur nouvp=ch.route(i);
      noStroke();
      beginShape(QUAD_STRIP);//la route
      fill(255,70,30);
      vertex(nouvp.x,nouvp.y,nouvp.z);
      vertex(ancp.x,ancp.y,ancp.z);
      fill(255,150,150);
      vertex(ancp.x,ancp.y+1500,ancp.z);
      vertex(nouvp.x,nouvp.y+1500,nouvp.z);
      endShape();
      beginShape(QUAD_STRIP);//le trottoir gauche
      fill(255);
      vertex(ancp.x,ancp.y+1500,ancp.z);
      vertex(nouvp.x,nouvp.y+1500,nouvp.z);fill(80,105,140);
      vertex(nouvp.x,nouvp.y+1800,nouvp.z);
      vertex(ancp.x,ancp.y+1800,ancp.z);
      endShape();
 
      beginShape(QUAD_STRIP);//le trottoir droit
      fill(255);
      vertex(ancp.x,ancp.y,ancp.z);
      vertex(nouvp.x,nouvp.y,nouvp.z);fill(80,100,140);
      vertex(nouvp.x,nouvp.y-300,nouvp.z);
      vertex(ancp.x,ancp.y-300,ancp.z);endShape();
    

      ancp=nouvp;
    }  
    //ici les tunnels
  int t0=(int)ch.t;
  
   for(int i=t0;i<ch.t+6.28;i++)
   {
     Vecteur rou0=ch.route(i);     
    Vecteur rou1=ch.route(i+0.5);
     Tunnel tu=new Tunnel(rou0,rou1,-400,255,-1130,1900,lacamera);
     tu.dessinerTunnel();
   }
   
  }
}

/////////////////////////////////////////////////////////////////////////////////////
//CLASSE VECTEUR
/////////////////////////////////////////////////////////////////////////////////////

 class Vecteur{

		  float x,y,z;
		  boolean estentrop;

	public   Vecteur(float x1,float y1,float z1){
	    this.x=x1;
	    this.y=y1;
	    this.z=z1;
	    this.estentrop=false;
  }

        public  Vecteur(){
	    x=0;
	    y=0;
	    z=0;
  }



  void normer(){
	  float lg=longueur();
	  if(lg!=0) {
		  x/=lg;
		  y/=lg;
		  z/=lg;}
  }

  Vecteur anguler(){
    float alfa=atan2(y,x);
    float beta=atan2(z,dist(0,0,x,y));
    return (new Vecteur(0,beta,alfa));
  }

  float produitscalaire(Vecteur v){
	  return x*v.x+y*v.y+z*v.z;}

  Vecteur produitvectoriel(Vecteur w){
	    Vecteur p=new Vecteur(0,0,0);
	    p.x=y*w.z-w.y*z;
	    p.y=z*w.x-w.z*x;
	    p.z=x*w.y-w.x*y;
    return p;
  }
  float distance(Vecteur v){
	    float dis=ajouter(v,-1).longueur();
    return dis;
  }

  float longueur(){
	  return dist(0,0,0,x,y,z);
  }

  void multiplier(float m){
	    x*=m;
	    y*=m;
	    z*=m;
  }
  Vecteur multiplie(float m){
	   return new Vecteur(x*m,y*m,z*m);
  }
  Vecteur ajouter(Vecteur v,float m){
		Vecteur res=new Vecteur(x+v.x*m, y+v.y*m,z+v.z*m);
    return res;
  }
  Vecteur composantesAbs(){
	    float xx=objectX(x,y,z);
	    float yy=objectY(x,y,z);
	    float zz=objectZ(x,y,z);
	return new Vecteur(xx,yy,zz);
  }

}

////////////////////////////////////////////////////
//CLASSE CAMERA
////////////////////////////////////////////////////
class Camera {
	float fov,   nearDist, farDist, aspect;
	Chemins ch;

public Camera(Chemins ch){

		this.ch=ch;
		fov = 60;
		nearDist = 400 / 1000.0f;
		farDist = 400 * 1000.0f;
		aspect = (float)width / (float)height;
}

  void placercamera(){
    beginCamera();
              perspective(fov, aspect, nearDist, farDist);
              lookat(ch.posOeil.x,ch.posOeil.y,ch.posOeil.z,
              ch.posRegard.x,ch.posRegard.y,ch.posRegard.z, 0,0, 1);
    endCamera();
   }
   //------------------------------------------------------

    Vecteur intersection(Vecteur devant, Vecteur derriere)
   {//intersection du segment (devant,derriere) avec le plan orthogonal à l'axe de la camera et placé un peu devant l'oeil 
	    Vecteur  dr = derriere.ajouter(devant,-1);
	    Vecteur dm=ch.centreEcran.ajouter(devant,-1);
	    float lambda=ch.normalEcran.produitscalaire(dm)/ch.normalEcran.produitscalaire(dr);
	    Vecteur ret=devant.ajouter(dr,lambda);
    return ret ;
  }



boolean tropPres(Vecteur m) {
        Vecteur cm=m.ajouter(ch.centreEcran,-1);
        float ret=ch.normalEcran.produitscalaire(cm);
return (ret <0);}





  void nettoyerliste(Vector liste){
    if(liste.size()>2){

      for(int i=0;i<liste.size()-2;i++){
		  Vecteur w0= (Vecteur)(liste.elementAt(i));
		  Vecteur w1= (Vecteur)(liste.elementAt(i+1));
		  Vecteur w2= (Vecteur)(liste.elementAt(i+2));
		  if(tropPres(w0) && tropPres( w1) && tropPres(w2) )
			  w1.estentrop=true;//ce sommet est inutile
      }
      Iterator iterateur=liste.iterator();
      while(iterateur.hasNext()){
		if( ((Vecteur)iterateur.next()).estentrop){
			iterateur.remove();
		}
      }
    }
  }
//Clipping
  Vector reduire(Vector liste){
	    nettoyerliste(liste);
	    Vector listef=new Vector();
    for (int i=0; i<liste.size()-1; i++) {
		if (tropPres((Vecteur)liste.elementAt(i))&&
			!(tropPres((Vecteur)liste.elementAt(i+1))) ){//cas hd
			Vecteur inter=intersection((Vecteur)liste.elementAt(i), (Vecteur)liste.elementAt(i+1));
			  listef.addElement(inter);
			}
		else{
			  if ( !(tropPres((Vecteur)liste.elementAt(i)))  &&
				  tropPres((Vecteur)liste.elementAt(i+1))) {//cas dh
				  listef.addElement(liste.elementAt(i));
				  listef.addElement( intersection((Vecteur)liste.elementAt(i),(Vecteur) liste.elementAt(i+1)));
				 }
			  else{
				  if ( !(tropPres((Vecteur)liste.elementAt(i)))  &&
					    !(tropPres((Vecteur)liste.elementAt(i+1))) ) {//cas dd
						listef.addElement(liste.elementAt(i));
					}
				}
			}
		}
    return listef;
  }

   }



////////////////////////////////////////////////////////////////////////////
//CLASSE POLYGONE
////////////////////////////////////////////////////////////////////////////



class Polygone{
                  Vecteur centre;
		  Vecteur[]  s;
		 color couleur;
		 Camera lacamera;

  public Polygone( Vecteur[] s,Camera lacamera,color couleur){
	   
           this.s=s;
	  this.lacamera=lacamera;
	  this.couleur=couleur;

  }

  void afficher(){
	 
	  Vector liste=new Vector();
	  for(int i=0;i<s.length;i++)
	  liste.add(s[i]);
	  liste.add(s[0]);

	Vector listef=lacamera.reduire(liste);

        if(listef.size()>2){
           
              
              beginShape(POLYGON);
                                     for(int i=0;i<listef.size();i++){
                                         
                                            Vecteur v=(Vecteur)listef.elementAt(i); 
                                            float q=180+50*i;
                                             if(i%2==0) fill(q,q,q*1.2);// 
                                              vertex(v.x,v.y,v.z);
                                      }
              endShape();
      }
}

}
 ////////////////////////////////////////////////////
//CLASSE TUNNEL
  ////////////////////////////////////////////////////
  class Tunnel{
  Polygone[]  polys;
  
  public Tunnel(Vecteur r,Vecteur e,float b,float d,float h,float k,Camera lacam){
  Vecteur[][] vec={
	 {new Vecteur(r.x,r.y+b,r.z+d), new Vecteur(e.x,e.y+b,e.z+d), new Vecteur(e.x,e.y+b,e.z+h), new Vecteur(r.x,r.y+b,r.z+h)},
         {new Vecteur(r.x,r.y+k,r.z+d), new Vecteur(e.x,e.y+k,e.z+d), new Vecteur(e.x,e.y+k,e.z+h), new Vecteur(r.x,r.y+k,r.z+h)},
         {new Vecteur(r.x,r.y+k,r.z+h), new Vecteur(e.x,e.y+k,e.z+h), new Vecteur(e.x,e.y+b,e.z+h), new Vecteur(r.x,r.y+b,r.z+h)}  
     ,  {new Vecteur(r.x-211,r.y+b-211,r.z+h-211), new Vecteur(r.x,r.y+b,r.z+h), new Vecteur(r.x,r.y+k,r.z+h), new Vecteur(r.x-211,r.y+k+211,r.z+h-211)}
     ,  {new Vecteur(r.x-211,r.y+b-211,r.z+h-211), new Vecteur(r.x,r.y+b,r.z+h), new Vecteur(r.x,r.y+b,r.z+13000), new Vecteur(r.x-211,r.y+b-211,r.z+13000)}
     ,  {new Vecteur(r.x-211,r.y+k+211,r.z+h-211), new Vecteur(r.x,r.y+k,r.z+h), new Vecteur(r.x,r.y+k,r.z+13000), new Vecteur(r.x-211,r.y+k+211,r.z+13000)}
 
        };
      this.polys=new Polygone[6];
      for(int i=0;i<polys.length;i++){
		 polys[i] =new Polygone(vec[i] ,lacam,color(150,150,190));
      }
      }
      public void  dessinerTunnel(){
              for(int ii=0;ii<polys.length;ii++){
                 polys[ii] .afficher();
               }
      }
}
////////////////////////////////////////////////////
//CLASSE CHEMINS
  ////////////////////////////////////////////////////
  class Chemins{
		 float     t,rayon;
Vecteur posOeil,posRegard,centreEcran,normalEcran,angles;
public Chemins(){
                this.t=0;
               this.rayon=1500.0;
  		this.posOeil=new Vecteur();
		this.posRegard =new Vecteur();
		this.centreEcran =new Vecteur();
		this.normalEcran =new Vecteur();
		this.angles =new Vecteur();
}
 
 public  Vecteur route(float tt){
    Vecteur p=new Vecteur(0,0,0);
    p.x=tt*2000;
    p.y=rayon/3*sin(tt*2);
    p.z=rayon*cos(tt);
    return p;
  }
 public Vecteur routeT(float tt){
    Vecteur p=new Vecteur(0,0,0);
    p.x=2000.0f;
    p.y=rayon/3*2*cos(tt*2);
    p.z=-rayon*sin(tt);
    p.normer();
    return p;
  }
  public  Vecteur routeN(float tt){
    Vecteur p=new Vecteur(0,0,0);
    p.x=0;
    p.y=-rayon/3*4*sin(tt*2);
    p.z=-rayon*cos(tt);
    p.normer();
    return p;
  }
 
	public void calcOeil(){
                 Vecteur v=route(t);
               posOeil.x=v.x-800;
               posOeil.y=v.y+500;
               posOeil.z=v.z-600;
	}
	public void  calcRegard(){
        Vecteur vv=routeT(t);
	Vecteur 	prov=new Vecteur(4000,vv.y*100+600,-150);
        posRegard=prov.ajouter(route(t),1);
	}

	public void  calcnormalEcran(){
		normalEcran=posRegard.ajouter(posOeil,-1);
		normalEcran.normer();

	}
	public void  calccentreEcran(){
			centreEcran=posOeil.ajouter(normalEcran.multiplie(200),1);
	}

	public void calcAngles(){
		angles=normalEcran.anguler();
	}

	public  void actualiser(){             
		calcOeil();
		calcRegard();
		calcnormalEcran();
		calccentreEcran();
		calcAngles();
	}
}