1. void setup() {
2.   ArrayList<PVector> pvl = new ArrayList<PVector>();
3.   
4.   pvl.add(new PVector());
5.   
6.   PVector v = new PVector();
7.   
8.   println(pvl.contains(v));
9.   
10. }

1. void setup() {
2.   Test t1 = new Test();
3.   Test t2 = new Test();
4.    println("equal: "+t1.equals(t2));
5.   
6.   ArrayList<Test> ta = new ArrayList<Test>();
7.    ta.add(t1);
8.    
9.    println("contains: "+ta.contains(t2));
10. }
11. 
    
12. class Test {
13.   
14.   int a = 0;
15.   
16.   Test() {
17.   }
18. 
    
19.   boolean equals(Test t) {
20.     return (a == t.a);
21.   }  
22.   
23.   int hashCode() {
24.     int result = 1;
25.     result = 31 * result;
26.     return result;
27.   }
28.   
29.   
30. }

1. void setup() {
2.   size(400, 400);
3.   smooth();
4. 
   
5. }
6. 
   
7. // . . . . . . . . . . . . . . . . . . .
8. 
   
9. void draw() {
10.   background(255);
11.   
12.   stroke(0);
13.   line(30, 30, 250, 250);
14.   
15.   ellipse(mouseX, mouseY, 5, 5);
16.   
17. 
    
18. }
19. 
    
20. // . . . . . . . . . . . . . . . . . . .

1. import traer.physics.*;
2. 
   
3. ParticleSystem physics;
4. 
   
5. float particleMass = 1.0;
6. 
   
7. void setup() {
8.   size(600, 600);
9.   smooth();
10.   frameRate(30);
11.   
12.   physics = new ParticleSystem();  
13.   physics.setGravity(0.0);
14.   physics.setDrag(1.0);
15. }
16. 
    
17. void draw() {
18.   background(255);
19.   
20.   physics.tick();
21.   
22.   for(int i = 0; i < physics.numberOfSprings(); i++) {
23.     Spring s = physics.getSpring(i);
24.     Particle anchor = s.getOneEnd();
25.     Particle node = s.getTheOtherEnd();
26.       
27.     noStroke();
28.     fill(255, 0, 0, 100);
29.     ellipse(node.position().x(), node.position().y(), 15, 15);  
30.     
31.     stroke(0);
32.     line(node.position().x(), node.position().y(), anchor.position().x(), anchor.position().y());
33.   }
34.   
35.   
36.   
37. }
38. 
    
39. void mousePressed() {
40.     Particle anchor = physics.makeParticle(particleMass, mouseX, mouseY, 0);
41.     anchor.makeFixed();
42.     
43.     Particle  node = physics.makeParticle(particleMass, mouseX, mouseY, 0);
44.     
45.     // If they are strong they act like a stick. If they are weak they take a long time to return to their rest length
46.     float strength = 0.1;
47.     // If springs have high damping they don't overshoot and they settle down quickly, with low damping springs oscillate.
48.     float damping = 1;
49.     // the spring wants to be at this length and acts on the particles to push or pull them exactly this far apart at all times.
50.     float restLength = 50;
51.     
52.     physics.makeSpring(anchor, node, strength, damping, restLength);
53.     
54.     // make repulsion for new one with every node
55.     for(int i = 0; i < physics.numberOfSprings(); i++) {
56.       Spring s = physics.getSpring(i);
57.       Particle a = s.getTheOtherEnd();
58.       strength = 10;
59.       float minimumDistance = 10;
60.       physics.makeAttraction(a, node, strength, minimumDistance);
61.     } 
62.  
63.     
64. }

1. class Node implements Comparable<Node> {
2.   
3.   int id;
4.   
5.   float lon;
6.   float lat;
7.   
8.   // A*
9.   float f = 0;
10.   float g = 0;
11.   float h = 0;
12.   Node parent;
13.   
14. 
    
15.   HashSet<Node> links = new HashSet<Node>();
16.   
17.   Node() {
18.   
19.   }
20.   
21.   Node(float lon, float lat) {
22.     this.id = idCount++;
23.     this.lon = lon;
24.     this.lat = lat;  
25.   }
26.   
27.   Node(int id, float lon, float lat) {
28.     this.id = id;
29.     this.lon = lon;
30.     this.lat = lat;  
31.   }
32.   
33.   
34.   void linkToNode(Node n) {
35.     links.add(n);
36.   }
37.   
38.   
39.   void reset() {
40.     f = g = h = 0;   
41.     parent = null;
42.   }
43.   
44.   int compareTo(Node n) {
45.     if(f < n.f) return -1;
46.     if(f == n.f) return 0;
47.     return 1;
48.   }
49.   
50.  
51. }

1. void mergeOverlappingNodes() {
2.   
3.   Iterator<Node> itr = nodes.iterator();
4.   
5.   while(itr.hasNext()) {
6.     Node n = itr.next();
7.     
8.     boolean remove = false;
9.     
10.     // check if the node can be removed
11.     for(Node linkedNode : n.links) {
12.       if ( (n.lon == linkedNode.lon) && (n.lat == linkedNode.lat)) { 
13.         remove = true;
14.         break;
15.       }
16.     } 
17.     
18.     for(Node linkedNode : n.links) { //ConcurrentModificationException
19.       linkedNode.links.remove(n);
20.     }
21.     
22.     for(Node linkedNode1 : n.links) {
23.        for(Node linkedNode2 : n.links) {
24.         linkedNode1.links.add(linkedNode2);
25.       }
26.     }
27.     
28.             
29.         /*
30.         for(Node aLinkedNodeFromTheOneToRemove : linkedNode.links) {
31.           //if(aLinkedNodeFromTheOneToRemove == n) println("true");
32.           aLinkedNodeFromTheOneToRemove.links.remove(linkedNode);
33.           aLinkedNodeFromTheOneToRemove.links.add(n);
34.         }
35.         */
36.         
37.         //linkedNode.links.add(n);
38.     
39.     if(remove) itr.remove();
40.     
41.    
42.     
43.   }  
44. }

1. void mergeOverlappingNodesOld() {
2. 
   
3.   
4.   Node theNode, otherNode;
5. 
   
6.   
7.   for (int i = nodes.size()-1; i >= 0; i--) {
8.     theNode = nodes.get(i);
9.    
10.     
11.    ArrayList<Node> nodesOnTheSamePosition = new ArrayList<Node>();
12.     
13.     // in this loop we find all nodes on the same position
14.     // and add them to the ArrayList: nodesOnSamePosition
15.     for (int j = nodes.size()-1; j >= 0; j--) {
16.       otherNode = nodes.get(j);
17.       
18.       if (theNode == otherNode) continue;
19. 
    
20.       if ( (theNode.lon == otherNode.lon) && (theNode.lat == otherNode.lat)) { 
21.                 
22.         nodesOnTheSamePosition.add(otherNode);
23.         
24.       }
25.     }
26.     
27.     // now relink and remove
28.     for(Node aNodeOnTheSamePosition : nodesOnTheSamePosition) {
29.       for(Node linkedNode : aNodeOnTheSamePosition.links) {
30.         theNode.links.add(linkedNode);
31.       }
32.       
33.       nodes.remove(aNodeOnTheSamePosition);
34.       theNode.links.remove(aNodeOnTheSamePosition);
35.     }
36.     // added in attempt to bug fix
37.     // now added above which in theory should work
38.     /*
39.     for(Node aNodeOnTheSamePosition : nodesOnTheSamePosition) {
40.       theNode.links.remove(aNodeOnTheSamePosition);
41.     }
42.     */
43.     
44.     // since nodes.size() is changed now we have to decrement i
45.     i -= nodesOnTheSamePosition.size();
46.     
47.     
48.   }
49. 
    
50. /*
51.   Node node1, node2; 
52. 
    
53.   HashSet<Node> nodesToRemove = new HashSet<Node>();
54.   //HashSet<Node> nodesNotToRemove = new HashSet<Node>();
55. 
    
56.   for (int i = nodes.size()-1; i >= 0; i--) {
57.     node1 = nodes.get(i);
58. 
    
59.     for (int j = nodes.size()-1; j >= 0; j--) {
60.       node2 = nodes.get(j);
61. 
    
62.       if (node1 == node2) continue;
63. 
    
64.       if (nodesToRemove.contains(node1)) continue;
65. 
    
66.       if ( (node1.lon == node2.lon) && (node1.lat == node2.lat)) { 
67. 
    
68.         HashSet<Node> links = new HashSet<Node>(node1.links);
69.         for (Node n : links) {
70.           n.links.remove(node1);  
71.           n.links.add(node2);
72. 
    
73.           // we have to remove them later else things go wrong
74.           nodesToRemove.add(node1);
75. 
    
76.           //nodesNotToRemove.add(node2);
77.         }
78.       }
79.     }
80.   }
81. 
    
82.   // println(nodesToRemove.size());
83. 
    
84.   Iterator<Node> itr = nodesToRemove.iterator();
85.   while (itr.hasNext ()) {
86.     Node nodeToRemove = itr.next();
87.     //if(nodesNotToRemove.contains(nodeToRemove)) continue;
88.     nodes.remove(nodeToRemove);
89.   }
90. 
    
91. */
92.   // check if correct
93.   /*
94.   for (Node n1 : nodes) {
95.     for (Node n2 : nodes) {
96.       if (n1 == n2) continue;
97. 
    
98.       if ( (n1.lon == n2.lon) && (n1.lat == n2.lat)) {
99.         println("my code is wrong...");
100.       }
101.     }
102.   }
103.   */
104. }

9. Select the Native library location item.
10. Click the Edit button.
11. Navigate to the folder containing the Leap native libraries.

 

1. public class PenTool extends Tool {
2. 
   
3. public PenTool() {
4. 
   
5. }
6. }

1. public boolean setActiveTool(Class<Tool> tool) {
2. for(Tool t : tools) {
3. if(t.getClass() == tool) {
4. activeTool = t;
5. return true;
6. }
7. }
8. return false;
9. }

1. import processing.opengl.*;
2. 
   
3. PImage img;
4. 
   
5. void setup() {
6.   size(400, 400, OPENGL);  
7. 
   
8.  // hint(ENABLE_DEPTH_SORT);
9. 
   
10.   img = loadImage("grid_2048.png");
11. }
12. 
    
13. void draw() {
14.   background(color(map(mouseX, 0, width, 0, 255), 200, 200));
15.   translate(width/2, height/2);
16.   rotateX(map(mouseY, 0, height, -TWO_PI, TWO_PI));
17.   rotateY(map(mouseX, 0, width, -TWO_PI, TWO_PI));
18.   imageMode(CENTER);
19.   line(50, 0, -100, 50, 0, 100);
20. 
    
21.   image(img, 0, 0);
22.   stroke(255, 0, 0);
23.   line(0, 0, -100, 0, 0, 100);
24. 
    
25. }

1. import peasy.*;
2. 
   
3. PeasyCam cam;
4. 
   
5. PVector interest;
6. SpotLight spotLigth;
7. 
   
8. void setup() {
9.   size(600, 600, P3D);
10.   cam = new PeasyCam(this, 400);
11. 
    
12.   interest = new PVector(0, 0, -100);
13. 
    
14.   spotLigth = new SpotLight(color(255, 200, 200), 0, 0, 0, interest, PI, 600);
15. }
16. 
    
17. void draw() {
18.   background(0); 
19. 
    
20.   if (keyPressed) {
21.     if (key == 'w') {
22.       spotLigth.z --;
23.     }
24.     if (key == 's') {
25.       spotLigth.z ++;
26.     }
27.     if (key == 'a') {
28.       spotLigth.x --;
29.     }
30.     if (key == 'd') {
31.       spotLigth.x ++;
32.     }
33.     if (key == 'q') {
34.       spotLigth.y ++;
35.     }
36.     if (key == 'e') {
37.       spotLigth.y --;
38.     }
39.   }
40.   
41.   float concentration = map(mouseX, 0, width, -50, 100);
42.   println(concentration);
43.   spotLigth.concentration = concentration;
44.   
45.   noStroke(); 
46.   spotLigth.render();
47.   translate(interest.x, interest.y, interest.z); 
48.   sphere(80);
49. }
50. 
    
51. 
    
52. 
    
53. class SpotLight {
54.   /*
55.   // red or hue value (depending on current color mode)
56.    float v1;
57.    // float: green or saturation value (depending on current color mode)
58.    float v2;
59.    // float: blue or brightness value (depending on current color mode)
60.    float v3;
61.    */
62. 
    
63.   color c;
64. 
    
65.   // xyz-coordinate of the light
66.   float x;
67.   float y;
68.   float z;
69.   // direction along the x axis
70.   //  float nx;
71.   //  float ny;
72.   //  float nz;
73.   PVector interest;
74.   // angle of the spotlight cone
75.   float angle;
76.   // exponent determining the center bias of the cone
77.   float concentration;
78. 
    
79.   SpotLight(color c, float x, float y, float z, PVector interest, float angle, float concentration) {
80.     this.c = c;
81.     this.x = x;
82.     this.y = y;
83.     this.z = z;
84.     this.interest =interest;
85.     this.angle = angle;
86.     this.concentration = concentration;
87.   }
88. 
    
89.   void render() {
90.     float v1, v2, v3;
91.     if (g.colorMode == RGB) {
92.       v1 = red(c);
93.       v2 = green(c);
94.       v3 = blue(c);
95.     } 
96.     else {
97.       v1 = hue(c);
98.       v2 = green(c);
99.       v3 = blue(c);
100.     }
101. 
     
102. 
     
103.     PVector v = new PVector(x, y, z);
104.     v.add(interest);
105.     v.normalize();
106. 
     
107.     float nx = v.x;
108.     float ny = v.y;
109.     float nz = v.z;
110. 
     
111.     spotLight(
112.     v1, v2, v2, 
113.     x, y, z, 
114.     nx, ny, nz, 
115.     angle, 
116.     concentration);
117.   }
118. }

1. public void waitToBeReady() {
2. if (programCommunicator != null) {
3. programCommunicator.waitToBeReady();
4. }
5. }

1. public void waitToBeReady() {
2. boolean ready = false;
3. while (ready == false) {
4. ready = field.update();
5. try {
6. sleep((long) (interval));
7. } catch (Exception e) {
8. e.printStackTrace();
9. }
10. }
11. }

That all works fine, unless i call waitToBeReady() from the main processing tab.

For example, if i make a method on the main processing tab:

1. void debug() {
2.    println("a");
3.     currentProgram.clearBlack();
4.     currentProgram.waitToBeReady();
5.     println("b");
6.     currentProgram.clearWhite();
7.     currentProgram.waitToBeReady();
8.     println("c");
9.     currentProgram.clearBlack();
10.     currentProgram.waitToBeReady();
11.     println("d");
12.     currentProgram.clearWhite();
13.     currentProgram.waitToBeReady();
14.     println("e");
15. }