//
//
//
//
//


// applet size variables
int xSize           = 400;
int ySize           = 400;
int xMid            = xSize/2;
int yMid            = ySize/2;

// gravity variables
int xGrav           = 0;
int yGrav           = 0;
int zGrav           = 0;
float gxv;
float gyv;
float gzv;
float gravity       = 0.1;

// camera variables
float xMouse, yMouse;
float rotationVar;
float elevation, azimuth, twist, distance;

int totalParticles  = 0;
int maxParticles    = 720;
Particle[] particle;

BImage myField;

boolean gravLines = false;
boolean connections = false;
boolean orbs = true;
boolean axis = false;

int counter = 0;

void setup(){
  size(xSize, ySize);
  //smooth();

  background(255);
  colorMode(RGB,255);
  
  elevation = radians(15.0f);
  azimuth = radians(0.0f);
  distance = 150.0f;
  
  myField = loadImage("field.gif");
  brightToAlpha(myField);
  particle  = new Particle[maxParticles];
}

void loop(){
  background(205,212,215);
  doCamera();
  
  if (mousePressed && counter == 0 && totalParticles < maxParticles - 1){
    particle[totalParticles] = new Particle(mouseX - xMid, mouseY - yMid, sin(totalParticles/4.0) * 20.0, totalParticles, 1.0);
    totalParticles ++;
    counter ++;
  }

  if (mouseX != pmouseX && mouseY != pmouseY){
    counter = 0;
  }

  for (int i=0; i<totalParticles; i++){
    particle[i].field();
  }
  for (int i=0; i<totalParticles; i++){
    particle[i].applyGravity();
  }
  for (int i=0; i<totalParticles; i++){
    particle[i].move();
  }
  if (orbs){
    for (int i=0; i<totalParticles; i++){
      particle[i].render();
    }
  }
  if (axis){
    stroke(150);
    line(0,0,-50,0,0,50);
  }
  
  //saveFrame("screenGrabs/magnets3D-####.tif");
}


void doCamera(){
  distance      = 100.0 + (totalParticles * 0.25);
  xMouse       -= (xMouse - (xMid - mouseX)) * .2f;
  yMouse       -= (yMouse - (yMid - mouseY)) * .2f;
  //xMouse += 3.2;
  //yMouse += 7.5;
  beginCamera();
  perspective(60.0f, (float)xSize / (float)ySize, 1.0f, 500);
  translate(0, 0, -distance);
  twist         = radians(xMouse / 2.0f);
  elevation     = radians(yMouse / 2.0f);
  
  rotateY(-twist);
  rotateX(elevation);
  rotateZ(-azimuth);
  endCamera();
}

void keyReleased(){
 if (key == 'o' || key == 'O'){
   if (orbs){
     orbs = false;
   } else {
     orbs = true;
   }
 } else if (key == 'g' || key == 'G'){
   if (gravLines){
     gravLines = false;
   } else {
     gravLines = true;
   }
 } else if (key == 'l' || key == 'L'){
   if (connections){
     connections = false;
   } else {
     connections = true;
   }
 } else if (key == 'a' || key == 'A'){
   if (axis){
     axis = false;
   } else {
     axis = true;
   }
 }
}


void mouseReleased(){
  counter = 0;
}

class Particle {
  int index;                // particle ID
  
  float x;                  // x position of particle
  float y;                  // y position of particle
  float z;                  // z position of particle
  
  float xv;                 // x velocity of particle
  float yv;                 // y velocity of particle
  float zv;                 // z velocity of particle

  float damp = 0.96;
  
  float E;                  // energy
  float tempR;              // xy distance
  float R;                  // total distance
  float F;                  // force
  float P;                  // Pauli force
  float A;                  // accel
  float Angle;              // xy angle to field center
  float ZAngle;             // z angle to field center
  float Q;                  // charge
  float M;                  // mass

  float zDepth;
  
  float gAngle;
  float gDist;
  float gZAngle;

  int totalConnections;
  int[] connected;
  
  float mySize;
  
  Particle(float xSent, float ySent, float zSent, int sentIndex, float sentQ){
    x         = xSent;
    y         = ySent;
    z         = zSent;

    index     = sentIndex;
    
    M         = 1.0;
    Q         = sentQ;
    
    connected = new int[100];
  }
  
  void field(){
    totalConnections = 0;
    for (int i=0; i<totalParticles; i++){
      if (i != index){
        tempR         = findDistance(x, y, particle[i].x, particle[i].y);
        R             = findDistance(x, y, z, particle[i].x, particle[i].y, particle[i].z);
        E             = constrain((particle[i].Q/(R * R)), -0.01, 0.01);
        
      //Having trouble implementing the Pauli Exclusion force.
      //Tends to shoot particles off into distant space
      //P             = abs(Q) * abs(particle[i].Q) / pow(R,12);
      //F             = (Q * E) + P;
      
        F             = (Q * E);
        A             = (F/M) * 5.0;
        Angle         = findAngle(x, y, particle[i].x, particle[i].y);

        xv           += cos(Angle) * A;
        yv           += sin(Angle) * A;
        
        ZAngle        = findAngle(0, z, tempR, particle[i].z);
        zv           += sin(ZAngle) * A;
        
        if (R < 35.0){
          connected[totalConnections] = i;
          totalConnections ++;
          if (connections){
            stroke(0, (35 - R) * 7.0);
            line(particle[i].x, particle[i].y, particle[i].z, x, y, z);
          }
        }
      }
    }
    xv *= damp;
    yv *= damp;
    zv *= damp;
    
    //Q -= (Q - ((totalConnections / 5.0) + 0.5)) * .1;
  }

  void applyGravity(){
    gAngle     = findAngle(xGrav,yGrav,x,y);
    gDist      = findDistance(xGrav,yGrav,x,y);
    gZAngle    = turnAngle(gZAngle, findAngle(0,zGrav,gDist,z));
    gZAngle    = findAngle(0,zGrav,gDist,z);
    
    gxv        = cos(gAngle) * gravity;
    gyv        = sin(gAngle) * gravity;
    gzv        = sin(gZAngle) * gravity;
    
    xv        += gxv;
    yv        += gyv;
    zv        += gzv;
    
    if (gravLines){
      stroke(255,0,0);
      line(x, y, z, x + gxv*100.0, y + gyv*100.0, z + gzv*100.0);
    }
  }
  
  
  float turnAngle (float current, float target) { 
    // assuming current and target are both between 0 and TWO_PI 
    float angle = target - current; 
    if (angle > PI) angle -= TWO_PI; 
    if (angle < -PI) angle += TWO_PI; 
    return angle; 
  } 
  
  void move(){
    x += xv;
    y += yv;
    z += zv;
  }

  void render(){
    mySize -= (mySize - (totalConnections + (255 - zDepth)/20.0)) * .2;
    
    push();
    translate(x, y, z);
    zDepth = ((screenZ(0,0,0) * 100.0) - 99.0) * 500.0;
    rotateZ(azimuth);
    rotateX(-elevation);
    rotateY(twist);
    
    tint(zDepth * .4,zDepth * .9,zDepth * 1.0);
    //println(tempColor);
    image(myField, 0 - mySize/2.0, 0 - mySize/2.0, mySize, mySize);

    pop();
  }
}


// create alpha for a bitmap by analyzing brightness (code by Ryan Alexander of Motion Theory)
void brightToAlpha(BImage b){
  b.format = RGBA;
  for(int i=0; i < b.pixels.length; i++) {
    b.pixels[i] = color(255,255,255,255 - brightness(b.pixels[i]));
  }
}




// find distance between 2 points in 2D space
float findDistance(float x1, float y1, float x2, float y2){
  float xd = x1 - x2;
  float yd = y1 - y2;
  
  float td = sqrt(xd * xd + yd * yd);
  return td;
}

// find distance between 2 points in 3D space
float findDistance(float x1, float y1, float z1, float x2, float y2, float z2){
  float xd = x1 - x2;
  float yd = y1 - y2;
  float zd = z1 - z2;
  
  float xyd = sqrt(xd * xd + yd * yd);
  float td = sqrt(zd * zd + xyd * xyd);
  return td;
}

// find angle in radians between 2 points in 2D space
float findAngle(float x1, float y1, float x2, float y2){
  float xd = x1 - x2;
  float yd = y1 - y2;

  float t = atan2(yd,xd);
  return t;
}





//