int amountOfTrees = 140; //change to get a smaller or bigger forest
int treesPerRow = 30; //decrease results in narrower forest
int amountOfBlossoms = 50; //same for the blossom-bushes
float pointOfView = 1.3; //Values between 1 and 2, the higher the number the closer you are to the forest

Branch[] myTrees; //define global Array, where later to create istances of Branches, here called myTrees.
Blossom[] myBlossoms;


PGraphics pg; //initiate PGraphics
float ang; 
color col;
color blossomcol;
int amountOfTrees = 140; //change to get a smaller or bigger forest
int treesPerRow = 30;  //decrease results in narrower forest
int amountOfBlossoms = 50;  //same for the blossom-bushes
int blossomsPerRow = 5;  //dito
 int rowcount = 0;
float pointOfView = 1.3; //Values between 1 and 2, the higher the number the closer you are to the forest


void setup() {
  noLoop(); 
  noStroke();
  smooth();  
  size(1200, 600); 
  background(240);
  pg = createGraphics(width, 500); //create PGraphics canvas with (canvaswidth, canvasheight);
  generateTrees(amountOfTrees); //function generate trees is called, to make several instances of Trees, Parameter = amountOfTrees
}

void draw() {
  scale(pointOfView); //scale whole scenery to simulate another viewpoint
  float yDisplacement = map(pointOfView, 1, 2, -40, -250);
  float xDisplacement = map(pointOfView, 1, 2, 0, -120);
  translate(xDisplacement, yDisplacement);
//too slow and ugly; there uncommented
//  pg.beginDraw();
//  pg.fill(0);
//  pg.ellipse(380, 120, 600, 90);
//  pg.filter(BLUR, 25);  
//  pg.endDraw();
//  image(pg, 40, 0.55*height);

  //  background(240);
  int blossomLoop = 0;
  for (int i = 1; i < myTrees.length; i++) {
    myTrees[i].paint();
    if (i > 100 ) {
      myBlossoms[blossomLoop].render();
      blossomLoop++;
    }

    if ((i % treesPerRow) == 0 && i != 0) { //check if i is a multiple of treesPerRow
      fill(240, 240, 240, 50); 
      rect(0, 0, width, height); //add half transparent rectangle to fade the tree rows at the back.
      fill(0, 0, 0, 50);
      translate(-10, 5);
      scale(1.1);
      //      println("You are my master");
    }
  }
}

void mousePressed() {
  save("pic.jpg");
  //  ang = random(HALF_PI - PI/30,HALF_PI + PI/30);  
  //  root1 = new Branch(new PVector(0.5*width,0.92*height,0),70,20,ang,col);
  //  redraw();
}

void generateTrees(int amountOfTrees) {

  myBlossoms = new Blossom[amountOfBlossoms]; 
  myTrees = new Branch[amountOfTrees]; //Number is the amount of tree pushed in the array.

  for (int i = 0; i < amountOfTrees; i++) { //generate all the Tree instances and push into Array
    rowcount += 1;

    if (rowcount == treesPerRow) {
      println(rowcount);
      rowcount = 0; // reset rowcount, to start new row
    }

    ang = random(HALF_PI - PI/30, HALF_PI + PI/30);  
    col = color(random(100, 140), random(60, 90), random(10, 30)); // make new random colors for each tree instance
    myTrees[i] = new Branch(new PVector(180+(rowcount*(random(10, 15))), 0.55*height+random(-10, 10), 0), 35, 4, ang, col);
  }

  for (int i = 0; i < amountOfBlossoms; i++) { //generate all the Blossom instances and push into Array
    rowcount += 1;
    if (rowcount == blossomsPerRow) {
      rowcount = 0; // reset rowcount, to start new row
    }

    myBlossoms[i] = new Blossom(random(150, 500), 0.53*height+random(-10, 30), random(40, 90), 10); // (X-pos, height(?), ~size(?), branches(?))
  }


  //  println(myTrees); //print Array
}

import controlP5.*;    // import controlP5 library
ControlP5 controlP5;   // global controlP5 object

Branch[] myTrees; //define global Array, which later containes istances of Branches, here called myTrees.
Blossom[] myBlossoms;


PGraphics pg; //initiate PGraphics
float ang; 
color col;
color blossomcol;
int amountOfTrees = 140; //change to get a smaller or bigger forest
int treesPerRow = 30;
int amountOfBlossoms = 50;
int blossomsPerRow = 5;
int rowcount = 0;
float pointOfView = 1.3; //Values between 1 and 2, the higher the number the closer you are to the forest
float Distance = 1;

void setup() {
//  noLoop(); 
  noStroke();
  smooth();  
  size(1200, 600); 
  background(240);
  pg = createGraphics(width, 500); //create PGraphics canvas with (canvaswidth, canvasheight);
  generateTrees(amountOfTrees); //function generate trees is called, to make several instances of Trees, Parameter = amountOfTrees
  controlP5 = new ControlP5(this);
  controlP5.addSlider("Distance")
    .setPosition(300, 100)
    .setRange(1,2)
    ;
}

void draw() {
  pushMatrix();
  scale(pointOfView); //scale whole scenery to simulate another viewpoint
  float yDisplacement = map(pointOfView, 1, 2, -40, -250);
  float xDisplacement = map(pointOfView, 1, 2, 0, -120);
  translate(xDisplacement, yDisplacement);
  popMatrix();
  background(240);
  
//too slow and ugly; therefor uncommented
//  pg.beginDraw();
//  pg.fill(0);
//  pg.ellipse(380, 120, 600, 90);
//  pg.filter(BLUR, 25);  
//  pg.endDraw();
//  image(pg, 40, 0.55*height);
  int blossomLoop = 0;
  pushMatrix();
  for (int i = 1; i < myTrees.length; i++) {
    myTrees[i].paint();
    if (i > 100 ) { // as soon as 100 trees are planted, the blossoms start to shoot...
      myBlossoms[blossomLoop].render();
      blossomLoop++; //just a count, here without effect, cause I did not implement the 'blossomsPerRow'.
    }

    if ((i % treesPerRow) == 0 && i != 0) { //check if i is a multiple of treesPerRow
      fill(240, 240, 240, 50); 
//      rect(0, 0, width, height); //add half transparent rectangle to fade the tree rows at the back.
      fill(0, 0, 0, 50);
      translate(-10, 5);
      scale(1.1);
      // println("You are my master");
    }
  }
  popMatrix();
  
}

void mousePressed() {
//  save("pic.jpg");
  //  ang = random(HALF_PI - PI/30,HALF_PI + PI/30);  
  //  root1 = new Branch(new PVector(0.5*width,0.92*height,0),70,20,ang,col);
  scale(Distance);
  redraw();
}

void generateTrees(int amountOfTrees) {

  myBlossoms = new Blossom[amountOfBlossoms]; 
  myTrees = new Branch[amountOfTrees]; //Number is the amount of tree pushed in the array.
  
  for (int i = 0; i < amountOfBlossoms; i++) { //generate all the Blossom instances and push into Array
    rowcount += 1;
    if (rowcount == blossomsPerRow) {
      rowcount = 0; // reset rowcount, to start new row
    }

    myBlossoms[i] = new Blossom(random(150, 500), 0.57*height+random(-10, 10), random(60, 70), 5); // (X-pos, height(?), ~size(?), branches(?))
  }


  for (int i = 0; i < amountOfTrees; i++) { //generate all the Tree instances and push into Array
    rowcount += 1;

    if (rowcount == treesPerRow) {
      println(rowcount);
      rowcount = 0; // reset rowcount, to start new row
    }

    ang = random(HALF_PI - PI/30, HALF_PI + PI/30);  
    col = color(random(100, 140), random(60, 90), random(10, 30)); // make new random colors for each tree instance
    myTrees[i] = new Branch(new PVector(180+(rowcount*(random(10, 15))), 0.55*height+random(-10, 10), 0), 35, 4, ang, col);
  }

  
}

void controlEvent(ControlEvent theEvent) {  // listener for all the user elements -> check if slider is used
  /* events triggered by controllers are automatically forwarded to 
     the controlEvent method. by checking the name of a controller one can 
     distinguish which of the controllers has been changed.
  */ 
 
  /* check if the event is from a controller otherwise you'll get an error
     when clicking other interface elements like Radiobutton that don't support
     the controller() methods
  */
  if(theEvent.isController()) { 
    
    print("control event from : "+theEvent.controller().name());
    println(", HEHEvalue : "+theEvent.controller().value());
    
    if(theEvent.controller().name()=="slider2") {
      println("Hey You controller");
    }
    
  }
}

class Blossom {
  float x, y;
  float h;
  float steps;
  
  Blossom() {
    x = 0;
    y = 0;
    h = 0;
    steps = 0;
  }
  
  Blossom(float x_, float y_, float h_, float s_) {
    x = x_;
    y = y_;
    h = map(h_, 0, height, 0, 160);
    steps = s_;
  }
  
  void render() {
//    stroke(32);
    branch(x, y, -HALF_PI, h);
  }
  
  void branch(float x_, float y_, float a_, float s_) {
    strokeWeight(s_/32);
    float a = random(-PI/16, PI/16)+a_;
    float nx = cos(a)*s_+x_;
    float ny = sin(a)*s_+y_;
    stroke(40, 16*s_);
    line(x_, y_, nx, ny);
    if (s_>10) {
      branch(nx, ny, a_-random(PI/4), s_*random(0.6, 0.8));
      branch(nx, ny, a_, s_*random(0.6, 0.8));
      branch(nx, ny, a_+random(PI/4), s_*random(0.6, 0.8));
    } else {
      float w = random(155, 255);
      stroke(255, w, w, random(90, 192));
      strokeWeight(random(0, 8));
      point(nx+random(-2, 2), ny+random(-2, 2));
      noStroke(); //stroke wieder entfernen
    }
  }
}

class Branch {
  PVector pos;
  float branchSize, diam, ang;
  color col;

  Branch extremeBranch, middleBranch;
  PVector extreme, middle;
  float branchSizeExtreme, branchSizeMiddle;
  float diamExtreme, diamMiddle;
  float angExtreme, angMiddle;
  color colSon;
  boolean withExtreme = false;
  boolean withMiddle = false;
  float sign, diamTop;
  
  Branch(PVector posTemp, float branchSizeTemp, float diamTemp, float angTemp, color colTemp) {
    pos = posTemp.get();
    branchSize = branchSizeTemp;
    diam = diamTemp;
    ang = angTemp;
    col = colTemp;
    
    if(branchSize > 30){
      colSon = color(red(col)*1.04,green(col)*1.02,blue(col)*1.01);
    }
    else{
      colSon = color(red(col)*0.8,green(col),blue(col)*0.9);
    }
    
    if((branchSize > 8) & (random(0,1) < 0.9)){
      withExtreme = true;
      if(branchSize > 30){
        branchSizeExtreme = random(0.85,0.95)*branchSize;
        diamExtreme = random(0.75,0.85)*diam;
        angExtreme = ang + random(-PI/7,PI/7);
        if(angExtreme > PI - 0.1*PI){
          angExtreme = angExtreme - random(PI*0.15,PI*0.3);
        }
        if(angExtreme < 0.1*PI){
          angExtreme = angExtreme + random(PI*0.15,PI*0.3);
        }
      }
      else{
        branchSizeExtreme = random(0.75,0.85)*branchSize;
        diamExtreme = 0.65*diam;
        angExtreme = ang + random(-PI/4,PI/4);
      }
      extreme = PVector.add(pos,new PVector(branchSize*cos(ang),-branchSize*sin(ang),0));
      extremeBranch = new Branch(extreme,branchSizeExtreme,diamExtreme,angExtreme,colSon);
    }

    if((branchSize > 8) & (random(0,1) < 40/branchSize) & (random(0,1) < 0.9)){
      withMiddle = true;
      if(branchSize > 30){
        branchSizeMiddle = random(0.85,0.95)*branchSize;
        diamMiddle = random(0.75,0.85)*diam;
        sign = random(-1,1);
        sign = sign/abs(sign);
        angMiddle = ang + sign*random(PI/8,PI/5);
      }
      else{
        branchSizeMiddle = random(0.75,0.9)*branchSize;
        diamMiddle = random(0.65,0.75)*diam;
        sign = random(-1,1);
        sign = sign/abs(sign);
        angMiddle = ang + sign*random(PI/9,PI/4);
      }
      float frac = random(0.6,0.9);
      middle = PVector.add(pos,new PVector(frac*branchSize*cos(ang),-frac*branchSize*sin(ang),0));
      middleBranch = new Branch(middle,branchSizeMiddle,diamMiddle,angMiddle,colSon);
    }
  }
  
  void paint() {
    fill(col);
    if(withExtreme){
      diamTop = diamExtreme;
    }
    else if(withMiddle){
      diamTop = diamMiddle;
    }
    else{
      diamTop = diam*0.5;
    }
    pushMatrix();
      translate(pos.x,pos.y);
      rotate(HALF_PI- ang);
      beginShape();
        vertex(-diam/2,0);
        vertex(-diamTop/2,-1.05*branchSize);
        vertex(diamTop/2,-1.05*branchSize);
        vertex(diam/2,0);
      endShape();
    popMatrix();
    if(withExtreme){
      extremeBranch.paint();
    }
    if(withMiddle){
      middleBranch.paint();
    }
  }
  
}