GLU.gluLookAt in Java OpenGL bindings scheint, nichts zu tun

EDIT: Reagiert, um die Eingabe in die ursprüngliche Frage. Sie lässt den ursprünglichen text unten, weil die Leute scheinen zu finden, um nützlich zu sein.

Ich glaube, dein problem ist, in den Würfel zu zeichnen-code. Überprüfen Sie die Kommentare unten: die glLoadIdentity nennen tut genau das, was Sie erwarten würde, - zwingt den cube vor dir:

gl2.glPushMatrix();     
gl2.glClear( GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT );
/** Try removing the following glLoadIdentity call below.
  * That call was blowing out the MODELVIEW matrix - it's removing your 
  * gluLookAt call and returning to the identity.
  * As a result, the cube will always be right there in front of you.
  */
//gl2.glLoadIdentity();
gl2.glTranslatef(x, y, z);
gl2.glBegin( GL2.GL_QUADS );
gl2.glColor3f( 1, 0, 0 ); //24 glVertex3f calls & some colour changes go here.
gl2.glVertex3f(...)
gl2.glEnd();
gl2.glPopMatrix(); 

Hier eine sehr kurze Erklärung darüber, was der Zusammenhang fordert, tun wird. Finden Sie in der Dokumentation für weitere Informationen:

gl2.glPushMatrix(); //This preserves current MODEL_VIEW matrix so you can get back here.
                    //Think of it as a checkpoint save in a game.
                    //Most of your objects will be wrapped in push and pop.
gl2.glLoadIdentity(); //This erases the MODEL_VIEW and replaces it with an identity.
                      //This un-does your previous gluLookAt call.  You will rarely use
                      //this inside an object (but it's not impossible).
                      //Does not apply here so don't use.
gl2.glTranslatef(x, y, z); //This is what puts your object out in space for you to find
                           //as opposed to putting it at the origin.  Most objects will
                           //have a translate (and likely a rotate as well).
                           //Note that the order of operations matters:
                           //translate and then rotate != rotate and then translate.
//QUAD strip code with vertices and colors - you're okay with these.
gl2.glPopMatrix(); //This brings back the MODEL_VIEW that you originally saved by pushing
                   //it.

Die große Sache über den matrix-code in OpenGL ist, dass, sobald Sie ein portfolio der Beispiel-code, den Sie verstehen, Sie haben immer als Referenz. Wenn ich wechselte von IrisGL zu OpenGL zurück in den Tag, es dauerte eine Weile, bis mein port utilities vorbei und dann habe ich nie bereut.

ORIGINAL:, die Sie benötigen, um Ihre cube-Zeichnung code - wenn Sie setzen die Würfel in der Umgebung von (0, 30, 0), ist es sehr wahrscheinlich, dass der code tut, was Sie gefragt, es zu.

Überprüfung der OpenGL-FAQ gibt es einen bestimmten Frage-und-Antwort, die wahrscheinlich relevant für das, was du tust: 8.080 Warum nicht gluLookAt Arbeit? ich werde die ganze Antwort zitieren, als es ist wirklich nicht eine gute Pause, aber bitte besuchen Sie die OpenGL-FAQ, die Antwort ist wahrscheinlich:

Dies ist in der Regel verursacht durch falsche
Transformationen.

Vorausgesetzt, Sie verwenden
gluPerspective() auf die Projektion
matrix-stack mit zNear und zFar als
der Dritte und vierte Parameter, den Sie
müssen gluLookAt auf die ModelView -
matrix-stack, und übergeben Sie dabei die Parameter so
Ihre geometrie fällt zwischen zNear und
zFar.

Es ist normalerweise am besten, zu Experimentieren mit
einfache Stück code, wenn Sie
versuchen zu verstehen, betrachten
Transformationen. Lassen Sie uns sagen, Sie sind
Versuch zu betrachten, eine Einheit Bereich
zentriert auf den Ursprung. Sie wollen
richten Sie Ihre Transformationen
folgt:

 glMatrixMode(GL_PROJECTION);
 glLoadIdentity(); 
 gluPerspective(50.0, 1.0, 3.0, 7.0); 
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity(); 
 gluLookAt(0.0, 0.0, 5.0,
           0.0, 0.0, 0.0,
           0.0, 1.0, 0.0);

Es ist wichtig zu beachten, wie die Projektion
und ModelView-Transformationen arbeiten
zusammen.

In diesem Beispiel die Projektion
transform-sets up a 50,0-Grad-Feld
der Blick, mit einem Aspekt-Verhältnis von 1.0.
Die zNear clipping-Ebene ist 3.0 Einheiten
im vorderen Teil des Auges, und die zFar
clipping-Ebene ist 7.0-Einheiten vor
für das Auge. Dies lässt eine Z-Volumen
Entfernung von 4.0 Einheiten, reichlich Platz für
eine Einheit Sphäre.

Die ModelView-Transformation setzt das Auge
position bei (0.0, 0.0, 5.0), und die
look-at-Punkt ist der Ursprung in der
center unserer unit sphere. Beachten Sie, dass
der position des Auges ist 5.0 Einheiten entfernt
aus dem Blick auf point. Dies ist
wichtig, weil ein Abstand von 5.0
Einheiten vor dem Auge ist in der
Mitte der Z-Volumen, das die
Projektion-Transformation definiert. Wenn die
gluLookAt () - Aufruf gesetzt hatte die Augen auf
(0.0, 0.0, 1.0), es produzieren würde
Entfernung von 1.0 auf die Herkunft. Diese
nicht lange genug, um zu umfassen
Bereich in der view-volume, und es
wäre abgeschnitten von der zNear clipping
Flugzeug.

Ähnlich, wenn Sie das Auge an
(0.0, 0.0, 10.0), der Abstand von 10,0
der Blick auf Punkt führt
das Gerät Sphäre als 10.0 Einheiten entfernt
vom Auge und weit hinter den zFar
clipping-Ebene platziert 7.0 Einheiten.

Wenn diese verwechselt hat, Lesen Sie auf
Transformationen in OpenGL red book
- oder OpenGL-Spezifikation. Nachdem Sie
verstehen Objekt-Koordinatenraum,
Auge Koordinatenraum und clip
Koordinatenraum, die oben genannten sollten
klar. Außerdem Experimentieren Sie mit
kleine test-Programme. Wenn Sie
Mühe, die richtigen verwandelt
in Ihrem Haupt-Anwendung-Projekt,
kann lehrreich sein, schreiben einen kleine
Stück code, der versucht zu reproduzieren
das problem mit einfacher geometrie.