// node space experiment
// conceived from a ongoing context browser project idea
// nodes and their interrelations a represented and rendered as metaballs
// rasterization is using thick lines parallel to vector(1,0,-1)
// author: info@toxi.co.uk
// last modified: 08/10/03

NodeSpace ns;
int       NodeCount=10;
int       spaceUnits=100;
int       unitOffset=spaceUnits/2;
float     currScale=0.01;
float     maxScale=3;
int       stepSize=4;

void setup() {
  size(760,400);

  ns=new NodeSpace(spaceUnits,spaceUnits,spaceUnits,NodeCount);
  for(int i=1; i<NodeCount; i++)
  ns.addNode(new Node(random(spaceUnits),random(spaceUnits),random(spaceUnits)));
}

void loop() {
  background(255);

  translate(width/2,height/2,0);
  rotateX(radians((height/2-mouseY)*0.5));
  rotateY(radians((width/2-mouseX)*0.5));
  currScale+=(maxScale-currScale)*0.025;
  scale(currScale);

  lights();
  stroke(255,10);
  fill(255,10);
  box(spaceUnits+2);
  noLights();
  noStroke();

  ns.updateNodes();
  ns.showNodes();

  // rasterize entire space by raymarching through
  // individual slices along the y axis
  for(int i=0; i<spaceUnits; i+=stepSize) {
    fill(100+i*1.55,200-i*2,255-i/2,60);
    ns.renderYSlice(i,stepSize,2.65);
  }
}

class Node {
  float x,y,z;
  float xspeed,yspeed,zspeed;
  String url;
  float potential;
  Node(float xx,float yy, float zz) {
    this.init(xx,yy,zz);
  }
  void init(float xx,float yy,float zz) {
    x=xx;
    y=yy;
    z=zz;
    xspeed=random(2);
    yspeed=random(5);
    zspeed=random(3);
    potential=random(10,40);
  }
  void update() {
    x+=xspeed;
    y+=yspeed;
    z+=zspeed;
    if (x>spaceUnits+40 || y>spaceUnits+40 || z>spaceUnits+40)
    this.init(-random(unitOffset),-random(unitOffset),-random(unitOffset));
  }
}

class NodeSpace {
  Node[] nodes;
  int numNodes;
  int w,h,d;
  int w2,h2,d2;

  NodeSpace(int ww,int hh,int dd, int maxNodes) {
    w=ww;
    h=hh;
    d=dd;
    w2=w/2;
    h2=h/2;
    d2=d/2;

    nodes=new Node[maxNodes];
    numNodes=0;
  }
  void addNode(Node n) {
    nodes[numNodes++]=n;
  }
  void updateNodes() {
    for(int i=0; i<numNodes; i++) nodes[i].update();
  }

  void renderYSlice(int sliceY, float stepSize,float isoLevel) {
    float[] pos=new float[3];
    boolean shapeFlag;
    float potential;
    float s2=0.5; // half the stroke width
    float isoLevel1=isoLevel-0.5; // lower iso boundary
    float isoLevel2=isoLevel+0.5; // higher boundary
    float vertexY=sliceY-h2;
    float xL=w2+s2,xR=w2-s2;
    float zL=d2+s2,zR=d2-s2;

    beginShape(QUADS);
    // step along positive z axis first
    for(float z=0; z<d; z+=stepSize) {
      pos[0]=0;
      pos[1]=sliceY;
      pos[2]=z;
      shapeFlag=false;
      while(pos[0]<w && pos[2]>=0) {
        // compute potential at curr point
        //potential=noise(pos[0]*0.1,sliceY*0.1,pos[2]*0.1);
        potential=calcPotentialAt(pos[0],pos[1],pos[2]);
        if (potential>isoLevel1 && potential<isoLevel2) {
          if (!shapeFlag) {
            vertex(pos[0]-xL,vertexY,pos[2]-zL);
            vertex(pos[0]-xR,vertexY,pos[2]-zR);
            shapeFlag=true;
          }
        } else {
          if (shapeFlag) {
            vertex(pos[0]-xR,vertexY,pos[2]-zR);
            vertex(pos[0]-xL,vertexY,pos[2]-zL);
            shapeFlag=false;
          }
        }
        // move towards positive X and z=0 plane
        pos[0]++;
        pos[2]--;
      }
      if (shapeFlag) {
        vertex(pos[0]-xR,vertexY,pos[2]-zR);
        vertex(pos[0]-xL,vertexY,pos[2]-zL);
      }
    }
    // now step along x axis
    for(float x=0; x<w; x+=stepSize) {
      pos[0]=x;
      pos[1]=sliceY;
      pos[2]=d;
      shapeFlag=false;
      while(pos[0]<w && pos[2]>=0) {
        // compute potential at curr point
        //potential=noise(pos[0]*0.1,sliceY*0.1,pos[2]*0.1);
        potential=calcPotentialAt(pos[0],pos[1],pos[2]);
        if (potential>isoLevel1 && potential<isoLevel2) {
          if (!shapeFlag) {
            vertex(pos[0]-xL,vertexY,pos[2]-zL);
            vertex(pos[0]-xR,vertexY,pos[2]-zR);
            shapeFlag=true;
          }
        } else {
          if (shapeFlag) {
            vertex(pos[0]-xR,vertexY,pos[2]-zR);
            vertex(pos[0]-xL,vertexY,pos[2]-zL);
            shapeFlag=false;
          }
        }
        // move towards positive X and z=0 plane
        pos[0]++;
        pos[2]--;
      }
      if (shapeFlag) {
        vertex(pos[0]-xR,vertexY,pos[2]-zR);
        vertex(pos[0]-xL,vertexY,pos[2]-zL);
      }
    }
    endShape();
  }

  float calcPotentialAt(float x,float y, float z) {
    float dx,dy,dz,distsq,p = 0;
    for(int i=0; i<numNodes; i++){
      dx = x - nodes[i].x;
      dy = y - nodes[i].y;
      dz = z - nodes[i].z;
      distsq = (dx*dx+dy*dy+dz*dz)+0.0001;
      p += nodes[i].potential*30/distsq;
    }
    return p;
  }

  void showNodes() {
    int sz=2;
    fill(255,230,0);
    for(int i=0; i<numNodes; i++) {
      if (nodes[i].x>=0 && nodes[i].x<=w && nodes[i].y>=0 && nodes[i].y<=h && nodes[i].z>=0 && nodes[i].z<=d) {
        push();
        translate(nodes[i].x-w2,nodes[i].y-h2,nodes[i].z-d2);
        box(sz);
        pop();
      }
    }
  }
}