#include <math.h></math.h>

#include <stdlib.h></stdlib.h>

#include <string.h></string.h>

#include <helianthus.h></helianthus.h>

#include "tree.h"

static const double segmentLength = 0.2;

static const double segmentWidth = 0.004;

static const double minWidth = 0.02;

static const double rootWidth = 0.8;

static const double branchesPerSegment = 0.2;

static const double leafSize = 8;

static const double leafPerBranch = 1;

static const double leafThreshold = 0.02 + 8/4/0.2*0.004; // minWidth + leafSize/4/segmentLength*segmentWidth

static double randomRange(double min, double max)

  { return randomFloat()*(max - min) + min; }

static double randomIncrement(double deviation)

  { return randomRange(-deviation, deviation); }

static double randomAmplifier(double deviation)

  { return randomRange(1 - deviation, 1 + deviation); }

static void leaf(double x, double y, double size) {

  double r = 0.5*size;//*randomAmplifier(0.5);

  saveState();

  noStroke();

  circle(x, y, r);

  restoreState();

}

static void branch(double x, double y, double angle, double width, double time, int flags) {

  double da = sin(time*randomRange(0.5, 1) + randomIncrement(PI));

  saveState();

  while(TRUE) {

    double length = segmentLength * randomAmplifier(0.1);

    double s = sin(angle/180*PI);

    double c = cos(angle/180*PI);

    double nx = x + c*length;

    double ny = y + s*length;

    double nw = width - segmentWidth;

    strokeWidth(width);

    line(x, y, nx, ny);

    if (width > leafThreshold && nw <= leafThreshold && randomFloat() < leafPerBranch && y > leafSize/2) {

      double dl = randomRange(0, length);

      leaf(x + c*dl, y + s*dl, leafSize);

    }

    if (width < minWidth || ny < 0)

      break;

    x = nx;

    y = ny;

    s += randomRange(0, 0.2);

    c += randomIncrement(0.15);

    angle = atan2(s, c)/PI*180;

    width -= segmentWidth;

    translate(x, y);

    rotate(da*pow(minWidth/width, 2));

    translate(-x, -y);

    if (randomFloat() < branchesPerSegment) {

      double k = randomRange(0, 0.3);

      double w = sqrt(width*width*k);

      if (w > minWidth) {

        width = sqrt(width*width*(1-k));

        double a = randomNumber(0, 1) ? angle - 90 + randomRange(0, 45)

                                      : angle + 90 - randomRange(0, 45);

        branch(x, y, a, w, time, flags);

      }

    }

  }

  restoreState();

}

void treeGenerate(Tree *t, double x, double y) {

  memset(t, 0, sizeof(*t));

  t->seed = rand();

  t->x = x;

  t->y = y;

  t->angle = 90 + randomIncrement(30);

  t->width = rootWidth*randomAmplifier(0.5);

}

void treeDraw(const Tree *t, double time, int flags) {

  saveState();

  translate(t->x, t->y);

  fill(colorByName("green"));

  stroke(colorByName("black"));

  srand(t->seed);

  branch(0, 0, t->angle, t->width, time, int flags);

  restoreState();

}

void treePrerender(Tree *t, Framebuffer fb) {

  srand(t->seed);

  branch(0, 0, t->angle, t->width, 0, FLAG_BOUNDS);

}

void treeDrawPrerendered(Tree *t);