# 3d punkt -> 2d punkt



## hdi (16. Dez 2008)

Hey, spiele seit heute etwas mit 3D herum, und es gibt zig Tutorials für diesen Zweck, und ich hab mir auch ein denk ich
sehr gutes geschnappt. Es tut sich auch was, aber ich kann's nicht richtig kontrollieren, weil ich nicht alles komplett
verstehe. Ich sag einfach mal, was ich tue, und was ich mir dabei denke:

1) ich erstelle einen 3*3*3 Würfel, wobei ich für die 27 Blöcke jeweils acht 3d-punkte habe, wobei -inf < z <= 0. 
D.h. die oberste Ebene des Würfels liegt bei z = 0. Dass z in den negativen Bereich geht, liegt daran dass mein
Tutorial sagt, es ist leichter so. Der Beobachter hockt an Stelle (0,0,0) und kuckt in den negativen z-Achsen Bereich, wo
eben die Objekte liegen.

2) Umwandeln tu ich die 3d-punkte dann so:


```
return new Point((int) (d * x / -z), (int) (d * y / -z));
```

wobei "d" ein float-wert ist, der die Distanz zwischen dem Beobachter (nochmal: 0,0,0) und der View-Ebene ist, auf die diese Punkte projiziert werden. Hier kommt der der mir etwas ungreifbare Teil:

Ich setze die Distanz anfangs auf folgenden Wert:


```
distance = (xDim / 2) / (float) Math.tan(angle / 2);
```

wobei xDim bei mir jetzt die Breite meines Fensters ist, und "angle" hab ich so gesetzt:


```
angle = (float) Math.toRadians(75);
```

Im Tutorial steht, man nimmt halt für den Blickwinkel so Werte wie 60,75,90, und ich soll doch einfach mal 75 nehmen. 
Ich verstehe das nicht ganz, 75 Grad zu was? Wenn mein Fenster zB 200*200 px gross ist, dann kommt bei distance
der Wert 130 heraus. Ich kann damit nix anfangen, wieso 130? Wie hängt das mit dem Winkel zusammen?

Und wo sag ich denn eigentlich, dass ich jetz von Position (0,0,0) auf das alles schaue? Weil das tu ich nirgends,
das Ding ist mein Würfel wird gezeichnet, aber z.T. "hinter" mir, ich seh nur die tiefere Hälfte. Ich hab ein wenig
mit z herumgespielt und es sind die verwirrendsten Dinge herausgekommen.

Also...das Mapping von 3d zu 2d an sich versteh ich schon, aber ich verstehe nicht wie ich genau festlege, wo
der Beobachter ist, und was überhaupt der Blickwinkel genau aussagt, und wie daraus genau diese distance zu Stande kommt.

Danke!


----------



## Marco13 (16. Dez 2008)

hdi hat gesagt.:
			
		

> Hey, spiele seit heute etwas mit 3D herum



Aha... :roll:



			
				hdi hat gesagt.:
			
		

> ```
> distance = (xDim / 2) / (float) Math.tan(angle / 2);
> ```
> 
> ...



Vermutlich (aufgrund der wenigen Information ist das aber nur geraten) sind diese 75° der FOV (Field-Of-View) - also der "Öffnungswinkel des Kamerablickfeldes" (Bei einer echten Kamera wäre das glaubich ... die Brennweite? Oder die Inverse davon...). Die 130 wären dann die Entfernung, die man braucht um den beschriebenen Bildausschnitt zu sehen.



			
				hdi hat gesagt.:
			
		

> Und wo sag ich denn eigentlich, dass ich jetz von Position (0,0,0) auf das alles schaue? Weil das tu ich nirgends, ...



Kommt drauf an - "Software", Java3D, JOGL, LWJGL, JMonkeyEngine, World of Warcraft .... es gibt viele Möglichkeiten, "mit 3D rumzuspielen"....


----------



## hdi (17. Dez 2008)

Hm ok, ich hab jetz noch etwas rumexperimentiert, und inzwischen wird mir der Würfel zumindest vollständig angezeigt, aber irgendwie noch immer falsch.

angle = 75°
distance = 130 (bei Fenster-Grösse 300*300)

d.h. ja mein Field-Of-View ist in der Ebene bei z = -130, oder wie?

Jetzt hab ich 4 Punkte bei z = -130 und 4 weitere bei z = -230, d.h. die Kantenlänge von meinem Würfel ist 100.
der obere (vordere) linke Punkt ist bei (width/2 - 50), d.h. mein Würfel passt dann auch ins Fenster vom Platz her.

Ich hab alle Punkte mit der o.g. Formel von 3d nach 2d transformiert und dann jeweils verbunden, und 
rauskommen tut das hier:





Aber ich versteh die Zusammenhänge noch immer nicht, z.B. wenn ich die Würfel-Punkte jetzt nicht bei z = -130 (vordere Ebene) bzw. z = -230 (hintere) setze, sondern sagen wir mal: 
vordere: z = -60
hintere: z = -160

dann kommt das hier raus:





Wieso ist die hintere Ebene noch immer auf dem gleichen Platz? Die Kantenlänge des Würfels hat sich nicht vergrössert, nur seine Position ist nach vorne gerutscht. Wieso wird der Würfel so komisch gestreckt angezeigt?

Und woher weiss ich, welche Positionen die 3d-punkte kriegen müssen, damit ich den Würfel als Quadrat sehe, was er ist, und nicht so komisch verzerrt? Ich rat hier nur rum, versteh das nicht


----------



## Marco13 (17. Dez 2008)

_Ich rat hier nur rum, versteh das nicht_
Ich bin gerade nicht sicher, wo das Frustrationspotential größer ist: Beim Rumraten (und nicht verstehen) oder beim Versuch, es DOCH zu verstehen. Es kann nämlich ziemlich kompliziert werden. 

Ich würde dir empfehlen, viel zu lesen, dir das aufzumalen, und solche Sachen wie http://en.wikipedia.org/wiki/3D_projection nachzuvollziehen und ggf. zur Verifikation zu verwenden. Du kannst per Hand ausrechnen, welche x-Koordinate die linke, hintere Kante deines Würfels haben müßte, und dann nachsehen, ob es stimmt (unabhängig davon ob es richtig oder falsch AUSSIEHT - es geht nur um die Frage, ob es richtig IST :wink: )

"Rumraten" ist problematisch - aber hilfreich könnte es im Falle dieses Würfels sein, "ein Gefühl" dafür zu entwickeln, ob das, was man da sieht, plausibel ist. Du könntest einen MouseMotionListener und einen MouseWheelListener an deinen Zeichenbereich hängen, so dass du den Würfel mit der Maus in x- und y-Richtung bewegen und mit dem Mausrad in z-Richtung verschieben kannst. Wenn er in einem Moment noch "richtig aussieht", und bei der kleinsten Verschiebung vollkommen ":autsch:" wird, erkennt man Fehler u.U. leichter...


----------



## hdi (17. Dez 2008)

Ja also mein Tutorial erklärt es eig. genauso wie der wiki-link, und an sich find ich es auch logisch, aber ich versteh scheinbar etwas falsch. Nochmal Schritt für Schritt, wär nett wenn du mir sagst wo mein Denk-/Verständnisfehler liegt:

1) Ich habe ein Fenster mit ner bestimmten grösse, zB 200*200

2) Für weiteres gehe ich davon aus, dass ich ein "right-handed" Koordinaten-System habe, d.h. x geht nach
rechts, y nach oben und z nach links unten. Ausserdem ist meine Kamera auf 0,0,0 und schaut in  Richtung -z (!) 

2) Ich lege eine Blickweite "angle" fest, und zwar geht der Winkel von der z-Achse in Richtung y-Achse (nach oben), ausgehend vom Punkt 0,0,0. D.h. je grösser mein Winkel, desto geringer muss der Abstand zum Field of View sein damit ich das ganze Fenster sehe (soweit alles logisch)

3) Ich berechne diese Distanz zwischen der Kamera bei 0,0,0 und dem Field Of View, damit man dieses komplett sehen kann:
distance = (width/2) / (angle/2)

4) Das heisst ja nun, dass mein FOV in der Ebene bei z = -distance liegt, wenn ich in Minus-Richtung die z-Achse entlang kucken will

5) Also darf ich dem Modell nur z-Punkte <= -distance geben, weil ja alle Objekte hinter dem FOV liegen müssen.
zB ein Punkt (0,0,-distance) wäre wie oben schon gesagt genau im Zentrum des FOV

Ich glaube das hier ist falsch, weil in nem Code-Bsp werden Objekte mit z = 0 erstellt, das Bsp ist leider nicht
ausführbar (Ich habe dazu Tonnen von Code mit main-Methoden, aber Eclipse sagt mir beim Start dass er keine
main findet  )

6) Zum Umwandeln der 3d-Punkte zu 2D benutze ich diese Formel:


```
p = new Point((int) (distance * this.x / -this.z), (int) (distance* this.y / -this.z));
```

Dann sind das jetzt die Koordinaten auf dem FOV. 

7) Dann ist ja noch von einer weiteren Umwandlung die Rede: Vom FOV zum Screen. Aber hier würd ich erstmal
stoppen, weil ich denke ich habe bis jetzt schon was falsch verstanden.

Freu mich auf die Hilfe :bae:


----------



## Marco13 (17. Dez 2008)

Erstmal vorneweg: Es ist schon eine Weile her, dass ich mich mit so low-leveligen Sachen beschäftigt habe. Also ... nicht erwarten, dass ich auf Basis eines Bildes und einiger Stichpunkte "DIE" Lösung aus dem Hut zaubere.

_4) Das heisst ja nun, dass mein FOV in der Ebene bei z = -distance liegt, wenn ich in Minus-Richtung die z-Achse entlang kucken will_

Was du mit "dem FOV" meinst, ist mir nicht klar. Es gibt einen Augpunkt und eine Blickrichtung (und up-vector, und FOV-Öffnungswinkel usw...). Der Augpunkt würde bei dir wohl bei z = -distance liegen....

_5) Also darf ich dem Modell nur z-Punkte <= -distance geben, weil ja alle Objekte hinter dem FOV liegen müssen.
zB ein Punkt (0,0,-distance) wäre wie oben schon gesagt genau im Zentrum des FOV_

Neee ???:L höh ... also, das Auge liegt bei (0,0,-distance). Dann müßte der Punkt (0,0,0) eigentlich im Zentrum des Blickfeldes liegen - und die z-Werte der Objekte müßten sinnvollerweise GRÖSSER als -distance sein ... Mit z=0 sollte man die Objekte also sehen können.

_6) Zum Umwandeln der 3d-Punkte zu 2D benutze ich diese Formel:_

```
p = new Point((int) (distance * this.x / -this.z), (int) (distance* this.y / -this.z));
```

Da ist mir jetzt der Zusammenhang und die Variablenbelegung nicht klar - FALLS "this.z == -distance" ist, macht die Formel nicht so viel Sinn...

Poste vielleicht mal ein Copy&Paste&Compile-Fähiges Porgramm, falls das geht, und beschreibe das, was du erwartest...


----------



## hdi (17. Dez 2008)

Hier mal ein paar Bilder aus dem Tut, damit du mehr verstehst wie ich das grad sehe:





Ich versteh einfach nicht welche Koorindaten ich den 3d-Punkten jetzt geben soll.

Wenn ich will dass mein Würfel in der Mitte des Screens angezeigt wird, von vorne, also nur als 2D Quadrat
sichtbar, welche Koordinaten muss ich ihm geben? Ich krieg's nicht hin, ich weiss jetzt auch nicht was ich dazu
noch gross sagen soll, ich häng total in der Luft. 

Das funktioniert irgendwie alles nicht...


----------



## hdi (17. Dez 2008)

So hier n ausführbares Programm. Mit dem Wheel kannste das Objekt der Tiefe nach bewegen.

Was ich eigentlich erwartet hatte: Dass ich nur ein 2D-Quadrat sehe, weil ich eig. dachte mit den geg. Koordinaten zeige ich den Würfel frontal. Und zwar in der Mitte vom Fenster. Wieso ich ihn aus diesem komischen Winkel sehe, verstehe ich nicht, genauso wenig warum er dauernd so komisch gestreckt aussieht, obwohl alle Kanten gleichlang sind...


```
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Cube3DTest extends JFrame implements MouseListener,
		MouseWheelListener {

	public static Cube3DTest c3dtest;

	public static void main(String[] args) {
		c3dtest = new Cube3DTest();
		c3dtest.setVisible(true);
	}

	public int width = 200;
	public int height = 200;
	public JPanel panel;
	public float distance;
	public float angle;

	public Cube cube;

	public Cube3DTest() {
		super("3D Demo");

		/* view setup */
		angle = (float) Math.toRadians(90);
		distance = (width / 2) / (float) (Math.tan(angle / 2));
		System.out.println("distance: " + distance);

		panel = new JPanel() {
			@Override
			protected void paintComponent(Graphics g) {
				super.paintComponent(g);
				cube.project(g);
			}
		};
		panel.setPreferredSize(new Dimension(300, 300));
		add(panel);
		pack();
		setLocationRelativeTo(null);
		setDefaultCloseOperation(EXIT_ON_CLOSE);

		this.addMouseListener(this);
		this.addMouseWheelListener(this);

		cube = new Cube();
	}

	class Cube {

		public int size = 50; // kantelänge
		Vector3D ulf, urf, llf, lrf; // upper left front, upper right front, usw..
		Vector3D ulb, urb, llb, lrb; // upper left back ,...

		public Cube() {
                        // würfel soll zentriert sein, die koordinaten für den oberen linken (front-)punkt also:
			int startx = width / 2 - size / 2; 
			int starty = height / 2 - size / 2;

                       // alle 8 würfel-punkte:
			ulf = new Vector3D(startx, starty, 0);
			urf = new Vector3D(startx + size, starty, 0);
			llf = new Vector3D(startx, starty+size, 0);
			lrf = new Vector3D(startx + size, starty + size, 0);

			ulb = new Vector3D(startx, starty, -size);
			urb = new Vector3D(startx + size, starty, -size);
			llb = new Vector3D(startx, starty+size, -size);
			lrb = new Vector3D(startx + size, starty + size, -size);
		}

		public void project(Graphics g) {
			
			Point pulf = ulf.to2D();
			Point purf = urf.to2D();
			Point pllf = llf.to2D();
			Point plrf = lrf.to2D();
			Point pulb= ulb.to2D();
			Point purb= urb.to2D();
			Point pllb= llb.to2D();
			Point plrb= lrb.to2D();

			g.drawLine(pulf.x, pulf.y, purf.x, purf.y);
			g.drawLine(pulf.x, pulf.y, pllf.x, pllf.y);
			g.drawLine(pulf.x, pulf.y, pulb.x, pulb.y);
			g.drawLine(purb.x, purb.y, pulb.x, pulb.y);
			g.drawLine(pllb.x, pllb.y, pulb.x, pulb.y);
			g.drawLine(pllb.x, pllb.y, pllf.x, pllf.y);
			g.drawLine(pllb.x, pllb.y, plrb.x, plrb.y);
			g.drawLine(purb.x,purb.y, plrb.x, plrb.y);
			g.drawLine(purb.x,purb.y, purf.x, purf.y);
			g.drawLine(plrf.x, plrf.y, purf.x, purf.y);
			g.drawLine(plrf.x, plrf.y, pllf.x, pllf.y);
			g.drawLine(plrf.x, plrf.y, plrb.x, plrb.y);
		}

		public void further() {
			ulf.z -= 1;
			urf.z -= 1;
			llf.z -= 1;
			lrf.z -= 1;
			ulb.z -= 1;
			urb.z -= 1;
			llb.z -= 1;
			lrb.z -= 1;

		}

		public void closer() {
			ulf.z += 1;
			urf.z += 1;
			llf.z += 1;
			lrf.z += 1;
			ulb.z += 1;
			urb.z += 1;
			llb.z += 1;
			lrb.z += 1;

		}
	}

	class Vector3D {
		public float x, y, z;

		public Vector3D(float x, float y, float z) {
			this.x = x;
			this.y = y;
			this.z = z;
		}

		public String toString() {
			return "(" + x + "," + y + "," + z + ")";
		}

		public Point to2D() {

			Point p;
			/* 3d -> 2d */
			float Z = distance + z;
			p = new Point((int) (distance * this.x / Z), (int) (distance
					* this.y / Z));

			System.out.println(this + " -> (" + p.x + "," + p.y + ")");
			return p;
		}
	}

	@Override
	public void mouseWheelMoved(MouseWheelEvent e) {
		if (e.getWheelRotation() < 0) {
			// zoom in
			cube.closer();
			panel.repaint();
		} else {
			// zoom out
			cube.further();
			panel.repaint();
		}

	}

	@Override
	public void mouseClicked(MouseEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void mouseEntered(MouseEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void mouseExited(MouseEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void mousePressed(MouseEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void mouseReleased(MouseEvent e) {
		// TODO Auto-generated method stub

	}
}
```


----------



## Marco13 (17. Dez 2008)

Ja, die Kamera ist bei 0,0,-distance, und man schaut die Achse entlang... Damit der Würfel zentriert ist, bräuchte die vordere Seite so Koordinaten wie

```
(-50,50) X----------X(50,50)
         |          |
         |          |
         |    o     |
         | Ursprung |
         |          |
(-50,-50)X----------X(50,-50)
```

Das sieht man auch ganz gut, wenn man der Empfehlng folgt (*räusper*) und den Würfel verschiebbar macht: Wenn man ihn so verschiebt, dass das Zentrum der Frontseite in der linken oberen Bildschirmecke (bei (0,0)) ist, sieht er schon richtiger aus. 

Man kann diese Verschiebung nachträglich reinrechnen. Das ganze ist ja jetzt sowieso SEHR speziell und SEHR rudimentär (wenn du ein Objekt mit 10000 Punkten hast, wirst du ja nicht 10000 Variablen erstellen - und die Projektion ist auch SEHR speziell für den aktuellen Fall....)

Hab' das mal angehängt.

Die starke Verzerrung rührte übrigens nicht zuletzt daher, dass ein FOV-Winkel von 90° schon ziemlich viel ist. Hab ihn mal reduziert

```
// Von [url]http://www.java-forum.org/de/viewtopic.php?t=79882&highlight=&sid=40d8724fd9a6b1867fc2dfd07780a23a[/url]

import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.*;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Cube3DTest extends JFrame implements MouseListener, MouseMotionListener,
      MouseWheelListener {

   public static Cube3DTest c3dtest;

   public static void main(String[] args) {
      c3dtest = new Cube3DTest();
      c3dtest.setVisible(true);
   }

   public int width = 200;
   public int height = 200;
   public JPanel panel;
   public float distance;
   public float angle;
   Point prev = new Point();
   public Cube cube;

   public Cube3DTest() {
      super("3D Demo");

      /* view setup */
      angle = (float) Math.toRadians(40);
      distance = (width / 2) / (float) (Math.tan(angle / 2));
      System.out.println("distance: " + distance);

      panel = new JPanel() {
         @Override
         protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            cube.project(g);
         }
      };
      panel.setPreferredSize(new Dimension(300, 300));
      add(panel);
      pack();
      setLocationRelativeTo(null);
      setDefaultCloseOperation(EXIT_ON_CLOSE);

      this.addMouseListener(this);
      this.addMouseMotionListener(this);
      this.addMouseWheelListener(this);

      cube = new Cube();
   }

   class Cube {

      public int size = 50; // kantelänge
      Vector3D ulf, urf, llf, lrf; // upper left front, upper right front, usw..
      Vector3D ulb, urb, llb, lrb; // upper left back ,...

      public Cube() {
                        // würfel soll zentriert sein, die koordinaten für den oberen linken (front-)punkt also:
         int startx = width / 2 - size / 2;
         int starty = height / 2 - size / 2;

                       // alle 8 würfel-punkte:
         ulf = new Vector3D(startx, starty, 0);
         urf = new Vector3D(startx + size, starty, 0);
         llf = new Vector3D(startx, starty+size, 0);
         lrf = new Vector3D(startx + size, starty + size, 0);

         ulb = new Vector3D(startx, starty, -size);
         urb = new Vector3D(startx + size, starty, -size);
         llb = new Vector3D(startx, starty+size, -size);
         lrb = new Vector3D(startx + size, starty + size, -size);
      }

      public void move(int dx, int dy)
      {
         ulf.x += dx;
         urf.x += dx;
         llf.x += dx;
         lrf.x += dx;
         ulb.x += dx;
         urb.x += dx;
         llb.x += dx;
         lrb.x += dx;

         ulf.y += dy;
         urf.y += dy;
         llf.y += dy;
         lrf.y += dy;
         ulb.y += dy;
         urb.y += dy;
         llb.y += dy;
         lrb.y += dy;

      }


      public void project(Graphics g) {

         Point pulf = ulf.to2D();
         Point purf = urf.to2D();
         Point pllf = llf.to2D();
         Point plrf = lrf.to2D();
         Point pulb= ulb.to2D();
         Point purb= urb.to2D();
         Point pllb= llb.to2D();
         Point plrb= lrb.to2D();

         g.drawLine(pulf.x, pulf.y, purf.x, purf.y);
         g.drawLine(pulf.x, pulf.y, pllf.x, pllf.y);
         g.drawLine(pulf.x, pulf.y, pulb.x, pulb.y);
         g.drawLine(purb.x, purb.y, pulb.x, pulb.y);
         g.drawLine(pllb.x, pllb.y, pulb.x, pulb.y);
         g.drawLine(pllb.x, pllb.y, pllf.x, pllf.y);
         g.drawLine(pllb.x, pllb.y, plrb.x, plrb.y);
         g.drawLine(purb.x,purb.y, plrb.x, plrb.y);
         g.drawLine(purb.x,purb.y, purf.x, purf.y);
         g.drawLine(plrf.x, plrf.y, purf.x, purf.y);
         g.drawLine(plrf.x, plrf.y, pllf.x, pllf.y);
         g.drawLine(plrf.x, plrf.y, plrb.x, plrb.y);
      }

      public void further() {
         ulf.z -= 1;
         urf.z -= 1;
         llf.z -= 1;
         lrf.z -= 1;
         ulb.z -= 1;
         urb.z -= 1;
         llb.z -= 1;
         lrb.z -= 1;

      }

      public void closer() {
         ulf.z += 1;
         urf.z += 1;
         llf.z += 1;
         lrf.z += 1;
         ulb.z += 1;
         urb.z += 1;
         llb.z += 1;
         lrb.z += 1;

      }
   }

   class Vector3D {
      public float x, y, z;

      public Vector3D(float x, float y, float z) {
         this.x = x;
         this.y = y;
         this.z = z;
      }

      public String toString() {
         return "(" + x + "," + y + "," + z + ")";
      }

      public Point to2D() {

         Point p;
         /* 3d -> 2d */
         float Z = distance + z;
         p = new Point((int) (distance * this.x / Z), (int) (distance * this.y / Z));


         p.x += width / 2;
         p.y += height / 2;

         System.out.println(this + " -> (" + p.x + "," + p.y + ")");
         return p;
      }
   }

   @Override
   public void mouseWheelMoved(MouseWheelEvent e) {
      if (e.getWheelRotation() < 0) {
         // zoom in
         cube.closer();
         panel.repaint();
      } else {
         // zoom out
         cube.further();
         panel.repaint();
      }

   }

   @Override
   public void mouseClicked(MouseEvent e) {
      // TODO Auto-generated method stub

   }

   @Override
   public void mouseEntered(MouseEvent e) {
      // TODO Auto-generated method stub

   }

   @Override
   public void mouseExited(MouseEvent e) {
      // TODO Auto-generated method stub

   }

   @Override
   public void mousePressed(MouseEvent e) {
      // TODO Auto-generated method stub

   }

   @Override
   public void mouseReleased(MouseEvent e) {
      // TODO Auto-generated method stub

   }
   @Override
   public void mouseMoved(MouseEvent e) {
      prev = e.getPoint();
   }
   @Override
   public void mouseDragged(MouseEvent e) {
      int dx = e.getX()-prev.x;
      int dy = e.getY()-prev.y;
      cube.move(dx,dy);
      panel.repaint();
      prev = e.getPoint();
   }
}
```


----------



## hdi (17. Dez 2008)

Ah ok, ich hatte den Zusammenhang nicht verstanden zwischen den Koordinaten und der Verschiebung im Nachhinein.

Also dass ich von 0,0,0 ausgehe beim Erstellen meiner Objekte, und dann das


```
p.x += width / 2;
p.y += height / 2;
```

mach. Mein Tutorial hat da wohl nen Fehler auch drin, weil der macht p.y -= height/2, und das ist Schmarrn.

Ausserdem finde ich dann die Zeichnungen im Tut verwirrend, denn so wie es da gezeichnet ist, ist die 
Kamera bei 0,0,0 und nicht bei 0,0,-distance. Da ist nur mein FOV, deswegen dachte ich das auch mit z <= -distance bei allen Objekten.

Ok, aber jetzt funzt es und ich konnte grad den Würfel auch korrekt in die Mitte setzen. 

*Vielen Dank!*


----------



## Marco13 (17. Dez 2008)

Naja, "Fehler" kann man so nicht sagen ... man kann die Kamera ja hinlegen, wo man will - und auch die Verschiebung (ob + oder -) höngt davon ab, worunter man Programmmiert. Dass bei Java (0,0) eben oben links ist, ist ... nur eine Konvention....


----------

