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

  NodeSpace(int widthOfSpace,int heightOfSpace,int depthOfSpace, int maxNodes) {
    w=widthOfSpace;
    h=heightOfSpace;
    d=depthOfSpace;
    w2=0;
    h2=0;
    d2=0;
    nodes=new Node[maxNodes];
    numNodes=0;
  }
  
  void addNode(Node n) {
    nodes[numNodes++]=n;
  }
  
  void update() {
    for(int i=0; i<numNodes; i++) nodes[i].update();
  }

  void renderYSlice(int sliceY, float stepSize,float isoLevel) {
    
    pushStyle();
    stroke(255,0,0);
    strokeWeight(1);
    line(0,sliceY,0,w,sliceY,0);
    popStyle();
    
    float[] pos=new float[3];
    boolean shapeFlag;
    float potential;
    float s2=1; // half the stroke width
    float isoLevel1=isoLevel-10.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].currPos.x;
      dy = y - nodes[i].currPos.y;
      dz = z - nodes[i].currPos.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].currPos.x>=0 && nodes[i].currPos.x<=w && nodes[i].currPos.y>=0 && nodes[i].currPos.y<=h && nodes[i].currPos.z>=0 && nodes[i].currPos.z<=d) {
        nodes[i].draw();
      }
    }
  }
}