I am doing a small project which involves creating different layers of hexagon grid with particles and springs. 

I managed to create different layers with a 3D array (but not sure this is efficient - so if u know a better way tell me) now I want to build planar faces between spring on one layer and another in the top one.

so now to draw lines btw springs I call the .getOneEnd() and getOtherEnd() methods of Traer library . This gives me two points - I need 4 for planar faces. Any idea about how I could organize the code?

2. import processing.opengl.*;
3. import traer.physics.*;
4. import peasy.*;
5. 
   
6. 
   
7. PeasyCam cam;
8. 
   
9. ParticleSystem pSys;
10. ArrayList particles = new ArrayList();
11. ArrayList springs = new ArrayList();
12. 
    
13. //GLobal Variables
14. int Scale = 3;
15. 
    
16. //Grid extents
17. int max_x = 20;
18. int max_y = 15;
19. 
    
20. //Top most level
21. int max_z =20;
22. // numebrs of layers
23. int numL = max_z/4;
24. 
    
25. Particle [][][]grid = new Particle [max_x][max_y][max_z];
26. 
    
27. 
    
28. float K = .2;//.4
29. float D = 0.2;
30. //spring rest length
31. float rest =.8; //.8
32. 
    
33. void setup() {
34.   size(600, 600, OPENGL);
35.   smooth();
36.   fill(0);
37. 
    
38.   cam = new PeasyCam(this,width/8,0,0,250);
39.   cam.setMinimumDistance(250);
40.   cam.setMaximumDistance(800);
41. 
    
42.   pSys = new ParticleSystem(0, 0.25);
43. 
    
44.   //Function to add particle and connect them with springs according to hex topology
45.   addHex();
46. }
47. 
    
48. 
    
49. void draw() {
50.  // pSys.tick(1);
51.   //  pSys.setGravity(0,0,2);
52.   background (0);  
53.   renderParticles();
54.   println(pSys.numberOfSprings());
55. }
56. 
    
57. 
    
58. void addHex() {
59. 
    
60. 
    
61. 
    
62.   for (int i=0; i<max_x; ++i) {
63.     for (int j=0; j<max_y; ++j) {
64.       for(int k=0; k<max_z; k+=numL) {
65. 
    
66. 
    
67. 
    
68.         grid[i][j][k]=  pSys.makeParticle(1,i*Scale, j*Scale, k);
69. 
    
70. 
    
71.         if ((i==0 || j==0) ||(i==max_x-1 ||(j==max_y-2))) {
72.           
73.          //make boundary fixed
74.           grid[i][j][k].makeFixed();
75.         }
76.       }
77.     }
78.   }
79. 
    
80.   for (int i=0;i<max_x-2; ++i) {
81.     for (int j=i%2*2; j<max_y-3; j+=4) {
82.         for(int k=0; k<max_z; k+=numL) {
83. 
    
84.       Particle a = grid[i][j+1][k];
85.       Particle b = grid[i][j+2][k];
86.       Particle c = grid[i+1][j+3][k];
87.       Particle d = grid[i+2][j+2][k];
88.       Particle e = grid[i+2][j+1][k];
89.       Particle f = grid[i+1][j][k];
90. 
    
91. 
    
92.   
93.       pSys.makeSpring(a,b, K, D, rest);
94.       pSys.makeSpring(b,c, K, D, rest);
95.       pSys.makeSpring(c,d, K, D, rest);
96.       pSys.makeSpring(d,e, K, D, rest);
97.       pSys.makeSpring(e,f, K, D, rest);
98.       pSys.makeSpring(f,a, K, D, rest);
99. 
    
100.      
101.         }
102.     }
103.   }
104. }
105. 
     
106. 
     
107. 
     
108. void renderParticles() {
109. 
     
110. 
     
111. 
     
112.   for (int i=0; i<pSys.numberOfParticles(); ++i) {
113.     Particle c = pSys.getParticle(i);
114. 
     
115.     pushMatrix();
116. 
     
117.     translate(0,0,c.position().z()*Scale);
118.    ellipse (c.position().x()*Scale, c.position().y()*Scale,3,3);
119.     
120.     popMatrix();
121.   }
122. 
     
123.   for (int i=0;i<pSys.numberOfSprings(); i++) {
124. 
     
125.     Spring s = pSys.getSpring( i );
126. 
     
127.     stroke(0,255,0);
128.     strokeWeight(1);
129.     
130.     
131.     Particle a = s.getOneEnd();
132.     Particle b = s.getTheOtherEnd();
133. 
     
134.     line(a.position().x()*Scale,a.position().y()*Scale,a.position().z()*Scale, b.position().x()*Scale, b.position().y()*Scale, b.position().z()*Scale);
135.     
136.     // draw a Plane btw a spring on a lower level and one on the next level
137. //    beginShape();
138. //    vertex(x,y,z);
139. //     vertex(x,y,z);
140. //     
141. //      vertex(x,y,z);
142. //       vertex(x,y,z);
143. //       endShape(CLOSE);
144.     
145.   }
146.   
147.   
148.   
149. }