//===================================================
    class Terrain{
        float[] generatrice;
        float inc,ample,rMax,rMax2;
         Vecteur coul;
        
         public Terrain(){
             coul=new Vecteur(-1f,2f,-1f); 
            inc=100;
            ample=4000f;
            rMax=2300;
            rMax2=rMax*rMax;
            generatrice=new float[int(rMax/inc)+1];  
            calculerGeneratrice();
         
        }
        float cote(float u){
            return  ample*u*u/rMax2;
        }
        float cote(float a,float b){
            return ample*(a*a+b*b)/rMax2;
        }
        
        void calculerGeneratrice(){
             
            for(int i=0;i<=rMax/inc;i++)
                generatrice[i]=cote(i*inc);
                
        }
        void dessiner(){
            fill(255);
            float inca=TWO_PI/60;
            float ci=cos(inca);
            float si=sin(inca);
            for(int k=0;k<=60;k++){
                float phi=inca*k;
                pushMatrix();
                rotateY(phi);
                noStroke();
  
          		beginShape(QUAD_STRIP);
          		for(float ra=0;ra<=rMax;ra+=inc){ 
                             Vecteur nor=getNormale(ra*cos(phi),ra*sin(phi));
    				  float scal=(Vecteur.dot(nor,coul))+1.0;
			fill(200+55*scal,200+scal*55,100);
          
                          /*Vecteur nor=getNormale(ra*cos(phi),ra*sin(phi));
                          nor=quatXY.tourner(nor);
    			  float scal=(Vecteur.dot(nor,coul));
			  fill(175+80*scal,190+scal*65,220+35*scal);*/
          		  vertex(ra,generatrice[int(ra/inc)],0);
          		  vertex(ra*ci,generatrice[int(ra/inc)],ra*si);
          		}
                 	endShape();
       	    popMatrix();
            }
        }
        
        
        
        void dessinerOmbre(float x,float z,float r){
            fill(55,55,0,50);
            noStroke();
            float y=cote(x,z)+100;
   
            float d=0.314f;
    	    beginShape(TRIANGLES);
    		for(float i=0;i<6.1f;i+=d){
                               Vecteur v=new Vecteur(x+r*cos(i),0,z+r*sin(i));
                               float longueur=v.length();
                               if(longueur>rMax){                               
                                v.x=v.x*rMax/longueur;         
                                v.z=v.z*rMax/longueur;
                              }
                              v.y=cote(v.x,v.z);
                              Vecteur w=new Vecteur(x+r*cos(i+d),0,z+r*sin(i+d));
                               float longueur1=w.length();
                               if(longueur1>rMax){                               
                                w.x=w.x*rMax/longueur1;         
                                w.z=w.z*rMax/longueur1;
                              }
                              w.y=cote(w.x,w.z);
                             
                              
                             
    		          vertex(v.x,v.y+50,v.z);
   		          vertex(x,y,z);
   		          vertex(w.x,w.y+50 ,w.z);
    		}
    	    endShape();
        }
        
        
        
        Vecteur getDerive(float x,float z){
            float y=cote(x,z);
            float u=sqrt(x*x+z*z);
            float psi=atan2(z,x);
            Vecteur res=new Vecteur(cos(psi),2*ample*u/rMax2,sin(psi));
             return res.normalize();
         }
        Vecteur getTangente(float x,float z){
           Vecteur res=new Vecteur(-z,0,x);
            return res.normalize();
        }
        Vecteur getNormale(float x,float z){
               	Vecteur res=getTangente(x,z).cross(getDerive(x,z));                 
                return res.normalize();
            }
         
        }