Processing Forum

Uncaught TypeError using vectors in pjs

[9 Replies]
- 26-May-2013 12:52 PM
- Forum: Processing with Other Languages
Hello everyone,

I'm trying to port a simple example of Node+Spring from Generative Gestaltung to processing js with no luck.

I've got rid of libraries and stuff that could cause pbs, it runs in plain java so it should work but I get an :

Uncaught TypeError: Object #<Node> has no method 'get'

So it seems that the error comes from the class Node, and as a matter of fact the class extends PVector, so I guess the issue would come from there. It's a weird error and I really don't know were to start digging to resolve this.

I already used extended class in pjs and it didn't seem to cause trouble, does anybody have an idea how to solve this ?
3. Node nodeA, nodeB;
4. Spring spring;
7. void setup() {
8. size(600, 600);
9. smooth();
10. fill(0);
12. PVector vecA = new PVector( width/2+random(-50, 50), height/2+random(-50, 50));
13. PVector vecB = new PVector( width/2+random(-50, 50), height/2+random(-50, 50));
15. nodeA = new Node(vecA);
16. nodeB = new Node(vecB);
18. nodeA.setDamping(0.1);
19. nodeB.setDamping(0.1);
21. spring = new Spring(nodeA, nodeB);
22. spring.setLength(100);
23. spring.setStiffness(0.6);
24. spring.setDamping(0.3);
25. }
28. void draw() {
29. background(255);
31. if (mousePressed == true) {
32. nodeA.x = mouseX;
33. nodeA.y = mouseY;
34. }
36. // update spring
37. spring.update();
39. // update node positions
40. nodeA.update();
41. nodeB.update();
44. // draw spring
45. stroke(0, 130, 164);
46. strokeWeight(4);
47. line(nodeA.x, nodeA.y, nodeB.x, nodeB.y);
49. // draw nodes
50. noStroke();
51. fill(0);
52. ellipse(nodeA.x, nodeA.y, 20, 20);
53. ellipse(nodeB.x, nodeB.y, 20, 20);
54. }
58. // M_6_1_01.pde
59. // Node.pde
60. //
61. // Generative Gestaltung, ISBN: 978-3-87439-759-9
62. // First Edition, Hermann Schmidt, Mainz, 2009
63. // Hartmut Bohnacker, Benedikt Gross, Julia Laub, Claudius Lazzeroni
64. // Copyright 2009 Hartmut Bohnacker, Benedikt Gross, Julia Laub, Claudius Lazzeroni
65. //
66. // http://www.generative-gestaltung.de
67. //
68. // Licensed under the Apache License, Version 2.0 (the "License");
69. // you may not use this file except in compliance with the License.
70. // You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
71. // Unless required by applicable law or agreed to in writing, software
72. // distributed under the License is distributed on an "AS IS" BASIS,
73. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
74. // See the License for the specific language governing permissions and
75. // limitations under the License.
77. class Node extends PVector{
79. // ------ properties ------
80. // if needed, an ID for the node
81. String id = "";
82. float diameter = 0;
84. float minX = -60000; // those were Float.MAX_VALUE before being 6000 because pjs complained about not knowing Float with a capital F
85. float maxX = 60000;
86. float minY = -60000;
87. float maxY = 60000;
88. float minZ = -60000;
89. float maxZ = 60000;
91. PVector velocity = new PVector();
92. PVector pVelocity = new PVector();
93. float maxVelocity = 10;
95. float damping = 0.5f;
96. // radius of impact
97. float radius = 200;
98. // strength: positive for attraction, negative for repulsion (default for Nodes)
99. float strength = -1;
100. // parameter that influences the form of the function
101. float ramp = 1.0f;
104. // ------ constructors ------
105. Node() {
106. }
108. Node(float theX, float theY) {
109. x = theX;
110. y = theY;
111. }
113. Node(float theX, float theY, float theZ) {
114. x = theX;
115. y = theY;
116. z = theZ;
117. }
119. Node(PVector theVector) {
121. x = theVector.x;
122. y = theVector.y;
123. z = theVector.z;
124. }
126. // ------ rotate position around origin ------
127. void rotateX(float theAngle) {
128. float newy = y * cos(theAngle) - z * sin(theAngle);
129. float newz = y * sin(theAngle) + z * cos(theAngle);
130. y = newy;
131. z = newz;
132. }
134. void rotateY(float theAngle) {
135. float newx = x * cos(-theAngle) - z * sin(-theAngle);
136. float newz = x * sin(-theAngle) + z * cos(-theAngle);
137. x = newx;
138. z = newz;
139. }
141. void rotateZ(float theAngle) {
142. float newx = x * cos(theAngle) - y * sin(theAngle);
143. float newy = x * sin(theAngle) + y * cos(theAngle);
144. x = newx;
145. y = newy;
146. }
148. // ------ calculate attraction ------
149. void attract(Node[] theNodes) {
150. // attraction or repulsion part
151. for (int i = 0; i < theNodes.length; i++) {
152. Node otherNode = theNodes[i];
153. // stop when empty
154. if (otherNode == null) break;
155. // not with itself
156. if (otherNode == this) continue;
158. this.attract(otherNode);
159. }
160. }
162. void attract(Node theNode) {
163. float d = PVector.dist(this, theNode);
165. if (d > 0 && d < radius) {
166. float s = pow(d / radius, 1 / ramp);
167. float f = s * 9 * strength * (1 / (s + 1) + ((s - 3) / 4)) / d;
168. PVector df = PVector.sub(this, theNode);
169. df.mult(f);
171. theNode.velocity.x += df.x;
172. theNode.velocity.y += df.y;
173. theNode.velocity.z += df.z;
174. }
175. }
177. // ------ update positions ------
178. void update() {
179. update(false, false, false);
180. }
182. void update(boolean theLockX, boolean theLockY, boolean theLockZ) {
184. velocity.limit(maxVelocity);
186. pVelocity = velocity.get();
188. if (!theLockX) x += velocity.x;
189. if (!theLockY) y += velocity.y;
190. if (!theLockZ) z += velocity.z;
192. if (x < minX) {
193. x = minX - (x - minX);
194. velocity.x = -velocity.x;
195. }
196. if (x > maxX) {
197. x = maxX - (x - maxX);
198. velocity.x = -velocity.x;
199. }
201. if (y < minY) {
202. y = minY - (y - minY);
203. velocity.y = -velocity.y;
204. }
205. if (y > maxY) {
206. y = maxY - (y - maxY);
207. velocity.y = -velocity.y;
208. }
210. if (z < minZ) {
211. z = minZ - (z - minZ);
212. velocity.z = -velocity.z;
213. }
214. if (z > maxZ) {
215. z = maxZ - (z - maxZ);
216. velocity.z = -velocity.z;
217. }
219. velocity.mult(1 - damping);
220. }
222. // ------ getters and setters ------
225. String getID() {
226. return id;
227. }
229. void setID(String theID) {
230. this.id = theID;
231. }
233. float getDiameter() {
234. return diameter;
235. }
237. void setDiameter(float theDiameter) {
238. this.diameter = theDiameter;
239. }
241. void setBoundary(float theMinX, float theMinY, float theMinZ,
242. float theMaxX, float theMaxY, float theMaxZ) {
243. this.minX = theMinX;
244. this.maxX = theMaxX;
245. this.minY = theMinY;
246. this.maxY = theMaxY;
247. this.minZ = theMinZ;
248. this.maxZ = theMaxZ;
249. }
251. void setBoundary(float theMinX, float theMinY, float theMaxX,
252. float theMaxY) {
253. this.minX = theMinX;
254. this.maxX = theMaxX;
255. this.minY = theMinY;
256. this.maxY = theMaxY;
257. }
259. float getMinX() {
260. return minX;
261. }
263. void setMinX(float theMinX) {
264. this.minX = theMinX;
265. }
267. float getMaxX() {
268. return maxX;
269. }
271. void setMaxX(float theMaxX) {
272. this.maxX = theMaxX;
273. }
275. float getMinY() {
276. return minY;
277. }
279. void setMinY(float theMinY) {
280. this.minY = theMinY;
281. }
283. float getMaxY() {
284. return maxY;
285. }
287. void setMaxY(float theMaxY) {
288. this.maxY = theMaxY;
289. }
291. float getMinZ() {
292. return minZ;
293. }
295. void setMinZ(float theMinZ) {
296. this.minZ = theMinZ;
297. }
299. float getMaxZ() {
300. return maxZ;
301. }
303. void setMaxZ(float theMaxZ) {
304. this.maxZ = theMaxZ;
305. }
307. PVector getVelocity() {
308. return velocity;
309. }
311. void setVelocity(PVector theVelocity) {
312. this.velocity = theVelocity;
313. }
315. float getMaxVelocity() {
316. return maxVelocity;
317. }
319. void setMaxVelocity(float theMaxVelocity) {
320. this.maxVelocity = theMaxVelocity;
321. }
323. float getDamping() {
324. return damping;
325. }
327. void setDamping(float theDamping) {
328. this.damping = theDamping;
329. }
331. float getRadius() {
332. return radius;
333. }
335. void setRadius(float theRadius) {
336. this.radius = theRadius;
337. }
339. float getStrength() {
340. return strength;
341. }
343. void setStrength(float theStrength) {
344. this.strength = theStrength;
345. }
347. float getRamp() {
348. return ramp;
349. }
351. void setRamp(float theRamp) {
352. this.ramp = theRamp;
353. }
354. }
358. // M_6_1_02.pde
359. // Spring.pde
360. //
361. // Generative Gestaltung, ISBN: 978-3-87439-759-9
362. // First Edition, Hermann Schmidt, Mainz, 2009
363. // Hartmut Bohnacker, Benedikt Gross, Julia Laub, Claudius Lazzeroni
364. // Copyright 2009 Hartmut Bohnacker, Benedikt Gross, Julia Laub, Claudius Lazzeroni
365. //
366. // http://www.generative-gestaltung.de
367. //
368. // Licensed under the Apache License, Version 2.0 (the "License");
369. // you may not use this file except in compliance with the License.
370. // You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
371. // Unless required by applicable law or agreed to in writing, software
372. // distributed under the License is distributed on an "AS IS" BASIS,
373. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
374. // See the License for the specific language governing permissions and
375. // limitations under the License.
377. class Spring {
378. Node fromNode;
379. Node toNode;
381. float length = 100;
382. float stiffness = 0.6;
383. float damping = 0.9;
385. // ------ constructors ------
386. Spring(Node theFromNode, Node theToNode) {
387. fromNode = theFromNode;
388. toNode = theToNode;
389. }
391. Spring(Node theFromNode, Node theToNode, float theLength, float theStiffness, float theDamping) {
392. fromNode = theFromNode;
393. toNode = theToNode;
395. length = theLength;
396. stiffness = theStiffness;
397. damping = theDamping;
398. }
400. // ------ apply forces on spring and attached nodes ------
401. void update() {
402. // calculate the target position
403. // target = normalize(to - from) * length + from
404. PVector diff = PVector.sub(toNode, fromNode);
405. diff.normalize();
406. diff.mult(length);
407. PVector target = PVector.add(fromNode, diff);
409. PVector force = PVector.sub(target, toNode);
410. force.mult(0.5);
411. force.mult(stiffness);
412. force.mult(1 - damping);
414. toNode.velocity.add(force);
415. fromNode.velocity.add(PVector.mult(force, -1));
416. }
418. // ------ getters and setters ------
419. Node getFromNode() {
420. return fromNode;
421. }
423. void setFromNode(Node theFromNode) {
424. fromNode = theFromNode;
425. }
427. Node getToNode() {
428. return toNode;
429. }
431. void setToNode(Node theToNode) {
432. toNode = theToNode;
433. }
435. float getLength() {
436. return length;
437. }
439. void setLength(float theLength) {
440. this.length = theLength;
441. }
443. float getStiffness() {
444. return stiffness;
445. }
447. void setStiffness(float theStiffness) {
448. this.stiffness = theStiffness;
449. }
451. float getDamping() {
452. return damping;
453. }
455. void setDamping(float theDamping) {
456. this.damping = theDamping;
457. }
458. }

ControlP5 Multi touch

[2 Replies]
- 31-Jan-2013 10:28 AM
- Forum: Contributed Library Questions
Hello,

I would like to use ControlP5 in android to build some gui for musical apps. I just wondered if there was a way to support Multi-touch events ?

I've already built a MT application but I did write my own classes sliders and buttons, and handled MT with a spare library : https://github.com/rjmarsan/AndroidProcessingMultitouch

ControlP5 speeds up the process of building a gui quite a lot, so I want to use it, but I would also need multi touch, does anyone has any idea how I could do that ?

Circular rotating maze with arcs : how to find my way out ?

[10 Replies]
- 21-Oct-2012 05:39 AM
- Forum: Programming Questions
Hello Everyone,

I'm struggling with this code for quite some time so I need a little adivce on how to work this out.

I have a Hero class which is a an ellipse moving around following mouse clicks with physics. I have an arc class to create an arrayList of arcs which will create a maze.

I need to find the opening in my arc , and handle collisions beetween my hero and my arc. And of course the arc is rotating around the center.

So I guess what best is using polar coordinates but I'm having trouble using acos() and asin() functions and finding the angle of my hero in the (0,TWO_PI) range I want to compare it to my arc starting angle and stoping angle.

I tried to calculate a bunch of stuff converting polar to cartesian but I think I'm getting lost... So any pointers would be greatly appreciated on how to resolve that.

Here's my code to get a grasp of what's going on at the moment.
1. Hero hero;
3. ArrayList arcs;
5. // unlock :ending animation
6. boolean locked = true;
8. void setup() {
9. size(600, 600);
10. background(0);
11. strokeWeight(2);
12. stroke(180);
14. PVector a = new PVector(0.0, 0.125);
15. PVector v = new PVector(0.0, 0.0);
16. PVector l = new PVector(width/2, height/2);
18. hero = new Hero(a, v, l);
20. arcs = new ArrayList();
21. for (int i=1 ; i<7 ;i++) {
22. arcs.add(new Arc(width/2, height/2, i*100, i*100, random (PI/3, PI), random (TWO_PI, TWO_PI-PI/2)));
23. }
24. }
27. void draw() {
29. background(0);
30. float c = -0.23; // Drag coefficient
31. PVector heroVel = hero.getVel(); // Velocity of our thing
32. PVector force = PVector.mult(heroVel, c); // Following the formula
33. hero.applyForce(force); // Adding the force to our object, which will ultimately affect its acc
34. // Run the Thing object
35. hero.makeAppear();
36. hero.go();
39. // for (int i=0; i<arcs.size();i++){
40. // drawing only the third one for tests (uncomment the for loop to see the maze)
41. Arc a = (Arc) arcs.get(3);
42. a.display();
43. a.collide(hero);
44. // }
46. if (mousePressed) {
47. // Compute difference vector between mouse and object location
48. // 3 steps -- (1) Get Mouse Location, (2) Get Difference Vector, (3) Normalize difference vector
49. PVector m = new PVector(mouseX, mouseY);
50. PVector diff = PVector.sub(m, hero.getLoc());
51. diff.normalize();
52. float factor = 0.1; // Magnitude of Acceleration (not increasing it right now)
53. diff.mult(factor);
54. //object accelerates towards mouse
55. hero.setAcc(diff);
56. }
57. else {
58. hero.setAcc(new PVector(0, 0));
59. }
62. // Boundaries of our window
63. if (hero.loc.x<0) {
64. PVector newV = hero.getVel();
65. newV.x*=-1;
66. hero.setVel(newV);
67. }
68. if (hero.loc.x>width) {
69. PVector newV = hero.getVel();
70. newV.x*=-1;
71. hero.setVel(newV);
72. }
73. if (hero.loc.y<0) {
74. PVector newV = hero.getVel();
75. newV.y*=-1;
76. hero.setVel(newV);
77. }
78. if (hero.loc.y>height) {
79. PVector newV = hero.getVel();
80. newV.y*=-1;
81. hero.setVel(newV);
82. }
83. /*
84. if (button.activate){
85. if(hero.loc.x > 450 ||hero.loc.x< 150 || hero.loc.y>450 || hero.loc.y<150){
86. locked = false;
87. }
88. }
90. if (!locked){
91. // animate
92. // run particle system
93. // diminish alpha value of lab
94. }
95. */
96. }
98. class Arc {
99. float xpos, ypos;
100. float awidth, aheight;
101. float astart, astop;
102. float angle = 0;
103. float updater;
105. // not complitely usefull
106. float xline, yline;
107. float x1pin, y1pin, x2pin, y2pin;
108. float starta, stopa;
109. float goodAngle=0;
111. Arc(float xpos0, float ypos0, float awidth0, float aheight0, float astart0, float astop0) {
112. xpos = xpos0;
113. ypos = ypos0;
114. awidth = awidth0;
115. aheight = aheight0;
116. astart = astart0;
117. astop = astop0;
118. updater = random(1)/100;
119. xline=0;
120. yline=0;
121. }
124. void display() {
125. pushMatrix();
126. pushStyle();
127. stroke(255);
128. strokeWeight(4);
129. noFill();
130. translate(xpos, ypos);
131. rotate(angle);
132. arc(0, 0, awidth, aheight, astart, astop);
133. ellipse(awidth/2*cos(astart), aheight/2*sin(astart), 5, 5);
134. ellipse(awidth/2*cos(astop), aheight/2*sin(astop), 5, 5);
135. popStyle();
136. popMatrix();
137. angle += updater;
138. }
141. void collide(Hero h) {
142. // we have to use polar coordinate to ease collision detection.
144. // calculate hero radius
145. float hradius = dist (h.loc.x, h.loc.y, width/2, height/2);
147. // calculate hero angle
148. float hangle = acos(map(hero.loc.x, 0, width, -width/2, width/2) / (hradius));
149. float hangle2 = asin(map(hero.loc.y, 0, height, -height/2, height/2) / (hradius));
151. // calculate updated start and end angles
152. starta = (astart + angle);
153. stopa = (astop + angle);
155. // drawing ellipses at start and end of the arc
156. x1pin = (awidth/2) * cos(astart+angle)+width/2;
157. y1pin = (aheight/2) * sin(astart+angle)+height/2;
158. x2pin = (awidth/2) * cos(astop+angle)+width/2;
159. y2pin = (aheight/2) * sin(astop+angle)+height/2;
160. // start
161. fill(255, 0, 0);
162. ellipse(x1pin, y1pin, 5, 5);
163. text(starta, x1pin, y1pin);
164. //end
165. fill(0, 250, 0);
166. ellipse(x2pin, y2pin, 5, 5);
167. text(stopa, x2pin, y2pin);
169. // drawing from center to hero using polar coordinates to check if they are good
170. // notice that sometimes i need to use the value obtain by the sin and sometimes by the cos
171. // i think it's the reason I'm having a hard time figuring this out
172. if (hero.loc.x< width/2 && hero.loc.y<height/2) {
173. xline = width/2 + (hradius) * cos(hangle);
174. yline = height/2 + (hradius) *sin(hangle2);
175. }
176. if (hero.loc.x< width/2 && hero.loc.y>height/2) {
177. xline = width/2 + (hradius) * cos(hangle);
178. yline = height/2 + (hradius) *sin(hangle);
179. }
180. if (hero.loc.x> height/2 && hero.loc.y<height/2) {
181. xline = width/2 + (hradius) * cos(hangle2);
182. yline = height/2 + (hradius) *sin(hangle2);
183. }
184. if (hero.loc.x> height/2 && hero.loc.y>height/2) {
185. xline = width/2 + (hradius) * cos(hangle2);
186. yline = height/2 + (hradius) *sin(hangle);
187. }
188. line(width/2, height/2, xline, yline);
191. // collision first check radius
192. if (hradius-h.diameter/2<awidth/2+4 && hradius+h.diameter/2>awidth/2-4) {
193. // check angle
194. // ... ? ...
199. }
200. }
201. }
206. class Hero {
207. PVector loc;
208. PVector vel;
209. PVector acc;
210. float maxvel;
211. float mass;
212. // to tween our object
213. float diameter =30;
214. float sDist;
215. float tweenfactor=0;
216. float cellS, cellS2;
217. // to makeAppear() and makeDisAppear()
218. float alph = 0;
220. //The Constructor (called when the object is first created)
221. Hero(PVector a, PVector v, PVector l) {
222. acc = a;
223. vel = v;
224. loc = l;
225. maxvel = 4;
226. mass = 20;
227. }
228. //main function to operate object
229. void go() {
230. update();
231. render();
232. }
233. //function to update location
234. void update() {
235. vel.add(acc);
236. loc.add(vel);
237. //limit speed to max
238. if (vel.mag() > maxvel) {
239. vel.normalize();
240. vel.mult(maxvel);
241. }
242. }
243. //function to display
244. void render() {
245. strokeWeight(8);
246. stroke(220, alph);
247. fill(175, alph);
248. tween(); // change appearance while moving
249. ellipse(loc.x, loc.y, diameter-cellS, diameter+cellS2);
250. }
251. // transform movement (used in draw)
252. void applyForce(PVector force) {
253. force.div(mass); // Newton's second law
254. acc.add(force); // Accumulate acceleration
255. }
256. //Add functions to our thing object to access the location, velocity and acceleration from outside the class
257. PVector getVel() {
258. return vel.get();
259. }
260. PVector getAcc() {
261. return acc.get();
262. }
263. PVector getLoc() {
264. return loc.get();
265. }
266. void setLoc(PVector v) {
267. loc = v.get();
268. }
269. void setVel(PVector v) {
270. vel = v.get();
271. }
272. void setAcc(PVector v) {
273. acc = v.get();
274. }
276. // ou tween function !
277. void tween() {
278. // distance from mouse
279. sDist = dist(mouseX, mouseY, loc.x, loc.y);
280. // change tween factor (angle for our wavelet animation)
281. if (sDist>75) {
282. tweenfactor+=0.3;
283. }
284. else {
285. tweenfactor+= map(sDist, 0, 75, 0.09, 0.25);
286. }
287. //scale our multiplication factor for our tween effect
288. float sMult = map(sDist, 0, 100, 0.09*diameter, .25 * diameter);
289. // fill to global variables to affect the drawing of our ellipse
290. cellS = sMult * cos(tweenfactor);
291. cellS2 = sMult * (.5 +(cos(tweenfactor)/2));
292. }
294. // time related functions called whe starting and leaving
295. void makeAppear() {
296. alph+=1;
297. alph = constrain(alph, 0, 180);
298. }
299. void makeDisappear() {
300. alph-=1;
301. alph = constrain(alph, 0, 180);
302. }
303. }

Springs : my android app using processing and libpd

[6 Replies]
- 15-Oct-2012 10:33 AM
- Forum: Android Processing
Hi everyone,

I released my first android app using processin, you can check out following this link :

https://play.google.com/store/apps/details?id=processing.test.springs&feature=search_result#?t=W251bGwsMSwxLDEsInByb2Nlc3NpbmcudGVzdC5zcHJpbmdzIl0.

Hope you like it, feel free to give feedback or give suggestions !

cheers

Opengl 2d flickering

[5 Replies]
- 04-Oct-2012 10:05 AM
- Forum: Core Library Questions
Hello eveyrone,

I'm developping some animated visualization from eeg data and I've got a flickering problem.

I work on a machine that is not mine (a desktop win 7 64 bits), and when I run some sketches I've built on my machine (again win 7 64 bits but laptop) some flickering appears although everything is fine on mine. I've tried using v1.5.1 and v2.03b and it's the same issue.

Basically I'm rotating a 2D shape that is being deformed en real time by eeg data without erasing the background. My shape is built with curveVertex with a fill() call with a high transparency level to get some nice texturing, nothing really fancy.

I've found this thread : https://forum.processing.org/topic/opengl-alpha-flickering-gl-gldepthmask-false

and will try something like this as soon as I can, but it deals with 3D, so I'm not sure it will affect my code.

Moreover I'm a little curious about why it works on my machine but not the other one, I may want to check some windows settings but what ? I'm also thinking about the refresing rate of the screen, it's designed to be projected so maybe hooking it up to a vp would supress the flickering on the projected image.

Please let me know if you have any thoughts on the subject, thanks for reading !

libraries available for android

[1 Reply]
- 11-Apr-2012 08:36 AM
- Forum: Android Processing
Hello everyone,

I believe this a frequently asked question, but is there a place with a list of all the librairies that works with android ?

I only know the ketai lib, and the osc lib to be working.

Does anyone know any others ?

peasycam controlled by OSC

[3 Replies]
- 26-Jan-2012 07:42 AM
- Forum: Contributed Library Questions
Hello Everyone,

First post here, i'm just beginning to discover processing.

I wondered if there were any examples of peasycam being controlled using OSC . Peasycam does exactly what I want but using the mouse, I would like to be able to control the same movement using a message received via OSC. I know how to receive messages from OSC in processing, but I don't understand what I should do to make peasycam respond to them .

Basically I will receive X and Y values from Pure Data that will be used to look around, then when a condition is met it will be able to move in the 3D sketch using the same values

If someone could point me out to the right direction that would be great.

thanks again

Activity Trend