• fullscreen
  • schizzo2.pde
  • int penx = 0;
    int peny = 0;
    int de = 2;
    cLista lista = new cLista();
    int el0 = 0;
    
    int by;
    
    // ------------------------------------------------------------
    
    void setup() { 
      size(800, 600);
    //  size(1024, 768);
    //  size(screen.width, screen.height);
      smooth();
      frameRate(30);
      colorMode(HSB, 1);
      ellipseMode(CENTER);
      stroke(0, 0, 0, 0.7);
      background(0, 0, 1);
    //  strokeWeight(0.3 * de + 1);
    strokeWeight(2);
      
      city();
    }
    
    // ------------------------------------------------------------
    
    void draw() {
      int t = 0;
      while((t++ < 50) && (el0 < lista.nr)) {
        lista._draw(el0++);
      }
      if (el0 == lista.nr) {
        noLoop();
      }
    }
    
    // ------------------------------------------------------------
    
    void mouseClicked() {
      lista.nr = 0;
      el0 = 0;
      city();
      background(0, 0, 1);
      loop();
    }
    
    // ------------------------------------------------------------
    
    void keyPressed()
    {
      if( key == 's') {
        save("city.tif");
      }
    }
    
    // ------------------------------------------------------------
    
    void city() {
    
      // cielo nero
    //  rettf(0, 0, width, int(0.95*height));
      // luna
      int rag = height / 10;
      lista.agg(0, (int)random(rag, width-rag), (int)random(0.3*height, 0.5*height-rag));
      lista.agg(6, rag, 0);
    
      // strade
      PVector p1;
      PVector p2;
      p1 = proietta(new PVector(-10, 0, 240));
      p2 = proietta(new PVector(-10, 0, -60));
      linea(p1, p2);
      p1 = proietta(new PVector(-20, 0, 240));
      p2 = proietta(new PVector(-20, 0, -60));
      linea(p1, p2);
      p1 = proietta(new PVector(-40, 0, -5));
      p2 = proietta(new PVector(240, 0, -5));
      linea(p1, p2);
      p1 = proietta(new PVector(-40, 0, -15));
      p2 = proietta(new PVector(240, 0, -15));
      linea(p1, p2);
    
      palazzo(new PVector(40, 0, 80));
      palazzo(new PVector(40, 0, 40));
      for(int z=9; z>0; z--) {
        palazzo(new PVector(0, 0, z*40));
      }
      for(int x=6; x>=0; x--) {
        palazzo(new PVector(x*40, 0, 0));
      }
    
      // alberi
      for(int x=220; x>=0; x-=40) {
        albero(new PVector(x, 0, -2));
        albero(new PVector(-2, 0, x));
      }
    
      // semafori
      semaforox(new PVector( 0, 0, 162));
      semaforox(new PVector( 0, 0,  82));
      semaforox(new PVector( 0, 0,   2));
      semaforoz(new PVector(82, 0,   0));
      semaforoz(new PVector( 2, 0,   0));
      
      palazzo(new PVector(0, 0, -53));
    }
    
    // ------------------------------------------------------------
    
    PVector proietta(PVector pt) {
      float d = 60.00;
      float h = 1.50;  
      float alfa = radians(30);
      
      float a = pt.x * sin(alfa) - pt.z * cos(alfa);
      float b = pt.x * cos(alfa) + pt.z * sin(alfa);
      float x = d * a / (b + d);
      float y = d * (pt.y - h) / (b + d);
      
      float sc = height / 90;
      return new PVector(0.63*width + sc*x, 0.95*height - sc*y);
    }
    
    // ------------------------------------------------------------
    
    void palazzo(PVector pt) {  
      int tipo = int(random(10));  
      int h = int(random(50, 100));
      boolean insegne = false;
      switch (tipo) {
        case 0:
          box3d(new PVector(pt.x+20, h, pt.z+10), new PVector(pt.x+21, h+random(20, 40), pt.z+11));
          box3d(new PVector(pt.x+10, h, pt.z+10), new PVector(pt.x+11, h+random(20, 40), pt.z+11));
          rettangolo_bianco(new PVector(pt.x, h, pt.z), new PVector(pt.x+30, h, pt.z), new PVector(pt.x+30, h, pt.z+30), new PVector(pt.x, h, pt.z+30));
          box3d(new PVector(pt.x, 20, pt.z), new PVector(pt.x+30, h-4, pt.z+30));
          for (int fi=30-3; fi>0; fi-=3) {
            linea(proietta(new PVector(pt.x, 20, pt.z+fi)), proietta(new PVector(pt.x, h-4, pt.z+fi)));
            linea(proietta(new PVector(pt.x+fi, 20, pt.z)), proietta(new PVector(pt.x+fi, h-4, pt.z)));
          }
          box3d(pt, new PVector(pt.x+30, 19, pt.z+30));
          insegne = true;
          break;
        case 1:
          int nr = int(random(5, 20));
          for (int i=nr-1; i>=0; i--) {
            box3d(new PVector(pt.x, i*4+4, pt.z), new PVector(pt.x+30, i*4+6, pt.z+30));
          }
          pilotis(pt, 30, 30, 4);
          insegne = true;
          break;
        case 2:
          box3d(new PVector(pt.x+1, h-10, pt.z+1), new PVector(pt.x+29, h, pt.z+29));
          box3d(new PVector(pt.x+ 2, 10, pt.z+22), new PVector(pt.x+ 4, h-10, pt.z+28));
          box3d(new PVector(pt.x+22, 10, pt.z+ 2), new PVector(pt.x+28, h-10, pt.z+ 4));
          box3d(new PVector(pt.x+ 4, 10, pt.z+ 4), new PVector(pt.x+22, h-10, pt.z+22));
          box3d(new PVector(pt.x+ 2, 10, pt.z+ 2), new PVector(pt.x+ 8, h-10, pt.z+ 8));
          basamento(pt, 10);
          insegne = true;
          break;
        case 3:
          box3d(new PVector(pt.x+14.5, h, pt.z+14.5), new PVector(pt.x+15.5, h+40, pt.z+15.5));
          if (h > 50) box3d(new PVector(pt.x+2, 50, pt.z+2), new PVector(pt.x+28, h, pt.z+28));
          if (h > 50) box3d(new PVector(pt.x+4, 42, pt.z+4), new PVector(pt.x+26, 50, pt.z+26));
          if (h > 42) box3d(new PVector(pt.x+2, 16, pt.z+2), new PVector(pt.x+28, 42, pt.z+28));
          if (h > 16) box3d(new PVector(pt.x+4, 12, pt.z+4), new PVector(pt.x+26, 16, pt.z+26));
          if (h > 12) basamento(pt, 12);
          insegne = true;
          break;
        case 4:
          cilindro3d(new PVector(pt.x, 31, pt.z), h-16, 32, 13, true);
          cilindro3d(new PVector(pt.x, 26, pt.z),    4, 32, 13, true);
          cilindro3d(new PVector(pt.x, 21, pt.z),    4, 32, 13, true);
          cilindro3d(new PVector(pt.x, 16, pt.z),    4, 32, 13, true);
          cilindro3d(new PVector(pt.x, 12, pt.z),    4, 32, 11, true);
          cilindro3d(new PVector(pt.x,  0, pt.z),   12, 32, 15, false);
          break;
        case 5:
          cilindro3d(new PVector(pt.x, h-2, pt.z), 2, 8, 13, true);
          cilindro3d(new PVector(pt.x, h-6, pt.z), 4, 8, 9, true);
          cilindro3d(new PVector(pt.x, 8, pt.z), h-14, 8, 13, true);
          basamento(pt, 8);
          insegne = true;
          break;
        case 6: // giardino
          box3d(pt, new PVector(pt.x+30, pt.y+1, pt.z+30));
          for (int i=0; i<10; i++) {
            float pz = map(i, 0, 10, 0, 22);
            float px = random(0, pz);
            PVector pt0 = new PVector(pt.x+26-px, pt.y+1, pt.z+26-pz+px);
            albero(pt0);
          }
          break;
        case 7:
          box3d(new PVector(pt.x+5, 32, pt.z+5), new PVector(pt.x+25, h, pt.z+25));
          box3d(new PVector(pt.x+10, 26, pt.z+10), new PVector(pt.x+20, 32, pt.z+20));
          box3d(new PVector(pt.x+5, 26, pt.z+24), new PVector(pt.x+5, 32, pt.z+25));
          box3d(new PVector(pt.x+5, 26, pt.z+18), new PVector(pt.x+5, 32, pt.z+19));
          box3d(new PVector(pt.x+5, 26, pt.z+11), new PVector(pt.x+5, 32, pt.z+12));
          box3d(new PVector(pt.x+24, 26, pt.z+5), new PVector(pt.x+25, 32, pt.z+6));
          box3d(new PVector(pt.x+18, 26, pt.z+5), new PVector(pt.x+19, 32, pt.z+6));
          box3d(new PVector(pt.x+11, 26, pt.z+5), new PVector(pt.x+12, 32, pt.z+6));
          box3d(new PVector(pt.x+ 5, 26, pt.z+5), new PVector(pt.x+ 6, 32, pt.z+6));
          cilindro3d(new PVector(pt.x, 6, pt.z), 20, 25, 15, false);
          box3d(new PVector(pt.x+10, 0, pt.z+10), new PVector(pt.x+20, 6, pt.z+20));
          box3d(new PVector(pt.x+5, 0, pt.z+24), new PVector(pt.x+5, 6, pt.z+25));
          box3d(new PVector(pt.x+5, 0, pt.z+18), new PVector(pt.x+5, 6, pt.z+19));
          box3d(new PVector(pt.x+5, 0, pt.z+11), new PVector(pt.x+5, 6, pt.z+12));
          box3d(new PVector(pt.x+24, 0, pt.z+5), new PVector(pt.x+25, 6, pt.z+6));
          box3d(new PVector(pt.x+18, 0, pt.z+5), new PVector(pt.x+19, 6, pt.z+6));
          box3d(new PVector(pt.x+11, 0, pt.z+5), new PVector(pt.x+12, 6, pt.z+6));
          box3d(new PVector(pt.x+ 5, 0, pt.z+5), new PVector(pt.x+ 6, 6, pt.z+6));
          insegne = true;
          break;
        case 8:
          box3d(new PVector(pt.x+2, 6, pt.z+2), new PVector(pt.x+18, h-10, pt.z+18));
          box3d(new PVector(pt.x, 0, pt.z+23), new PVector(pt.x+2, h  , pt.z+28));
          box3d(new PVector(pt.x, 0, pt.z+18), new PVector(pt.x+2, h-5, pt.z+23));
          box3d(new PVector(pt.x, 0, pt.z+ 7), new PVector(pt.x+2, h-5, pt.z+12));
          box3d(new PVector(pt.x, 0, pt.z+ 2), new PVector(pt.x+2, h  , pt.z+ 7));
          box3d(new PVector(pt.x+23, 0, pt.z), new PVector(pt.x+28, h  , pt.z+2));
          box3d(new PVector(pt.x+18, 0, pt.z), new PVector(pt.x+23, h-5, pt.z+2));
          box3d(new PVector(pt.x+ 7, 0, pt.z), new PVector(pt.x+12, h-5, pt.z+2));
          box3d(new PVector(pt.x+ 2, 0, pt.z), new PVector(pt.x+ 7, h  , pt.z+2));
          insegne = true;
          break;
        case 9:
          cilindro3d(new PVector(pt.x, 0, pt.z), h, 32, 11, true);
          box3d(new PVector(pt.x, 0, pt.z+15), new PVector(pt.x+4, h, pt.z+30));
          box3d(new PVector(pt.x+15, 0, pt.z), new PVector(pt.x+30, h, pt.z+4));
          insegne = true;
          break;
      }
      
      if (insegne) {
        float iw = random(1, 1.5);
        float ih = random(2, 10);
        float ipos = random(2, 14);
        rettangolo_bianco(new PVector(pt.x+ipos, 4, pt.z-1), new PVector(pt.x+ipos, 4+ih, pt.z-1), new PVector(pt.x+ipos, 4+ih, pt.z-1-iw), new PVector(pt.x+ipos, 4, pt.z-1-iw));
        iw = random(1, 1.5);
        ih = random(2, 10);
        ipos = random(2, 14) + 15;
        rettangolo_bianco(new PVector(pt.x+ipos, 4, pt.z-1), new PVector(pt.x+ipos, 4+ih, pt.z-1), new PVector(pt.x+ipos, 4+ih, pt.z-1-iw), new PVector(pt.x+ipos, 4, pt.z-1-iw));
        iw = random(1, 1.5);
        ih = random(2, 10);
        ipos = random(2, 14);
        rettangolo_bianco(new PVector(pt.x-1, 4, pt.z+ipos), new PVector(pt.x-1, 4+ih, pt.z+ipos), new PVector(pt.x-1-iw, 4+ih, pt.z+ipos), new PVector(pt.x-1-iw, 4, pt.z+ipos));
        iw = random(1, 1.5);
        ih = random(2, 10);
        ipos = random(2, 14) + 15;
        rettangolo_bianco(new PVector(pt.x-1, 4, pt.z+ipos), new PVector(pt.x-1, 4+ih, pt.z+ipos), new PVector(pt.x-1-iw, 4+ih, pt.z+ipos), new PVector(pt.x-1-iw, 4, pt.z+ipos));
      }
    }
    
    // ------------------------------------------------------------
    
    void basamento(PVector pt, float h) {
      int nr1 = int(random(1, 5));
      int nr2 = int(random(1, 5));
      float inter1 = 27.0 / nr1;
      float inter2 = 27.0 / nr2;
      box3d(pt, new PVector(pt.x+30, h, pt.z+30));
      rettangolo_rigato(new PVector(pt.x, 6, pt.z+2), new PVector(pt.x, h-2, pt.z+2), new PVector(pt.x, h-2, pt.z+28), new PVector(pt.x, 6, pt.z+28));
      for (int i=0; i<nr1; i++) {
        rettangolo_rigato(new PVector(pt.x, 0, pt.z+2+i*inter1), new PVector(pt.x, 4, pt.z+2+i*inter1), new PVector(pt.x, 4, pt.z+1+(i+1)*inter1), new PVector(pt.x, 0, pt.z+1+(i+1)*inter1));
      }
      rettangolo_nero(new PVector(pt.x+2, 6, pt.z), new PVector(pt.x+2, h-2, pt.z), new PVector(pt.x+28, h-2, pt.z), new PVector(pt.x+28, 6, pt.z));
      for (int i=0; i<nr2; i++) {
        rettangolo_nero(new PVector(pt.x+2+i*inter2, 0, pt.z), new PVector(pt.x+2+i*inter2, 4, pt.z), new PVector(pt.x+1+(i+1)*inter2, 4, pt.z), new PVector(pt.x+1+(i+1)*inter2, 0, pt.z));
      }
    }
    
    // ------------------------------------------------------------
    
    void albero(PVector pt0) {
      PVector pt1 = pt0.get();
      pt1.y += 4;
      PVector pt2 = pt1.get();
      pt2.x += 2;
      pt2.z -= 2;
      PVector pp0 = proietta(pt0);
      PVector pp1 = proietta(pt1);
      PVector pp2 = proietta(pt2);
      lista.agg(0, (int)pp1.x, (int)pp1.y);
      lista.agg(6, int(pp2.x-pp1.x), 0);
      dlinea(pp0, pp1);
    }
    
    // ------------------------------------------------------------
    
    void semaforox(PVector pt0) {
      linea(proietta(new PVector(pt0.x -2, 0, pt0.z)), proietta(new PVector(pt0.x -2, 5, pt0.z)));
      linea(proietta(new PVector(pt0.x-28, 0, pt0.z)), proietta(new PVector(pt0.x-28, 5, pt0.z)));
      linea(proietta(new PVector(pt0.x -2, 4, pt0.z)), proietta(new PVector(pt0.x-28, 4, pt0.z)));
      linea(proietta(new PVector(pt0.x -2, 5, pt0.z)), proietta(new PVector(pt0.x-28, 5, pt0.z)));
      rettangolo_bianco(new PVector(pt0.x -4, 4, pt0.z), new PVector(pt0.x -4, 5, pt0.z), new PVector(pt0.x -9, 5, pt0.z), new PVector(pt0.x -9, 4, pt0.z));
      rettangolo_bianco(new PVector(pt0.x-11, 4, pt0.z), new PVector(pt0.x-11, 5, pt0.z), new PVector(pt0.x-19, 5, pt0.z), new PVector(pt0.x-19, 4, pt0.z));
      rettangolo_bianco(new PVector(pt0.x-21, 4, pt0.z), new PVector(pt0.x-21, 5, pt0.z), new PVector(pt0.x-26, 5, pt0.z), new PVector(pt0.x-26, 4, pt0.z));
    }
    
    // ------------------------------------------------------------
    
    void semaforoz(PVector pt0) {
      linea(proietta(new PVector(pt0.x, 0, pt0.z -2)), proietta(new PVector(pt0.x, 5, pt0.z -2)));
      linea(proietta(new PVector(pt0.x, 0, pt0.z-18)), proietta(new PVector(pt0.x, 5, pt0.z-18)));
      linea(proietta(new PVector(pt0.x, 4, pt0.z -2)), proietta(new PVector(pt0.x, 4, pt0.z-18)));
      linea(proietta(new PVector(pt0.x, 5, pt0.z -2)), proietta(new PVector(pt0.x, 5, pt0.z-18)));
      rettangolo_bianco(new PVector(pt0.x, 4, pt0.z -4), new PVector(pt0.x, 5, pt0.z -4), new PVector(pt0.x, 5, pt0.z -9), new PVector(pt0.x, 4, pt0.z -9));
      rettangolo_bianco(new PVector(pt0.x, 4, pt0.z-11), new PVector(pt0.x, 5, pt0.z-11), new PVector(pt0.x, 5, pt0.z-16), new PVector(pt0.x, 4, pt0.z-16));
    }
    
    // ------------------------------------------------------------
    
    void box3d(PVector pt1, PVector pt2) {
      PVector p1 = proietta(new PVector(pt1.x, pt1.y, pt2.z));
      PVector p2 = proietta(new PVector(pt1.x, pt2.y, pt2.z));
      PVector p3 = proietta(new PVector(pt1.x, pt1.y, pt1.z));
      PVector p4 = proietta(new PVector(pt1.x, pt2.y, pt1.z));
      PVector p5 = proietta(new PVector(pt2.x, pt1.y, pt1.z));
      PVector p6 = proietta(new PVector(pt2.x, pt2.y, pt1.z));
      PVector p7 = proietta(new PVector(pt2.x, pt1.y, pt2.z));
    
      lista.agg(3, (int)p1.x, (int)p1.y);
      lista.agg(3, (int)p2.x, (int)p2.y);
      lista.agg(3, (int)p4.x, (int)p4.y);
      lista.agg(3, (int)p6.x, (int)p6.y);
      lista.agg(3, (int)p5.x, (int)p5.y);
      lista.agg(4, (int)p7.x, (int)p7.y);
    
      if (p7.y > p1.y) {
        lista.agg(3, (int)p1.x, (int)p1.y);
        lista.agg(3, (int)p3.x, (int)p3.y);
        lista.agg(3, (int)p5.x, (int)p5.y);
        lista.agg(5, (int)p7.x, (int)p7.y);
      }
      
      dlinea((int)p1.x, (int)p1.y, (int)p3.x, (int)p3.y);
      dlinea((int)p1.x, (int)p1.y, (int)p2.x, (int)p2.y);
      dlinea((int)p2.x, (int)p2.y, (int)p4.x, (int)p4.y);
      dlinea((int)p3.x, (int)p3.y, (int)p4.x, (int)p4.y);
      dlinea((int)p3.x, (int)p3.y, (int)p5.x, (int)p5.y);
      dlinea((int)p5.x, (int)p5.y, (int)p6.x, (int)p6.y);
      dlinea((int)p4.x, (int)p4.y, (int)p6.x, (int)p6.y);
      if (p7.y > p1.y) {
        dlinea((int)p1.x, (int)p1.y, (int)p7.x, (int)p7.y);
        dlinea((int)p5.x, (int)p5.y, (int)p7.x, (int)p7.y);
      }
      
      striscia(pt2.y - pt1.y, p3, p4, p5, p6);
    }
    
    // ------------------------------------------------------------
    
    void cilindro3d(PVector pt, float h, int nrseg, float rad, boolean contorno) {
      PVector [][] pv = new PVector[nrseg][2];
      for (int i=0; i<nrseg; i++) {
        float alfa = map(i, 0, nrseg, 0, TWO_PI);
        pv[i][0] = proietta(new PVector(pt.x+15+rad*cos(alfa), pt.y, pt.z+15-rad*sin(alfa)));
        pv[i][1] = proietta(new PVector(pt.x+15+rad*cos(alfa), pt.y+h, pt.z+15-rad*sin(alfa)));
      }
      for (int i=0; i<nrseg; i++) {
        int j = (i + nrseg - 1) % nrseg;
        if (pv[i][0].x <= pv[j][0].x) {
          if (i > 0) {
            lista.agg(3, (int)pv[j][0].x, (int)pv[j][0].y);
            lista.agg(3, (int)pv[i][0].x, (int)pv[i][0].y);
            lista.agg(3, (int)pv[i][1].x, (int)pv[i][1].y);
            lista.agg(4, (int)pv[j][1].x, (int)pv[j][1].y);
          }
        }
      }
      for (int i=0; i<nrseg; i++) {
        lista.agg(3, (int)pv[i][0].x, (int)pv[i][0].y);
      }
      lista.agg(5, (int)pv[0][0].x, (int)pv[0][0].y);
      for (int i=0; i<nrseg; i++) {
        int j = (i + nrseg - 1) % nrseg;
        float alfa = map(i, 0, nrseg, 0, TWO_PI) + 1;
        if (pv[i][0].x <= pv[j][0].x) {
          if (pv[(i+1)%nrseg][0].x >= pv[i][0].x) {
            linea(pv[i][0], pv[i][1]);
          }
          if (contorno) linea(pv[i][0], pv[i][1]);
          if (i > 0) {
            dlinea(pv[j][0], pv[i][0]);
            dlinea(pv[j][1], pv[i][1]);
            if (sin(alfa) > 0) striscia(h, pv[i][0], pv[i][1], pv[j][0], pv[j][1]);
          }
        }
        else {
          if (pv[(i+1)%nrseg][0].x <= pv[i][0].x) {
            linea(pv[i][0], pv[i][1]);
          }
        }
      }
    }
    
    // ------------------------------------------------------------
    
    void pilotis(PVector pt0, float dex, float dez, float h) {
      int nrx = int((dex - 1) / 6);
      int nrz = int((dez - 1) / 6);
      float delx = (dex-1) / nrx;
      float delz = (dez-1) / nrz;
      for (int i=nrz; i>0; i--) {
        box3d(new PVector(pt0.x, 0, pt0.z+i*delz), new PVector(pt0.x+1, h, pt0.z+i*delz+1));
      }
      for (int i=nrx; i>=0; i--) {
        box3d(new PVector(pt0.x+i*delx, 0, pt0.z), new PVector(pt0.x+i*delx+1, h, pt0.z+1));
      }
    }
    
    // ------------------------------------------------------------
    // striscia tratteggiata in orizzontale
    
    void striscia(float del, PVector p1, PVector p2, PVector p3, PVector p4) {
      float r1 = (p1.y - p2.y) / del;
      float r2 = (p3.y - p4.y) / del;
      float pp = 0;
      while (pp < del) {
        linea(int(p1.x), int(p2.y + pp * r1), int(p3.x), int(p4.y + pp * r2));
        pp += 0.5;
      }
    }
    
    // ------------------------------------------------------------
    
    void rettangolo_bianco(PVector pt1, PVector pt2, PVector pt3, PVector pt4) {
      PVector p1 = proietta(pt1);
      PVector p2 = proietta(pt2);
      PVector p3 = proietta(pt3);
      PVector p4 = proietta(pt4);
      lista.agg(3, (int)p1.x, (int)p1.y);
      lista.agg(3, (int)p2.x, (int)p2.y);
      lista.agg(3, (int)p3.x, (int)p3.y);
      lista.agg(4, (int)p4.x, (int)p4.y);
      linea(p1, p2);
      linea(p2, p3);
      linea(p3, p4);
      linea(p4, p1);
    }
    
    void rettangolo_rigato(PVector pt1, PVector pt2, PVector pt3, PVector pt4) {
      rettangolo_bianco(pt1, pt2, pt3, pt4);
      striscia(pt2.y - pt1.y, proietta(pt1), proietta(pt2), proietta(pt4), proietta(pt3));
    }
    
    void rettangolo_nero(PVector pt1, PVector pt2, PVector pt3, PVector pt4) {
      PVector p1 = proietta(pt1);
      PVector p2 = proietta(pt2);
      PVector p3 = proietta(pt3);
      PVector p4 = proietta(pt4);
      lista.agg(3, (int)p1.x, (int)p1.y);
      lista.agg(3, (int)p2.x, (int)p2.y);
      lista.agg(3, (int)p3.x, (int)p3.y);
      lista.agg(5, (int)p4.x, (int)p4.y);
    }
    
    // ------------------------------------------------------------
    
    // rettangolo pieno
    void rettf(int sx, int sy, int ex, int ey) {
      
      int dex = ex - sx;
      int dey = ey - sy;
      lista.agg(0, sx, sy);
      for (int i=0; i<min(dex, dey); i+=6) {
        lista.agg(1, sx, sy + i);
        lista.agg(1, sx + i, sy);
      }
      if (dex > dey) {
        for (int i=0; i<dex-dey; i+=6) {
          lista.agg(1, sx + i, ey);
          lista.agg(1, sx + dey + i, sy);
        }
      }
      else {
        for (int i=0; i<dey-dex; i+=6) {
          lista.agg(1, sx, sy + dex + i);
          lista.agg(1, ex, sy + i);
        }
      }
      for (int i=min(dex, dey); i>=0; i-=6) {
        lista.agg(1, ex - i, ey);
        lista.agg(1, ex, ey - i);
      }
    }
    
    // ------------------------------------------------------------
    
    void linea(int sx, int sy, int ex, int ey) {
      lista.agg(0, sx, sy);
      lista.agg(1, ex, ey);
    }
    
    void linea(PVector p1, PVector p2) {
      linea((int)p1.x, (int)p1.y, (int)p2.x, (int)p2.y);
    }
    
    // ------------------------------------------------------------
    
    void dlinea(int sx, int sy, int ex, int ey) {
      linea(sx, sy, ex, ey);
      linea(sx, sy, ex, ey);
    }
    
    void dlinea(PVector p1, PVector p2) {
      dlinea((int)p1.x, (int)p1.y, (int)p2.x, (int)p2.y);
    }
    
    // ------------------------------------------------------------
    
    class cLista {
      int mat[][] = new int [100000][3];
      int nr = 0;
      PVector [] pv = new PVector[100];
      int nrv = 0;
    
      cLista() {
        for (int i=0; i<pv.length; i++) {
          pv[i] = new PVector(0, 0);
        }
      }
      
      void agg(int tipo, int px, int py) {
        mat[nr][0] = tipo;
        mat[nr][1] = px + int(random(-de, de));
        mat[nr][2] = py + int(random(-de, de));
        nr++;
      }
      
      void _draw(int el) {
        switch(mat[el][0]) {
          case 0: // move to
            penx = mat[el][1];
            peny = mat[el][2];
            break;
          case 1: // line to
            stroke(0, 0, 0, 0.5);
            noFill();
            line(penx, peny, mat[el][1], mat[el][2]);
            penx = mat[el][1];
            peny = mat[el][2];
            break;
          case 2: // rettangolo pieno
            noStroke();
            fill(0, 0, 1);
            rect(penx, peny, mat[el][1] - penx, mat[el][2] - peny);
            break;
          case 3: // vertice poligono pieno
            pv[nrv].x = mat[el][1];
            pv[nrv].y = mat[el][2];
            nrv++;
            break;
          case 4: // chiusura poligono pieno bianco
            pv[nrv].x = mat[el][1];
            pv[nrv].y = mat[el][2];
            nrv++;
            noStroke();
            fill(0, 0, 1);
            beginShape();
            for (int i=0; i<nrv; i++) {
              vertex(pv[i].x, pv[i].y);
            }
            endShape(CLOSE);
            nrv = 0;
            break;
          case 5: // chiusura poligono pieno nero
            pv[nrv].x = mat[el][1];
            pv[nrv].y = mat[el][2];
            nrv++;
            noStroke();
            fill(0, 0, 0);
            beginShape();
            for (int i=0; i<nrv; i++) {
              vertex(pv[i].x, pv[i].y);
            }
            endShape(CLOSE);
            nrv = 0;
            break;
          case 6: // sfera
            int px0;
            int py0;      
            int px1 = 0;
            int py1 = 0;
            int nrs = height / 6;
            float ra = random(2.1, 2.4);
            noStroke();
            fill(0, 0, 1);
            ellipse(penx, peny, 2*mat[el][1], 2*mat[el][1]);   
            stroke(0, 0, 0, 0.5);
            noFill();
            for (int i=0; i<nrs; i++) {
              float alfa = map(i, 0, nrs, 0, 2 * TWO_PI);
              px0 = px1;
              py0 = py1;
              float rad = mat[el][1] + 2 * de * sin(ra*alfa);
              px1 = penx + int(rad * cos(alfa));
              py1 = peny + int(rad * sin(alfa));
              if (i > 0) {
                line(px0, py0, px1, py1);
              }
            }
            break;
        }
      }
    }
    
    // ------------------------------------------------------------
    
    

    code

    tweaks (1)

    about this sketch

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

    license

    advertisement

    Luca Sassone

    Schizzo 2

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

    A cityscape sketch similar to the one at http://www.openprocessing.org/visuals/?visualID=12095.
    Click the mouse for another city.
    Very simple: buildings size and position are random generated and so the details. Every lines have a bit of random shift at the edges for giving a handdraw like. All lines are stored in a pipeline for sequential rendering.

    Awesome, just like the first one~ It is rather amazing how real it looks.
    Josh Norman
    4 Oct 2010
    I really like the hand drawn look. it gives it so much character
    fantastic and extra-original. bravissimo.
    claudemit
    5 Oct 2010
    wow,good job!
    bitcraft
    7 Oct 2010
    stunning! this is a real masterpiece.
    Felipe Cuadra
    7 Oct 2010
    this is gourgeous!
    I love how coding can give such results.
    congrats! :D

    I shall read every line of code to learn...
    antiplastik
    10 Oct 2010
    great!
    Pretty amazing.
    brian jones
    8 Dec 2010
    Thanks for sharing this impressive sketch!

    I'm a big fan of adding a bit of random variation to give things a more 'organic' feel.
    Harikrishnan G.
    28 Dec 2010
    Love this!
    matthew pearce
    13 Feb 2011
    Mint.
    SiV
    14 Mar 2011
    Bravo!!! taken as an example of programming...
    Nom Bot
    24 Apr 2011
    makes me want to be an architect ...
    seriously beautiful sketch, this
    Christopher Aaby
    27 Sep 2011
    Wow, the handdrawn look is spot-on! I will have to try some stuff like that. Very awesome!
    R.A. Robertson
    3 Nov 2011
    Looking forward to the 3D version...
    (-;
    This is impressive and visually compelling. It definitely inspires me to try something like that.
    Eduardo Obieta
    12 Jun 2012
    So Nice¡¡¡
    Very nice! I favorited this!
    Gottfried
    25 May 2013
    Formidable-merci !
    Milka Horozova
    19 Jun 2013
    Amazing work! <3
    I used the program for my drawing machine:
    https://vimeo.com/91832952
    Luca Sassone
    14 Apr 2014
    Is fashinating to see how El Rassama draw like a human hand. Very nice job.
    You need to login/register to comment.