• fullscreen
  • Alcys_Turtle_Logo_3D.pde
  • Button.pde
  • Instruction.pde
  • Programmes.pde
  • Tortue.pde
  • /**
     *Alcys_Turtle_Logo_3D
     *par Jacques Maire
     *fait le 28 juillet 2012
     *Une tortue qui deviendra interactive ?!
     */
    
    
    
    import remixlab.proscene.*;
    Scene scene;
    Tortue tortue;
    Programmes lesProgrammes;
    int noProgramme, nbPrgm;
    PFont tahoma;
    Button2D button;
    
    
    
    
    void setup() {
      size(900, 700, P3D);
      scene=new Scene(this);
      scene.setGridIsDrawn(true);
      scene.setAxisIsDrawn(true);
      scene.disableKeyboardHandling();
      scene.camera().setPosition(new PVector(0, 0, 12000));
      scene.camera().setOrientation(new Quaternion(new PVector(1, 0, 0), 0.10));
      frameRate(30);
      nbPrgm=11;
      noProgramme=0;
      lesProgrammes=new Programmes();
      tortue=new Tortue(lesProgrammes.programmes[noProgramme].liste);
      tahoma = loadFont("Tahoma-21.vlw");
    
      textFont(tahoma);
      button = new ClickButton(scene, new PVector(50, 50), "TURTLE "+noProgramme, 21);
    }
    void draw() {
      float ang=0.0005*millis();
      background(0, 0, 30);
      directionalLight(255, 255, 150, 0, -1, -1);
      directionalLight(0, 155, 250, -1, -1, -1); 
      directionalLight(75*sq(1+sin(0.3*ang)), 0, 75*sq(2+sin(0.5*ang)), 0, 0.5, 0);
      directionalLight( 0, 125*sq(cos(2*ang)), 100+155*sq(cos(2*ang)), -0.1, 0, 0.5);
      directionalLight( 255, 230, 200, 1, 1, -1);
      tortue.dessiner();
      tortue.moteur();
      fill(255);
      button.display();
    }
    
    
    /**
     * Button 2D.
     * by Jean Pierre Charalambos.
     * 
     * Base class of "2d buttons" that shows how simple is to implement
     * a MouseGrabber which can enable complex mouse interactions.
     */
    
    public class Button2D extends MouseGrabber {
      String myText;
      PFont myFont;
      int myWidth;
      int myHeight;  
      PVector position;
    
      Button2D(Scene scn, PVector p, int fontSize) {
        this(scn, p, "", fontSize);
      }
    
      Button2D(Scene scn, PVector p, String t, int fontSize) {
        super(scn);
        position = p;
        myText = t;    
        textFont( tahoma, 21);
        textMode(SCREEN);
        textAlign(CENTER);
        setText(t);
      }
    
      void setText(String text) {
        myText = text;
        myWidth = (int) textWidth(myText);
        myHeight = (int) (textAscent() + textDescent());
      }
    
      void display() {
        pushStyle();
        if (grabsMouse())
          fill(255, 0, 0);
        else
          fill(255);
        text(myText, position.x, position.y, myWidth, myHeight);
        popStyle();
      }
    
      void checkIfGrabsMouse(int x, int y, Camera camera) {
        // Rectangular activation area
        setGrabsMouse( (position.x <= x ) && ( x <= position.x + myWidth ) && (position.y <= y ) && ( y <= position.y + myHeight ) );
      }
    }
    
    //---------------------------------------------------------------------
    
    
    public class ClickButton extends Button2D {
      boolean addBox;
    
      public ClickButton(Scene scn, PVector p, String t, int fontSize) {
        super(scn, p, t, fontSize);
      }
    
      void mouseClicked(Scene.Button button, int numberOfClicks, Camera camera) {
        noProgramme=(int)(noProgramme+1)%nbPrgm;
        tortue=new  Tortue(lesProgrammes.programmes[noProgramme].liste);
        setText("TURTLE "+noProgramme);
        scene.camera().setPosition(new PVector(0, 0, 12000));
        scene.camera().setOrientation(new Quaternion(new PVector(1, 0, 0), 0.1));
      }
    }
    
    
    
    abstract class Instruction {   
      public abstract void dessiner();
      public abstract String getNom();
    }
    
    //-------------------------------------------------
    
    class Tourne extends Instruction
    {
      PVector pos, dir;
      float angle;
      int compteur, compte;
      Quaternion q;
      String nom;
    
      Tourne( PVector p, PVector d, float a) {
        pos=p;
        dir=d;
        angle=a;
        compteur=floor(angle/0.1);
        q=new Quaternion(dir, angle/compteur);
        nom="tourne";
      }
    
      String getNom() {
        return nom;
      } 
    
    
      void dessiner() {
        compte++;
        //println("tourne  "+compte+"   "+compteur);
        if (compte>=compteur+1) {
          tortue.finInstruction=true;
          compte=0;
        }
        else {
          tortue.repere1.setTranslation(PVector.sub(pos, q.rotate(pos)));
          tortue.repere1.setRotation(q); 
          tortue.positions.add(tortue.repere1.position());
          tortue.orientations.add(tortue.repere1.orientation());
          tortue.repere.setPosition((PVector)tortue.positions.get(tortue.positions.size()-1));
          tortue.repere.setOrientation((Quaternion)tortue.orientations.get(tortue.orientations.size()-1));
        }
      }
    }
    //---------------------------------------------
    
    class Avance extends Instruction 
    {
    
      public String  nom;
      PVector vecInc, vecBut;
      int compteur, compte;       
    
      public Avance( PVector but) {
        this.vecBut=new PVector (but.x, but.y, but.z);
        this.nom="avance";     
        this.compteur=(int)Math.ceil(vecBut.mag()/50);
        this.vecInc= (compteur>0)?  PVector.mult(vecBut, 1.0/compteur) : vecBut;
        compte=0;
      }
      //
      String getNom() {
        return nom;
      }
      //
      public void dessiner() { 
        //println(nom);
        compte++;
        if (  compte>=compteur +1) {
          tortue.finInstruction=true; 
          compte=0;
        }
        else {    
          tortue.repere1.setTranslation(vecInc);
          tortue.positions.add(tortue.repere1.position()); 
          tortue.orientations.add(tortue.repere.orientation()); 
          tortue.repere.setPosition((PVector)tortue.positions.get(tortue.positions.size()-1));
        }
      }
    }
    //-----------------------------------------------
    
    
    class Ouvre extends Instruction { 
      String nom;
      public Ouvre() {
    
        this.nom="ouvre";
      }
      String getNom() {
        return nom;
      }
    
      public void dessiner() {
        //println(nom);
        tortue.finInstruction=true;
      }
    }  
    //---------------------------------------------
    
    class Ferme extends Instruction {
      String nom;   
      public Ferme() {
    
        this.nom="ferme";
      }
    
    
      String getNom() {
        return nom;
      }
    
      public void dessiner() { 
        //println(nom); 
        String lnom;         
    
        int bee=0;//nombre de parentheses "ouvre" rencontrées dans la remontée
        int clos=1;//nombre de parentheses "ferme" rencontrées dans la remontée
        int lign= tortue.ligne;
        do {
          lign--;
          if (tortue.listing[lign].getNom() == "ouvre") bee++;
          if (tortue.listing[lign].getNom()=="ferme") clos++;
        }
        while (bee != clos);//on remonte dans le listing pour trouver autant d'"ouvre" que de "ferme"
        tortue.ligne=lign-1;           
        tortue.finInstruction=false;
      }
    }
    
    //--------------------------------------
    
    class Repete extends Instruction {
      String nom;
      int compteur, compteur0;
         
      public Repete( int compteur) {          
        this.compteur=compteur;
        this.compteur0=compteur;             
        this.nom="repete";
      }
    
    
      String getNom() {
        return nom;
      }
      //
      public void dessiner() { 
        if (compteur==0) {
          int bee=0;
          int clos=0;
          int lign= tortue.ligne;
          do {
            lign++;      
            if (tortue.listing[lign].getNom()=="ouvre") bee++;
            if (tortue.listing[lign].getNom()=="ferme") clos++;
          }
          while (bee != clos);
          tortue.ligne=lign;
          compteur=compteur0;//remise en etat
        }
        else {
          compteur--;
        }
        tortue.finInstruction=true;
      }
    }   
    
    //-------------------------------------------
    
    class GoTo extends Instruction { 
      String nom;
      int lign;
    
      GoTo( int lign) {
        this.lign=lign;
        this.nom="goto";
      }
    
      void dessiner() {
        tortue.ligne=lign-1;
        tortue.finInstruction=true;
      }
      String getNom() {
        return nom;
      }
    }  
    
    
    class Listing {
      Instruction[] liste;
    
      Listing(Instruction[] li) {    
        liste=li;
      };
    }
    
    
    
    
    //----------------------------------------
    
    class Programmes {
    
      Listing[] programmes;
    
      Programmes() {
        programmes=new Listing[nbPrgm];
        Instruction[] inst0= {
          new  Repete(8), 
          new Ouvre(), 
          new Avance(new PVector(0, 0, 2000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(0, 1, 0), PI/4), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 0.5*PI), 
          new Avance(new PVector(0, 0, 1000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 1.5*PI), 
          new Avance(new PVector(0, 0, 1000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 1.5*PI), 
          new Avance(new PVector(0, 0, 1000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 0.5*PI), 
          new Ferme()
          };   
          programmes[0]= new Listing(inst0);
    
    
        Instruction[] inst1= {
          new  Repete(3), 
          new Ouvre(), 
          new Avance(new PVector(0, 3000, 0)), 
          new Tourne(new PVector(0, 1000, 0), new PVector(1, 0, 0), PI), 
          new Tourne(new PVector(0, 1000, 0), new PVector(1, 1, 0), PI/2), 
          new Ferme()
          }; 
          programmes[1]= new Listing(inst1);
    
        Instruction[] inst2= {
          new  Repete(20), 
          new Ouvre(), 
          new Avance(new PVector(0, 3000, 0)), 
          new Tourne(new PVector(0, 1000, 0), new PVector(1, 0, 0), PI), 
          new Tourne(new PVector(0, 1000, 0), new PVector(1, 1, 0), PI/2), 
          new Tourne(new PVector(0, 0, -1000), new PVector(1, -2, 1), PI/2), 
          new Ferme()
          };
          programmes[2]= new Listing(inst2);
    
        Instruction[] inst3= {
          new  Repete(4), 
          new Ouvre(), 
          new Avance(new PVector(0, 3000, 0)), 
          new Tourne(new PVector(0, 1000, 0), new PVector(1, 0, 0), PI), 
          new Tourne(new PVector(0, 1000, 0), new PVector(1, 1, 0), PI/2), 
          new Tourne(new PVector(0, 0, -1000), new PVector(1, -2, 1), PI/2), 
          new  Repete(2), 
          new Ouvre(), 
          new Avance(new PVector(0, 3000, 0)), 
          new Tourne(new PVector(0, 1000, 0), new PVector(1, 0, 0), PI), 
          new Tourne(new PVector(0, 1000, 0), new PVector(1, 1, 0), PI/2), 
          new Ferme(), 
          new Ferme()
          };
          programmes[3]= new Listing(inst3);  
    
        Instruction[] inst4= {
          new  Repete(3), 
          new Ouvre(), 
          new Avance(new PVector(0, 3000, 0)), 
          new Tourne(new PVector(0, -3000, 0), new PVector(1, 0, 0), PI/3), 
          new Avance(new PVector(0, 0, 3000)), 
          new Tourne(new PVector(0, 0, -3000), new PVector(1, 0, 0), PI/3), 
          new Ferme()
          };   
          programmes[4]= new Listing(inst4);
    
        Instruction[] inst5={
          new  Repete(8), 
          new Ouvre(), 
          new Avance(new PVector(0, 0, 900)), 
          // new Tourne(new PVector(0, 0, 0), new PVector(0, 1, 0), 0.5*PI),
          new Tourne(new PVector(1000, 0, 0), new PVector(0, 1, 0), PI), 
          new Tourne(new PVector(0, 1000, 0), new PVector(-1, 0, 0), PI), 
          new Avance(new PVector(0, 0, 900)), 
          new Tourne( new PVector(-1000, 0, 0), new PVector(0, -1, 0), 1.5*PI), 
          new Ferme()
          };
          programmes[5]=new Listing(inst5 );
    
        Instruction[] inst6={
          new  Repete(16), 
          new Ouvre(), 
          new Avance(new PVector(0, 0, 900)), 
          // new Tourne(new PVector(0, 0, 0), new PVector(0, 1, 0), 0.5*PI),
          new Tourne(new PVector(1000, 0, 0), new PVector(0, 1, 0), 0.5*PI), 
          new Avance(new PVector(0, 0, 900)), 
          new Tourne(new PVector(0, 1000, 0), new PVector(-1, 0, 0), 9.0*PI/6.0), 
          new Avance(new PVector(0, 0, 1900)), 
          new Ferme()
          };
          programmes[6]=new Listing(inst6 ); 
    
        Instruction[] inst7= {
          new  Repete(8), 
          new Ouvre(), 
          new Avance(new PVector(0, 0, 3000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, -1, 0), PI/4), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 0.5*PI), 
          new Avance(new PVector(0, 0, 4000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 1.5*PI), 
          new Avance(new PVector(0, 0,3000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 1.5*PI), 
          new Avance(new PVector(0, 0,4000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 0.5*PI), 
          new Ferme()
          };   
          programmes[7]= new Listing(inst7);  
    
        Instruction[] inst8= {
          new  Repete(8), 
          new Ouvre(), 
          new Avance(new PVector(0, 0, 2000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(0, 1, 0), PI/4), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 0.5*PI), 
          new Avance(new PVector(0, 0, 1000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 1.5*PI), 
          new Avance(new PVector(0, 0, 1000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 1.5*PI), 
          new Avance(new PVector(0, 0, 1000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), 0.5*PI), 
          new Tourne(new PVector(0, 2000, 2000), new PVector(1, 0, 0), 0.5*PI), 
          new  Repete(8), 
          new Ouvre(), 
          new Avance(new PVector(0, 0, -1000)), 
          new Tourne(new PVector(0, 200, 0), new PVector(1, 0, 0), PI/4), 
          new Tourne(new PVector(0, 200, 0), new PVector(1, 1, 0), -PI/4), 
          new Ferme(), 
          new Tourne(new PVector(0, 2000, 2000), new PVector(-1, 0, 0), 0.5*PI), 
          new Ferme()
          };
          programmes[8]= new Listing(inst8);
    
    
    
        Instruction[] inst9= {
          new  Repete(8), 
          new Ouvre(), 
          new Avance(new PVector(0, 0, 3000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), PI/8), 
          new Tourne(new PVector(0, 0, 0), new PVector(0, 1, 0), PI/2), 
          new Avance(new PVector(0, 0, 3000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(0, 1, 0), PI/2), 
          new Avance(new PVector(0, 0, 3000)), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), PI/8), 
          new Ferme()
          };
          programmes[9]= new Listing(inst9);
    
    
    
        Instruction[] inst10= { 
          new  Repete(8), 
          new Ouvre(), 
          new Tourne(new PVector(0, 0, 0), new PVector(1, 0, 0), PI/4), 
          new Avance(new PVector(0, 0, 1500)), 
          new Tourne(new PVector(0, 750, 0), new PVector(1, 0, 0), TWO_PI), 
          new Tourne(new PVector(750, 0, 0), new PVector(0, 1, 0), TWO_PI), 
          new Tourne(new PVector(-750, 0, 0), new PVector(0, 1, 0), TWO_PI), 
          new Avance(new PVector(0, 0, 1500)), 
          new Ferme()
          };
          programmes[10]= new Listing(inst10);
      }
    }
    
    
    class Tortue {
      ArrayList positions;
      ArrayList orientations;
      InteractiveFrame repere, repere1;
      Instruction[] listing;
    
      boolean finInstruction;
      int ligne;
    
      Tortue(Instruction[] prgm) {
        listing=prgm;
        finInstruction=false;
        ligne=0;
        repere=new InteractiveFrame(scene);
        repere1=new InteractiveFrame(scene);
        repere1.setReferenceFrame(repere);
        repere.setPosition(new PVector(0, 0, 0));
        repere.setOrientation(new Quaternion(new PVector(0, 0, 1), 0));
        repere1.setTranslation(new PVector(0, 0, 0));
        repere1.setRotation(new Quaternion(new PVector(0, 0, 1), 0));
        positions=new ArrayList();
        orientations=new ArrayList();
        positions.add(repere.position());
        orientations.add(repere.orientation());
      }
    
    
      void dessiner() {
        float c=200;
        noStroke();
        fill(255);
        PVector u, v, w, t, u1, v1, w1, t1;
        repere.setPosition((PVector)positions.get(0));
        repere.setOrientation((Quaternion)orientations.get(0));
        pushMatrix();
        repere.applyTransformation();
        scene.drawAxis(1000);
    
        u=repere.inverseCoordinatesOf(new PVector(-c, -c, 0));
        v=repere.inverseCoordinatesOf(new PVector(-c, c, 0));
        w=repere.inverseCoordinatesOf(new PVector(c, c, 0));
        t=repere.inverseCoordinatesOf(new PVector(c, -c, 0)); 
        popMatrix();
        for (int i=1;i<positions.size();i++) {
          repere.setPosition((PVector)positions.get(i));
          repere.setOrientation((Quaternion)orientations.get(i));
          pushMatrix();
          repere.applyTransformation(); 
          if (i==positions.size()-1) {
            scene.drawAxis(2000);   
            fill(255, 0, 0);
            sphere(300);
            fill(125, 125, 200);
          }
          u1=repere.inverseCoordinatesOf(new PVector(-c, -c, 0));
          v1=repere.inverseCoordinatesOf(new PVector(-c, c, 0));
          w1=repere.inverseCoordinatesOf(new PVector(c, c, 0));
          t1=repere.inverseCoordinatesOf(new PVector(c, -c, 0));
    
          popMatrix();
          beginShape(QUAD_STRIP);
          vertex(u.x, u.y, u.z);
          vertex(u1.x, u1.y, u1.z);
          vertex(v.x, v.y, v.z);
          vertex(v1.x, v1.y, v1.z);
          vertex(w.x, w.y, w.z);
          vertex(w1.x, w1.y, w1.z);
          vertex(t.x, t.y, t.z);
          vertex(t1.x, t1.y, t1.z);
          vertex(u.x, u.y, u.z);
          vertex(u1.x, u1.y, u1.z);
          endShape();
          u=u1.get();
          v=v1.get();
          w=w1.get();
          t=t1.get();
        }
      }
    
    
      void moteur() {
        if (ligne<listing.length-1) {
          if (finInstruction )
          {
            ligne++;
            finInstruction=false;
            listing[ligne].dessiner();
          }
          else {
            listing[ligne].dessiner();
          }
        }
      }
    }
    
    

    code

    tweaks (1)

    about this sketch

    This sketch is running as Java applet, exported from Processing.

    license

    advertisement

    jacques maire

    Turtle_Logo_3D

    Add to Faves Me Likey@! 1
    You must login/register to add this sketch to your favorites.

    Built with Proscene

    CLICK the button to another drawing

    You need to login/register to comment.