hello,

fascinating question.

This is a small sketch to demonstrate the 3D space and a 3D mouse.

The sketch shows a smal scene.
The sketch comes with 8 camera-positions you can cycle through with pressing SPACE.
1st camera from front (traditional), here called south. Then left (here called west), then north, then east,
then south, but higher up and equally high west, north and east again and then back to the beginning.

Use cursor keys to change camera x + and - and y + and - .
Also p and L for cam Z + and - ( u resets).


The red box denotes the 3D mouse.

Please note that when you look from west, the mouse-x still moves the virtual move X (although it looks like back and forth now).

Please note how easy it is now to paint 3D-Shapes now.

More usage:
SPACE-change cam; mouse drag or left-click to change 3D-mouse x and y position;
keys f and r to move 3D-mouse Z;
              right-click to set 3D-point.

Greetings, Chrisir    

1. //
2. // https://forum.processing.org/topic/determining-3d-mouse-position-using-z-coordinate-with-p3d-renderer
3. //
4. // program state
5. final int stateStartScreen = 0;
6. final int stateNormal = 1;
7. //
8. int state=stateStartScreen ;
9. //
10. final float floorY=600;
11. //
12. float CameraX;
13. float CameraY;
14. float CameraZ;
15. //
16. float angle; // for the blue bar
17. //
18. PVector mouse3D = new PVector();
19. //
20. String globalCamName="";
21. float angleNumAt; // for numAt // rotating numbers (using angle angleNumAt in degrees)
22. //
23. CameraPosition [] cameraPositions = new CameraPosition[8];
24. int indexCameraPositions=0;
25. //
26. ArrayList<Ball> balls; // the points of the shape you draw
27. //
28. void setup()
29. {
30.   size( 800, 800, P3D );
31.   balls = new ArrayList();
32.   //
33.   CameraX = 0;
34.   CameraY = 0;
35.   CameraZ = 0;
36.   //  noCursor();
37.   mouse3D.set(width/2, height/2, 0);
38.   // default cam
39.   cameraPositions[0] = new CameraPosition(new PVector(width/2.0, height/2.0, (height/2.0) / tan(PI*30.0 / 180.0)),
40.   new PVector (  width/2.0, height/2.0, 0   ),
41.   new PVector (   0, 1, 0  ),
42.   "from south (default)" );
43.   //
44.   cameraPositions[1] = new CameraPosition(new PVector(-320, height/2.0, -10),
45.   new PVector (  width/2.0, height/2.0, 0   ),
46.   new PVector (   0, 1, 0  ),
47.   "from west" );
48.   //
49.   cameraPositions[2] = new CameraPosition(new PVector(width/2.0, height/2.0, -1 * ( (height/2.0) / tan(PI*30.0 / 180.0))),
50.   new PVector (  width/2.0, height/2.0, 0   ),
51.   new PVector (   0, 1, 0  ),
52.   "from north " );
53.   //
54.   cameraPositions[3] = new CameraPosition(new PVector(width+320, height/2.0, -10),
55.   new PVector (  width/2.0, height/2.0, 0   ),
56.   new PVector (   0, 1, 0  ),
57.   "from east " );
58.   //
59.   // now all 4 directions but higher
60.   int i=0;
61.   cameraPositions[4] = new CameraPosition( new PVector (cameraPositions[i].pos.x, cameraPositions[i].pos.y, cameraPositions[i].pos.z),
62.   new PVector (cameraPositions[i].lookAt.x, cameraPositions[i].lookAt.y, cameraPositions[i].lookAt.z),
63.   new PVector (cameraPositions[i].up.x, cameraPositions[i].up.y, cameraPositions[i].up.z),
64.   "from south (higher) " );
65.   cameraPositions[4].pos.y -= 300; 
66.   //
67.   i=1;
68.   cameraPositions[5] = new CameraPosition( new PVector (cameraPositions[i].pos.x, cameraPositions[i].pos.y, cameraPositions[i].pos.z),
69.   new PVector (cameraPositions[i].lookAt.x, cameraPositions[i].lookAt.y, cameraPositions[i].lookAt.z),
70.   new PVector (cameraPositions[i].up.x, cameraPositions[i].up.y, cameraPositions[i].up.z),
71.   "from west (higher) " );
72.   cameraPositions[5].pos.y = cameraPositions[4].pos.y ;
73.   //
74.   i=2;
75.   cameraPositions[6] = new CameraPosition( new PVector (cameraPositions[i].pos.x, cameraPositions[i].pos.y, cameraPositions[i].pos.z),
76.   new PVector (cameraPositions[i].lookAt.x, cameraPositions[i].lookAt.y, cameraPositions[i].lookAt.z),
77.   new PVector (cameraPositions[i].up.x, cameraPositions[i].up.y, cameraPositions[i].up.z),
78.   "from north (higher) " );
79.   cameraPositions[6].pos.y = cameraPositions[4].pos.y ;
80.   //
81.   i=3;
82.   cameraPositions[7] = new CameraPosition( new PVector (cameraPositions[i].pos.x, cameraPositions[i].pos.y, cameraPositions[i].pos.z),
83.   new PVector (cameraPositions[i].lookAt.x, cameraPositions[i].lookAt.y, cameraPositions[i].lookAt.z),
84.   new PVector (cameraPositions[i].up.x, cameraPositions[i].up.y, cameraPositions[i].up.z),
85.   "from east (higher) " );
86.   cameraPositions[7].pos.y = cameraPositions[4].pos.y ;
87.   //
88.   //
89. } // setup
90. //
91. void draw()
92. {
93.   background(0);
94.   switch (state) {
95.   case stateStartScreen:
96.     fill(255);
97.     String text1 = "This is a small sketch to demonstrate the 3D space and a 3D mouse. \n\n"
98.       +"credit http://forum.processing.org/topic/determining-3d-mouse-position-using-z-coordinate-with-p3d-renderer \n"
99.       + "The sketch shows a smal scene. The sketch comes with 8 camera-positions you can cycle through with pressing SPACE. \n"
100.       +"1st camera from front (traditional), here called south. Then left (here called west), then north, then east, \n"
101.       +"then south, but higher up and equally high west, north and east again and then back to the beginning. \n\n"
102.       +"Use cursor keys to change camera x + and - and y + and - . Also p and L for cam Z + and - (u resets).\n\n\n"
103.       +"The red box denotes the 3D mouse. \n\n"
104.       +"Please note that when you look from west, the mouse-x still moves the virtual move X (although it looks like back and forth now). \n\n"
105.       +"Please note how easy it is now to paint 3D-Shapes now. \n\n"
106.       +"usage: SPACE-change cam; mouse drag or left-click to change 3D-mouse x and y position; key f and r to move z; "
107.       +"\n              right-click to set 3D-point.\n\n\n"
108.       +"Press any key.";
109.     // println(text1);
110.     text (text1, 30, 50, width-50, 1900);
111.     break;
112.   case stateNormal:
113.     drawForStateNormal();
114.     break;
115.   } // switch
116. } // func
117. //
118. void drawForStateNormal() {
119.   // help
120.   camera();
121.   fill(255);
122.   text ("usage: SPACE-change cam; mouse drag or left-click to change 3D-mouse x and y position; key f and r to move z; "
123.     +"\n              right-click to set 3D-point", 30, 50);
124.   text("3D-mouse pos: " + mouse3D.x+", "+mouse3D.y+", "+mouse3D.z, width-250, 70);
125.   text("cam pos: "
126.     +  str( cameraPositions[ indexCameraPositions ].pos.x + CameraX)
127.     +  ", "
128.     +  str( cameraPositions[ indexCameraPositions ].pos.y + CameraY)
129.     +  ", "
130.     +  str( cameraPositions[ indexCameraPositions ].pos.z + CameraZ), width-250, 100);
131.   //
132.   text("camera is "
133.     +globalCamName
134.     + ", #"
135.     +indexCameraPositions, 30, 30);
136.   // camera 
137.   cameraPositions[ indexCameraPositions ].use();
138.   //
139.   //
140.   // Floor
141.   drawFloor();
142.   // some stuff
143.   fill (0, 0, 255); // blue
144.   boxAt(100, 600-20, 0);
145.   numAt(100, 600-20, 0, 1);
146.   fill (255, 0, 255); // pink
147.   boxAt(100, 600-20, -160);
148.   numAt(100, 600-20, -160, 2);
149.   fill (255, 255, 0); // yellow
150.   boxAt(700, 600-20, -160);
151.   numAt(700, 600-20, -160, 3);
152.   fill (0, 255, 0); // green
153.   boxAt(700, 600-20, 0);
154.   numAt(700, 600-20, 0, 4);
155.   angleNumAt++;
156.   // ==================================================
157.   //
158.   //
159.   // show virtual 3D mouse
160.   pushMatrix();
161.   fill(255, 2, 2);
162.   translate(mouse3D.x, mouse3D.y, mouse3D.z);
163.   box (20, 20, 20);
164.   popMatrix();
165.   //
166.   // paint blue bar / box
167.   stroke(111, 110, 110);
168.   fill(111, 110, 110);
169.   pushMatrix();
170.   translate(width/2, 0, 0);
171.   rotateY(angle);
172.   MyBox (-100, 350, -0,
173.   100, 350, -0,
174.   15, color (2, 0, 255));
175.   popMatrix();
176.   angle+=.01;
177.   //
178.   // for-loop
179.   Ball ball2=null;
180.   for (int i = 0; i < balls.size()-1; i++) {
181.     Ball ball = balls.get(i);
182.     ball.display();
183.     ball2 = balls.get(i+1);
184.     ball2.display();
185.     stroke(144);
186.     line (ball.x, ball.y, ball.z,
187.     ball2.x, ball2.y, ball2.z);
188.   } // for
189.   //
190.   stroke(90);
191.   if (ball2!=null)
192.     line (   ball2.x, ball2.y, ball2.z,
193.     mouse3D.x, mouse3D.y, mouse3D.z  );
194.   //
195.   //  // a new for-loop to delete balls
196.   //  // (it is better to have 2 separate for-loops)
197.   //  for (int i = balls.size()-1; i >= 0; i--) {
198.   //    Ball ball = balls.get(i);
199.   //    if (ball.y+ball.h > height) {
200.   //      balls.remove(i);
201.   //    } // if
202.   //  } // for
203.   //
204. } // func
205. //
206. void keyPressed() {
207.   //
208.   switch (state) {
209.     //
210.   case stateStartScreen:
211.     state=stateNormal;
212.     break;
213.   default:
214.     if (key == CODED) {
215.       // cursor is for camera
216.       if (keyCode == UP) {
217.         CameraY-=10;
218.       }
219.       else if (keyCode == DOWN) {
220.         CameraY+=10;
221.       }
222.       else if (keyCode == RIGHT) {
223.         CameraX+=10;
224.       }
225.       else if (keyCode == LEFT) {
226.         CameraX-=10;
227.       }
228.       else {
229.         // nothing
230.       }
231.     }
232.     else { 
233.       // not key == CODED
234.       //
235.       if (key=='r') {
236.         mouse3D.z-=11;
237.       }
238.       else if (key=='f') {
239.         mouse3D.z+=11;
240.       }
241.       else if (key=='p') {
242.         CameraZ-=11;
243.       }
244.       else if (key=='l'||key=='L') {
245.         CameraZ+=11;
246.       }
247.       else if (key=='u'||key=='U') {
248.         CameraX=0;
249.         CameraY=0;
250.         CameraZ=0;
251.       }     
252.       else if (key==' ') {
253.         // SPACE
254.         indexCameraPositions++;
255.         if (indexCameraPositions >= cameraPositions.length) {
256.           indexCameraPositions=0;
257.         }
258.       }
259.     }
260.     break;
261.   }
262. }
263. //
264. void boxAt(float x, float y, float z) {
265.   pushMatrix();
266.   translate(x, y, z);
267.   box (20, 20, 20);
268.   popMatrix();
269. }
270. //
271. void numAt(float x, float y, float z, int num) {
272.   // rotating numbers (using angle angleNumAt)
273.   pushMatrix();
274.   translate(x, y-19, z);
275.   rotateY(radians(angleNumAt));
276.   text ( str (num), -2, 0, 0);
277.   popMatrix();
278. }
279. //
280. void MyBox(float x1, float y1, float z1,
281. float x2, float y2, float z2,
282. float weight, color strokeColour)
283. // was called drawLine; programmed by James Carruthers
284. // see http://processing.org/discourse/yabb2/YaBB.pl?num=1262458611/0#9
285. {
286.   PVector p1 = new PVector(x1, y1, z1);
287.   PVector p2 = new PVector(x2, y2, z2);
288.   PVector v1 = new PVector(x2-x1, y2-y1, z2-z1);
289.   float rho = sqrt(pow(v1.x, 2)+pow(v1.y, 2)+pow(v1.z, 2));
290.   float phi = acos(v1.z/rho);
291.   float the = atan2(v1.y, v1.x);
292.   v1.mult(0.5);
293.   pushMatrix();
294.   translate(x1, y1, z1);
295.   translate(v1.x, v1.y, v1.z);
296.   rotateZ(the);
297.   rotateY(phi);
298.   noStroke();
299.   fill(strokeColour);
300.   box(weight, weight, p1.dist(p2)*1.2);
301.   popMatrix();
302. }
303. void drawFloor() {
304.   stroke(255);
305.   // draw floor:
306.   //
307.   // to right (background)
308.   line ( 20, floorY, -200,
309.   width-20, floorY, -200);
310.   // to right (in the front)
311.   line ( 20, floorY, -0,
312.   width-20, floorY, -0);
313.   // left side
314.   line ( 20, floorY, -200,
315.   20, floorY, -0);
316.   // right side  
317.   line ( width-20, floorY, -200,
318.   width-20, floorY, -0);
319. }
320. //
321. void mouseReleased() {
322.   if (mouseButton == LEFT)
323.   {
324.     float dx = mouseX ;
325.     float dy = mouseY ;
326.     mouse3D.x=dx;
327.     mouse3D.y=dy;
328.   } // if
329.   else if (mouseButton == RIGHT) {
330.     balls.add(new Ball(mouse3D.x, mouse3D.y, mouse3D.z,
331.     10, 5, 10,
332.     1, 11, 252));
333.   } // else if
334. } // func
335. //
336. void mouseDragged() {
337.   float dx = mouseX - pmouseX;
338.   float dy = mouseY - pmouseY;
339.   mouse3D.x+=dx;
340.   mouse3D.y+=dy;
341. }
342. //
343. // classes
344. // ======================================================
345. class CameraPosition {
346.   // see http://www.processing.org/reference/camera_.html
347.   PVector pos;     // eye
348.   PVector lookAt;  // center
349.   PVector up;      // up
350.   String name = "";
351.   //
352.   // constr
353.   CameraPosition ( PVector pos_, PVector lookAt_, PVector up_, String name_ ) {
354.     //
355.     pos    = pos_;
356.     lookAt = lookAt_;
357.     up     = up_;
358.     name   = name_;
359.     //
360.   } // constr
361.   //
362.   void use () {
363.     camera(pos.x+CameraX, pos.y+CameraY, pos.z+CameraZ,
364.     lookAt.x, lookAt.y, lookAt.z,
365.     up.x, up.y, up.z);
366.     globalCamName=name;
367.   } // method
368.   //
369.   //  void print() {
370.   //    printCamera();
371.   //  } // method
372.   //
373.   //
374. } // classs
375. //
376. // ==================================================
377. class Ball { 
378.   // pos
379.   float x;
380.   float y;
381.   float z;
382.   // size
383.   float w;
384.   float h;
385.   float d;
386.   // color // or use color
387.   float r, g, b;
388.   Ball(float tempX, float tempY, float tempZ,
389.   float tempW, float tempH, float tempD,
390.   float tempR, float tempG, float tempB) {
391.     x = tempX;
392.     y = tempY;
393.     z = tempZ;
394.     //
395.     w = tempW;
396.     h = tempH;
397.     d = tempD;
398.     //
399.     // color
400.     r = tempR;
401.     g = tempG;
402.     b = tempB;
403.     //
404.   }
405.   //
406.   void display() {
407.     fill(r, g, b);
408.     pushMatrix();
409.     translate(x, y, z);
410.     box (w, h, d);
411.     popMatrix();
412.   }
413.   //
414. } // class
415. //