int count = 0;

String[] Tag = new String[14];
String Tag(String Prfx, String Sufx)
{
  Tag[ 0]=Prfx+"                                                o       "  +Sufx;
  Tag[ 1]=Prfx+"             oooo               oooo     oo    oo       "  +Sufx;
  Tag[ 2]=Prfx+"            ooooooo   oooo    ooooooo     oo  oo        "  +Sufx;
  Tag[ 3]=Prfx+"           oo   oooo ooooooo oooo  ooo     ooooo        "  +Sufx;
  Tag[ 4]=Prfx+"           oo    oooooo  ooooooo    oo      oooo        "  +Sufx;
  Tag[ 5]=Prfx+"           ooo   ooooo     oooooo  ooo      ooooo       "  +Sufx;
  Tag[ 6]=Prfx+"            ooooooooooo   ooooooooooo      oo  oooo     "  +Sufx;
  Tag[ 7]=Prfx+"              oooooo oooooooo  oooo    o   oo    oo     "  +Sufx;
  Tag[ 8]=Prfx+"                ooo   oooo                              "  +Sufx;
  Tag[ 9]=Prfx+"   --( Guillaume  ooo  LaBelle )--       goo.x@gmx.ch   "  +Sufx;
  Tag[10]=Prfx+"          oo     oo                                     "  +Sufx;
  Tag[11]=Prfx+"          ooo   ooo                                     "  +Sufx;
  Tag[12]=Prfx+"          oooooooo                                      "  +Sufx;
  Tag[13]=Prfx+"            oooo                                        "  +Sufx;

  return join(Tag,"\n");
}

BFont LogicFont;
void setup()
{
  size(500, 550);
  initSlider();
  initButtons();
  //noStroke();
  smooth();

  ellipseMode(CENTER_DIAMETER);
  LogicFont = loadFont("SlideFont.vlw");

  //Init();
  //pyramid();
  //cube();
  //building00a();
  //dome(10, 5, tempMem);
  //motsBase();
  //curvedLines(12);
  //knot();
  initScale();
}

int Background = 255;
void loop()
{
  background(Background);

  updateSlider(); //ForLoop
  updateButtons();
  push();
  //updateProjective();
  updateOrbit();
  Cub();
  //Draw(); //DON'T REMOVE
  pop();
}

//------------------------------------------------------------
//------------------------------------------------------------
//--( VUES )--
//------------------------------------------------------------
float xmag, ymag = 0;
float newXmag, newYmag = 0;
void updateOrbit(){
  translate(width/2, width/2, -30);
  if(key=='1')
  {
    newXmag = mouseX/float(width) * TWO_PI;
    newYmag = mouseY/float(height) * TWO_PI;
    key='a';
  }
  float diff = xmag-newXmag;
if (abs(diff) >  0.01) { xmag -= diff/4.0; }
  diff = ymag-newYmag;
if (abs(diff) >  0.01) { ymag -= diff/4.0; }
  rotateX(-ymag);
  rotateY(-xmag);

  if(key=='2')
  {
    scScene*=0.875+(mouseY/float(height))/4;
    key='a';
  }
  scale(100*scScene);
}

void updateProjective(){
  translate(width/2, height/2);

  scale(100*scScene);
}

float scNode, scLine, scAngle, scLabel, scScene, rndMoov;  //Scales
void initScale(){
  scNode = 1;
  scLine = 1;
  scAngle = 3;
  scLabel = 0.75;
  scScene = 0.0075;
  rndMoov = 0.01;
}

int rR = 2; int rRt = 100;

//------------------------------------------------------------
//------------------------------------------------------------
//--( DIVERS )--
//------------------------------------------------------------
float rRnd(float rR, float rRt){
  float rRnd = random(rR)/rRt-(rR/rRt)/2;
  return rRnd;
};

int r(int max){
  return int(random(max));
}

//------------------------------------------------------------
//------------------------------------------------------------
//--( Sliders )--
//------------------------------------------------------------
/*Global*/
BFont slideFont;
HScrollbar[] GooSlider = new HScrollbar[7];
///////////////////////////////
//Sliders fn
///////////////////////////////
void initSlider(){
  slideFont = loadFont("SlideFont.vlw");
  int co = 150;
  GooSlider[0] = new HScrollbar(10/*xPos*/, height-10*1/*yPos*/,width-100/*width*/,8/*height*/,05/*friction*/,5/*init*/,0/*MIN*/,10/*MAX*/, "AFF", color(co,co,co) );
  GooSlider[1] = new HScrollbar(10/*xPos*/, height-10*2/*yPos*/,width-100/*width*/,8/*height*/,05/*friction*/,5/*init*/,0/*MIN*/,10/*MAX*/, "ATT", color(co,co,co) );
  GooSlider[2] = new HScrollbar(10/*xPos*/, height-10*1/*yPos*/,width-100/*width*/,8/*height*/,05/*friction*/,170/*init*/,0.1/*MIN*/,250/*MAX*/, "cLen", color(co,co,co) );
  GooSlider[3] = new HScrollbar(10/*xPos*/, height-10*2/*yPos*/,width-100/*width*/,8/*height*/,05/*friction*/,15/*init*/,0.1/*MIN*/,30/*MAX*/, "cLar", color(co,co,co) );
  GooSlider[4] = new HScrollbar(10/*xPos*/, height-10*3/*yPos*/,width-100/*width*/,8/*height*/,05/*friction*/,10/*init*/,0.1/*MIN*/,20/*MAX*/, "bum", color(co,co,co) );
  GooSlider[5] = new HScrollbar(10/*xPos*/, height-10*4/*yPos*/,width-100/*width*/,8/*height*/,05/*friction*/,PI/4/*init*/,0.0/*MIN*/,PI/2/*MAX*/, "ROT", color(co,co,co) );
  GooSlider[6] = new HScrollbar(10/*xPos*/, height-10*5/*yPos*/,width-100/*width*/,8/*height*/,05/*friction*/,7/*init*/,0/*MIN*/,20/*MAX*/, "NUM", color(co/2,co/2,co/2) );
  //GooSlider[5] = new HScrollbar(10/*xPos*/, height-10*6/*yPos*/,width-100/*width*/,8/*height*/,05/*friction*/,21/*init*/,0/*MIN*/,40/*MAX*/, "GRV", color(co,co/2,0) );
  //GooSlider[2] = new HScrollbar(10/*xPos*/, height-10*3/*yPos*/,width-100/*width*/,8/*height*/,35/*friction*/,0.5/*init*/,0/*MIN*/,1/*MAX*/, "PHY", color(co,co,co) );
}

void updateSlider(){
  for(int i=2;i<GooSlider.length; i++)
  {
    GooSlider[i].update();
    GooSlider[i].draw();
  }
}

///////////////////////////////
//Sliders
///////////////////////////////
class HScrollbar
{
  int swidth, sheight;    // width and height of bar
  int xPos, yPos;         // x and y position of bar
  float spos, newspos;    // x position of slider
  int sposMin, sposMax;   // max and min values of slider
  int loose;              // how loose/heavy
  boolean over;           // is the mouse over the slider?
  boolean locked;
  float ratio;
  float value;
  float valueMAX;
  float valueMIN;

  color couleur;
  String name;

  HScrollbar (int xPos, int yPos, int sw, int sh, int l, float v, float MIN, float MAX, String name, color couleur) {
    swidth = sw;
    sheight = sh;
    int widthtoheight = sw - sh;
    ratio = (float)sw / (float)widthtoheight;
    this.xPos = xPos;
    this.yPos = yPos-sheight/2;
    //spos = xPos + swidth/2 - sheight/2;
    spos = (swidth*v)/(MAX-MIN);
    newspos = spos;
    sposMin = xPos;
    sposMax = xPos + swidth - sheight;
    loose = l;
    value = v;
    valueMAX = MAX;
    valueMIN = MIN;

    this.couleur=couleur;
    this.name = name;
  }

  void update() {
    if(over()) {
      over = true;
    } else {
      over = false;
    }
    if(mousePressed && over) {
      locked = true;
    }
    if(!mousePressed) {
      locked = false;
    }
    if(locked) {
      newspos = constrain(mouseX-sheight/2, sposMin, sposMax);
    }
    if(abs(newspos - spos) > 1) {
      spos = spos + (newspos-spos)/loose;
    }
  }

  int constrain(int val, int minv, int maxv) {
    return min(max(val, minv), maxv);
  }

  boolean over() {
    if(mouseX > xPos && mouseX < xPos+swidth &&
    mouseY > yPos && mouseY < yPos+sheight) {
      return true;
    } else {
      return false;
    }
  }

  void draw() {

    fill(red(couleur), green(couleur), blue(couleur), 150);
    stroke(red(couleur), green(couleur), blue(couleur) );
    line(xPos, yPos+sheight/2, xPos+swidth, yPos+sheight/2);
    rect(spos, yPos, sheight, sheight);

    fill(red(couleur), green(couleur), blue(couleur), 30);
    noStroke();
    rect(xPos, yPos+sheight/4, swidth, sheight/2);

    fill(red(couleur), green(couleur), blue(couleur));
    value = getPos();
    textFont(slideFont, 18);
    text( " "+name+" "+nf(value, 0, 2), xPos+swidth, yPos+sheight/2+6);
  }

  float getPos() {
    return ((valueMAX-valueMIN)*(spos * ratio))/swidth;
  }
}

///////////////////////////////
//Buttons fn
///////////////////////////////
int Bval=9;
RectButton[] Buttons = new RectButton[10];
void initButtons(){
  color base = color(200,200,200);
  color high = color(150,150,150);
  int w=15;
  int s=4;
  for(int i =0;i<Buttons.length;i++)
  Buttons[i] = new RectButton(w*i+s,s,w-s,base,high,i);
}

void updateButtons(){
  for(int i =0;i<Buttons.length;i++)
  {
    if(locked == false) Buttons[i].update();
    else locked = false;
    if(mousePressed)  if(Buttons[i].pressed()) Bval = Buttons[i].value;
    Buttons[i].display();
  }
}

///////////////////////////////
//Buttons
///////////////////////////////
boolean locked =false;

class RectButton
{
  int x, y;
  int size;
  color basecolor, highlightcolor;
  color currentcolor;
  int value;
  boolean over = false;
  boolean pressed = false;

  void update()
  {
    if(over()) {
      currentcolor = highlightcolor;
    } else {
      currentcolor = basecolor;
    }
  }

  boolean pressed()
  {
    if(over) {
      locked = true;
      return true;
    } else {
      locked = false;
      return false;
    }
  }

  RectButton(int _x, int _y, int _size, color _color, color _highlight, int _value)
  {
    x = _x;
    y = _y;
    size = _size;
    basecolor = _color;
    highlightcolor = _highlight;
    currentcolor = basecolor;
    value=_value;
  }

  boolean over()
  {
    if( overRect(x, y, size, size) ) {
      over = true;
      return true;
    } else {
      over = false;
      return false;
    }
  }

  void display()
  {
    stroke(100);
    fill(currentcolor);
    rect(x, y, size, size);
  }
}
boolean overRect(int x, int y, int width, int height)
{
  if (mouseX >= x && mouseX <= x+width &&
  mouseY >= y && mouseY <= y+height) {
    return true;
  } else {
    return false;
  }
}

//------------------------------------------------------------
//------------------------------------------------------------
//--( Vec3D )--
//------------------------------------------------------------
// Vec3D - simple 3D vector class
// processing.unlekker.net

class Vec3D {
  float x,y,z;

Vec3D(){}
  Vec3D(float _x,float _y,float _z) {
    x=_x;
    y=_y;
    z=_z;
  }

  Vec3D(Vec3D v) {
    x=v.x;
    y=v.y;
    z=v.z;
  }

  void set(float _x,float _y,float _z) {
    x=_x;
    y=_y;
    z=_z;
  }

  void set(Vec3D v) {
    x=v.x;
    y=v.y;
    z=v.z;
  }

  void add(float _x,float _y,float _z) {
    x+=_x;
    y+=_y;
    z+=_z;
  }

  void add(Vec3D v) {
    x+=v.x;
    y+=v.y;
    z+=v.z;
  }

  void sub(float _x,float _y,float _z) {
    x-=_x;
    y-=_y;
    z-=_z;
  }

  void sub(Vec3D v) {
    x-=v.x;
    y-=v.y;
    z-=v.z;
  }

  void mult(float m) {
    x*=m;
    y*=m;
    z*=m;
  }

  void div(float m) {
    x/=m;
    y/=m;
    z/=m;
  }

  float length() {
    return sqrt(x*x+y*y+z*z);
  }

  void normalise() {
    float l=length();
    if(l!=0) {
      x/=l;
      y/=l;
      z/=l;
    }
  }

  ////////////////////////////////////
  void rotateX(float val) {
    // Floats are not precise enough, so doubles are used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmp1=y*cosval - z*sinval;
    double tmp2=y*sinval + z*cosval;
    y=(float)tmp1;
    z=(float)tmp2;
  }
  void rotateY(float val) {
    // Floats are not precise enough, so doubles are used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmp1=x*cosval - z*sinval;
    double tmp2=x*sinval + z*cosval;
    x=(float)tmp1;
    z=(float)tmp2;
  }
  void rotateZ(float val) {
    // Floats are not precise enough, so doubles are used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmp1=x*cosval - y*sinval;
    double tmp2=x*sinval + y*cosval;
    x=(float)tmp1;
    y=(float)tmp2;
  }

  ////////////////////////////////////
  void transform(float[][] M){
    x = M[0][0]*x + M[1][0]*y + M[2][0]*z + M[3][0];
    y = M[0][1]*x + M[1][1]*y + M[2][1]*z + M[3][1];
    z = M[0][2]*x + M[1][2]*y + M[2][2]*z + M[3][2];
  }
  void translate(Vec3D V){
    float[][] M =
    {
    {1,0,0},
    {0,1,0},
    {0,0,1},
    {V.x,V.y,V.z}
    };
    transform(M);
  }
  void scale(float _x,float _y,float _z){
    float[][] M =
    {
    {_x,0,0},
    {0,_y,0},
    {0,0,_z},
    {0,0,0}
    };
    transform(M);
  }
}

//------------------------------------------------------------
//------------------------------------------------------------
//--( gPoint )--
//------------------------------------------------------------

class Vec3Doo extends Vec3D {

Vec3Doo(){}
Vec3Doo(float x,float y,float z) {this.x=x;this.y=y;this.z=z;}
Vec3Doo(Vec3D v) {x=v.x;y=v.y;z=v.z;}

  ////////////////////////////////////
  float lengthRapid() {
    return x*x+y*y+z*z;
  }
  ////////////////////////////////////
  void normalize() {
    float l=length();
    if(l!=0) {
      x/=l;
      y/=l;
      z/=l;
    }
  }
  ////////////////////////////////////
  void transform(float[][] M){
    x = M[0][0]*x + M[1][0]*y + M[2][0]*z + M[3][0];
    y = M[0][1]*x + M[1][1]*y + M[2][1]*z + M[3][1];
    z = M[0][2]*x + M[1][2]*y + M[2][2]*z + M[3][2];
  }
  void translate(Vec3Doo V){
    float[][] M =
    {
    {1,0,0},
    {0,1,0},
    {0,0,1},
    {V.x,V.y,V.z}
    };
    transform(M);
  }
  void scale(float _x,float _y,float _z){
    float[][] M =
    {
    {_x,0,0},
    {0,_y,0},
    {0,0,_z},
    {0,0,0}
    };
    transform(M);
  }
  void scale(float _x){
    float[][] M =
    {
    {_x,0,0},
    {0,_x,0},
    {0,0,_x},
    {0,0,0}
    };
    transform(M);
  }
  void draw(){
    line(0,0,0,x,y,z);
  }
  void setScalar(float Sc){
    float OldLength = length();
    float ratio = Sc/OldLength;
    scale(ratio);
  }
}

Vec3Doo vcross(Vec3Doo A, Vec3Doo B){
  double Cx = (double)A.y*(double)B.z - (double)A.z*(double)B.y;
  double Cy = (double)A.z*(double)B.x - (double)A.x*(double)B.z;
  double Cz = (double)A.x*(double)B.y - (double)A.y*(double)B.x;
  return new Vec3Doo((float)Cx,(float)Cy,(float)Cz);
}

//------------------------------------------------------------
//------------------------------------------------------------
//--( Dome )--
//------------------------------------------------------------

void line(Vec3D a, Vec3D b)
{
  line(a.x,a.y,a.z,b.x,b.y,b.z);
}

class Bloc{
  Vec3D[] pt;
  int[][] l;

  Bloc(Vec3D[] _pt, int[][] _l)
  {
    pt = new Vec3D[_pt.length];
    for(int i=0;i<_pt.length;i++)
    {
      pt[i]=new Vec3D(_pt[i]);
      //print("("+pt[i].x+"-"+pt[i].y+"-"+pt[i].z+")");
    }
    //println();
    l = new int[_l.length][2];
    for(int i=0;i<_l.length;i++)
    {
      l[i][0]=_l[i][0];
      l[i][1]=_l[i][1];
      //print("("+l[i][0]+"-"+l[i][1]+")");
    }
    //println();
  }

  Bloc(Bloc unBloc)
  {
    pt = new Vec3D[unBloc.pt.length];
    for(int i=0;i<unBloc.pt.length;i++)
    pt[i]=new Vec3D(unBloc.pt[i]);
    l = new int[unBloc.l.length][2];
    for(int i=0;i<unBloc.l.length;i++)
    {
      l[i][0]=unBloc.l[i][0];
      l[i][1]=unBloc.l[i][1];
    }
  }

  void sym(int sw)
  {
    if(sw==0)
    for(int i=0;i<pt.length;i++)
    pt[i].scale(-1,1,1);
    else if(sw==1)
    for(int i=0;i<pt.length;i++)
    pt[i].scale(1,-1,1);
    else if(sw==2)
    for(int i=0;i<pt.length;i++)
    pt[i].scale(1,1,-1);
  }

  void rot(int sw, float ang)
  {
    if(sw==0)
    for(int i=0;i<pt.length;i++)
    pt[i].rotateX(ang);
    else if(sw==1)
    for(int i=0;i<pt.length;i++)
    pt[i].rotateY(ang);
    else if(sw==2)
    for(int i=0;i<pt.length;i++)
    pt[i].rotateZ(ang);
  }

  void sub(Vec3D z)
  {
    for(int i=0;i<pt.length;i++)
    pt[i].sub(z);
  }

  void add(Vec3D z)
  {
    for(int i=0;i<pt.length;i++)
    pt[i].add(z);
  }

  void update()
  {

  }

  void draw()
  {
    //stroke(0);
    for(int i=0;i<l.length;i++)
    {
      line(pt[l[i][0]],pt[l[i][1]]);
      //print("("+pt[l[i][0]].x+"-"+pt[l[i][0]].y+"-"+pt[l[i][0]].z+")");
      //print("("+pt[l[i][1]].x+"-"+pt[l[i][1]].y+"-"+pt[l[i][1]].z+")");
    }
    //println();
  }
  void drawFace()
  {

  }

}

Bloc join(Bloc A, Bloc B)
{
  Vec3D[] pt=new Vec3D[A.pt.length+B.pt.length];
  int[][] l =new int[A.l.length+B.l.length][2];

  for(int i=0;i<A.pt.length;i++)
  pt[i]=A.pt[i];
  for(int i=0;i<B.pt.length;i++)
  pt[i+A.pt.length]=B.pt[i];

  for(int i=0;i<A.l.length;i++)
  {
    l[i][0]=A.l[i][0];
    l[i][1]=A.l[i][1];
  }
  for(int i=0;i<B.l.length;i++)
  {
    l[i+A.l.length][0]=B.l[i][0]+A.pt.length;
    l[i+A.l.length][1]=B.l[i][1]+A.pt.length;
  }

  Bloc C = new Bloc(pt,l);
  return C;
}

void Cub(){
  float cLen= GooSlider[2].value;
  float cLar= GooSlider[3].value;
  Vec3D[] pt=new Vec3D[4];
  pt[0]=new Vec3D(-cLen,-cLen,-cLen);
  pt[1]=new Vec3D(    0,-cLen,-cLen);
  pt[2]=new Vec3D(pt[0]);
  pt[2].add(cLar,cLar,0);
  pt[3]=new Vec3D(pt[1]);
  pt[3].add(0,cLar+GooSlider[4].value-10,0);

int[][] l={ {0,1},{0,2},{2,3} };

Bloc niv0=new Bloc(pt,l);
//niv1.draw();

//------------------------------
Bloc niv1=new Bloc(niv0);
niv1.sub(niv0.pt[0]);
niv1.rot(0,GooSlider[5].value-PI/4);
//niv1.sym(1);
//niv1.rot(0,-PI/4);
niv1.add(niv0.pt[0]);

niv1.pt[2]=new Vec3D(niv1.pt[2].y,niv1.pt[2].y,niv1.pt[2].z);

//stroke(0); niv1.draw();

//------------------------------
Bloc nic1=new Bloc(niv1);
nic1.sub(niv1.pt[0]);
nic1.rot(0,PI/4);
nic1.sym(1);
nic1.rot(0,-PI/4);
nic1.add(niv1.pt[0]);
//nic1.draw();
Vec3D jct=new Vec3D(niv1.pt[2]);
jct.sub(nic1.pt[2]);
jct.div(2);
jct.add(nic1.pt[2]);
//niv1.pt[4]=jct;
//nic1.pt[4]=jct;

//niv1.pt[2]=new Vec3D(niv1.pt[2].y,niv1.pt[2].y,niv1.pt[2].z);
//nic1.pt[2]=new Vec3D(niv1.pt[2].y,niv1.pt[2].y,niv1.pt[2].z);

Bloc niv2=join(niv1,nic1);
//stroke(0); niv2.draw();

if(Bval==1)
{
  //------------------------------
  //Membrures
  int subnum=int(GooSlider[6].value)+2;
  Vec3D memDista=new Vec3D(niv2.pt[2]);
  memDista.sub(niv2.pt[3]);
  memDista.div(subnum-1);

  int plus=niv2.pt.length/2;
  Vec3D memDistb=new Vec3D(niv2.pt[2+plus]);
  memDistb.sub(niv2.pt[3+plus]);
  memDistb.div(subnum-1);

  Vec3D memDistc=new Vec3D(memDista.x,0,0);
  //memDistc.div(subnum-1);
  //subnum++;

  Vec3D[] ptm=new Vec3D[(subnum)*3];
  int[][] lm =new int[(subnum)*3][2];

  for(int i=0;i<subnum;i++)
  {
    ptm[i]=new Vec3D(memDista);
    ptm[i].mult(i);
    ptm[i].add(niv2.pt[3]);

    ptm[i+subnum]=new Vec3D(memDistb);
    ptm[i+subnum].mult(i);
    ptm[i+subnum].add(niv2.pt[3+plus]);

    ptm[i+subnum*2]=new Vec3D(memDistc);
    ptm[i+subnum*2].mult(i);
    ptm[i+subnum*2].add(niv2.pt[1]);

    lm[i][0]=i;
    lm[i][1]=i+subnum;

    lm[i+subnum][0]=i+subnum*2;
    lm[i+subnum][1]=i+subnum;

    lm[i+subnum*2][0]=i;
    lm[i+subnum*2][1]=i+subnum*2;
  }

  Bloc mem=new Bloc(ptm,lm);
  //stroke(0,0,255); mem.draw();

  niv2=join(niv2,mem);
}

if(Bval==2 | Bval==6)
{
  //------------------------------
  //Membrures
  int subnum=int(GooSlider[6].value)+2;
  Vec3D memDista=new Vec3D(niv2.pt[2]);
  memDista.sub(niv2.pt[3]);
  memDista.div(subnum-1);

  int plus=niv2.pt.length/2;
  Vec3D memDistb=new Vec3D(niv2.pt[2+plus]);
  memDistb.sub(niv2.pt[3+plus]);
  memDistb.div(subnum-1);

  Vec3D memDistc=new Vec3D(memDista.x,0,0);
  //memDistc.div(subnum-1);
  //subnum++;

  Vec3D[] ptm=new Vec3D[(subnum)*3];
  int[][] lm =new int[(subnum)*6][2];

  for(int i=0;i<subnum;i++)
  {
    ptm[i]=new Vec3D(memDista);
    ptm[i].mult(i);
    ptm[i].add(niv2.pt[3]);

    ptm[i+subnum]=new Vec3D(memDistb);
    ptm[i+subnum].mult(i);
    ptm[i+subnum].add(niv2.pt[3+plus]);

    ptm[i+subnum*2]=new Vec3D(memDistc);
    ptm[i+subnum*2].mult(i);
    ptm[i+subnum*2].add(niv2.pt[1]);

    lm[i][0]=i;
    lm[i][1]=i+subnum;

    lm[i+subnum][0]=i+subnum*2;
    lm[i+subnum][1]=i+subnum;

    lm[i+subnum*2][0]=i;
    lm[i+subnum*2][1]=i+subnum*2;
  }

  for(int i=0;i<subnum-1;i++)
  {
    lm[i+subnum*3][0]=i;
    lm[i+subnum*3][1]=i+subnum*1+1;

    lm[i+subnum*4][0]=i+subnum*1;
    lm[i+subnum*4][1]=i+subnum*2+1;

    lm[i+subnum*5][0]=i+subnum*2;
    lm[i+subnum*5][1]=i+1;
  }

  Bloc mem=new Bloc(ptm,lm);
  //stroke(0,0,255); mem.draw();

  niv2=join(niv2,mem);
}

//------------------------------
Bloc nic2=new Bloc(niv2);
nic2.sub(niv1.pt[3]);
nic2.sym(0);
nic2.add(niv1.pt[3]);

Bloc niv3=join(niv2,nic2);
//stroke(0); if(Bval==5 | Bval==6 | Bval==7) niv3.draw();

if(Bval==7|Bval==8)
{
  //------------------------------
  //Membrures
  int subnum=int(GooSlider[6].value)+2;
  Vec3D memDista=new Vec3D(niv3.pt[2]);
  memDista.sub(niv3.pt[2+niv3.pt.length/2]);
  memDista.div(subnum-1);

  int plus=niv3.pt.length/4;
  Vec3D memDistb=new Vec3D(niv3.pt[2+plus]);
  memDistb.sub(niv3.pt[2+plus+niv3.pt.length/2]);
  memDistb.div(subnum-1);

  Vec3D memDistc=new Vec3D(memDista.x,0,0);
  //memDistc.div(subnum-1);
  //subnum++;

  Vec3D[] ptm=new Vec3D[(subnum)*3];
  int[][] lm =new int[(subnum)*9][2];

  for(int i=0;i<subnum;i++)
  {
    ptm[i]=new Vec3D(memDista);
    ptm[i].mult(i);
    ptm[i].add(niv3.pt[2+niv3.pt.length/2]);

    ptm[i+subnum]=new Vec3D(memDistb);
    ptm[i+subnum].mult(i);
    ptm[i+subnum].add(niv3.pt[2+plus+niv3.pt.length/2]);

    ptm[i+subnum*2]=new Vec3D(memDistc);
    ptm[i+subnum*2].mult(i);
    ptm[i+subnum*2].add(niv3.pt[niv3.pt.length/2]);
    ptm[i+subnum*2].add(-cLar,0,0);

    lm[i][0]=i;
    lm[i][1]=i+subnum;

    lm[i+subnum][0]=i+subnum*2;
    lm[i+subnum][1]=i+subnum;

    lm[i+subnum*2][0]=i;
    lm[i+subnum*2][1]=i+subnum*2;
  }

  //if(Bval==8)
  for(int i=0;i<subnum-1;i++)
  {
    lm[i+subnum*3][0]=i;
    lm[i+subnum*3][1]=i+subnum*1+1;

    lm[i+subnum*4][0]=i+subnum*1;
    lm[i+subnum*4][1]=i+subnum*2+1;

    lm[i+subnum*5][0]=i+subnum*2;
    lm[i+subnum*5][1]=i+1;
    
    lm[i+subnum*6][0]=i;
    lm[i+subnum*6][1]=i+subnum*2+1;

    lm[i+subnum*7][0]=i+subnum*1;
    lm[i+subnum*7][1]=i+subnum*0+1;

    lm[i+subnum*8][0]=i+subnum*2;
    lm[i+subnum*8][1]=i+subnum*1+1;
  }

  Bloc mem=new Bloc(ptm,lm);
  //stroke(0,0,255); mem.draw();

  niv3=join(niv3,mem);
}

stroke(0); if(Bval==5 | Bval==6 | Bval==7) niv3.draw();

//------------------------------
Bloc nic3=new Bloc(niv3);
nic3.sub(niv1.pt[0]);
nic3.sym(0);
nic3.rot(1,-PI/2);

nic3.add(niv1.pt[0]);
//stroke(255,0,0);nic3.draw();

Bloc nic3b=new Bloc(niv3);
nic3b.sub(niv1.pt[0]);
nic3b.sym(0);
nic3b.rot(2,-PI/2);

nic3b.add(niv1.pt[0]);
//stroke(0,255,0);nic3b.draw();

Bloc niv4=join(join(niv3,nic3),nic3b);
stroke(0); if(Bval==4)  niv4.draw();

//------------------------------
Bloc nic4=new Bloc(niv4);
nic4.rot(0,PI);
//stroke(255,0,0);nic4.draw();
Bloc niv5=join(niv4,nic4);
stroke(100,60,0);  if(Bval!=4 & Bval!=5 & Bval!=6 & Bval!=7 ) niv5.draw();

//------------------------------
Bloc nic5=new Bloc(niv5);
nic5.sym(0);
nic5.sym(1);
//stroke(255,0,0);
if(Bval!=3 & Bval!=4 & Bval!=5 & Bval!=6 & Bval!=7 ) nic5.draw();

if(Bval==9) 
{ 
int rndSlide=(int)(random(GooSlider.length)); 
GooSlider[rndSlide].newspos = random(GooSlider[rndSlide].sposMax);
Bval=0;
 }

}