import controlP5.*;
import processing.opengl.*;


/**
 * explore_perlin -- 
 * 
 * Author: Greg Schafer (grschafer at gmail) -- 
 * This applet generates a perlin noise "landscape" and gives the users some controls over the camera
 * and some noise parameters. Inspired by Notch's hint about how the landscape in Minecraft is generated. --
 * Controls:
 *    -Move the mouse to "move" the landscape,
 *    -Hold CTRL to move the mouse without moving the landscape,
 *    -Click and drag to move the camera --
 * Goal: Explore! Feedback is welcome.
 */

// This is all public because of strict applet permissions  =\
public PImage extrude;
public float[][] values;
public float angle = 0;
public int scaler = 20;
public int fieldWidth = 64;
public int fieldLength = 48;
/*public int fieldWidth = 128;
public int fieldLength = 96;*/

public float mapX = 0;
public float mapY = 0;
public float camX = 0;
public float camY = 0;
public float prevdx = 0;
public float prevdy = 0;

public float lastRots[] = {
  0.0, 0.0, 0.0
};
public float curRots[] = new float[3];
public float noiseScale = 0.20;
public float noiseFalloff = 0.50;
public float waterLevel = 0;
public float noiseX[][];
public float noiseY[][];

public ControlP5 controlP5;
public int uiBarHeight = 40;
public boolean allowCameraMovement = true;
public boolean boxy = false;
public boolean edges = false;
public boolean waterVisible = false;

void setup()
{
  //size(640, 480, OPENGL);
  size(640, 480, P3D);
  extrude = new PImage(fieldWidth, fieldLength);    // just used for width,height of noise field

  // Load the image into a new array
  values = new float[extrude.width][extrude.height];
  noiseX = new float[extrude.width][extrude.height];
  noiseY = new float[extrude.width][extrude.height];
  waterLevel = 6*extrude.height;

  initGUI();
}

public void initGUI()
{
  controlP5 = new ControlP5(this);
  controlP5.addToggle("boxy", false, 10, 4, 20, 20);
  controlP5.addToggle("edges", false, 40, 4, 20, 20);
  controlP5.addSlider("noiseScale", 0.01, 1, noiseScale, 80, 10, 100, 20);
  controlP5.addSlider("noiseFalloff", 0, 1, noiseFalloff, 240, 10, 100, 20);
  controlP5.addToggle("water", false, 420, 4, 20, 20);
  controlP5.addSlider("waterLevel", 0, 6*extrude.height, waterLevel, 450, 10, 100, 20).setDecimalPrecision(0);
  ((Slider)controlP5.controller("waterLevel")).lock();
  ((Slider)controlP5.controller("waterLevel")).setColorForeground(color(80, 80, 80));
  controlP5.addBang("regen", 610, 4, 20, 20).setTriggerEvent(Bang.RELEASE);
}

void draw()
{
  // draw 3D stuff
  hint(ENABLE_DEPTH_TEST);  // not sure if this is necessary
  pushMatrix();         // get translation (for drawing UI overlay later)

  lights();
  background(0);

  float cameraY = height/2.0;
  float fov = mouseY/float(width) * PI/2;
  float cameraZ = cameraY / tan(fov / 2.0);
  float aspect = float(width)/float(height);


  //perspective(PI/3, aspect, cameraZ/10.0, cameraZ*10.0);
  perspective();

  // translate before rotating
  translate(width/2, height/2, -width/2);

  noiseDetail(4, noiseFalloff);
  regenNoiseValues(mouseX, mouseY);  // noise values updated in mouseMoved()

  // interpolate between current and target rotations
  for (int i = 0; i < 3; ++i)
  {
    // curRots is updated in mouseDragged() event handler function (below)
    lastRots[i] += 0.05*(curRots[i] - lastRots[i]);
  }
  rotateX(lastRots[0]);
  rotateZ(lastRots[2]);

  // translate before drawing
  translate(-scaler*extrude.width/2, -scaler*extrude.height/2, 4*extrude.height);

  // regen noise values
  for (int y = 0; y < extrude.height; y++)
  {
    for (int x = 0; x < extrude.width; x++)
    {
      float noiseVal = noise(noiseX[x][y], noiseY[x][y]) * 255;
      values[x][y] = noiseVal;
    }
  }

  if (edges)
    stroke(0);
  drawSurface();

  // draw water plane
  if (waterVisible)
  {
    fill(0, 0, 255, 80);
    beginShape();
    vertex(0, 0, -waterLevel);
    vertex(0, scaler*extrude.height, -waterLevel);
    vertex(scaler*extrude.width, scaler*extrude.height, -waterLevel);
    vertex(scaler*extrude.width, 0, -waterLevel);
    endShape(CLOSE);
  }

  popMatrix();         // regen translation to draw UI overlay
  hint(DISABLE_DEPTH_TEST);  // not sure if this is necessary

  // draw UI rectangle
  fill(0, 80);
  rect(0, 0, width, uiBarHeight);
  controlP5.draw();
}

public void regenNoiseValues(int mx, int my)
{
  // regen noise values if camera isn't rotating
  for (int y = 0; y < extrude.height; y++)
  {
    for (int x = 0; x < extrude.width; x++)
    {
      // remove the int() cast for smoother map movement (in-between grid values possible)
      noiseX[x][y] = (int(mapX/4) + x) * noiseScale/2;
      noiseY[x][y] = (int(mapY/4) + y) * noiseScale/2;
      // use a base perlin noise to generate noiseScale values? (for regional uniqueness)
    }
  }
}

public void regen()  // generates new noise seed based on current time
{
  noiseSeed(second() + minute() + hour() + millis());
}

public void mouseMoved()  // map movement
{
  // if user holds down ctrl, then moving the mouse
  // won't move the noise map/surface (this is to allow
  // the user to use menu w/o losing spot in landscape)
  boolean disableMapMovement = false;
  if (keyPressed)
    if (key == CODED)
      if (keyCode == CONTROL)
        disableMapMovement = true;

  if (!disableMapMovement)
  {
    float dx = mouseX - pmouseX;
    float dy = mouseY - pmouseY;
    // if cursor has moved "too far" (10x most recent mouse displacement)
    // then it probably went off screen or over the ui bar, so that big
    // displacement should be ignored (so that the noise surface doesn't
    // "jump" because it's translating really far
    if (mouseY > uiBarHeight && dist(pmouseX, pmouseY, mouseX, mouseY)*.1 < mag(prevdx, prevdy))
    {
      mapX += dx;
      mapY += dy;
    }
    prevdx = dx;
    prevdy = dy;
  }
}
public void mouseDragged()  // camera movement
{
  if (allowCameraMovement)
  {
    camX += mouseX - pmouseX;
    camY += mouseY - pmouseY;
    curRots[0] = -camY * 1.5*PI/float(height/2);
    curRots[2] = camX * 1.5*PI/float(width/2);
  }
}

// these functions adjust the coordinate system for rotating/translating the noise surface
public void mousePressed()
{
  if (mouseY <= uiBarHeight)
    allowCameraMovement = false;
  else
    allowCameraMovement = true;
}

public void water()
{
  // flip boolean value
  // enable/disable waterLevel slider
  Slider waterSlider = ((Slider)controlP5.controller("waterLevel"));
  if (waterVisible)
  {
    waterVisible = false;
    waterSlider.lock();
    waterSlider.setColorForeground(color(80, 80, 80));
  }
  else
  {
    waterVisible = true;
    waterSlider.unlock();
    waterSlider.setColorForeground(color(0, 105, 140));
  }
}

// loops to draw the surface of the perlin noise
public void drawSurface()
{
  // display the noise surface
  for (int y = 1; y < extrude.height; y++)
  {
    for (int x = 1; x < extrude.width; x++)
    {
      // add some kind of height-based texturing (green valleys, stony mountains, etc)?
      fill(255 - values[x][y]);

      if (!boxy)    // then normal vertexing
      {
        beginShape();
        vertex(x*scaler, y*scaler, -values[x][y]);
        vertex(x*scaler-scaler, y*scaler, -values[x-1][y]);
        vertex(x*scaler-scaler, y*scaler-scaler, -values[x-1][y-1]);
        vertex(x*scaler, y*scaler-scaler, -values[x][y-1]);
        endShape(CLOSE);
      }
      else        // minecraft-ify! = blocky terrain
      {
        float val1 = int(-values[x][y]/scaler)*scaler;
        float val2 = int(-values[x][y-1]/scaler)*scaler;
        float val3 = int(-values[x-1][y]/scaler)*scaler;
        beginShape();
        vertex(x*scaler, y*scaler, val1);
        vertex(x*scaler-scaler, y*scaler, val1);
        vertex(x*scaler-scaler, y*scaler-scaler, val1);
        vertex(x*scaler, y*scaler-scaler, val1);
        endShape(CLOSE);
        // with edges
        beginShape();
        vertex(x*scaler, y*scaler-scaler, val1);
        vertex(x*scaler, y*scaler-scaler, val2);
        vertex(x*scaler-scaler, y*scaler-scaler, val2);
        vertex(x*scaler-scaler, y*scaler-scaler, val1);
        endShape(CLOSE);
        beginShape();
        vertex(x*scaler-scaler, y*scaler, val1);
        vertex(x*scaler-scaler, y*scaler, val3);
        vertex(x*scaler-scaler, y*scaler-scaler, val3);
        vertex(x*scaler-scaler, y*scaler-scaler, val1);
        endShape(CLOSE);
      }
    }
  }
}