// Tie Dye
// David Bollinger, May 2006
// http://www.davebollinger.com
// for Processing 0115 Beta

// random number seed
int currentSeed = 0;
// number of "octaves" of waviness
int numOctaves = 3;
// number of waves, need 3 (H,S,B) for each octave
int numWaves = numOctaves * 3;
// decrease in intensity at each subsequent octave past first
float falloff = 0.75;
// array of wave generators
Waver[] waves;
// draw only grayscale brightness?
boolean bGrayscaleMode = false;
// draw each pattern opaque instead of overlaid on previous?
boolean bOpaqueMode = true;
// used to animate and step through rows of image
int currenty = 0;
// number of rows processed per frame
int rowsperframe = 10;
// for very first image we draw opaque regardless
boolean bVeryFirstImage = true;

void setup() {
  size(480,480,P3D);
  framerate(30);
  waves = new Waver[numWaves];
  for (int i=0; i<numWaves; i++)
    waves[i] = new Waver();
  colorMode(HSB, 1.0);
  background(#000000);
  loadPixels();
  next();
}

void draw() {
  int idx = currenty * width;
  for (int y=currenty; y<currenty+rowsperframe && y<height; y++) {
    float normy = float(y) / (height-1);
    for (int x=0; x<width; x++) {
      float normx = float(x) / (width-1);

      float v1=0.0, v2=0.0, v3=0.0;
      float hueoffset = 0.0;
      
      float intensity = 1.0;
      for (int i=0; i<numOctaves; i++) {
        v1 += waves[i*3+0].value(normx,normy) * intensity;
        hueoffset += waves[i*3+0].hoffset * intensity;
        v2 += waves[i*3+1].value(normx,normy) * intensity;
        v3 += waves[i*3+2].value(normx,normy) * intensity;
        if (bGrayscaleMode) {
          v3 += v1 + v2;
          v1 = v2 = 0.0;
        }
        intensity *= falloff;
      }
      
      // clamp values to 0..1
      v1 = clamp_triangle(v1);
      v2 = clamp_sine(v2);
      v3 = clamp_sine(v3);
      // rotate hue (if not grayscale)
      if (!bGrayscaleMode)
        v1 = rotate(v1, hueoffset);
      // squish saturation values to midrange (if opaque, if not grayscale)
      if (bOpaqueMode && !bGrayscaleMode)
        v2 = squish(v2, 0.3, 0.7);
      // gamma adjust brightness (if not grayscale)
      if (!bGrayscaleMode)           
        v3 = stretch(v3, 2.2);
       
      int c = color(v1, v2, v3);
      if (bOpaqueMode || bVeryFirstImage) {
        // just output pixel directly
        pixels[idx++] = c;
      } else {
        // blend
        int p = pixels[idx];
        int mix = (0xff000000) |
                  ((((c&0xff0000)+(p&0xff0000))>>1)&0xff0000) +
                  ((((c&0xff00)+(p&0xff00))>>1)&0xff00) +
                  ((((c&0xff)+(p&0xff))>>1)&0xff);
        pixels[idx++] = mix;
      }
    }
  }
  updatePixels();
  
  currenty += rowsperframe;
  if (currenty >= height) {
    next();
  }
}

void next() {
  bVeryFirstImage = (currentSeed == 0);
  randomSeed(currentSeed++);
  for (int i=0; i<numWaves; i++)
    waves[i].define();
  currenty = 0;
}

void keyPressed() {
  if (key=='g')
    bGrayscaleMode = !bGrayscaleMode;
  if (key=='o')
    bOpaqueMode = !bOpaqueMode;
}

void mousePressed() {
  if (mouseButton==RIGHT) {
    background(#000000);
    loadPixels();
    next();
  }
}

class Waver {
  float offsetx, offsety; // where is the "zero" of the function
  float scalex, scaley; // what is the scale of the coordinates
  float cosscalex, cosscaley; // cosine term factors
  float sinscalex, sinscaley; // sine term factors
  float hoffset; // for hue rotation
  Waver() { define(); }
  // make random parameters
  void define() {
    offsetx = random(0.0, 1.0);
    offsety = random(0.0, 1.0);
    scalex = random(0.5, 2.0);  
    scaley = random(0.5, 2.0);
    cosscalex = random(-4.0, 4.0);  
    cosscaley = random(-4.0, 4.0);
    sinscalex = random(-4.0, 4.0);  
    sinscaley = random(-4.0, 4.0);
    hoffset = random(0.0, 1.0);
  }
  // return wave value at specified normalized coordinates
  // essentially just a bunch of polar sines of sines
  float value(float normx, float normy) {
    // transform cartesian coordinates
    float x = (normx - offsetx) * scalex;
    float y = (normy - offsety) * scaley;
    // calc polar coordinates
    float dist = sqrt(x*x+y*y);
    float theta = atan2(y,x);
    // and sinus versions of those
    float sindist = sin(dist);
    float sintheta = sin(theta);
    // calc the warp term
    float warp = sin(sinscalex*sintheta + sinscaley*sindist) + cos(cosscalex*sintheta + cosscaley*sindist);
    return warp;
  }  
}

// clamp to 0..1 with a vengence
float clamp_clip(float value) {
  if (value < 0.0) value = 0.0;
  else if (value > 1.0) value = 1.0;
  return value;
}

// clamp to 0..1 using sine wave
float clamp_sine(float value) {
  while (value < 0.0) value += 1.0;
  while (value > 1.0) value -= 1.0;
  value = sin(value * PI);
  return value;
}
  
// clamps to 0..1 using a triangle wave
// (better for hue than clamp_sine, otherwise bunching up around reds/purples occurs)
float clamp_triangle(float value) {
  while (value < 0.0) value += 2.0;
  while (value > 2.0) value -= 2.0;
  if (value > 1.0) value = 2.0 - value;
  return value;
}

// gamma adjust
float stretch(float value, float gamma) {
  float rgamma = (gamma <= 0.0) ? 1.0 : 1.0 / gamma;
  return pow(value,rgamma);
}

// compress towards midrange (could expand too, but not used here)
float squish(float value, float minim, float range) {
  return minim + value * range;
}

// constant offset with wrap
float rotate(float value, float offset) {
  value += offset;
  while (value > 1.0) value -= 1.0;
  return value;
}

// uh, invert
float invert(float value) {
  return 1.0 - value;
}