/**
 * Esfera. 
 * David Pena.  
 * 
 * Distribucion aleatoria uniforme sobre la superficie de una esfera.
 *
 * Modifications by subpixel (v3)
 */

/*
 * Modifications by subpixel:
 * v1:
 *  removal of unused global arrays;
 *  calculate end point of a hair as the hairLength distance from the hair base, not as a point at a fixed distance from the centre of the sphere (which causes hairs to stretch);
 *  reverse Ymouse reactivity so ball spins in the direction of mouse movement instead of against it;
 *  added start/pause functionality on mouse click event
 * v2: 2008-11-09
 *  renamed/repurposed some identifiers
 *    Globals: cuantos -> NUM_HAIRS, lista[] -> HAIRS[], radio -> BASE_RADIUS,
 *     hairmin/max -> MIN/MAX_HAIR_LENGTH, rx/ry -> RX/RY
 *    class pelo -> class Hair
 *      dibujar() -> draw()
 *  new class Oscillator
 *  Oscillator introduced for the radius of the inner sphere, the base of the "outer sphere" (the hairs),
 *    and also the number of hairs displayed.
 *  The inner sphere is now red so you can see it
 *  Moving the mouse increases the "heart rate" of the inner sphere (which gradually slows down)
 *  Moving the mouse also increases the base radius of the outer sphere based on the speed
 * v3: 2008-11-17
 *  Extracted class Hair and class Oscillator to separate files.
 *  Removed redundant FRAME variable (can use global frameCount if necessary)
 *  Added some keyboard controls.
 *    [up]/[down] control outer sphere osciallation step
 *    [z] toggles pause for inner sphere oscillator
 *    [x] toggles pause for outer sphere oscillator
 *    [c] toggles pause for hair count osciallator
 *  Added some 3D text
 *  Added some snaking tentacles; three new osciallators control parameters.
 */

import processing.opengl.*;

// ------------------------------------------------------------
// Global variables
// ------------------------------------------------------------

boolean looping = false; // Opening state of the sketch. Set true to open un-paused.

int FRAME_RATE = 30;

int NUM_HAIRS = 800;  // Number of hairs
Hair[] HAIRS;  // Array/list of hairs
float BASE_RADIUS;  // Radius of the sphere
float MIN_HAIR_LENGTH;  // Minimum hair length
float MAX_HAIR_LENGTH;  // Maximum hair length
float RX = 0;
float RY = 0;

Oscillator innerOscillator;  // Oscillator for inner sphere
Oscillator outerOscillator;  // Oscillator for outer sphere (base of hairs)
Oscillator countOscillator;  // Oscillator for number of hairs to display

Oscillator to1;
Oscillator to2;
Oscillator to3;

PFont font;

void init()
{
//E  frame.setUndecorated(true);
  super.init();
}

// ------------------------------------------------------------
// Main setup method.
// ------------------------------------------------------------
void setup()
{
  size(640, 480, OPENGL);  // Set the canvas size, and use OpenGL rendering
  frameRate(FRAME_RATE);

  if (!looping) noLoop();  // Opportunity to open the sketch in a paused state

  BASE_RADIUS = height/4;  // The central sphere is half the window height (radius therefore 1/4 window height)
  MIN_HAIR_LENGTH = BASE_RADIUS * 0.1;  // Minimum hair length set proportionally to the sphere radius
  MAX_HAIR_LENGTH = BASE_RADIUS * 0.4;  // Maximum hair length ser proportionally to the sphere radius

  HAIRS = new Hair[NUM_HAIRS];  // Initialise the array for the number of hairs

  for (int i=0; i<NUM_HAIRS; i++)  // For each hair...
  {
    float phi = random(TWO_PI);  // Any angle in 360 degrees
    float theta = asin( random(-BASE_RADIUS,BASE_RADIUS) / BASE_RADIUS );
    float hairLength = random(MIN_HAIR_LENGTH, MAX_HAIR_LENGTH);

    HAIRS[i] = new Hair(phi, theta, hairLength);  // Create a new hair object and save it in the array
  }

  innerOscillator = new Oscillator(0.9 * BASE_RADIUS, 0.2 * BASE_RADIUS, 0.11);
  outerOscillator = new Oscillator(1.2 * BASE_RADIUS, 0.2 * BASE_RADIUS, 0.05);
  countOscillator = new Oscillator(0.5 * NUM_HAIRS,   0.5 * NUM_HAIRS,   0.01);
  
  to1 = new Oscillator(0,   PI/12, TWO_PI / FRAME_RATE / 5);
  to2 = new Oscillator(0,   PI/12, TWO_PI / FRAME_RATE / 7, PI/4);
  to3 = new Oscillator(0.9, 0.15,  TWO_PI / FRAME_RATE / 9, -PI/3);

  noiseDetail(3);

  font = loadFont("BroadwayBT-Regular-48.vlw");
  textFont(font);
}

// ------------------------------------------------------------
// Main draw method.
// ------------------------------------------------------------
void draw()
{
  innerOscillator.tick();
  outerOscillator.tick();
  countOscillator.tick();

  to1.tick();
  to2.tick();
  to3.tick();

  background(0);
  translate(width/2, height/2, -width/4);  // Position the coordinate origin at the centre of the window

  // Ease towards current mouse "position" (orientation determined by mouse position)... "step 10% of the current difference each frame

  float rxp = ((mouseX-(width/2))*0.005);
  float ryp = (((height/2)-mouseY)*0.005);

  float dx = rxp - RX;
  float dy = ryp - RY;
  float dist = sqrt( dx * dx + dy * dy );

  innerOscillator.phaseStep = ( innerOscillator.phaseStep + dist * 0.002 ) * 0.998;

  RX = (RX*0.9)+(rxp*0.1);
  RY = (RY*0.9)+(ryp*0.1);
  rotateY(RX);
  rotateX(RY);

  fill(64, 0, 0); // 25% Red...
  noStroke(); // No outline...

  //sphere(sphereRadius);  // Draw the sphere (to occlude hairs on the side away from the viewpoint)

  sphere( innerOscillator.value() );  // Draw the sphere (to occlude hairs on the side away from the viewpoint)

  int displayHairs = round(countOscillator.value());

  for (int i=0; i < displayHairs; i++)  // For each hair...
  {
    HAIRS[i].draw( dist * 40 );  // Calculate and draw the hair
  }

  for (float angle = 0; angle <= TWO_PI; angle += TWO_PI / 8)
  {
    pushMatrix();  // Remember base matrix of the sphere so we can come back for the next text/tentacle
    
    // Add the word "Hello" sticking out from the edge of the sphere.
    // Tilt it towards the "front" a bit so it is kine of like a flower.
    
    pushMatrix();  // Remember state so we can go back and insert a tentacle
    
    rotateZ(angle);
    translate(innerOscillator.value(), 0, 0);
    rotateY(-PI/6);
    fill(0, 102, 153);
    textAlign(LEFT);
    text("Hello", 0, 24, 0);

    popMatrix();

    // Add a tentacle made up of a sequence of relatively sized/positioned/oriented boxes
    
    rotateZ(angle + TWO_PI/16);
    translate(innerOscillator.value(), 0, 0);

    float opacity = 200;
    for (int j = 0; j < 15; j++)
    {
      translate(20, 0, 0);   // Move along a bit
      rotateZ(to1.value());  // Turn a bit
      rotateX(to2.value());  // Twist a bit
      scale(to3.value());  // Scale each segment relative to the last (may be bigger or smaller depending on oscialltor)
      fill(200, 200, 0, opacity);
      noStroke(); // No outline...
      box(40);
      opacity *= 0.7;  // Make each segment less opaque than the last
    }
    
    popMatrix();  // Go back to base matrix of the sphere for the next text/tentacle
  }
}

// ------------------------------------------------------------
// Start / stop (pause) the main loop each time a mouse
// button is pressed.
// Added by subpixel to get a closer look at the details
// without having to take a screenshot, and also to
// give the user a chance to kill the CPU / GPU load on
// their machine if/when the applet is embedded on a page
// and the user no longer cares for the animation.
// ------------------------------------------------------------
void mousePressed()
{
  if (looping)
  {
    // Pause the main loop
    noLoop();
    looping = false;
  }
  else
  {
    // (Re-)start the main loop
    loop();
    looping = true;
  }
}

// ------------------------------------------------------------
// Handle keyboard input
// ------------------------------------------------------------
void keyPressed()
{
  if (key == CODED)
  {
    if      (keyCode == UP)    outerOscillator.phaseStep += 0.01;
    else if (keyCode == DOWN)  outerOscillator.phaseStep -= 0.01;
  }
  else if (key == 'z')
  {
    innerOscillator.togglePause();
  }
  else if (key == 'x')
  {
    outerOscillator.togglePause();
  }
  else if (key == 'c')
  {
    countOscillator.togglePause  ();
  }
}