// water test with vertex colouring and multitexturing
// use mouse to control perlin noise octaves and position in space
// author: info@toxi.co.uk

float yoff,zoff,ns=0.125,zs=4.75;
int ww=12;
int dd=5;
int imgScale=20;
int imgW=ww*imgScale;
int imgH=dd*imgScale;
float du=(float)imgW/(2*ww+1);
float dv=(float)imgH/(2*dd+1);
float[] surfaceZ;
float spray_threshold=0.78;
BImage noiseImg;

ParticleSystem spray;

void setup() {
  size(512,256);
  // array to store noise values (z coordinate of vertices)
  surfaceZ=new float[(ww*2+1)*(dd*2+1)*2];
  // create image object for texture
  noiseImg=new BImage(imgW,imgH);
  
  // set mode for UV mapping to use pixel space
  textureMode(IMAGE_SPACE);

  // setup light
  g.lightKind[2]=DIFFUSE;
  g.lightX[2] = width*0.5;
  g.lightY[2] = 10;
  g.lightZ[2] = height;
  g.lightR[2] = g.lightG[2] = g.lightB[2] = 1;

  // setup foam/spray particles
  spray=new ParticleSystem(20);

}

void loop() {
  float nx,ny=yoff,z1,z2,vz1,vz2,x0=mouseX*0.01;

  // ripple control
  noiseDetail(6,0.45+mouseY*(0.175/height));

  // setup viewport
  background(20,40,50);
  noStroke();
  translate(width*0.5,height*.6,0);
  rotateX(PI/3.25);//-noise(x0+ww*ns,yoff+2*dd,zoff)*0.25);
  rotateY((width*0.5-mouseX)*0.0005);
  scale(28);

  // no lights needed for 1st texture pass
  noLights();

  // vertex counter
  int surfID=0;

  // start build mesh
  for(int y=-dd; y<=dd; y++) {
    nx=x0;
    beginShape(TRIANGLE_STRIP);
    for(int x=-ww; x<ww; x++) {
      // compute noise values
      z1=noise(nx,ny,zoff);
      z2=noise(nx,ny+ns,zoff);
      // scale for vertices
      vz1=z1*zs;
      vz2=z2*zs;
      // check if we need more spray particles
      if (z1>spray_threshold) {
        spray.add(x,y,vz1);
        // use white as spray colour
        fill(255,150);
      } else fill(0,z1*160,z1*255,pow(10,0.85+z1*2));
      vertex(x,y,vz1);
      if (z2>spray_threshold) {
        spray.add(x,y+1,vz2);
        fill(255,150);
      } else fill(0,z2*160,z2*255,pow(10,0.85+z2*2));
      vertex(x,y+1,vz2);
      // store pre-mulitplied noise values for next pass
      surfaceZ[surfID++]=vz1;
      surfaceZ[surfID++]=vz2;
      nx+=ns;
    }
    endShape();
    ny+=ns;
  }

  // 2nd pass, draw surface again with texture
  fill(255);
  lights();

  // update texture image for this layer
  updateTexture();

  // slightly offset transform matrix to avoid zBuffer fighting
  translate(0,0,0.01);

  float u,v=0;
  ny=yoff;
  surfID=0;
  for(int y=-dd; y<=dd; y++) {
    nx=x0;
    u=0;
    beginShape(TRIANGLE_STRIP);
    texture(noiseImg);
    for(int x=-ww; x<ww; x++) {
      // use pre-computed z values from 1st pass
      vz1=surfaceZ[surfID++];
      vz2=surfaceZ[surfID++];
      // set vertices with UV coords
      vertex(x,y,vz1,u,v);
      vertex(x,y+1,vz2,u,v+dv);
      nx+=ns;
      u+=du;
    }
    endShape();
    ny+=ns;
    v+=dv;
  }
  // animate waves
  zoff+=0.03;
  yoff-=0.06;

  // update particles
  noLights();
  fill(255,50);
  spray.update();

  // show texture image
  //blend(noiseImg,0,0,imgW,imgH,0,height-imgH,imgW,height,ADD);
}

void updateTexture() {
  // use fixed noise setting for texture
  noiseDetail(4,0.5);
  int x,y,yy,c,idx=0;
  // update texture according to main settings
  float nx,ny=yoff,z=yoff*2;
  float ns=0.05+mouseY*0.0002;
  float x0=-mouseX*0.05;
  // compute new pixels
  for(y=0; y<imgH; y++) {
    nx=x0;
    yy=y<<1;
    for(x=0; x<imgW; x++) {
      c=(int)(cloudfilter(noise(nx,ny,z))*yy);
      // noise value is used as basis for alpha, green and blue components
      noiseImg.pixels[idx++]=c<<24 | (c<<7)&0xff00 | c;
      nx-=ns;
    }
    ny+=ns;
  }
}

// filter out low density noise
float cloudfilter(float val) {
  return (1-pow(0.97,max(val-0.4,0)*200));
}


// veeeeeery simple particle system class
class ParticleSystem {
  Particle[] particles;
  int nParticles;
  int currParticleID=0;

  ParticleSystem(int n) {
    nParticles=n;
    particles=new Particle[n];
    for(int i=0; i<nParticles; i++) particles[i]=new Particle();
  }

  // add an active particle
  // also does some additional culling if we're too close to camera
  void add(int x,int y,float z) {
    if (y<dd-2) {
      particles[currParticleID++].reset((float)x,(float)y,z);
      currParticleID%=nParticles;
    }
  }

  void update() {
    for(int i=0; i<nParticles; i++) particles[i].update();
  }

  // the actual particle behaviour
  class Particle {
    float x,y,z,r;
    float xspeed,yspeed,zspeed;
    float grav;
    boolean active;

    Particle() {
      active=false;
    }

    void reset(float xx,float yy,float zz) {
      x=xx;
      y=yy;
      z=zz;
      xspeed=random(-0.5,0.5);
      yspeed=random(-0.3,0.3);
      zspeed=random(1.5);
      r=random(0.02,0.1);
      grav=-.66;
      active=true;
    }

    void update() {
      if (active) {
        x+=xspeed;
        y+=yspeed;
        z+=grav+zspeed;
        zspeed*=0.65;
        push();
        translate(x,y,z);
        sphere(r);
        pop();
        if (z<0) active=false;
      }
    }
  }
}