Fractal Moutains

/**

 * author Oggy 2014

 * This sketch is composed of a tiling of size NB_TILES_SIDE*NB_TILES_SIDE.

 * For each tile, a Tree is built. It will hold all the nodes for this tile.

 * In the draw() method, each Tree will be browsed to display only the leaf nodes

 **/

​

final int NB_TILES_SIDE = 3;

final int NB_POINTS_SIDE = NB_TILES_SIDE+1;

final float TILE_SIZE = 150;

final int MAX_DEPTH = 4;

final int HEIGHT_H = 150;

float lowestH;//used to vertically translate the mountain3 in order to have it rotate correctly

float highestH;//used to vertically translate the mountain3 in order to have it rotate correctly

float deltaH;//used to vertically translate the mountain3 in order to have it rotate correctly

Tree[][] trees;//trees that will hold the nodes, one tree per tile

PVector[][] randomPoints;//add some randomness in the original points[][]

PVector[][] points;//original points of the tiling

​

void setup()

{

  size(800, 600, P3D);

  initPointsAndTrees();

}

​

void initPointsAndTrees()

{

  deltaH = 0;

  points = new PVector[NB_POINTS_SIDE][NB_POINTS_SIDE];

  randomPoints = new PVector[NB_POINTS_SIDE][NB_POINTS_SIDE];

  for (int i = 0; i < NB_POINTS_SIDE; i++)

  {

    for (int j = 0; j < NB_POINTS_SIDE; j++)

    {

      randomPoints[i][j] = new PVector(random(.1, .9) * TILE_SIZE, random(.1, .9) * TILE_SIZE);

    }

  }

  for (int i = 0; i < NB_POINTS_SIDE; i++)

  {

    for (int j = 0; j < NB_POINTS_SIDE; j++)

    {

      points[i][j] = new PVector(i*TILE_SIZE - TILE_SIZE*NB_TILES_SIDE/2 + randomPoints[i][j].x, 

      j*TILE_SIZE - TILE_SIZE*NB_TILES_SIDE/2 + randomPoints[i][j].y, 

      random(HEIGHT_H));

    }

  }

​

  trees = new Tree[NB_TILES_SIDE][NB_TILES_SIDE];

  for (int i = 0; i < NB_TILES_SIDE; i++)

  {

    for (int j = 0; j < NB_TILES_SIDE; j++)

    {

      trees[i][j] = new Tree(points[i][j], points[i+1][j], points[i+1][j+1], points[i][j+1]);

    }

  }

​

  for (int i = 0; i < NB_TILES_SIDE; i++)

  {

    for (int j = 0; j < NB_TILES_SIDE; j++)

    {

      deltaH += trees[i][j].deltaH;

    }

  }

  deltaH /= (NB_TILES_SIDE*NB_TILES_SIDE);

}

​

void draw()

{

  translate(width/2, height/2);

  rotateX(TWO_PI * mouseY / height);

  rotateZ(TWO_PI * mouseX / width);

  background(210);

  for (int i = 0; i < NB_TILES_SIDE; i++)

  {

    for (int j = 0; j < NB_TILES_SIDE; j++)

    {

      drawTree(trees[i][j].root);

    }

  }

}

​

void drawTree(Node p_node)

{

  if (p_node.depth == MAX_DEPTH)

  {

    drawTriangles(p_node);

  }

  else

  {

    drawTree(p_node.nodeA);

    drawTree(p_node.nodeB);

    drawTree(p_node.nodeC);

    drawTree(p_node.nodeD);

  }

}

​

void drawTriangles(Node p_node)

{ 

  PVector A = p_node.A;

  PVector B = p_node.B;

  PVector C = p_node.C;

  PVector D = p_node.D;

  PVector H = p_node.H;

  fill(p_node.colorNode, 200);

  stroke(p_node.colorNode/2, 50);

  //noStroke();

  beginShape(TRIANGLES);

  vertex(A.x, A.y, A.z-deltaH);

  vertex(H.x, H.y, H.z-deltaH);

  vertex(B.x, B.y, B.z-deltaH); 

  vertex(B.x, B.y, B.z-deltaH);

  vertex(H.x, H.y, H.z-deltaH);

  vertex(C.x, C.y, C.z-deltaH);  

  vertex(C.x, C.y, C.z-deltaH);

  vertex(H.x, H.y, H.z-deltaH);

  vertex(D.x, D.y, D.z-deltaH); 

  vertex(D.x, D.y, D.z-deltaH);

  vertex(H.x, H.y, H.z-deltaH);

  vertex(A.x, A.y, A.z-deltaH);  

  endShape(CLOSE);

}

​

void mousePressed()

{

  initPointsAndTrees();

}

​

​

class Node

{

  PVector A, B, C, D;

  public PVector H;

  Node nodeA, nodeB, nodeC, nodeD; 

  int depth;

  color colorNode;// = color((int)random(255), (int)random(255), (int)random(255));

​

  Node(PVector p_A, PVector p_B, PVector p_C, PVector p_D, int p_depth)

  {

    A = p_A;

    B = p_B;

    C = p_C;

    D = p_D;

    depth = p_depth;

  }

}

​

class Tree

{

  Node root;

  float deltaH;

  Tree(PVector p_A, PVector p_B, PVector p_C, PVector p_D)

  {

    root = new Node(p_A, p_B, p_C, p_D, 0);

    addNodes(root);

  }

​

  void addNodes(Node p_node)

  {

    int depth = p_node.depth + 1;

    PVector A = p_node.A;

    PVector B = p_node.B;

    PVector C = p_node.C;

    PVector D = p_node.D;

    PVector H = new PVector((A.x + B.x + C.x + D.x)/4, (A.y + B.y + C.y + D.y)/4, (A.z + B.z + C.z + D.z)/4);

    //H.z = 150/(depth) + random(100/depth);// + random(50);// + 1.1 * max(A.z, max(B.z, C.z));//120;

    H.z += random(-HEIGHT_H/(depth*depth), HEIGHT_H/(depth*depth));

    if (lowestH > H.z)

    {

      lowestH = H.z;

    }

    else if (highestH < H.z)

    {

      highestH = H.z;

    }

    deltaH = (lowestH + highestH)/2;

​

    p_node.H = H;

//    p_node.colorNode = (int)min(abs(H.z), 255);

    p_node.colorNode = (int)map(min(abs(H.z), HEIGHT_H), 0, HEIGHT_H, 0, 255);

​

    if (depth <= MAX_DEPTH)

    {

      float u = random(.1, .9);//.5;//random(.1, .9);//

      float v = random(.1, .9);//.5;//random(.1, .9);//

​

      PVector AB = new PVector(A.x + u*(B.x-A.x), A.y + u*(B.y-A.y), A.z + u*(B.z-A.z));

      PVector BC = new PVector(B.x + u*(C.x-B.x), B.y + u*(C.y-B.y), B.z + u*(C.z-B.z));

      PVector CD = new PVector(C.x + u*(D.x-C.x), C.y + u*(D.y-C.y), C.z + u*(D.z-C.z));

      PVector DA = new PVector(D.x + u*(A.x-D.x), D.y + u*(A.y-D.y), D.z + u*(A.z-D.z));

​

      Node nodeA = new Node(A, AB, H, DA, depth);

      Node nodeB = new Node(B, BC, H, AB, depth);

      Node nodeC = new Node(C, CD, H, BC, depth);

      Node nodeD = new Node(D, DA, H, CD, depth);

      p_node.nodeA = nodeA;

      p_node.nodeB = nodeB;

      p_node.nodeC = nodeC;

      p_node.nodeD = nodeD;

​

      addNodes(nodeA);

      addNodes(nodeB);

      addNodes(nodeC);

      addNodes(nodeD);

    }

  }

}

​

​

​

​