/**
 * Esfera. 
 * David Pena.  
 * 
 * Distribucion aleatoria uniforme sobre la superficie de una esfera.
 *
 * Modifications by subpixel:
 *  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
 */


import processing.opengl.*;

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

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

int NUM_HAIRS = 1200;  // 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;

float FRAME = 0;  // Current frame number

Oscillator OSC_INNER;  // Oscillator for inner sphere
Oscillator OSC_OUTER;  // Oscillator for outer sphere (base of hairs)
Oscillator OSC_COUNT;  // Oscillator for number of hairs to display

// ------------------------------------------------------------
// Main setup method.
// ------------------------------------------------------------
void setup()
{
  size(640, 480, OPENGL);  // Set the canvas size, and use OpenGL rendering
  
  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...
  {
    HAIRS[i] = new Hair();  // Create a new hair object and save it in the array
  }

  OSC_INNER = new Oscillator(0.9 * BASE_RADIUS, 0.2 * BASE_RADIUS, 0.11);
  OSC_OUTER = new Oscillator(1.2 * BASE_RADIUS, 0.2 * BASE_RADIUS, 0.05);
  OSC_COUNT = new Oscillator(NUM_HAIRS * 0.5, NUM_HAIRS * 0.5, 0.01);

  noiseDetail(3);
}

// ------------------------------------------------------------
// Main draw method.
// ------------------------------------------------------------
void draw()
{
  FRAME++;  // Increase frame counter
  OSC_INNER.tick();
  OSC_OUTER.tick();
  OSC_COUNT.tick();
  
  background(0);
  translate(width/2,height/2);  // 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 );

  OSC_INNER._phaseStep = ( OSC_INNER._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); // Black...
  noStroke(); // No outline...
  
  //sphere(sphereRadius);  // Draw the sphere (to occlude hairs on the side away from the viewpoint)

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

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

// ------------------------------------------------------------
// Class for an individual hair.
// ------------------------------------------------------------
class Hair
{
  // MEMBER VARIABLES

  // The location of the base of the hair (or at least the angles from the centre of the sphere)
  // is fixed at the creation of the hair object instance.
  // Use different methods to choose angles phi and theta, since using
  // random(TWO_PI) for both tends to make the distribution of hairs clumpy.
  float phi = random(TWO_PI);  // Any angle in 360 degrees
  float theta = asin( random(-BASE_RADIUS,BASE_RADIUS) / BASE_RADIUS );

  // The length of the hair is fixed at the creation of the hair object instance.
  float hairLength = random(MIN_HAIR_LENGTH, MAX_HAIR_LENGTH);

  // METHODS
  
  // The draw method for the hair.
  void draw() { draw(0); }
  
  void draw(float baseOffset){
    // Calculate the position of the base of the hair on the sphere
    float r = OSC_OUTER.value() + baseOffset;
    float rct = r * cos(theta);
    float x = rct * cos(phi);
    float y = rct * sin(phi);
    float z = r * sin(theta);
    
    // Determine some offset angle(s) for the end of the hair
    float off  = ( noise( millis() * 0.0005, sin(phi)     ) - 0.5 ) * PI;
    float offb = ( noise( millis() * 0.0007, sin(z) * 0.01) - 0.5 ) * PI;
    
    float thetaff = theta + off;
    float phff = phi + offb;
    
    // Calculate the position of the end of the hair (which will be the hairLength from the base of the hair)
    float x1 = x + hairLength * cos(thetaff) * cos(phff);
    float y1 = y + hairLength * cos(thetaff) * sin(phff);
    float z1 = z + hairLength * sin(thetaff);
    
    beginShape(LINES);
    stroke(0);  // No stroke when locating to the base of the hair
    vertex(x, y, z);  // The base of the hair
    stroke(200, 150);
    vertex(x1, y1, z1);  // The tip of the hair
    endShape();
  }
}

// ------------------------------------------------------------
// 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;
  }
}


// ------------------------------------------------------------
// Class for a basic sine wave oscillator.
// Initialise with median value, amplitude, phaseStepAmount (and optionally phaseOffset)
// Synchronise by calling tick().
// Retrieve current output value via value().
// ------------------------------------------------------------
class Oscillator
{
  float _phase;
  float _phaseStep;
  float _median;
  float _amplitude;

  // Constructor requiring only median, amplitude and phase step amount  
  Oscillator(float medianValue, float amplitude, float phaseStepAmount)
  {
    this(medianValue, amplitude, phaseStepAmount, 0);
  }    
  
  // Constructor  median, amplitude, phase step amount and phase offset
  Oscillator(float medianValue, float amplitude, float phaseStepAmount, float phaseOffset)
  {
    _phase = phaseOffset;
    _phaseStep = phaseStepAmount;
    _median = medianValue;
    _amplitude = amplitude * 0.5;
  }    

  // Advance the phase for the next timeslice/iteration/what-have-you
  void tick()
  {
    _phase += _phaseStep;
  }
 
  // Retrieve the current output value for the oscillator 
  float value()
  {
    return _median + _amplitude * sin( _phase );
  }
}