Cluster cluster;
int numSlices = 6;
float radius = 180;
float gridWidth;
float gridHeight;
boolean isPaused = false;
boolean showTexture = false;
boolean showLines = false;
int axisMode = 1;
float speedMod = 1;
boolean darkStroke = true;
float texWidth;
float texHeight;
float uv0, uv1;

float satMod = 0;

void setup()
{
  size(940, 540, P3D);
  colorMode(HSB);
  background(0);
  textureMode(NORMALIZED);

  angleStep = radians(360/numSlices);
  calculateGrid();
  cluster = new Cluster();
}

void draw()
{ 
  background(0);
  if (showLines) stroke(0);
  else noStroke();

  cluster.update();

  if (showTexture) image(cluster.tex, width/2-cluster.pg.width/2, height/2-cluster.pg.height/2);
  else drawHexGrid();
}

void randomize()
{
  axisMode = floor(random(0, 3));

  int r = floor(random(0, 3));
  switch (r)
  {
  case 0:
  radius = 90;
  break;

  case 1:
  radius = 120;
  break;

  case 2:
  radius = 180;
  break;

    default:
      break;
  }

  calculateGrid();
  cluster.createParts();
}

void drawHexGrid()
{ 
  int xCount = width/gridWidth + 1;
  int yCount = height/gridHeight + 1;
  float xOffset;

  for (int x=0; x<xCount; x++)
  {
    for (int y=0; y<yCount; y++)
    {
      if (y%2 == 0) xOffset = 0;
      else xOffset = gridWidth/2;

      pushMatrix();
      translate(x*gridWidth+xOffset, y*gridHeight, 0);
      rotateZ(angleStep/2);

      switch (axisMode)
      {
      case 0:
        drawHex1();
        break;

      case 1:
        drawHex2();
        break;

      case 2:
        drawHex3();
        break;

      default:
        break;
      }

      popMatrix();
    }
  }
}

void drawHex1()
{
  beginShape(TRIANGLE_FAN);
  texture(cluster.tex);
  vertex(0, 0, 0, 0.5, 1);

  for (int i=0; i<6; i++)
  {
    float x1 = cos(angleStep*i) * radius;
    float y1 = sin(angleStep*i) * radius;
    float x2 = cos(angleStep*(i+1)) * radius;
    float y2 = sin(angleStep*(i+1)) * radius;

    if (i%2 == 0)
    {
      vertex(x1, y1, 0, uv0, 0);
      vertex(x2, y2, 0, uv1, 0);
    } else
    {
      vertex(x1, y1, 0, uv1, 0);
      vertex(x2, y2, 0, uv0, 0);
    }
  }

  endShape();
}

void drawHex2()
{
  beginShape(TRIANGLE_FAN);
  texture(cluster.tex);
  vertex(0, 0, 0, 0.5, 1);

  for (int i=0; i<numSlices; i++)
  {
    float x1 = cos(angleStep*i) * radius;
    float y1 = sin(angleStep*i) * radius;
    float x3 = cos(angleStep*(i+1)) * radius;
    float y3 = sin(angleStep*(i+1)) * radius;
    float x2 = (x1 + x3) / 2;
    float y2 = (y1 + y3) / 2;

    vertex(x1, y1, 0, uv0, 0);
    vertex(x2, y2, 0, uv1, 0);
    vertex(x3, y3, 0, uv0, 0);
  }

  endShape();
}

void drawHex3()
{
  beginShape(TRIANGLE_FAN);
  texture(cluster.tex);
  vertex(0, 0, 0, 0.5, 1);

  for (int i=0; i<numSlices; i++)
  {
    float x1 = cos(angleStep*i) * radius;
    float y1 = sin(angleStep*i) * radius;
    float x5 = cos(angleStep*(i+1)) * radius;
    float y5 = sin(angleStep*(i+1)) * radius;
    float x3 = (x1 + x5) / 2;
    float y3 = (y1 + y5) / 2;
    float x2 = (x1 + x3) / 2;
    float y2 = (y1 + y3) / 2;
    float x4 = (x3 + x5) / 2;
    float y4 = (y3 + y5) / 2;

    vertex(x1, y1, 0, uv0, 0);
    vertex(x2, y2, 0, uv1, 0);
    vertex(x3, y3, 0, uv0, 0);
    vertex(x4, y4, 0, uv1, 0);
    vertex(x5, y5, 0, uv0, 0);
  }

  endShape();
}

void calculateGrid()
{
  float angle = radians(360/numSlices/2);
  float b = radius * cos(angle);
  gridWidth = b * 2;
  float a = sqrt(radius*radius - b*b);
  gridHeight = radius + a;

  texHeight = b;
  texWidth = a*2;

  switch (axisMode)
  {
  case 0:
    uv0 = 0;
    uv1 = 1;
    break;

  case 1:
    uv0 = 0.25;
    uv1 = 0.75;
    break;

  case 2:
    uv0 = 0.375;
    uv1 = 0.625;
    break;

  default:
    break;
  }
}

void cycleAxisMode()
{
  axisMode++;
  if (axisMode > 2) axisMode = 0;
  calculateGrid();
}

void cycleZoom()
{
  switch (radius)
  {
  case 90:
    radius = 180;
    break;

  case 120:
    radius = 90;
    break;

  case 180:
    radius = 120;
    break;

  default:
    radius = 120;
    break;
  }
  calculateGrid();
}

void mousePressed()
{
  randomize();
}

void keyPressed()
{
  if (key == ' ') isPaused = !isPaused;
  if (key == 's') save();
  if (key == 't') showTexture = !showTexture;
  if (key == 'g') showLines = !showLines;
  if (key == 'c') cluster.randomizeColor();
  if (key == 'a') cycleAxisMode();
  if (key == 'z') cycleZoom();
  if (key == 'r') cluster.createParts();
  if (key == '=') speedMod *= 1.2;
  if (key == '-') speedMod *= 0.8;
  if (key == 'l') darkStroke = !darkStroke;
}

class Cluster
{
  PGraphics pg;
  PImage tex;
  int numParts = 40;
  Part[] allParts;

  Cluster()
  {
    pg = createGraphics(texWidth, texHeight);
    pg.colorMode(HSB);
    pg.noSmooth();

    createParts();
    update();
  }

  void update()
  {
    pg.beginDraw();
    updateParts(); 
    pg.endDraw();  
    tex = pg.get();
  }

  void createParts()
  {
    allParts = new Part[numParts];

    for (int i=0; i<numParts; i++)
    {
      allParts[i] = new Part(pg);
    }
  }

  void updateParts()
  {
    pg.ellipseMode(CORNER);
    pg.background(0);
    pg.strokeWeight(0.5);

    for (int i=0; i<numParts; i++)
    {
      allParts[i].update();
    }
  }

  void randomizeColor()
  {
    for (int i=0; i<numParts; i++)
    {
      allParts[i].randomizeColor();
    }
  }
}

class Part
{
  PGraphics pg;
  int age;
  int numVectors = 10;
  PVector[] v;
  float x, y;
  float rot, rotSpeed;
  float scale, scaleOsc, scaleOscSpeed;
  float hue, sat, bright;
  float hueSpeed;
  float satOsc, satOscSpeed;
  float brightOsc, brightOscSpeed;

  Part(PGraphics _pg)
  {
    pg = _pg;
    v = new PVector[numVectors];
    init();
    scaleOsc = random(100);
    move();
  }

  void init()
  {
    age = 0;
    x = random(0, pg.width);
    y = random(0, pg.height);
    rot = random(radians(360));
    rotSpeed = random(0.002, 0.005);
    if (random() > 0.5) rotSpeed *= -1;
    scale = 0;
    scaleOsc = 0;
    scaleOscSpeed = random(0.002, 0.004);
    randomizeColor();

    for (int i=0; i<numVectors; i++) {
      v[i] = new PVector(random(-pg.width, pg.width), random(-pg.height, pg.height));
    }
  }

  void randomizeColor()
  {
    hue = random(255);
    hueSpeed = random(0.01, 0.2);

    satOsc = random(100);
    satOscSpeed = random(0.001, 0.003);
    sat = sin(satOsc);
    sat = map(sat, -1, 1, 0, 255);

    brightOsc = random(100);
    brightOscSpeed = random(0.001, 0.003);
    bright = sin(brightOsc);
    bright = map(bright, -1, 1, 0, 255);
  }

  void update()
  {
    if (!isPaused) move();
    render();
  }

  void move()
  {
    age++;

    rot += rotSpeed * speedMod;
    scaleOsc += scaleOscSpeed * speedMod;
    scale = sin(scaleOsc);
    if (age > 100 && abs(scale) < 0.01) init();

    hue += hueSpeed;
    satOsc += satOscSpeed;
    brightOsc += brightOscSpeed;
    sat = sin(satOsc);
    sat = map(sat, -1, 1, 0, 255);
    bright = sin(brightOsc);
    bright = map(bright, -1, 1, 0, 255);
  }

  void render()
  {
    if (darkStroke) pg.stroke(0);
    else pg.stroke(255);

    pg.pushMatrix();
    pg.fill(hue%255, sat, bright, 255);
    pg.translate(x, y);
    pg.rotate(rot);
    pg.scale(scale, scale);
    pg.beginShape();
    pg.vertex(v[0].x, v[0].y);
    pg.bezierVertex(v[1].x, v[1].y, v[2].x, v[2].y, v[3].x, v[3].y);
    pg.bezierVertex(v[4].x, v[4].y, v[5].x, v[5].y, v[6].x, v[6].y);
    pg.bezierVertex(v[7].x, v[7].y, v[8].x, v[8].y, v[9].x, v[9].y);
    pg.vertex(v[0].x, v[0].y);
    pg.endShape();
    pg.popMatrix();
  }
}

PGraphics buffer;
PerlinImage perlinImage;
boolean autoPlay = true;
boolean isPaused = false;
boolean doesDissolve = false;

void setup()
{
  size(940, 540);
  background(0);
  perlinImage = new PerlinImage(940, 540);
  perlinImage.start();
  buffer = createGraphics(940, 540);
  buffer.colorMode(HSB);
}

void draw()
{
  doesDissolve = 23.4;

  buffer.beginDraw();
  if (!isPaused)
  {
    perlinImage.update();
    if (autoPlay) if (frameCount % 300 == 0) perlinImage.start();
  }
  buffer.endDraw();
  image(buffer, 0, 0);
}

void reset()
{
  buffer.background(0);
  perlinImage.init();
}

void mousePressed()
{
  isPaused = false;
  perlinImage.start();
}

void keyPressed()
{
  if (key == 'a') autoPlay = !autoPlay; 
  if (key == 'c') reset();
  if (key == ' ') isPaused = !isPaused;
  if (key == 's') save();
  if (key == 'd') doesDissolve = !doesDissolve;
}

class PerlinImage
{
  boolean isRunning = false;

  float w;
  float h;
  int ix;
  int iy;
  int count;
  float hue, sat, bright;
  float noiseOffset;
  float threshold;
  float noiseScale;

  int[] positions;
  int index;
  int numPixels;

  PerlinImage(float _w, float _h)
  {
    w = _w;
    h = _h;
    numPixels = w*h;
    positions = new int[numPixels];
    init();
  } 

  void init()
  {
    index = 0;

    for (int i=0; i<numPixels; i++) positions[i] = i;

    if (doesDissolve)
    {
      for (int i = numPixels - 1; i > 0; i--) 
      {
        int j = floor(random() * (i + 1));
        int temp = positions[i];
        positions[i] = positions[j];
        positions[j] = temp;
      }
    }

    ix = 0;
    iy = 0;
    hue = random(255);
    sat = random(255);
    bright = random(255);
    noiseOffset = random(10000);
    threshold = random(0.4, 0.6);
    noiseScale = random(0.001, 0.02);
  }

  void start()
  {
    if (!isRunning)
    {
      isRunning = true; 
      init();
    }
  }

  void update()
  { 
    if (isRunning) render();
  }

  void render()
  {
    int numSteps = 3000;
    float n;

    for (int i=0; i<numSteps; i++)
    {
      iy = floor(positions[index]/width);
      ix = positions[index]%width;

      n = noise(ix*noiseScale, iy*noiseScale, noiseOffset);
      if (n < threshold) n = 0;
      else n = 1;

      buffer.fill(hue, sat, bright, n*255);
      buffer.noStroke();
      buffer.rect(ix, iy, 1, 1);

      index++;
      if (index > numPixels) isRunning = false;
    }
  }
}

Gradient g;
Part[][] allParts;
int xCount;
int yCount;
int numParts;
int gridSize = 30;

boolean cameraOrtho = false;
boolean isPaused = false;
boolean autoPlay = false;
boolean[] edit;

void setup()
{
  size(940, 540, P3D);
  colorMode(HSB);
  background(0);
  noStroke();
  smooth();
  edit = new boolean[10];
  g = new Gradient();
  createParts();
}

void draw()
{
  if (!isPaused && autoPlay) if (frameCount % 800 == 0) randomizeParts();

  g.update();

  background(0);

  pushMatrix();
  translate(0, 0, 10);
  directionalLight(255, 0, 150, -0.3, 0.5, -1);
  directionalLight(255, 0, 150, 0.5, -0.3, -1);
  popMatrix();

  translate(0, 0, -100);
  if (cameraOrtho) ortho(-940/2, 940/2, -540/2, 540/2, -10000, 10000);
  else perspective();

  updateParts();
}

void createParts()
{
  xCount = ceil(width/gridSize);
  yCount = ceil(height/gridSize);
  allParts = new Part[xCount+1][yCount+1];

  for (int i=0; i<=yCount; i++)
  {
    for (int j=0; j<=xCount; j++)
    {     
      Part part = new Part(j*gridSize, i*gridSize, (i*j+j)*0.01);
      part.colorRatio = (i+j)/(xCount+1+yCount+1);
      allParts[i][j] = part;
    }
  }
}

void updateParts()
{
  xCount = ceil(width/gridSize);
  yCount = ceil(height/gridSize);

  for (int i=0; i<=yCount; i++)
  {
    for (int j=0; j<=xCount; j++)
    {
      Part part = allParts[i][j];
      part.update();
    }
  }
}

void randomizeParts(Part part)
{
  g.changeColors();

  float scaleMod = random(0, 0.01);
  float rotMod = random(0, 3);
  float speedMod = random(0.5, 1);

  float noiseMod = random(0.0, 0.01);
  float colorSpeed = random(0, 0.015);

  float boxW = random(1, 600);
  float boxH = random(1, 600);
  float boxD = random(1, 600);

  xCount = ceil(width/gridSize);
  yCount = ceil(height/gridSize);

  for (int i=0; i<=yCount; i++)
  {
    for (int j=0; j<=xCount; j++)
    {
      Part part = allParts[i][j];
      part.tscaleMod = scaleMod;
      part.tnoiseMod = noiseMod;
      part.trotMod = rotMod;
      part.tspeedMod = speedMod;
      part.tcolorSpeed = colorSpeed;
      part.tboxW = boxW;
      part.tboxH = boxH;
      part.tboxD = boxD;
    }
  }
}

void mousePressed()
{
  randomizeParts();
  autoPlay = false;
}

void keyPressed()
{
  if (key == 'o') cameraOrtho = !cameraOrtho;
  if (key == 's') save();
  if (key == ' ') isPaused = !isPaused;
  if (key == 'r') randomizeParts();
  if (key == 'a') autoPlay = !autoPlay;
  if (key == 'c') g.changeColors();

  if (key == '1') edit[1] = true;
  if (key == '2') edit[2] = true;
  if (key == '3') edit[3] = true;
  if (key == '4') edit[4] = true;
  if (key == '5') edit[5] = true;
  if (key == '6') edit[6] = true;
  if (key == '7') edit[7] = true;
  if (key == '8') edit[8] = true;
  if (key == '9') edit[9] = true;
}

void keyReleased()
{
  if (key == '1') edit[1] = false;
  if (key == '2') edit[2] = false;
  if (key == '3') edit[3] = false;
  if (key == '4') edit[4] = false;
  if (key == '5') edit[5] = false;
  if (key == '6') edit[6] = false;
  if (key == '7') edit[7] = false;
  if (key == '8') edit[8] = false;
  if (key == '9') edit[9] = false;
}

class Gradient
{
  PGraphics pg;
  float w = 300;
  color[] allColorsNew;
  color[] allColorsCurrent;
  int trans = w;
  int brightFloor = 100;
  int satFloor = 200;

  Gradient()
  {
    allColorsNew = new color[w];
    allColorsCurrent = new color[w];

    createPalette();

    for (int i=0; i<=w; i++)
    {
      allColorsCurrent[i] = allColorsNew[i];
    }
  }

  void update()
  {
    for (int i=0; i<5; i++)
    {
      if (trans <= w)
      {
        allColorsCurrent[trans] = allColorsNew[trans];
      }
      trans++;
    }
  }

  void changeColors()
  {
    trans = 0;
    satFloor = random(255);
    brightFloor = random(255);
    createPalette();
  }

  void createPalette()
  {
    pg = createGraphics(w, 1);
    pg.colorMode(HSB);
    pg.beginDraw();

    pg.noStroke();

    color baseColor = color(random(255), random(satFloor, 255), random(brightFloor, 255));
    pg.background(baseColor);

    int numColors = 4;
    for (int i=0; i<numColors; i++)
    {
      addColor();
    }

    pg.endDraw();

    for (int i=0; i<w; i++)
    {
      allColorsNew[i] = pg.get(i, 0);
    }
  }

  void addColor()
  {
    color c = color(random(255), random(satFloor, 255), random(brightFloor, 255));
    float pos = random(w);
    float size = w/4;

    for (int i=0; i<w; i++)
    {
      float ratio = 0;
      float d = abs(i-pos);
      if (d < size)
      {
        ratio = 1.0 - (d/size);
      }
      pg.fill(hue(c), saturation(c), brightness(c), (ratio)*255);
      pg.rect(i, 0, 1, 1);
    }
  }

  void draw()
  {
    image(pg, 0, height/2, width, 10);
  }

  color getColor(float _ratio)
  {
    float ratio = constrain(_ratio, 0, 1);
    int index = floor((w-1) * _ratio);
    return allColorsCurrent[index];
  }
}

class Part
{
  float x, y, z;
  float rx, ry, rz;
  float vrx, vry, vrz;
  float colorRatio;

  float osc1, osc2, osc3;

  float scaleMod = 0.001;
  float noiseMod = 0.002;
  float rotMod = 3;
  float speedMod = 0.25;
  float colorSpeed = 0.003;
  float colorTime = 0;
  float boxW = 300;
  float boxH = 300;
  float boxD = 300;

  float tscaleMod = scaleMod;
  float tnoiseMod = noiseMod;
  float trotMod = rotMod;
  float tspeedMod = speedMod;
  float tcolorSpeed = colorSpeed;
  float tboxW = boxW;
  float tboxH = boxH;
  float tboxD = boxD;

  Part(float _x, float _y, float _z)
  {
    x = _x;
    y = _y;
    z = _z;
  }

  void update()
  {
    updateInputValues();
    updateProperties();
    if (!isPaused) 
    {
      updateColor();
      move();
    }
    render();
  }

  void updateInputValues()
  {
    if (edit[1]) tnoiseMod = getValue(tnoiseMod, -0.01, 0.01);
    if (edit[2]) tcolorSpeed = getValue(tcolorSpeed, -0.02, 0.02);

    if (edit[3]) tscaleMod = getValue(tscaleMod, -0.02, 0.02);
    if (edit[4]) trotMod = getValue(trotMod, -3, 3);
    if (edit[5]) tspeedMod = getValue(tspeedMod, -2, 2);

    if (edit[6]) tboxW = tboxH = tboxD = getValue(tboxW, 0, 800);
    if (edit[7]) tboxW = getValue(tboxW, 0, 800);
    if (edit[8]) tboxH = getValue(tboxH, 0, 800);
    if (edit[9]) tboxD = getValue(tboxD, 0, 800);
  }

  void updateProperties()
  {
    float transMod = 0.1;
    scaleMod += (tscaleMod - scaleMod) * transMod;
    noiseMod += (tnoiseMod - noiseMod) * transMod;
    rotMod += (trotMod - rotMod) * transMod;
    speedMod += (tspeedMod - speedMod) * transMod;
    colorSpeed += (tcolorSpeed - colorSpeed) * transMod;
    boxW += (tboxW - boxW) * transMod;
    boxH += (tboxH - boxH) * transMod;
    boxD += (tboxD - boxD) * transMod;
  }

  void updateColor()
  {
    colorTime += colorSpeed;

    float n = noise(x*noiseMod, y*noiseMod, colorTime);
    n = map(n, 0.3, 0.7, 0, 1);
    n = constrain(n, 0, 1); 
    colorRatio = n;
  }

  void move()
  {
    osc1 += 0.01 * speedMod;
    osc2 += 0.007 * speedMod;
    osc3 += 0.003 * speedMod;

    rx = sin(osc1 + x*scaleMod) * rotMod;
    ry = sin(osc2 + y*scaleMod) * rotMod;
    rz = sin(osc3 + (x+z)*scaleMod*0.1) * rotMod;
  }

  void render()
  { 
    pushMatrix();
    translate(x, y, z);
    rotateY(ry);
    rotateX(rx);
    rotateZ(rz);
    fill(g.getColor(colorRatio));
    box(boxW, boxH, boxD);
    popMatrix();
  }

  float getValue(float value, float lower, float upper)
  {
    float v = value;
    v += (map(mouseX, 0, width, lower, upper) - value) * 0.3;
    return v;
  }
}

  

Part part;
Gradient g;
float count = 1;
int timeStep = 0;

float osc = 0;
float gridMod = 1.0;

boolean isPaused = false;
boolean autoPlay = true;
boolean bigLine = false;

void setup()
{
  size(940, 540);
  colorMode(HSB);
  background(255);
  rectMode(CENTER);
  init();
}

void init()
{
  if (random(10) > 5) bigLine = true;
  else bigLine = false;

  timeStep = 0;
  gridMod = random(0.4, 1.2);
  g = new Gradient();
  background(0);
  part = new Part(0, 0);
}

void mousePressed()
{
  init();
}

void draw()
{
  if (autoPlay) if (timeStep % 2000 == 0) init();
  if (!isPaused) update();
}

void update()
{
  timeStep++;

  osc += 0.01;
  float ratio = map(sin(osc), -1, 1, 0, 1);

  fill(g.getColorAtRatio(ratio));
  noStroke();

  int count = 0;

  float xRes = 15*gridMod;
  float yRes = 10*gridMod;

  float w = width * 2.0;
  float h = height * 2.0;

  for (int i=-width/2; i<=w+w/10; i+=w/xRes)
  {
    count++;
    for (int j=-height/2; j<=h+h/10; j+=h/yRes)
    {
      pushMatrix();

      float offset = 0;
      if (count % 2 == 0) offset = h/yRes/2;

      translate(floor(i), floor(j+offset));

      drawRect(part.x, part.y);
      drawRect(-part.x, part.y);
      drawRect(part.x, -part.y);
      drawRect(-part.x, -part.y);

//      renderRadial(part.x, part.y);

      popMatrix();
    }
  }

  part.update();
}

void renderRadial(float x, float y)
{
  int numAxis = 4;
  float step = 360 / numAxis;
  step = radians(step);

  for (int i=0; i<numAxis; i++)
  {
    drawRect(x, y);
    rotate(step);
  }
}

void drawRect(float _x, float _y)
{
  float x = _x % width;
  float y = _y % height;

  if (bigLine) rect(x, y, 20, 1);
  else rect(x, y, 1, 1);
}

void keyPressed()
{
  if (key == ' ') isPaused = !isPaused;
  if (key == 's') save();
  if (key == 'a') autoPlay = !autoPlay;
  if (key == 'l') bigLine = !bigLine;
}

class Gradient
{
  PGraphics pg;
  float w = 300;
  color[] allColorsNew;
  color[] allColorsCurrent;

  int trans = w;

  int brightnessFloor = 0;

  Gradient()
  {
    allColorsNew = new color[w];
    allColorsCurrent = new color[w];

    createPalette();

    for (int i=0; i<=w; i++)
    {
      allColorsCurrent[i] = allColorsNew[i];
    }
  }

  void update()
  {
    for (int i=0; i<5; i++)
    {
      if (trans <= w)
      {
        allColorsCurrent[trans] = allColorsNew[trans];
      }
      trans++;
    }
  }

  void changeColors()
  {
    trans = 0;
//    brightnessFloor = random(255);
    createPalette();
  }

  void createPalette()
  {
    pg = createGraphics(w, 1);
    pg.colorMode(HSB);
    pg.beginDraw();

    pg.noStroke();

    color baseColor = color(random(255), random(255, 255), random(255, 255));
    pg.background(baseColor);

    int numColors = 6;
    for (int i=0; i<numColors; i++)
    {
      addColor();
    }

    pg.endDraw();

    for (int i=0; i<w; i++)
    {
      allColorsNew[i] = pg.get(i, 0);
    }
  }

  void addColor()
  {
    color c = color(random(255), random(0, 255), random(brightnessFloor, 255));
    float pos = random(w);
    float size = w/4;

    for (int i=0; i<w; i++)
    {
      float ratio = 0;
      float d = abs(i-pos);
      if (d < size)
      {
        ratio = 1.0 - (d/size);
      }
      pg.fill(hue(c), saturation(c), brightness(c), (ratio)*255);
      pg.rect(i, 0, 1, 1);
    }
  }

  void draw()
  {
    image(pg, 0, height/2, width, 10);
  }

  color getColorAtRatio(float _ratio)
  {
    int index = floor(w * _ratio);
    return allColorsCurrent[index];
  }
}

class Part
{
  float x;
  float y;
  float dir = 0;
  int life = 0;
  int dirSwitch = 0;

  Part(float _x, float _y)
  {
    x = _x;
    y = _y;
    dir = floor(random(0, 3));
    changeDirections();
  }

  void update()
  {
    life++;
    checkDirection();
    move();
  }

  void checkDirection()
  { 
    if (life % dirSwitch == 0) 
    {
      changeDirections();
    }
  }

  void changeDirections()
  {
    life = 0;
    dirSwitch = ceil(random(0, 4)) * 10;

    float trigger = random(100);

    switch(dir)
    {
    case 0:
    case 1:
      if (trigger > 50) dir = 2;
      else dir = 3;
      break;

    case 2:
    case 3:
      if (trigger > 50) dir = 0;
      else dir = 1;
      break;
    }
  }

  void move()
  {
    switch(dir)
    {
    case 0:
      x++;
      break;

    case 1:
      x--;
      break;

    case 2:
      y++;
      break;

    case 3:
      y--;
      break;
    }
  }

  void wrap()
  {
    if (x > width) x = 0;
    if (x < 0) x = width;
    if (y > height) y = 0;
    if (y < 0) y = height;
  }
}

Part[][] allParts;
int xCount = 20;
int yCount = 20;
int numPoints;

Gradient g;

boolean mouseIsMoving;
boolean horzColors = false;
boolean autoSwitchColors = true;
boolean isPaused = false;
int lineColor = 0;

int mode = 0;
int numModes = 4;

void setup()
{
  size(940, 540);
  colorMode(HSB);
  background(0);
  createParts();

  g = new Gradient();
}

void draw()
{
  if (mouseX-pmouseX == 0 && mouseY-pmouseY == 0) mouseIsMoving = false; 
  else mouseIsMoving = true;

  g.update();

  if (frameCount % 400 == 0 && autoSwitchColors && !isPaused) changeColors();

  background(0);

  if (!isPaused) updateParts();

  strokeWeight(0.3);
  stroke(lineColor);

  if (horzColors) drawMeshHorz();
  else drawMeshVert();
}

void changeColors()
{
  g.changeColors();
}

void createParts()
{
  numPoints = (xCount+1) * (yCount+1);
  allParts = new Part[xCount+1][yCount+1];

  float xSpacing = width/xCount;
  float ySpacing = height/yCount;

  for (int i=0; i<=xCount; i++)
  {
    for (int j=0; j<=yCount; j++)
    {
      Part part = new Part(i*xSpacing, j*ySpacing);
      part.i = i;
      part.j = j;
      allParts[i][j] = part;
    }
  }
}

void updateParts()
{
  for (int i=1; i<xCount; i++)
  {
    for (int j=1; j<yCount; j++)
    {
      Part part = allParts[i][j];
      part.update();
    }
  }
}

void drawMeshHorz()
{  
  float count = 0;
  float ratio;
  Part part1;
  Part part2;

  for (int i=0; i<xCount; i++)
  {
    beginShape(TRIANGLE_STRIP);
    for (int j=0; j<=yCount; j++)
    {
      count++;
      part1 = allParts[i][j];
      part2 = allParts[i+1][j];
      ratio = count/numPoints;
      fill(g.getColorAtRatio(ratio));
      vertex(part1.x, part1.y, 0);
      vertex(part2.x, part2.y, 0);
    }
    endShape();
  }
}

void drawMeshVert()
{  
  float count = 0;
  float ratio;
  Part part1;
  Part part2;

  for (int j=0; j<yCount; j++)
  {
    beginShape(TRIANGLE_STRIP);
    for (int i=0; i<=xCount; i++)
    {
      count++;
      part1 = allParts[i][j];
      part2 = allParts[i][j+1];
      ratio = count/numPoints;
      fill(g.getColorAtRatio(ratio)); 
      vertex(part1.x, part1.y, 0);
      vertex(part2.x, part2.y, 0);
    }
    endShape();
  }
}

void mousePressed()
{
  mode++;
  if (mode >= numModes) mode = 0;
}

void keyPressed()
{
  if (key == 'x') horzColors = !horzColors;
  if (key == 'a') autoSwitchColors = !autoSwitchColors;
  if (key == 'p') isPaused = !isPaused;
  if (key == 'c') changeColors();

  if (key == 'l')
  {
     switch (lineColor)
    {
      case 0:
      lineColor = 126;
      break;

      case 126:
      lineColor = 255;
      break;

      case 255:
      lineColor = 0;
      break;

       default:
       break;
    } 
  }
}

class Gradient
{
  PGraphics pg;
  float w = 300;
  color[] allColorsNew;
  color[] allColorsCurrent;

  int trans = w;

  int brightnessFloor = 100;

  Gradient()
  {
    allColorsNew = new color[w];
    allColorsCurrent = new color[w];

    createPalette();

    for (int i=0; i<=w; i++)
    {
      allColorsCurrent[i] = allColorsNew[i];
    }
  }

  void update()
  {
    for (int i=0; i<5; i++)
    {
      if (trans <= w)
      {
        allColorsCurrent[trans] = allColorsNew[trans];
      }
      trans++;
    }
  }

  void changeColors()
  {
    trans = 0;
    brightnessFloor = random(255);
    createPalette();
  }

  void createPalette()
  {
    pg = createGraphics(w, 1);
    pg.colorMode(HSB);
    pg.beginDraw();

    pg.noStroke();

    color baseColor = color(random(255), random(255, 255), random(255, 255));
    pg.background(baseColor);

    int numColors = 6;
    for (int i=0; i<numColors; i++)
    {
      addColor();
    }

    pg.endDraw();

    for (int i=0; i<w; i++)
    {
      allColorsNew[i] = pg.get(i, 0);
    }
  }

  void addColor()
  {
    color c = color(random(255), random(0, 255), random(brightnessFloor, 255));
    float pos = random(w);
    float size = w/4;

    for (int i=0; i<w; i++)
    {
      float ratio = 0;
      float d = abs(i-pos);
      if (d < size)
      {
        ratio = 1.0 - (d/size);
      }
      pg.fill(hue(c), saturation(c), brightness(c), (ratio)*255);
      pg.rect(i, 0, 1, 1);
    }
  }

  void draw()
  {
    image(pg, 0, height/2, width, 10);
  }

  color getColorAtRatio(float _ratio)
  {
    int index = floor(w * _ratio);
    return allColorsCurrent[index];
  }
}

class Part
{
  float x;
  float y;
  float orgX;
  float orgY;
  float vx;
  float vy;
  int i;
  int j;

  float osc = 10;
  float osc2 = 20;
  float osc3 = 30;
  float osc4 = 40;
  float osc5 = 50;
  float osc6 = 60;

  Part(float _x, float _y)
  {
    orgX = x = _x;
    orgY = y = _y;
  }

  void update()
  {
    switch (mode)
    {
    case 0: 
      oscilate();
      break;

    case 1:
      mouseMove();
      break;

    case 2:
      noiseMove();
      break;

    case 3:
      mouseMove2();
      break;

    default:
      break;
    }
  }

  void oscilate()
  {
    osc += 0.03;
    osc2 += 0.051;
    osc3 += 0.0011;
    osc4 += 0.0013;
    osc5 += 0.0021;
    osc6 += 0.0034;

    float mod1 = sin(osc3) * 100;
    float mod2 = sin(osc4) * 100;  

    float mod3 = map(sin(osc5), -1, 1, 0.3, 2.0);
    float mod4 = map(sin(osc6), -1, 1, 0.3, 2.0);

    float newX = orgX + cos(osc + j*mod3) * mod1;
    float newY = orgY + sin(osc2 + i*mod4) * mod2;

    x += (newX - x) * 0.3;
    y += (newY - y) * 0.3;
  }

  void noiseMove()
  {
    float noiseMod = map(mouseX, 0, width, 0.001, 0.01);
    float n = noise(orgX*noiseMod, orgY*noiseMod, frameCount*0.003);
    n = map(n, 0, 1, -1, 1);

    float n2 = noise(orgX*noiseMod, orgY*noiseMod, (frameCount+10000)*0.003);
    n2 = map(n2, 0, 1, -1, 1);

    float h = map(mouseY, 0, height, 50, 400);

    x += ((orgX + n * h) - x) * 0.3;
    y += ((orgY + n2 * h) - y) * 0.3;
  }

  void mouseMove()
  {
    if (mouseIsMoving)
    {
      float d = dist(mouseX, mouseY, orgX, orgY); 
      float range = 200;
      float mag = range - d;
      if (d < range)
      {
        vx -= mag * 0.005;
        vy -= mag * 0.005;
      }
    }

    vx += (orgX - x) * 0.01;
    vy += (orgY - y) * 0.01;

    vx *= 0.99;
    vy *= 0.99;

    x += vx;
    y += vy;
  }

  void mouseMove2()
  {
    float d = dist(mouseX, mouseY, orgX, orgY); 
    float range = 150;
    float mag = range - d;
    if (d < range)
    {
      vx -= (mouseX - orgX) * mag/range * 0.03;
      vy -= (mouseY - orgY) * mag/range * 0.03;
    }

    vx += (orgX - x) * 0.01;
    vy += (orgY - y) * 0.01;

    vx *= 0.95;
    vy *= 0.95;

    x += vx;
    y += vy;
  }
}

 

PFont font;
Part part;
int time = 1;
int r1, r2, r3, r4;
int numAxis = 1;
color bgColor;
boolean showsFPS = false;
boolean doesPaint = true;
boolean autoplay = true;
boolean isPaused = false;
ColorPalette cp;
float spread = 5;
float osc1, osc2;

void setup()
{
  size(940, 540);
  colorMode(HSB);
  background(0);
  strokeWeight(0.5);
  font = createFont("Helvetica", 24);
  bgColor = color(0, 10);
  randomize();
  part = new Part(0, 0);
}

void draw()
{ 
  if (!isPaused)
  {
    if (!doesPaint)
    {
      fill(bgColor);
      noStroke();
      rect(0, 0, width, height);
    }

    if (showsFPS) displayFPS();

    if (autoplay)
    {
      time++;
      if (time > 700) randomize();
    }

    translate(width/2, height/2);
    noFill();

    osc1 += 0.0011;
    osc2 += 0.0013;

    r1 = abs(sin(osc1) * 0.009) + 0.001;
    r2 = abs(sin(osc2) * 0.009) + 0.001;

    part.draw();
  }
}

void randomize()
{
  time = 1;
  if (doesPaint) background(0);
  randomizeColor();
  randomizeShape();
  randomizeAxis();
}

void randomizeShape()
{
  if (doesPaint) background(0);
  int bottom = 0.001;
  int top = 0.01;
  r1 = random(bottom, top); 
  r2 = random(bottom, top); 
  r3 = random(bottom, top); 
  r4 = random(bottom, top);
  spread = random(1, 20);
}

void randomizeAxis()
{
  if (doesPaint) background(0);
  numAxis = round(random(2, 30));
}

void randomizeColor()
{
  cp = new ColorPalette();
}

void mouseClicked()
{
  randomize();
  autoplay = false;
}

void keyPressed()
{
  if (key == 'f') showsFPS = !showsFPS;
  if (key == 'd')
  {
    float a = alpha(bgColor);
    if (a == 10) a = 40;
    else a = 10;
    bgColor = color(0, a);
  }

  if (key == 'p') doesPaint = !doesPaint;
  if (key == 'a') autoplay = !autoplay;
  if (key == ' ') isPaused = !isPaused;
  if (key == 'c') randomizeColor();
  if (key == 's') randomizeShape();
  if (key == 'x') randomizeAxis();
  if (key == 'b') background(0);

  if (key == '=') 
  {
    numAxis++;
    if (doesPaint) background(0);
  }
  if (key == '-') 
  {
    numAxis--;
    if (doesPaint) background(0);
  }
  if (numAxis < 1) numAxis = 1;
  if (numAxis > 30) numAxis = 30;
}

void displayFPS()
{
  textFont(font, 18);
  fill(255);
  String output = "fps=";
  output += (int) frameRate;
  text(output, 10, 30);
}

class ColorPalette
{
  PGraphics pg;
  float w = 300;
  color[] allColors;

  ColorPalette()
  {
    createPalette();

    allColors = new color[w];
    for (int i=0; i<w; i++)
    {
      allColors[i] = pg.get(i, 0);
    }
  }

  color getColorAtRatio(float _ratio)
  {
    int index = floor(w * _ratio);
    return allColors[index];
  }

  void createPalette()
  {
    pg = createGraphics(w, 1);
    pg.colorMode(HSB);
    pg.beginDraw();

    pg.noStroke();

    color baseColor = color(random(255), random(255, 255), random(255, 255));
    pg.background(baseColor);

    int numColors = 6;
    for (int i=0; i<numColors; i++)
    {
      addColor();
    }

    pg.endDraw();
  }

  void addColor()
  {
    color c = color(random(255), random(0, 255), random(150, 255));
    float pos = random(w);
    float size = w/4;

    for (int i=0; i<w; i++)
    {
      float ratio = 0;
      float d = abs(i-pos);
      if (d < size)
      {
        ratio = 1.0 - (d/size);
      }
      pg.fill(hue(c), saturation(c), brightness(c), (ratio)*255);
      pg.rect(i, 0, 1, 1);
    }
  }

  void draw()
  {
    image(pg, 0, height/2, width, 10);
  }
}

class Part
{
  PVector pos[];
  int trailLength = 100;
  float speed = 0.03;
  float o1, o2, o3, o4;

  Part(float _x, float _y)
  {
    pos = new PVector[trailLength];

    for (int i=0; i<trailLength; i++)
    {
      pos[i] = new PVector(0, 0);
    }
  }

  void draw()
  {
    float step = radians(360/numAxis);
    float x, y;

    for (int i=0; i<trailLength; i++)
    {
      o1 += r1*speed;
      o2 += r2*speed;
      o3 += r3*speed;
      o4 += r4*speed;

      x = sin(o1 + i*spread*r1) * 250;
      y = cos(o2 + i*spread*r2) * 100;
      x += sin(o3 + i*spread*r3) * 250;
      y += cos(o4 + i*spread*r4) * 100;
      pos[i].x += (x - pos[i].x) * 0.1;
      pos[i].y += (y - pos[i].y) * 0.1;
    }

    for (int i=1; i<trailLength; i++)
    {  
      stroke(cp.getColorAtRatio(i/trailLength));

      pushMatrix();
      for (int j=0; j<numAxis; j++)
      {
        rotate(step);
        line(pos[i].x, pos[i].y, pos[i-1].x, pos[i-1].y);
      }
      popMatrix();
    }
  }
}

boolean autoplay = false;
boolean showsFPS = false;
boolean clearsBackground = true;
boolean windEnabled = true;
PFont font;
float rotRange = 10;
float rotDecay = 1.1;
float sizeDecay = 0.7;
float lengthDecay = 0.91;
int levelMax = 8;
int leafLevel = 2;
float leafChance = 0.3;
float branchHue = 50;
float leafHue = 150;
float leafSat = 100;
float mouseWind = 0;
float mouseWindV = 0;
float startLength;
float startSize;
color trunkColor;
color bgColor;
int time = 0;
float lengthRand = 1.0;
float bloomWidthRatio = 0.6;
float bloomSizeAverage = 15;

float mDamp = 0.00002;
float wDamp = 0.003;
float mFriction = 0.98;

float flowerChance = 0.1;
color flowerColor;
float flowerWidth = 10;
float flowerHeight = 20;

Node node;

void setup()
{
  size(940, 540);
  colorMode(HSB);
  font = createFont("Helvetica", 24);
  ellipseMode(CENTER);

  randomize();
  reset();
}

void draw()
{
  if (autoplay)
  {
    time++;
    if (time > 600)
    {
      time = 0;
      randomize();
      reset();
    }
  }

  float dx = mouseX - pmouseX;
  mouseWindV += dx * mDamp;
  mouseWindV += (0 - mouseWind) * wDamp;
  mouseWindV *= mFriction;
  mouseWind += mouseWindV;

  if (clearsBackground) background(bgColor);
  if (showsFPS) displayFPS();
  translate(width/2, height);
  node.draw();
}

void reset()
{
  background(bgColor);
  node = new Node(startLength, startSize, rotRange, 0);
}

void randomize()
{
  randomizeBackground();
  randomizeColor();
  rotRange = random(20, 60);
  rotDecay = random(0.9, 1.1);
  startLength = random(20, 80);
  startSize = random(3, 20);
  lengthRand = random(0.0, 0.2);
  leafChance = random(0.3, 0.9);
  sizeDecay = random(0.6, 0.7);
  lengthDecay = map(startLength, 20, 80, 1.1, 0.85); 
  leafLevel = random(0, 4);
  bloomWidthRatio = random(0.01, 0.9);
  bloomSizeAverage = random(10, 40);

  mDamp = 0.00002;
  wDamp = 0.005;
  mFriction = 0.96;

  flowerWidth = random(5, 15);
  flowerHeight = random(10, 30);
  flowerChance = 0.1;
}

void randomizeBackground()
{
    bgColor = color(random(255), random(0, 100), 255);
}

void randomizeColor()
{
  branchHue = random(0, 255);
  leafHue = random(0, 255);
  leafSat = random(0, 255);
  flowerColor = color(random(255), random(0, 255), 255);
  if (node) node.randomizeColor();
}

void displayFPS()
{
  textFont(font, 18);
  fill(150);
  String output = "fps=";
  output += (int) frameRate;
  text(output, 10, 30);
}

void keyPressed()
{
  if (key == 'f') showsFPS = !showsFPS;
  if (key == 'a') autoplay = !autoplay;
  if (key == 'p') clearsBackground = !clearsBackground;
  if (key == 'w') windEnabled = !windEnabled;
  if (key == 'r') reset();
  if (key == 'b') randomizeBackground();
  if (key == 'c') randomizeColor();
}

void mousePressed()
{
  time = 0;
  randomize();
  reset();
}
class Node
{
  float len;
  float size;
  float rot;
  int level;
  float s = 0;
  float windFactor = 1.0;
  boolean doesBloom;
  color branchColor;
  float bloomSize;
  color leafColor;
  float leafRot;
  float leafScale = 0.0;
  int leafDelay;
  boolean doesFlower;
  float flowerScale = 0.0;
  float flowerScaleT = 1.0;
  float flowerBright = 255;
  int flowerDelay;

  Node n1;
  Node n2;

  Node(float _len, float _size, float _rotRange, int _level)
  {
    len = _len * (1 + random(-lengthRand, lengthRand));
    size = _size;
    level = _level;
    rot = radians(random(-_rotRange, _rotRange));
    if (level < leafLevel) rot *= 0.3;
    if (level == 0 ) rot = 0;
    windFactor = random(0.2, 1);
    doesBloom = false;
    if (level >= leafLevel && random(1) < leafChance) doesBloom = true;
    bloomSize = random(bloomSizeAverage*0.7, bloomSizeAverage*1.3);
    leafRot = radians(random(-180, 180));
    flowerScaleT = random(0.8, 1.2);
    flowerDelay = round(random(200, 250));
    leafDelay = round(random(50, 150));
    randomizeColor();

    if (random(1) < flowerChance) doesFlower = true;

    float rr = _rotRange * rotDecay;

    if (level < levelMax)
    {
      n1 = new Node(len*lengthDecay, size*sizeDecay, rr, level+1);
      n2 = new Node(len*lengthDecay, size*sizeDecay, rr, level+1);
    }
  }

  void draw()
  {
    strokeWeight(size);
    s += (1.0 - s) / (15 + (level*5));
    scale(s);

    pushMatrix();

    if (level >= leafLevel) stroke(branchColor);
    else stroke(0);
    float rotOffset = sin( noise( (float)millis() * 0.000006  * (level*1) ) * 100 );
    if (!windEnabled) rotOffset = 0;
    rotate(rot + (rotOffset * 0.1 + mouseWind) * windFactor);
    line(0, 0, 0, -len);
    translate(0, -len);

    // draw leaves
    if (doesBloom)
    {
      if (leafDelay < 0)
      {
        leafScale += (1.0 - leafScale) * 0.05;
        fill(leafColor);
        noStroke();
        pushMatrix();
        scale(leafScale);
        rotate(leafRot);
        translate(0, -bloomSize/2);
        ellipse(0, 0, bloomSize*bloomWidthRatio, bloomSize);
        popMatrix();
      } 
      else
      {
        leafDelay--;
      }
    }

    // draw flowers
    if (doesFlower && level > levelMax-3)
    {
      if (flowerDelay < 0)
      {
        pushMatrix();
        flowerScale += (flowerScaleT - flowerScale) * 0.1;
        scale(flowerScale);
        rotate(flowerScale*3);
        noStroke();
        fill(hue(flowerColor), saturation(flowerColor), flowerBright);
        ellipse(0, 0, flowerWidth, flowerHeight);
        rotate(radians(360/3));
        ellipse(0, 0, flowerWidth, flowerHeight);
        rotate(radians(360/3));
        ellipse(0, 0, flowerWidth, flowerHeight);
        fill(branchColor);
        ellipse(0, 0, 5, 5);
        popMatrix();
      } else
      {
        flowerDelay--;
      }
    }

    pushMatrix();
    if (n1) n1.draw();
    popMatrix();

    pushMatrix();
    if (n2) n2.draw();
    popMatrix();

    popMatrix();
  }

  void randomizeColor()
  {
    branchColor = color(branchHue, random(170, 255), random(100, 200));
    leafColor = color(leafHue, leafSat, random(100, 255));
    flowerBright = random(200, 255);

    if (n1) n1.randomizeColor();
    if (n2) n2.randomizeColor();
  }
}

 

Pylon allPylons[];
int numPylons = 10;
boolean cameraOrtho = true;
boolean whiteLines = false;
boolean lightBackground = false;

float minDist = 150;
float growMax = 300;
int mode = 1;
int gridSizeX = 10;
int gridSizeY = 10;

float rotX = 45;
float rotY = 45;

boolean isPaused = false;
boolean drawsFromCenter = false;

void setup()
{
  size(940, 540, P3D);
  colorMode(HSB);

  createPylons();
}

void draw()
{
  pushMatrix();
  translate(0, 0, 10);

  directionalLight(255, 0, 150, -0.3, 0.5, -1);
  directionalLight(255, 0, 150, 0.5, -0.3, -1);
  popMatrix();

  if (lightBackground) background(200);
  else background(50);

  if (cameraOrtho) ortho(-940/2, 940/2, -540/2, 540/2, -10000, 10000);
  else perspective();

  for (int i=0; i<gridSizeX*gridSizeY; i++)
  {
    Pylon pylon = allPylons[i];
    pylon.draw();
  }
}

void createPylons()
{
  int index = 0;
  allPylons = new PVector[gridSizeX*gridSizeY];

  float w = 940/gridSizeX;
  float h = 540/gridSizeY;

  float hue1 = random(0, 255);
  float hue2 = random(0, 255);
  float hue3 = random(0, 255);
  float hue4 = random(0, 255);
  float hue5 = random(0, 255);

  float sat1 = random(0, 255);
  float sat2 = random(0, 255);
  float sat3 = random(0, 255);
  float sat4 = random(0, 255);
  float sat5 = random(0, 255);

  float chance = random(1);

  for (int x=0; x<gridSizeX; x++)
  {
    for (int y=0; y<gridSizeY; y++)
    {
      Pylon pylon = new Pylon();
      pylon.x = x * w + w/2;
      pylon.y = y * h + h/2;
      pylon.w = w * 1.0;
      pylon.h = h * 1.0;

      pylon.hue = hue1;
      pylon.sat = sat1;
      if (random(1) > chance)
      { 
        pylon.hue = hue2;
        pylon.sat = sat2;
      } else if (random(1) > chance)
      {
        pylon.hue = hue3;
        pylon.sat = sat3;
      } else if (random(1) > chance)
      {
        pylon.hue = hue4;
        pylon.sat = sat4;
      } else if (random(1) > chance) 
      {
        pylon.hue = hue5;
        pylon.sat = sat5;
      }

      pylon.time = -dist(mouseX, mouseY, pylon.x, pylon.y) * 0.06;
      allPylons[index] = pylon;
      index++;
    }
  }
}

void mousePressed()
{
  gridSizeX = round(random(1, 30));
  gridSizeY = round(random(1, 30));
  mode = round(random(0, 3));

  drawsFromCenter = round(random(0, 1));

  float range = 360;
  rotX = random(0, range);
  rotY = random(0, range);

  createPylons();
}

void keyPressed()
{
  if (key == 'o') cameraOrtho = !cameraOrtho;
  if (key == 'l') whiteLines = !whiteLines;
  if (key == 'b') lightBackground = !lightBackground;
  if (key == 'd') drawsFromCenter = !drawsFromCenter;
  if (key == 'p') isPaused = !isPaused;
  if (key == 'c') createPylons();

  if (key == 'm')
  {
    mode++;
    if (mode > 3) mode = 0;
  }

  if (key == '=')
  {
    gridSizeX++;
    gridSizeY++;
    createPylons();
  }

  if (key == '-')
  {
    gridSizeX--;
    gridSizeY--;
    createPylons();
  }

  if (key == 'g')
  {
    gridSizeX = round(random(1, 30));
    gridSizeY = round(random(1, 30)); 
    createPylons();
  }
}

class Pylon
{
  float w, h, d;
  float x, y, z;
  float hue, sat, bright;
  float size = 0.0;
  float targetSize = 1.0;
  float scaleSpeed = 0.05;
  float maxSize = 700;

  float vd;
  float target = 10;
  float time = 0;

  Pylon()
  {
    scaleSpeed = random(0.05, 0.1);
    z = random(10);
    w = 0;
    h = 0;
    d = 0;

    hue = random(0, 255);
    sat = random(100, 255);
    bright = random(100, 255);
  }

  void draw()
  {
    pushMatrix();

    if (whiteLines) noStroke();
    else stroke(0);

    if (!isPaused)
    {
      z = y-x;
    time++;
    if (time > 0) size += (targetSize - size) * scaleSpeed;
    else size = 0;

    if (mode == 0)
    {
      float dx = abs(mouseX-x);
      float dy = abs(mouseY-y);

      if (dx < w/2 && dy < h/2) target = 500;
      else target *= 0.99;

      vd += (target - d) * 0.3;
      vd *= 0.5;
      d += vd;
    } 
    else if (mode == 1)
    {
      float distance = dist(mouseX, mouseY, x, y);
      target = map(distance, 150, 0, 10, 350);

      vd += (target - d) * 0.3;
      vd *= 0.5;
      d += vd;
    }
    else if (mode == 2)
    {
      float distance = dist(mouseX, mouseY, x, y);
      target = map(distance, 300, 0, 10, 200);

      vd += (target - d) * 0.01;
      vd *= 0.99;
      d += vd;
    }
    else if (mode == 3)
    {
      float distance = dist(mouseX, mouseY, x, y);
      target = sin(distance * 0.01 - millis()*0.002) * 100;
      target = abs(target);

      vd += (target - d) * 0.3;
      vd *= 0.5;
      d += vd;
    }

    if (d < 10)
    {
      d = 10;
      vd = 0;
    }
    }

    translate(x, y, z);
    rotateY(radians(rotY));
    rotateX(radians(rotX));  

    if (!drawsFromCenter) translate(0, 0, d/2*size);

    fill(hue, sat, bright);
    box(w*size, h*size, d*size);

    popMatrix();
  }
}

   

Pylon allPylons[];
int numPylons = 10;
boolean cameraOrtho = true;
boolean whiteLines = true;
boolean lightBackground = true;

void setup()
{
  size(940, 540, P3D);
  colorMode(HSB);

  allPylons = new PVector[numPylons];
  createPylons();
}

void draw()
{
  if (lightBackground) background(220);
  else background(50);

  if (cameraOrtho) ortho(-width, width, -height, height, -10000, 10000);
  else perspective();

  float camX = map(mouseX, 0, width, 1000, -1000);
  float camY = map(mouseY, 0, height, 1000, -1000);
  camera(camX, camY, 1000, 0, 0, 0, 0.0, 1.0, 0.0);

  for (int i=0; i<numPylons; i++)
  {
    Pylon pylon = allPylons[i];
    pylon.draw();
  }
}

void createPylons()
{
  for (int i=0; i<numPylons; i++)
  { 
    Pylon pylon = new Pylon();
    allPylons[i] = pylon;
  }
}

void mousePressed()
{
  createPylons();
}

void keyPressed()
{
  if (key == 'p') cameraOrtho = !cameraOrtho;
  if (key == 'l') whiteLines = !whiteLines;
  if (key == 'b') lightBackground = !lightBackground;

  if (key == 'c')
  { 
    for (int i=0; i<numPylons; i++)
    { 
      allPylons[i].randomizeColor();
    }

  }
  if (key == 's')
  {
    for (int i=0; i<numPylons; i++)
    { 
      allPylons[i].randomizeSize();
    }
  }

  if (key == 'x')
  {
    lightBackground = !lightBackground;
    whiteLines = !whiteLines;
  }
}

class Pylon
{
  float w, h, d;
  float x, y, z;
  float hue, sat, bright;
  float size = 0.0;
  float targetSize = 1.0;
  float scaleSpeed = 0.05;

  float maxSize = 700;

  Pylon()
  {
    x = random(-50, 50);
    y = random(-50, 50);
    z = random(-50, 50);

    randomizeSize();
    randomizeColor();

    scaleSpeed = (w/maxSize) * 0.1 + 0.1;
  }

  void draw()
  {
    pushMatrix();
    size += (targetSize - size) * scaleSpeed;

    if (whiteLines) stroke(255);
    else stroke(0);
    fill(hue, sat, bright);
    box(w*size, h, d);

    popMatrix();
  }

  void randomizeColor()
  {
    hue = random(0, 255);
    sat = random(0, 255);
    bright = random(0, 255);
  }

  void randomizeSize()
  {
    w = random(10, maxSize);
    h = random(10, maxSize);
    d = random(10, maxSize);
    size = 0;
  }
}

 

Flower flower;
float bgColor = 0;
boolean isPaused = false;
int time = 0;
boolean autoplay = false;

void setup()
{
  size(940, 540, P3D);
  colorMode(HSB);

  init();
}

void draw()
{
  if (autoplay)
  {
    time++;
    if (time > 1000)
    {
      init();
      time = 0;
    }
  }

  background(bgColor);

  pushMatrix();
  translate(width/2, height/2);
  flower.draw();
  popMatrix();
}

void init()
{
  time = 0;
  flower = new Flower();
}

void mousePressed()
{
  init();
}

void keyPressed()
{
  if (key == 'b')
  {
    if (bgColor == 0) bgColor = 255;
    else if (bgColor == 255) bgColor = 0;
  }

  if (key == 'p')
  {
    isPaused = !isPaused;
  }

  if (key == 'a') autoplay = !autoplay;
}

class Flower
{
  PetalCluster[] clusters;
  int numClusters = 5;

  Flower()
  {
    numClusters = round(random(2, 5));
    createClusters();
  }

  void draw()
  {
    for (int i=0; i<numClusters; i++)
    {
      clusters[i].draw();
    }
  }

  void createClusters()
  { 
    clusters = new PetalCluster[numClusters];

    int numPetals = round(random(2, 30));

    for (int i=0; i<numClusters; i++)
    {
      if (numPetals % 2 == 0 && numPetals > 2 && i > 0)
      {
        if (random(1) > 0.5)
        {
          numPetals *= 0.5;
        }
      } else if (numPetals % 3 == 0 && numPetals > 3 && i > 0)
      {
        if (random(1) > 0.5)
        {
          numPetals /= 3;
        }
      }

      PetalCluster cluster = new PetalCluster(numPetals);
      clusters[i] = cluster;
    }
  }
}

class Petal
{
  PVector[] allVectors;
  int numNodes = 3;
  float hue, sat, bright;

  float nearRot = -360;
  float farRot = 360;

  float rotation = 0;
  float rotSpeed = 1;

  float size = 0.0;
  float targetSize = 1.0;

  float time = 0;
  float mouseRot = 0;
  float shadowRatio = 0.5;

  Petal()
  {
    hue = random(0, 255);
    sat = random(0, 255);
    bright = random(150, 255);
    numNodes = round(random(1, 10));
    nearRot = random(-360, 360);
    farRot = random(-360, 360);
    rotSpeed = random(0.1, 1.0);
    shadowRatio = random(0.3, 0.7);
    createVectors();
    mouseRot = map(mouseX, 0, width, nearRot*3, farRot*3);
  }

  void update()
  {
    time++;

    size += (targetSize - size) * 0.01;

    if (!isPaused)
    {
      rotation += rotSpeed;
    }

    mouseRot += (map(mouseX, 0, width, nearRot*3, farRot*3) - mouseRot) * 0.1;
  }

  void draw()
  {
    pushMatrix();

    scale(size);

    float rotX = map(size, 0, 1, 90, 0);
    rotateX(radians(rotX));

    rotateY(radians(rotation + mouseRot));

    fill(hue, sat, bright);
    stroke(hue, sat, bright * 0.7);
    strokeWeight(1);

    beginShape(TRIANGLE);

    curveVertex(0, 0, 0);
    curveVertex(0, 0, 0);

    fill(hue, sat, bright * shadowRatio);
    for (int i=0; i<numNodes; i++)
    {
      curveVertex(allVectors[i].x, allVectors[i].y, allVectors[i].z);
    }

    fill(hue, sat, bright);
    curveVertex(0, 0, 0);
    curveVertex(0, 0, 0);

    endShape();

    popMatrix();
  }

  void createVectors()
  {
    allVectors = new PVector[numNodes];

    for (int i=0; i<numNodes; i++)
    {
      PVector vector = new PVector(random(-200, 200), random(300), random(-200, 200));
      allVectors[i] = vector;
    }
  }
}

class PetalCluster
{
  Petal petal;
  int numPetals = 10;
  float rotationOffset = 0.01;
  float time = 0.0;

  PetalCluster(int _numPetals)
  {
    numPetals = _numPetals;
    petal = new Petal();
    rotationOffset = random(-0.1, 0.1);
    time = random(1000);
  }

  void draw()
  {
    if (!isPaused)
    {
      time++;
      time += map(mouseX, 0, width, -rotationOffset*10, rotationOffset*10);
    }
    petal.update();

    for (int i=0; i<numPetals; i++)
    {
      float step = 360.0f/numPetals;
      float rot = step * i;
      drawPetal(rot);
    }
  }

  void drawPetal(float rot)
  {
    pushMatrix();

    rotateZ(radians(rot + time*rotationOffset));
    petal.draw();

    popMatrix();
  }
}

ArrayList<Rect> allRects;

float prob = 0;

float hueRange = 0.05;
float satRange = 0.05;
float brightRange = 0.1;

float time = 0;
float drawSpacing = 1.0;
float axisSwitch = 0.5;
boolean doesDrawLines = true;
float lineSize = 0.5;
int lineType = 1;
static final int LineTypeWhite = 0;
static final int LineTypeBlack = 1;
static final int LineTypeColor = 2;

void setup()
{
  size(940, 540, P3D);
  colorMode(HSB, 1.0, 1.0, 1.0, 1.0);
  background(0.0);

  drawFractal();
}

void draw()
{
  translate(0.5, 0.5);

  time += 0.1;

  if (doesDrawLines)
  {
    switch (lineType)
    {
    case LineTypeWhite:
      stroke(1.0, 1.0);
      break;

    case LineTypeBlack:
      stroke(0.0, 1.0);
      break;

    case LineTypeColor:
      stroke(allRects.get(0).hue, allRects.get(0).sat, allRects.get(0).bright, 1.0);
      break;

    default:
      break;
    }

    strokeWeight(lineSize);
  } else
  {
    noStroke();
  }

  for (int i=0; i<allRects.size (); i++)
  {
    Rect rect = allRects.get(i);

    if (rect.isAlive)
    {
      if (time > rect.drawTrigger)
      {
        rect.draw();
        rect.lifeCounter += 1;
        if (rect.lifeCounter > 10) rect.isAlive = false;
      }
    }
  }
}

void drawRect(Rect rect)
{
  if (rect.w > 20 && rect.h > 20)
  {
    float ratio1 = random(1);
    float ratio2 = 1 - ratio1;

    float offset = 1;

    if (random(1) > axisSwitch)
    {
      Rect r1 = new Rect(rect.x, rect.y, rect.w*ratio1, rect.h, rect.hue, rect.sat, rect.bright, rect.drawTrigger+drawSpacing);
      allRects.add(r1);
      if (random(1) > prob) drawRect(r1);

      Rect r2 = new Rect(rect.x+rect.w*ratio1, rect.y, rect.w*ratio2, rect.h, rect.hue, rect.sat, rect.bright, rect.drawTrigger+drawSpacing*1.5);
      allRects.add(r2);
      if (random(1) > prob) drawRect(r2);
    } else
    {
      Rect r1 = new Rect(rect.x, rect.y, rect.w, rect.h*ratio1, rect.hue, rect.sat, rect.bright, rect.drawTrigger+drawSpacing);
      allRects.add(r1);
      if (random(1) > prob) drawRect(r1);

      Rect r2 = new Rect(rect.x, rect.y+rect.h*ratio1, rect.w, rect.h*ratio2, rect.hue, rect.sat, rect.bright, rect.drawTrigger+drawSpacing*1.5);
      allRects.add(r2);
      if (random(1) > prob) drawRect(r2);
    }
  }
}

void drawFractal()
{
  allRects = new ArrayList<Rect>();

  Rect rect = new Rect(0, 0, width, height, 1.0, 1.0, 1.0, 0);
  rect.hue = random(1);
  rect.sat = random(1);
  rect.bright = random(0.2, 1.0);
  drawRect(rect);
}

void mousePressed()
{
  background(0.0);
  axisSwitch = random(0.1, 0.9);
  time = 0;
  prob = random(0, 0.1);
  hueRange = random(0, 0.2);
  satRange = random(0, 0.2);
  brightRange = random(0, 0.3);
  drawFractal();
}

void keyPressed()
{
  if (key == 'l')
  {
    doesDrawLines = !doesDrawLines;
  }

  if (key == '=')
  {
    lineSize++;
    if (lineSize > 20) lineSize = 20;
  }

  if (key == '-')
  {
    lineSize--;
    if (lineSize < 1) lineSize = 1;
  }

  if (key == 'c')
  {
     lineType++;
    if (lineType> 2) lineType = 0; 
  }
}

class Rect
{
  float x;
  float y;
  float w;
  float h;
  float hue;
  float sat;
  float bright;
  float drawTrigger;
  boolean isAlive = true;
  int lifeCounter = 0;

  Rect(float _x, float _y, float _w, float _h, float _hue, float _sat, float _bright, float _drawTrigger)
  {
    x = _x;
    y = _y;
    w = _w;
    h = _h;

    float tempHue = _hue + random(-hueRange, hueRange);
    if (tempHue > 1.0) tempHue = 0.0;
    if (tempHue < 0.0) tempHue = 1.0;
    hue = tempHue;

    float tempSat = _sat + random(-satRange, satRange);
    sat = constrain(tempSat, 0, 1);

    float tempBright = _bright + random(-brightRange, brightRange);
    bright = constrain(tempBright, 0, 1);

    drawTrigger = _drawTrigger;
  }

  void draw()
  {
    fill(hue, sat, bright);
    rect(x, y, w, h);
  }
}

ArrayList<PVector> allVectors;

float wanderSpeed = 0.7;
int numSteps = 10; 

float lineHue = 1.0;
float lineSat = 0.0;
float lineBright = 1.0;
float colorTrigger = 0.999;

boolean autoplay = false;

void setup()
{
  size(940, 540);
  colorMode(HSB, 1.0, 1.0, 1.0, 1.0);
  background(0.0);
  noFill();

  createLine();
  randomizeColor();
}

void draw()
{
  strokeWeight(1.01);
  // randomize color if neccesary
  if (random(0, 1) > colorTrigger) randomizeColor();

  stroke(lineHue, lineSat, lineBright, 0.05);
  fill(255);

  // draw top line
  beginShape();

  for (int i=0; i<allVectors.size (); i++)
  {
    PVector vector = allVectors.get(i);
    if (i == 0) curveVertex(vector.x, vector.y);
    curveVertex(vector.x, vector.y);
    if (i == allVectors.size()-1) curveVertex(vector.x, vector.y);
  }
  endShape();

  // draw bottom line
  beginShape();
  for (int i=0; i<allVectors.size (); i++)
  {
    PVector vector = allVectors.get(i);
    if (i == 0)curveVertex(vector.x, height-vector.y);
    curveVertex(vector.x, height-vector.y);
    if (i == allVectors.size()-1) curveVertex(vector.x, height-vector.y);

    vector.x += random(-wanderSpeed, wanderSpeed);
    vector.y += random(-wanderSpeed, wanderSpeed);
    vector.y += 0.1;

    if (i == 0) vector.x = 0;
    if (i == allVectors.size()-1) vector.x = width;
  }
  endShape();

  checkAutoplay();
}

void checkAutoplay()
{
  if (autoplay)
  {
    // reset if line has left screen
    for (int i=0; i<allVectors.size (); i++)
    {
      PVector vector = allVectors.get(i);
      if (vector.y < height) return;
    }
    // reset if boundary check didn't exit functiion
    reset();
  }
}

void createLine()
{
  allVectors = new ArrayList<PVector>();

  for (int i=0; i<=numSteps; i++)
  {
    PVector vector = new PVector(i * width/numSteps, height/2);
    allVectors.add(vector);
  }
}

void randomizeColor()
{
  lineHue = random(0, 1);
  lineSat = random(0, 1);
}

void reset()
{
  background(0.0);
  createLine();
  randomizeColor();
  wanderSpeed = random(0.3, 2.0);
  numSteps = (int)random(1, 20);
  colorTrigger = random(0.99, 0.9999);
}

void mousePressed()
{
  reset();
}

void keyPressed()
{
  if (key == 'c')
  {
    randomizeColor();
  }

  if (key == 'r')
  {
    lineHue = 1.0;
    lineSat = 0.0;
    lineBright = 1.0;
  }

  if (key == 'a')
  {
    autoplay = !autoplay;
  }
}

int tileCountX = 5;
int tileCountY = 5;
float tileWidth;
float tileHeight;

int lineCountX = 10;
int lineCountY = 10;

boolean doesOscilate = false;
boolean doesTrackMouse = true;

float lineHue = 1.0;
float lineSat = 0.0;
float lineBright = 0.0;
float bgHue = 1.0;
float bgSat = 0.0;
float bgBright = 1.0;
float lineSize = 1;
float centerOffset = 0.1;

boolean doesOffsetRows = true;
boolean doesInterlaceMouse = true;

void setup()
{
  size(940, 540);
  colorMode(HSB, 1.0, 1.0, 1.0, 1.0);
  background(1.0);
  strokeWeight(1);
}

void draw()
{
  background(bgHue, bgSat, bgBright);

  tileWidth = 940 / tileCountX;
  tileHeight = 540 / tileCountY;

  float HH = tileHeight/2;
  float HW = tileWidth/2;

  for (int gridY=0; gridY<=tileCountY; gridY++)
  {
    for (int gridX=0; gridX<=tileCountX; gridX++)
    {
      pushMatrix();

      float rowOffset = 0;

      if (doesOffsetRows)
      {
        rowOffset = gridY%2 * tileWidth/2;
      }

      translate(tileWidth*gridX + rowOffset, tileHeight*gridY);

      noFill();
      stroke(lineHue, lineSat, lineBright, 0.5);

      PVector center = new PVector(0, 0);
      float offsetMag = 20;

      float mouseOffsetX = map(mouseX, 0, width, -HW, HW);
      float mouseOffsetY = map(mouseY, 0, height, -HH, HH);

      if (doesInterlaceMouse)
      {
        if (rowOffset > 0)
        {
          mouseOffsetX *= - 1;
          mouseOffsetY *= -1;
        }
      }

      if (doesTrackMouse)
      {
        center.x += mouseOffsetX * 1;
        center.y += mouseOffsetY * 1;
      }

      if (doesOscilate)
      {
        center.x += sin(gridX+millis()*0.001)*offsetMag + cos(gridY+millis()*0.0015)*offsetMag;
        center.y += cos(gridX+millis()*0.0015)*offsetMag + sin(gridY+millis()*0.001)*offsetMag;
      }

      // draw vertical lines
      for (int i=0; i<=lineCountX; i++)
      {
        float ratioPos = (float)i / (float)lineCountX;
        float xPos = map(ratioPos, 0, 1, -HW, HW);

        PVector top = new PVector(xPos, HH);
        PVector bottom = new PVector(xPos, -HH);

        line(center.x, center.y, top.x, top.y);
        line(center.x, center.y, bottom.x, bottom.y);
      }

      // draw horizontal lines
      for (int i=0; i<=lineCountY; i++)
      {
        float ratioPos = (float)i / (float)lineCountY;
        float yPos = map(ratioPos, 0, 1, -HH, HH);

        PVector left = new PVector(-HW, yPos);
        PVector right = new PVector(HW, yPos);

        line(center.x, center.y, left.x, left.y);
        line(center.x, center.y, right.x, right.y);
      }

      popMatrix();
    }
  }
}

void keyPressed()
{
  if (key == 'o')
  {
    doesOscilate = !doesOscilate;
  }

  if (key == 'm')
  {
    doesTrackMouse = !doesTrackMouse;
  }

  if (key == 'c')
  {
    lineHue = random(0, 1);
    lineSat = random(0, 1);
    lineBright = random(0, 1);
    bgHue = random(0, 1);
    bgSat = random(0, 1);
    bgBright = random(0, 1);
  }

  if (key == 'r')
  {
    lineHue = 1.0;
    lineSat = 0.0;
    lineBright = 0.0;
    bgHue = 1.0;
    bgSat = 0.0;
    bgBright = 1.0;
  }
}

void mousePressed()
{
  lineCountX = (int)random(0, 7) * 2;
  lineCountY = (int)random(0, 7) * 2;
  tileCountX = (int)random(1, 10);
  tileCountY = (int)random(1, 10);

  doesOffsetRows = true;
  if (random(1) > 0.5) doesOffsetRows = false;

  doesInterlaceMouse = true;
  if (random(1) > 0.5) doesInterlaceMouse = false;

}

Part[] allParts;
int numParts = 10;
boolean isPaused = false;

Part part;

void setup()
{
  size(940, 540);
  colorMode(HSB, 1.0, 1.0, 1.0, 1.0);
  background(0.0);
  strokeWeight(1.01);
  createParts();
}

void draw()
{ 
  updateParts();
}

void createParts()
{
  numParts = round(random(3, 10));
  allParts = new Part[numParts];

  for (int i=0; i<numParts; i++)
  {
    Part part = new Part(width/2, height/2, 0.05);
    allParts[i] = part;
  }
}

void updateParts()
{ 
  if (!isPaused)
  {
    for (int i=0; i<allParts.length; i++)
    {
      allParts[i].update();
    }
  }
}

void mousePressed()
{
  background(0);
  firstTime = true;
  createParts();
}

void keyPressed()
{
  if (key == 'c')
  {
    background(0);
  }

  if (key == 'p')
  {
    isPaused = !isPaused;
  }
}

class Part
{
  PVector pos = new PVector(0,0,0);
  PVector vel = new PVector(0,0,0);
  float size = 10;
  float scale;
  float accelMod = 0.1;
  float hue = 0.0;
  float sat = 0.0;

  Part(float _x, float _y, float _accelMod)
  {
    accelMod = _accelMod;
    pos.set(_x, _y, 0);
    vel.set(random(-1, 1), random(-1, 1), 0);
    scale = random(5, 100);
    hue = random(0, 1);
    sat = random(0, 1);
  }

  void update()
  {
    PVector accel = PVector.random3D();
    accel.mult(accelMod);
    vel.add(accel);
    vel.mult(0.995);

    pos.add(vel);     
    size += (vel.mag() * scale - size) * 0.02;
    wrap();

    noFill();
    stroke(hue, sat, 1.0, 0.05);
    ellipse(pos.x, pos.y, size, size);
  }

  void wrap()
  {
    float radius = size/2;
    float top = 0 - radius;
    float bottom = height + radius;
    float left = 0 - radius;
    float right = width + radius;

    if (pos.x > right)
    {
      pos.x = left;
    } else if (pos.x < left)
    {
      pos.x = right;
    }

    if (pos.y > bottom)
    {
      pos.y = top;
    } else if (pos.y < top)
    {
      pos.y = bottom;
    }
  }
}

  

float cellSize = 15;
Node[] nodes;
int xRes, yRes;

boolean showsFPS = false;
PFont font;

float lineSize = 10;
float perlinRes;
float mx, my;

void setup()
{
  size(940, 540);
  colorMode(HSB, 100);
  background(0);
  font = createFont("Helvetica", 24);
  createNodes();
}

void draw()
{
  background(0);
  noFill();
  stroke(100, 20);

  mx = mouseX;
  my = mouseY;
  if (mx == 0) mx = width/2;
  if (my == 0) my = height/2;
  lineSize = mx + 20;
  perlinRes = my/100000 + 0.003;
  updateNodes();
  if (showsFPS) displayFPS();
}

void createNodes()
{
  xRes = ceil(width/cellSize) + 2;
  yRes = ceil(height/cellSize) + 2;
  nodes = new Node[(xRes)*(yRes)];

  for (int i=0; i<yRes; i++)
  {
    for (int j=0; j<xRes; j++)
    {
      float cx = j*cellSize + cellSize/2;
      float cy = i*cellSize + cellSize/2;
      cx -= cellSize;
      cy -= cellSize;
      Node node = new Node(cx, cy);
      nodes[i*xRes+j] = node;
    }
  }
}

void updateNodes()
{
  float noiseScale = 0.0053;
  noiseScale = perlinRes;
  float noiseSpeed = 0.001;
  float a;
  PVector vector;

  for (int i=0; i<yRes; i++)
  {
    for (int j=0; j<xRes; j++)
    {
      Node node = nodes[i*xRes+j];
      a = noise(i*noiseScale, j*noiseScale, frameCount*noiseSpeed)*TWO_PI*4;
      vector = new PVector(cos(a), sin(a));
      node.vector = vector;
      node.update();
    }
  }
}

void displayFPS()
{
  textFont(font, 18);
  fill(100);
  String output = "fps=";
  output += (int) frameRate;
  text(output, 10, 30);
}

void keyPressed()
{
  if (key == 'f') showsFPS = !showsFPS;
}

boolean sketchFullScreen() {
  return false;
}

class Node
{
  float x, y, vx, vy;
  PVector vector;

  Node(float _x, float _y)
  {
    x = _x;
    y = _y;
    vx = 0.0;
    vy = 0.0;
  }

  void update()
  {
    vector.mult(lineSize);
    line(x, y, x+vector.x, y+vector.y);
  }

}

  

float cellWidth = 40;
float cellHeight = 10;
Node[] nodes;
int xRes, yRes;

void setup()
{
  size(940, 540);
  colorMode(HSB, 100);
  background(0);
  ellipseMode(CENTER);
  createNodes();
  noStroke();
}

void draw()
{
  updateNodes();
}

void createNodes()
{
  xRes = ceil(width/cellWidth) + 2;
  yRes = ceil(height/cellHeight) + 2;
  nodes = new Node[(xRes)*(yRes)];

  for (int i=0; i<yRes; i++)
  {
    for (int j=0; j<xRes; j++)
    {
      float cx = j*cellWidth + cellWidth/2;
      float cy = i*cellHeight + cellHeight/2;
      cx -= cellWidth;
      cy -= cellHeight;
      if (i%2 == 0) cx += cellWidth/2;
      Node node = new Node(cx, cy);
      nodes[i*xRes+j] = node;
    }
  }
}

void updateNodes()
{
  float noiseScale = 0.01;
  float noiseSpeed = 0.003;

  for (int i=0; i<yRes; i++)
  {
    for (int j=0; j<xRes; j++)
    {
      Node node = nodes[i*xRes+j];
      node.energy = noise(i*noiseScale, j*noiseScale*3, frameCount*noiseSpeed) * 2.0;
      node.setYOffset(noise(i*noiseScale*3.4, j*noiseScale*6.4, frameCount*noiseSpeed*1.33) * 2.0 - 1.0);
      node.update();
    }
  }
}

class Node
{
  float x, y;
  color c;
  float energy;
  float hue;
  float saturation;
  float brightness;
  float yOffset;
  float hueOffset;
  float osc = random(0.0, 100.0);
  float oscSpeed = random(0.003, 0.03);

  Node(float _x, float _y)
  {
    x = _x;
    y = _y;
    c = color(random(100), random(100), random(30, 100));
    saturation = random(10,80);
    brightness = random(20,80);
    hueOffset = random(-0.1, 0.1);
  }

  void update()
  { 
    osc += oscSpeed;
    saturation = (sin(osc) + 1.0) * 40 + 10;
    brightness = (sin(osc*0.6) + 1.0) * 30 + 20;

    c = color((energy+hueOffset)*100%100, saturation, brightness, 100);
    fill(c);
    noStroke();

    pushMatrix();
    translate(x, y + yOffset * 100.0);
    ellipse(x, y, cellWidth*2.1, cellHeight*5.8);
    popMatrix();
  }

  void setYOffset(float offset)
  {
    yOffset += (offset - yOffset) * 0.05;
  }

}

    

PGraphics canvas;
PGraphics auxCanvas;
float fadeSpeed = 2.0;
Chain chain;
float startX;
float startY;
float osc = 0.0;
float oscSpeed = 0.005;
boolean isPaused = false;
boolean chainIsActive = true;

void setup()
{
  size(940, 540);
  canvas = createGraphics(width, height);
  auxCanvas = createGraphics(width, height);
  startX = random(width);
  startY = random(height);
  chain = new Chain();

  canvas.beginDraw();
  canvas.background(0);
  canvas.endDraw();
  auxCanvas.beginDraw();
  auxCanvas.background(0);
  auxCanvas.endDraw();
  canvas.colorMode(HSB, 255);
  auxCanvas.colorMode(HSB, 255);
  colorMode(HSB, 255);

  smooth();
  canvas.smooth();
  auxCanvas.smooth();
}

void draw() 
{
  if (!isPaused)
  {
    osc += oscSpeed;
    float ratio = sin(osc);
    float invRatio = cos(osc);
    float offsetX = cos(osc) * 0.1;
    float offsetY = sin(osc) * 0.1;

    canvas.beginDraw();
    canvas.image(auxCanvas, 0, 0, width, height);
    if (chainIsActive) chain.update();
    canvas.endDraw();
    image(canvas, 0, 0);
    auxCanvas.beginDraw();
    auxCanvas.image(canvas, -fadeSpeed*0.5, -fadeSpeed*0.5, width+fadeSpeed, height+fadeSpeed);
    auxCanvas.endDraw();
  }
}

boolean sketchFullScreen()
{
  return false;
}

void keyPressed()
{
  if (key == 'p') isPaused = !isPaused;
  if (key == 'c') chainIsActive = !chainIsActive;
}

class Chain
{
  int numParts = 500;
  Part[] parts;
  float hue = random(TWO_PI);
  float saturation = 125;
  float brightness = 125;
  float osc = random(TWO_PI);
  float x, y, vx, vy;

  Chain()
  {
    x = startX;
    y = startY;
    vx = 0;
    vy = 0;
    createParts();
  }

  void update()
  {
    canvas.noFill();
    updateHue();

    if (mouseX == pmouseX && mouseY == pmouseY)
    {
      vx += random(-1.0, 1.0) * 1.0;
      vy += random(-1.0, 1.0) * 1.0;

      vx *= 0.99;
      vy *= 0.99;
    }
    else
    {
      vx += (mouseX - x) * 0.01;
      vy += (mouseY - y) * 0.01;

      vx *= 0.9;
      vy *= 0.9;
    }

    x += vx;
    y += vy;

    if (x > width)
    { 
      x = width;
      vx *= -1;
    }
    if (x < 0)
    { 
      x = 0;
      vx *= -1;
    }
    if (y > height) 
    { 
      y = height;
      vy *= -1;
    }
    if (y < 0) 
    { 
      y = 0;
      vy *= -1;
    }

    updateParts();
  }

  void updateParts()
  {
    for (int i=0; i<numParts; i++)
    {
      parts[i].update();
    }
  }

  void createParts()
  {
    parts = new Part[numParts];

    for (int i=0; i<numParts; i++)
    {
      Part part = new Part();
      if (i > 0) part.leader = parts[i-1];
      part.hueOffset = i * (255/6/numParts);
      parts[i] = part;
    }
  }

  void updateHue()
  {
    osc += 0.003;
    hue += 0.1;
    hue = hue % 255;
    saturation = (sin(osc)/2 + 0.5) * 255;
    brightness = (sin(osc*0.3)/2 + 0.5) * 255;
  }
}

class Part
{
  float x, y, vx, vy;
  Part leader = null;
  float spring = 0.2;
  float friction = 0.56;
  float hueOffset = 0.0;
  float hue = 0.0;

  Part()
  {
    x = startX;
    y = startY;
    vx = 0.0;
    vy = 0.0;
  }

  void update()
  {
    if (leader == null)
    {
      vx += (chain.x - x) * spring;
      vy += (chain.y - y) * spring;
    }
    else
    {
      vx += (leader.x - x) * spring;
      vy += (leader.y - y) * spring;
    }

    vx *= friction;
    vy *= friction;

    x += vx;
    y += vy;

    if (leader != null)
    {
      hue = (chain.hue + hueOffset) % 255;
      canvas.stroke(hue, chain.saturation, chain.brightness, 255);
      canvas.line(x, y, leader.x, leader.y);
    }
  }
}

boolean showsFPS = false;
boolean showsField = false;
PFont font;

float gridSize = 70;
int xRes, yRes;
Node[] nodes;

int numParts = 3000;
Part[] parts;

void setup()
{
  size(940, 540);
  background(255);
  noStroke();
  rectMode(CENTER);
  ellipseMode(CENTER);
  createField();
  createParts();
  font = createFont("Helvetica", 24);
}

void draw()
{
  fill(0, 15);
  noStroke();
  rect(width/2, height/2, width, height);
  updateField();
  updateParts();
  if (showsFPS) displayFPS();
}

void scatter()
{
  for (int i=0; i<numParts; i++)
  {
    Part part = parts[i];   
    part.vx += random(-1.0, 1.0) * 50.5;
    part.vy += random(-1.0, 1.0) * 50.5;
  }
}

void displayFPS()
{
  textFont(font, 18);
  fill(255);
  String output = "fps=";
  output += (int) frameRate;
  text(output, 10, 30);
}

void updateField()
{
  for (int i=0; i<yRes; i++)
  {
    for (int j=0; j<xRes; j++)
    {
      Node node = nodes[i*xRes+j];
      float noiseScale = 0.1;
      float a = noise(i*noiseScale,j*noiseScale, frameCount*0.003)*TWO_PI*2;
      PVector vector = new PVector(cos(a), sin(a));
      node.vector = vector;
      if (showsField) node.render();
    }
  }
}

void updateParts()
{
  noFill();
  stroke(255, 70);

  for (int i=0; i<numParts; i++)
  {
    Part part = parts[i];

    int xPos = floor(part.x/gridSize);
    int yPos = floor(part.y/gridSize);
    int currentIndex = yPos*xRes + xPos;

    part.vx += nodes[currentIndex].vector.x * 0.7;
    part.vy += nodes[currentIndex].vector.y * 0.7;

    part.vx += random(-1.0, 1.0) * 0.5;
    part.vy += random(-1.0, 1.0) * 0.5;

    part.update();
    part.render();
  }
}

void createField()
{
  xRes = ceil(width/gridSize);
  yRes = ceil(height/gridSize);
  nodes = new Node[xRes*yRes];

  for (int i=0; i<yRes; i++)
  {
    for (int j=0; j<xRes; j++)
    {
      float noiseScale = 0.1;
      float a = noise(i*noiseScale,j*noiseScale)*TWO_PI;
      PVector vector = new PVector(cos(a), sin(a));

      float cx = j*gridSize + gridSize/2;
      float cy = i*gridSize + gridSize/2;
      PVector center = new PVector(cx, cy);
      Node node = new Node(vector, center);
      nodes[i*xRes+j] = node;
    }
  }
}

void createParts()
{
  parts = new Part[numParts];
  for (int i=0; i<numParts; i++)
  {
    Part part = new Part(random(width), random(height));
    parts[i] = part;
  }
}

void keyPressed()
{
  if (key == 'f') showsFPS = !showsFPS;
  if (key == 'g') showsField = !showsField;
}

boolean sketchFullScreen() 
{
  return false;
}

class Node
{
  PVector vector;
  PVector center;
  color randColor;

  Node(PVector v, PVector c)
  {
    vector = v;
    center = c;
    selectNewColor();
  }

  void update()
  {
  }

  void render()
  {
    noStroke();
    fill(randColor);
    rect(center.x, center.y, gridSize, gridSize);
    PVector renderVector = vector.get();
    renderVector.mult(gridSize/2);
    stroke(150);
    line(center.x, center.y, center.x+renderVector.x, center.y+renderVector.y);
  }

  void selectNewColor()
  {
    randColor = color(random(255), random(255), random(255), 40);
  }

}

class Part
{
  float x, y, vx, vy, px, py;

  Part(float _x, float _y)
  {
    x = px = _x;
    y = py = _y;
    vx = 0.0;
    vy = 0.0;
  }

  void update()
  {
    px = x;
    py = y;

    vx *= 0.95;
    vy *= 0.95;

    x += vx;
    y += vy;

    wrap();
  }

  void wrap()
  {
    if (x > width) x = px = 0;
    if (x < 0) x = px = width;

    if (y > height) y = py = 0;
    if (y < 0) y = py = height;
  }

  void render()
  {
    line(x, y, px, py);
  }
}

  

float cellSize = 50;
Node[] nodes;
int xRes, yRes;

float currentHue = 0.0;

void setup()
{
  size(940, 540);
  colorMode(HSB, 100);
  background(0);
  ellipseMode(CENTER);
  rectMode(CENTER);
  createNodes();
}

void draw()
{
  background(0);
  currentHue += 0.01;
  currentHue = currentHue%100;
  updateNodes();
}

void createNodes()
{
  xRes = ceil(width/cellSize) + 2;
  yRes = ceil(height/cellSize) + 2;
  nodes = new Node[(xRes)*(yRes)];

  for (int i=0; i<yRes; i++)
  {
    for (int j=0; j<xRes; j++)
    {
      float cx = j*cellSize + cellSize/2;
      float cy = i*cellSize + cellSize/2;
      cx -= cellSize;
      cy -= cellSize;
      Node node = new Node(cx, cy);
      nodes[i*xRes+j] = node;
    }
  }
}

void updateNodes()
{
  float noiseScale = 0.01;
  for (int i=0; i<yRes; i++)
  {
    for (int j=0; j<xRes; j++)
    {
      Node node = nodes[i*xRes+j];
      node.setEnergy(noise(i*noiseScale, j*noiseScale, frameCount*0.0008));
      node.update();
    }
  }
}

class Node
{
  float x, y, energy, ve;
  float size = 300;
  float rotation;

  Node(float _x, float _y)
  {
    x = _x;
    y = _y;
    energy = 0.5;
    ve = 0.0;
    rotation = PI / 4;
  }

  void update()
  {
    float edgeSoftness = 50;
    noStroke();
    fill(energy*400%100, 100, 100, 30);
    pushMatrix();
    translate(x, y);
    rotate(energy*TWO_PI*4);
    rect(0, 0, cellSize*2, cellSize*2);
    popMatrix();
  }

  void setEnergy(float e)
  {
    float de = e - energy;
    ve += de * 0.001;
    ve *= 0.95;
    energy += ve;
  }
}

  

Box[] allBoxes;
int numBoxes = 100;

float currentHue;
float hueStep = 0.5;
float xOffset;

void setup()
{
  size(940, 540);

  colorMode(HSB, 360, 1.0, 1.0, 1.0);
  background(360);
  currentHue = random(360.0);
  allBoxes = new Box[numBoxes];
  createBoxes();
  noStroke();

  xOffset = 0.0;
}

void draw()
{
  //  background(360);

  //  xOffset = (mouseX - width/2) * 0.002;
  xOffset = 0;

  for (int i=0; i<allBoxes.length; i++)
  {
    allBoxes[i].update();
  }
}

void createBoxes()
{
  for (int i=0; i<numBoxes; i++)
  {
    Box box = new Box();
    allBoxes[i] = box;
  }
}

float getNewHue()
{
  currentHue += hueStep;
  if (currentHue >= 360.0) currentHue = 0.0;
  return currentHue;
}

boolean sketchFullScreen() {
  return false;
}
class Box
{
  float x, y, ww, hh;
  float h, s, v;
  float speed;
  float size = 400;

  Box()
  {
    reset();
    y = random(height);
  }

  void update()
  {
    y -= speed;
    x -= (xOffset*v);
    fill(h, s, v, 0.05);
    rect(x, y, ww, hh);

    wrap();
  }

  void wrap()
  {
    if (y+hh < 0)
    {
      reset();
    }

    if (x > width)
    {
      x = 0-ww;
    }

    if (x < 0-ww)
    {
      x = width;
    }
  }

  void reset()
  {    
    x = random(width+size)-size/2;
    y = height;
    ww = random(size);
    hh = random(size);
    h = getNewHue();
    s = random(1.0);
    v = random(1.0);
    speed = random(0.2, 1.0);
  }
}