// OPENGL Voodoo for additive rendering
import processing.opengl.*;
import javax.media.opengl.*;
PGraphicsOpenGL pgl;
GL gl;
//

PImage glowKernel; // generated glow kernel for each particle


BeadSystem[] bs;
int NUMANCHORS; // number of centers
int NUMCHAINS; // number of bead systems per center
int NUMBEADS; // number of beads per bead system



void setup(){
  
  size(800,540,OPENGL);
  hint( ENABLE_OPENGL_4X_SMOOTH );  
  background(0); 

  NUMANCHORS=10;
  NUMCHAINS=6;
  NUMBEADS=10;

  //glow kernel
  float glowKernelWidth=100f;// glow core size parameter
  float glowKernelDecayPower=2.2f;// glow core decay power
  int reqGlowKernelSize =4*(int)pow(100f*glowKernelWidth,1f/glowKernelDecayPower);// required image size to accomodate the glow kernel
  println(reqGlowKernelSize+1);

  glowKernel=createImage(reqGlowKernelSize, reqGlowKernelSize, RGB);
  for(int i=0; i <  reqGlowKernelSize; i++) {
    for(int j=0; j <  reqGlowKernelSize; j++) {
      float bri=255.999999f*glowKernelWidth/(glowKernelWidth+pow(dist(i,j,reqGlowKernelSize/2,reqGlowKernelSize/2),glowKernelDecayPower));// radial symmetric decreasing function
      glowKernel.pixels[i+reqGlowKernelSize*j] = color(bri);
    }
  }


  bs=new BeadSystem[NUMANCHORS*NUMCHAINS];
  for(int i=0;i<NUMANCHORS;i++){
    PVector c=new PVector(random(0,width),random(0,height),random(0,-200));
    for(int j=0;j<NUMCHAINS;j++){
      bs[i+NUMANCHORS*j]=new BeadSystem(c,NUMBEADS,10f,200f,glowKernel); 
    }
  }


}

void draw(){
  // OPENGL Voodoo for additive rendering
  background(0);
  pgl=(PGraphicsOpenGL)g;
  gl=pgl.gl; 
  pgl.beginGL();
  gl.glDepthMask(true);
  gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
  pgl.endGL();
  gl.glClear(GL.GL_DEPTH_BUFFER_BIT); 
  // draw everything that should be normally drawn
  
  stroke(255,20);
  noFill(); 

  for(int i=0;i<NUMANCHORS*NUMCHAINS;i++){
    bs[i].update();
    bs[i].drawArcs();
    bs[i].drawSpokes();
  }
  // OPENGL Voodoo for additive rendering
  pgl.beginGL();
  gl.glDepthMask(false);
  gl.glBlendFunc( GL.GL_SRC_ALPHA, GL.GL_ONE );
  pgl.endGL();
  // draw everything that should be additively blended
  noStroke();
  fill(255);
  for(int i=0;i<NUMANCHORS*NUMCHAINS;i++){
    bs[i].drawBeads();
  }

}

void keyPressed() {
  bs=new BeadSystem[NUMANCHORS*NUMCHAINS];
  for(int i=0;i<NUMANCHORS;i++){
    PVector c=new PVector(random(0,width),random(0,height),random(0,-200));
    for(int j=0;j<NUMCHAINS;j++){
      bs[i+NUMANCHORS*j]=new BeadSystem(c,NUMBEADS,10f,200f,glowKernel); 
    }
  }
}


class BeadSystem{
  PVector center;
  BeadOnArc[] beads;
  int NUMBEADS;
  float minRadius;
  float maxRadius;
  PImage beadImage;

  BeadSystem(PVector center, int NUMBEADS, float minRadius, float maxRadius, PImage beadImage){
    this.center=center;
    this.NUMBEADS=NUMBEADS;
    beads=new BeadOnArc[NUMBEADS];
    this.minRadius=minRadius;
    this.maxRadius=maxRadius;
    this.beadImage=beadImage;
    for(int i=0;i<NUMBEADS;i++){
      float r=random(this.minRadius,this.maxRadius);
      beads[i] =new BeadOnArc(this.center,r,16,random(-PI,PI),random(-HALF_PI,HALF_PI),random(-0.05,0.05), this.beadImage,1.0f-.8f*r/this.maxRadius,color(random(160,255.99999),random(160,255.99999),random(220,255.99999)));
    }
    Arrays.sort(beads);// sort beads with increasing radius. This makes it easier to connect adjacent trajectories with spokes.
  }

  void update(){
    for(int i=0;i<NUMBEADS;i++){
      beads[i].update(); 
    }
  }

  void drawArcs(){
    for(int i=0;i<NUMBEADS;i++){
      beads[i].drawArc();
    }
  }

  void drawSpokes(){
    for(int i=1;i<NUMBEADS;i++){
      line(beads[i]._x,beads[i]._y,beads[i]._z,center.x+(beads[i]._x-center.x)*beads[i-1].radius/beads[i].radius,center.y+(beads[i]._y-center.y)*beads[i-1].radius/beads[i].radius,beads[i]._z);
    }
  }

  void drawBeads(){
    for(int i=0;i<NUMBEADS;i++){
      beads[i].drawBead(); 
    }
  }
}


class BeadOnArc implements Comparable {
  PVector center; //anchor of bead
  float radius; //distance from center
  float angleOffset; // angle offset of arc
  float angleSpan; // span of arc
  float angleSteps; // number of curve segmenst in the arc;
  float angularVel; // angular change per timestep
  float da; // angle per curve segment;
  PImage beadImage; // additive for particle rendering, used for additive blend 
  float beadScale; // scaling factor for the bead image
  color beadTint; // color tint to apply to bead image

  float _x,_y,_z;

  BeadOnArc(PVector center, float radius, int angleSteps , float angleOffset, float angleSpan,float angularVel,PImage beadImage, float beadScale, color beadTint){
    this.center=center;
    this.radius=radius;
    this.angleSteps=max(1,angleSteps);
    this.angleOffset=angleOffset;
    this.angleSpan=angleSpan;
    this.angularVel=angularVel;
    da=this.angleSpan/this.angleSteps;
    this.beadImage=beadImage;
    this.beadScale=beadScale;
    this.beadTint=beadTint;
    this._x=this.center.x-this.radius*sin(this.angleOffset);
    this._y=this.center.y+this.radius*cos(this.angleOffset);
    this._z=this.center.z;

  }

  void update(){ //one timestep, add angularVel to angleOffset, keep angleOffset in range [0, TWO_PI)
    angleOffset+=angularVel;
    while(angleOffset>=TWO_PI) angleOffset-=TWO_PI;
    while(angleOffset<0f) angleOffset+=TWO_PI;
    _x=center.x-radius*sin(angleOffset);
    _y=center.y+radius*cos(angleOffset);
  }



  void drawArc(){
    float angle;
    beginShape();

    for(int i=0; i<angleSteps+1;i++){
      angle=i*da+angleOffset;
      if(i==0) curveVertex(center.x-radius*sin(angle),center.y+radius*cos(angle),center.z);// needed to properly start curve 
      curveVertex(center.x-radius*sin(angle),center.y+radius*cos(angle),center.z);
      if(i==angleSteps) curveVertex(center.x-radius*sin(angle),center.y+radius*cos(angle),center.z);// needed to properly end curve 
    }
    endShape();
  }

  void drawBead(){
    pushMatrix();
    translate(_x,_y,_z);// offset to bead position
    scale(beadScale);// rescale image
    translate(-beadImage.width/2,-beadImage.height/2);// offset from left-top corner to center of image, apply before rescaling image
    tint(beadTint);
    image(beadImage,0,0);
    popMatrix();
  }

  public int compareTo( Object other) {
    final int BEFORE = -1;
    final int EQUAL = 0;
    final int AFTER = 1;


    if ( this == other ) return EQUAL;

    if (this.radius < ((BeadOnArc)other).radius) return BEFORE;
    if (this.radius > ((BeadOnArc)other).radius) return AFTER;

    return EQUAL;
  }


}