PVector pt, pt0, pt1, pt2, pt3;
float speed = 1,
      noiseScale = 100, // higher makes the noise affect the position more
      noiseDiv = 50, // higher is less noise
      outerSteps = 620, // fewer makes the points on the edges rotate faster
      yOffset = 180,
      sinFreq = 0.01,
      sinAmp = 50,
      colorFreq = 0.002,
      bgAlpha = 0.0, // make non-zero to fade out screen; for whatever reason values below 0.004 won't fade back the screen
      strokeWt = 0.25;
color fgColor, bgColor;
int pass = 0; // keep track of how many passes across the screen we've made

void setup() {
  size(620, 360);
  pt = new PVector(0, height/2, 0);
  pt0 = new PVector(0, 0, 0);
  pt1 = new PVector(width, 0, 0);
  pt2 = new PVector(width, height, 0);
  pt3 = new PVector(0, height, 0);
  smooth();
  colorMode(RGB, 1.0);
  // have to set color values after changing the colorMode
  fgColor = color(0, 1.0, 0, 0.2);
  bgColor = color(0, 0, 0);
  // clear the screen to black initially
  background(0);
}
void draw() {
  // draw a rectangle over the whole screen to fade back the image if desired
  fill(bgColor, bgAlpha);
  noStroke();
  rect(0, 0, width, height);
  // draw the lines from the edges to the generator
  stroke(fgColor);
  strokeWeight(strokeWt);
  line(pt.x, pt.y, pt0.x, pt0.y);
  line(pt.x, pt.y, pt1.x, pt1.y);
  line(pt.x, pt.y, pt2.x, pt2.y);
  line(pt.x, pt.y, pt3.x, pt3.y);
  // update the color
  //fgColor = color(0, (sin(frameCount * colorFreq) + 1) * 0.5, 0, alpha(fgColor));

  // update the position of the "generator" - a sin wav with added noise in speed and position
  pt.x = pt.x + speed * noise(frameCount / noiseDiv);
  if (pt.x > width) {
    pt.x = 0;
    pass++;
    // if the color is green, set it to black; if it's black, set it to green
    if (green(fgColor) == 1.0)
      fgColor = color(0, 0, 0, alpha(fgColor));
    else
      fgColor = color(0, 1.0, 0, alpha(fgColor));
  }
  pt.y = yOffset + (noise(frameCount / noiseDiv) - 0.5) * noiseScale + sin(frameCount*sinFreq) * sinAmp;
  // update the positions of the points on the edges so they circle around
  pt0.x = (pt0.x + (width/outerSteps)*speed) % width;
  pt1.y = (pt1.y + (height/outerSteps)*speed) % height;
  pt2.x -= (width/outerSteps)*speed;
  if (pt2.x < 0)
    pt2.x = width;
  pt3.y -= (height/outerSteps)*speed;
  if (pt3.y < 0)
    pt3.y = height;
}

// large version
// second attempt at a fibonacci spiral
// first attempt was great, but used rotation,
// which is expensive and imprecise
// here's the beginning of the fibonacci sequence...
// 0, 1, 1, 2, 3, 5, 8

void setup() {
  size(611, 378);
  smooth();
  frameRate(30);
}
int[] s = new int[3];
int tmp, phase;
float speed;
void draw() {
  // clear the screen to a nice green
  background(228, 236, 215);
  // initialize variables
  s[0] = 0;
  s[1] = 0; // first number of the fibonacci sequence
  s[2] = 1; // second number of the fibonacci sequence
  phase = 0; // simple counter; use this to apply fx to the boxes linearly
  speed = 0.01; // speed of the effects

  // set the origin at the end of the spiral
  translate(442, 272);
  // flip vertically to match my logo
  scale(1.0, -1.0);
  rotate(PI);
  // this loop constructs the spiral
  // basically, draw a square of side s,
  // rotate 90deg, calculate the new s0 and s,
  // move up s0 + s, and repeat...
  while (s[2] < 611) {
    // use a sin function to give us some nice undulating effects
    float wave = sin((frameCount + phase*20) * speed) + 1.0;
    // styles for the arcs
    fill(0, 0, wave * 64, 10); // undulating transparent black fill
    stroke(255, wave * 255); // undulating white stroke

    // draw the quarter-circles inside the squares
    // set the stroke weight to 2 for the arc that makes the spiral
    if (phase % 4 == 0) strokeWeight(2); else strokeWeight(1);
    arc(s[2], s[2], 2*s[2], 2*s[2], PI, 3*PI/2.0);
    if (phase % 4 == 1) strokeWeight(2); else strokeWeight(1);
    arc(0, s[2], 2*s[2], 2*s[2], -PI/2.0, 0);
    if (phase % 4 == 2) strokeWeight(2); else strokeWeight(1);
    arc(0, 0, 2*s[2], 2*s[2], 0, PI/2.0);
    if (phase % 4 == 3) strokeWeight(2); else strokeWeight(1);
    arc(s[2], 0, 2*s[2], 2*s[2], PI/2.0, PI);
    // styles for the squares
    noFill();
    stroke(255, 255, 255, 255);
    strokeWeight(1);
    // draw the square
    rect(0, 0, s[2], s[2]);
    // calculate the next number in the fibonacci sequence
    tmp = s[2];
    s[2] += s[1];
    s[0] = s[1];
    s[1] = tmp;
    // translate to get in position for the next square
    switch(phase % 4) {
      case 0:
        translate(s[1], 0);
      break;
      case 1:
        translate(-s[0], s[1]);
      break;
      case 2:
        translate(-s[2], -s[0]);
      break;
      case 3:
        translate(0, -s[2]);
      break;
    }
    phase++;
  }
}