//import traer.physics.*;
import SoniaHelper.*;
import pitaru.sonia_v2_9.*;
import processing.opengl.*;
//import javax.media.opengl.*;

class Circle
{
  Circle()
  {
  }
  
  float x, y;
  float ox, oy;
  float size;
  float distance;
  int partnerIdx;
  int repelIdx;
  boolean connect;
}

int spectrumLength=2048; // Needs to be power of 2
int bandsteps;
float maxdist,damperval;
SoniaHelper ffthelper;

int numCircles = 700;
Circle[] circles;

int numRepels = 2;
vec3[] repelPos;

PGraphicsOpenGL pgl;
GL opengl;
//GLU glu;

//ParticleSystem physics;
//Particle last;

CG cg;

void setup()
{
  size( 800, 600, OPENGL );
  
  // if enabled the screen will clear
  hint( ENABLE_OPENGL_4X_SMOOTH );
  smooth();

  ///////////////////////////////////////////////////////////
  // Start sonia sound library
  ///////////////////////////////////////////////////////////

  Sonia.start(this);

  // line input set up
  LiveInput.start(spectrumLength);
  LiveInput.useEnvelope( true, 2.4f );
//  LiveInput.useEqualizer( true );  

  // SoniaHelper( int _n, int _nbands,boolean doAvg )
  ffthelper=new SoniaHelper( spectrumLength, 256, false );
  ffthelper.setMaxLimits( 200, 2000 );
  damperval=0.5f;
  ffthelper.setDamper( damperval );

  repelPos = new vec3[numRepels];
  repelPos[0] = new vec3( width/2, 0, 0 );
  repelPos[1] = new vec3( 0, height/2, 0 );
  
  int i;  
  circles = new Circle[numCircles];
  randomSeed( 888 );
  for( i=0; i<numCircles; i++ )
  {
    circles[i] = new Circle();
    
    circles[i].x = round( random(width) );
    circles[i].y = round( random(height) );
    circles[i].ox = circles[i].x;
    circles[i].oy = circles[i].y;
    circles[i].size = random(54)+6;
    circles[i].partnerIdx = (int)random(numCircles);
    circles[i].repelIdx = 0;
    circles[i].connect = false;
    circles[i].distance = 0;
  }  
  ellipseMode( CENTER );
  rectMode( CENTER );
  
//  physics = new ParticleSystem( 0, 0.001 );
 
  // access opengl
  pgl = (PGraphicsOpenGL) g; 
  opengl = pgl.gl;
  
  noCursor();
  noStroke();
  opengl.glEnable( GL.GL_BLEND );
  opengl.glDisable( GL.GL_DEPTH_TEST );
  opengl.glBlendFunc( GL.GL_SRC_ALPHA, GL.GL_ONE );  
  
/*  cg = new CG();
  cg.loadVertexShader("vshader.vert"); 
  cg.loadFragmentShader("pshader.frag"); 
  cg.useShaders();*/
  
  strokeWeight( 1 );

  background( 0 );
}

void draw()
{
  float time = millis() * 0.001;
  int i;
  
  // get spectrum data  
  LiveInput.getSpectrum();
  ffthelper.update( LiveInput.spectrum );
  
  background( 0 );
/*  //fade background 
  fill( 0, 14 ); 
  noStroke(); 
  rect( 0, 0, width*2, height*2 );*/

  //stuff unrelated to drawing... 
  //draw initial stuff that doens't need the shader. 
//  cg.startShader(); 
   
/*  // Cg programs need the OpenGL modelview projection matrix. 
  CgGL.cgGLSetStateMatrixParameter( cg.getVertParameter("ModelViewProj"), 
          CgGL.CG_GL_MODELVIEW_PROJECTION_MATRIX, 
          CgGL.CG_GL_MATRIX_IDENTITY );  */
            
/*  //
  // draw particles
  //
  for( i=0; i<5; i++ )
  {
    Particle p = physics.makeParticle( 1.0f, repelPos.x, repelPos.y, 0 );
    p.setVelocity( random(-1, 2), random(-1, 1), 0 );
    if ( last != null )
      physics.makeSpring( p, last, 0.1f, 0.1f, 10 );
    last = p;
  }
  physics.tick();

  noStroke();
  for( i=0; i<physics.numberOfParticles(); ++i )
  {
    Particle p = physics.getParticle( i );
    fill( 255, 255/(p.age()+1) );
    ellipse( p.position().x(), p.position().y(), 40, 40 );
    if ( p.age() > 196 )
      p.kill();
  }*/

  //
  // compute repulsion force
  //
  repulseForce();

  //
  // draw each particle and connecting lines
  //
  fill( 255 );
  for( i=0; i<numCircles; i++ )
  {
    float size = circles[i].size; //random(4)+6;
   
/*    if( circles[i].connect )// && i%5 == 0 )
    {
      int idx = circles[i].repelIdx; //partnerIdx;
      beginShape( LINES );
      stroke( 0 );
      vertex( repelPos[idx].x, repelPos[idx].y );
      //stroke( 255, 0, 0, circles[i].distance );
      vertex( circles[i].x, circles[i].y );
      endShape();
      //stroke( 0, 104 );
      //line( circles[i].x, circles[i].y, repelPos.x, repelPos.y );//circles[idx].x, circles[idx].y );
      noStroke();
    }*/
    
    //fill( 1+size, circles[i].x*5, circles[i].y, 255 );   
    
    float freq = (pow(ffthelper.band[i%255],2))*100000;
    //fill( 255, 0, 0, circles[i].distance );
    
    if( i%10 == 0 )
      fill( 255, 255, 255, (circles[i].distance*0.25)+freq );
    else
      fill( 255, 0, 0, (circles[i].distance*0.25)+freq );
    
    //fill( 600-circles[i].distance, circles[i].x*0.3, 500-circles[i].distance, 500-circles[i].distance );
    ellipse( circles[i].x, circles[i].y, size, size );    

    fill( 0 );//, circles[i].distance-freq );
    ellipse( circles[i].x, circles[i].y, size*0.3, size*0.3 );
  }

  fill( 255 );//, 0, 0, 255 );
  float rSize = pow(ffthelper.band[64],2)*200;
  
  pushMatrix();
  translate( repelPos[0].x, repelPos[0].y, 0 );
  //rotateZ( time*.1 );
  ellipse( 0, 0, 30+rSize, 30+rSize );
  popMatrix();

  pushMatrix();
  translate( repelPos[1].x, repelPos[1].y, 0 );
  //rotateZ( time*.3 );
  ellipse( 0, 0, 30+rSize, 30+rSize );
  popMatrix();
  
//  cg.endShader();  
  
//  println( frameRate );
}

void repulseForce()
{
  int i;
  float ox, oy;
  float distance;
  
    repelPos[1].x += (pow(ffthelper.band[64],2))*10000;
    repelPos[1].y = 250+sin(pow(ffthelper.band[36],2))*150000; 
    repelPos[0].x = 250+sin(pow(ffthelper.band[36],2))*150000;
    repelPos[0].y += (pow(ffthelper.band[64],2))*10000; 
  
    for( i=0; i<numRepels; i++ )
    {
      if( repelPos[i].x < -10 ) repelPos[i].x = width+10;
      if( repelPos[i].x > width+10 ) repelPos[i].x = -10;
      if( repelPos[i].y < -10 ) repelPos[i].y = height;
      if( repelPos[i].y > height ) repelPos[i].y = -10;
    }
      
  for( int j=0; j<numRepels; j++ )
  {
    
   float rx = repelPos[j].x;
   float ry = repelPos[j].y;
    
  for( i=0; i<numCircles; i++ )
  {
    float x = circles[i].x;
    float y = circles[i].y;    
    ox = circles[i].ox;
    oy = circles[i].oy;

    float angle = atan2( y-ry, x-rx );
        
    //circles[i].distance = ( pow(rx-x,2) + pow(ry-y,2) ) * 0.01;
    circles[i].distance = sqrt( sq(rx-x) + sq(ry-y) );
    float repulsion = 2000.0f / circles[i].distance;
    
    if( circles[i].distance < 150 )
    {
      circles[i].connect = true;
      circles[i].repelIdx = j;
    }
    else
    {
      circles[i].connect = false;
    }
      
    circles[i].x += repulsion * cos(angle) + (ox-x) * 0.1;
    circles[i].y += repulsion * sin(angle) + (oy-y) * 0.1;

//    circles[i].size += (repulsion * sin(angle) + (oy-y) * 0.01);
//    float rad = 20;
//    if( circles[i].size > rad ) circles[i].size = rad;
//    if( circles[i].size < -rad ) circles[i].size = -rad;
  }
  }
}

void keyPressed()
{
  if( key == 's' )
  {
    saveFrame( "frame.tga" );
  }
}
    
void stop()
{
  super.stop();
}