# JOGL Würfel hat durchsichtige Seiten?



## Aldimann (2. Feb 2010)

Hi zusammen,

ich hab hier was zusammen getippt um ein paar erste Schritte mit JOGL zu wagen.

Problem ist jetzt, das eine Seite eigentlich Rot sein sollte, die wird aber gar nicht gezeigt. Außerdem ist der Würfel beim Rotieren an manchen Seiten zu bestimmten Winkeln durchsichtig.

Kann mir jemand erklären wieso?

Außerdem frage ich mich, wieso der awt MouseListerner nicht geht :/

Hoffe mir kann jmd. helfen.

Danke schonmal!

Hier der Code:


```
import java.awt.Frame;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import net.java.games.jogl.Animator;
import net.java.games.jogl.GL;
import net.java.games.jogl.GLCanvas;
import net.java.games.jogl.GLCapabilities;
import net.java.games.jogl.GLDrawable;
import net.java.games.jogl.GLDrawableFactory;
import net.java.games.jogl.GLEventListener;

public class NewJOGL {

	private static float angle = 0;
	private static final int SIZE = 160;

	public static void main(String[] args) {
		new NewJOGL();
	}

	public NewJOGL() {
		GLCanvas canvas = GLDrawableFactory.getFactory().createGLCanvas(
				new GLCapabilities());
		JOGLImpl jogl = new JOGLImpl();
		canvas.addGLEventListener(jogl);
		Animator animator = new Animator(canvas);
		addCanvasToFrame(canvas, animator, jogl);
		animator.start();
	}

	private void addCanvasToFrame(GLCanvas canvas, final Animator animator, JOGLImpl jogl) {
		Frame f = new Frame();
		f.setSize(500, 500);
		f.add(canvas);
		f.setVisible(true);
		f.addMouseListener(jogl);
		f.addWindowListener(new WindowAdapter() {
			@Override
			public void windowClosing(WindowEvent e) {
				animator.stop();
				System.exit(0);
			}
		});

	}

	class JOGLImpl implements GLEventListener, MouseListener {

		@Override
		public void display(GLDrawable arg0) {
			GL gl = arg0.getGL();
			gl.glClear(GL.GL_COLOR_BUFFER_BIT);
			gl.glMatrixMode(GL.GL_MODELVIEW);
			gl.glLoadIdentity();

			 angle++;

			// System.out.println(angle);
			gl.glRotatef(angle / 120, 1, 1, 0);
			drawCenteredCube(gl);

		}

		private void drawCenteredCube(GL gl) {
			gl.glColor4f(1, 0, 0, 0);
			drawSquareFace(gl);
			gl.glColor4f(1, 1, 0, 0);
			gl.glRotatef(90, 1, 0, 0);
			drawSquareFace(gl);
			gl.glColor4f(0, 0, 1, 0);
			gl.glRotatef(90, 1, 0, 0);
			drawSquareFace(gl);
			gl.glColor4f(0, 1, 0, 0);
			gl.glRotatef(90, 1, 0, 0);
			drawSquareFace(gl);
			gl.glColor4f(0, 1, 1, 0);
			gl.glRotatef(90, 0, 1, 0);
			drawSquareFace(gl);
			gl.glColor4f(1, 0, 1, 0);
			gl.glRotatef(180, 0, 1, 0);
			drawSquareFace(gl);
		}

		private void drawSquareFace(GL gl) {
			gl.glBegin(GL.GL_QUADS);
			gl.glVertex3f(-SIZE / 2, -SIZE / 2, SIZE / 2);
			gl.glVertex3f(-SIZE / 2, SIZE / 2, SIZE / 2);
			gl.glVertex3f(SIZE / 2, SIZE / 2, SIZE / 2);
			gl.glVertex3f(SIZE / 2, -SIZE / 2, SIZE / 2);
			gl.glEnd();
		}

		@Override
		public void displayChanged(GLDrawable arg0, boolean arg1, boolean arg2) {
			// TODO Auto-generated method stub

		}

		@Override
		public void init(GLDrawable arg0) {
			GL gl = arg0.getGL();
			gl.glClearColor(0, 0, 0, 1);
			gl.glColor3f(0, 0, 0);
		}

		@Override
		public void reshape(GLDrawable drawable, int x, int y, int width,
				int height) {
			GL gl = drawable.getGL();
			gl.glMatrixMode(GL.GL_PROJECTION);
			gl.glLoadIdentity();
			gl.glOrtho(-width, width, -height, height, -160, 160);
			// TODO
		}

		@Override
		public void mouseClicked(MouseEvent e) {
			System.out.println("clicked");
		}

		@Override
		public void mouseEntered(MouseEvent e) {
			System.out.println("entered");
		}

		@Override
		public void mouseExited(MouseEvent e) {
			System.out.println("exit");
		}

		@Override
		public void mousePressed(MouseEvent e) {
			System.out.println("pressed");
		}

		@Override
		public void mouseReleased(MouseEvent e) {
			System.out.println("released");
		}

	}
}
```


----------



## Marco13 (2. Feb 2010)

Hab's jetzt nicht getestet, aber ... es kann sein, dass die Würfelseiten einfach falschrum sind. Kannst mal nach GL_FRONT_AND_BACK suchen und das einschalten, oder die Fraglichen Seiten rumdrehen. (BTW: Das alles mit glRotate usw. zu machen ist ... vielleicht etwas aufwändig... bei einem Würfel geht's vielleicht noch, aber bei einem Dodekaeder wird's ein Krampf :autsch:  )...

Den MouseListener könntest du mal an den canvas hängen...


----------



## Guest2 (2. Feb 2010)

Moin,

Marco hat ja eigentlich schon fast alles gesagt, aber doppelt hält besser: 

1. Jede Fläche hat in OpenGL eine Vorder- und eine Rückseite. Wenn Du auf eine Fläche siehst und die einzelnen Eckpunkte sind gegen den Uhrzeigersinn angeordnet, betrachtest Du die Vorderseite. Sind die Eckpunkte mit dem Uhrzeigersinn, ist es die Rückseite. Man kann zur Beschleunigung das Zeichnen der Rückseiten unterdrücken (gl.glEnable(GL2.GL_CULL_FACE)). Default sollte das aber bereits disabled sein.

2. Das sieht so merkwürdig aus, weil Du keinen ZBuffer verwendest. Setze mal in der init() ein gl.glEnable(GL.GL_DEPTH_TEST) und in der display() ein gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) (statt dem bisherigen glClear()), dann sollte das gehen.

3. Genau, der MouseListener gehört ans canvas.

4. Die JoGL Version die Du nutzt ist ganz alt (vor JoGL1). Vielleicht wäre es günstig wenn Du zumindest auf JoGL1 (Version 1.1.1a: Index of /media/jogl/builds/archive/jsr-231-1.1.1a/) updaten würdest. Das wäre dann die letzte und aktuelle Version von JoGL1.

Gruß,
Fancy


----------



## Evil-Devil (3. Feb 2010)

Krank, wie du das gemacht hast.

Hier ein mal ein kompletter Würfel (LWJGL Code Auszug aus nem Tut von mir)

```
// Der Würfel aller Würfel ^__^'
GL11.glBegin(GL11.GL_QUADS);
	// Front Side
	GL11.glNormal3f(0.0f,0.0f,1.0f);
	GL11.glVertex3f(-1.0f,-1.0f,1.0f);
	GL11.glVertex3f(1.0f,-1.0f,1.0f);
	GL11.glVertex3f(1.0f,1.0f,1.0f);
	GL11.glVertex3f(-1.0f,1.0f,1.0f);
	// Back Side
	GL11.glNormal3f(0.0f,0.0f,-1.0f);
	GL11.glVertex3f(1.0f,-1.0f,-1.0f);
	GL11.glVertex3f(-1.0f,-1.0f,-1.0f);
	GL11.glVertex3f(-1.0f,1.0f,-1.0f);
	GL11.glVertex3f(1.0f,1.0f,-1.0f);
	// Left Side
	GL11.glNormal3f(-1.0f,0.0f,0.0f);
	GL11.glVertex3f(-1.0f,-1.0f,-1.0f);
	GL11.glVertex3f(-1.0f,-1.0f,1.0f);
	GL11.glVertex3f(-1.0f,1.0f,1.0f);
	GL11.glVertex3f(-1.0f,1.0f,-1.0f);
	// Right Side
	GL11.glNormal3f(1.0f,0.0f,0.0f);
	GL11.glVertex3f(1.0f,-1.0f,1.0f);
	GL11.glVertex3f(1.0f,-1.0f,-1.0f);
	GL11.glVertex3f(1.0f,1.0f,-1.0f);
	GL11.glVertex3f(1.0f,1.0f,1.0f);
	// Top Side
	GL11.glNormal3f(0.0f,1.0f,0.0f);
	GL11.glVertex3f(-1.0f,1.0f,1.0f);
	GL11.glVertex3f(1.0f,1.0f,1.0f);
	GL11.glVertex3f(1.0f,1.0f,-1.0f);
	GL11.glVertex3f(-1.0f,1.0f,-1.0f);
	// Bottom Side
	GL11.glNormal3f(0.0f,-1.0f,0.0f);
	GL11.glVertex3f(1.0f,-1.0f,-1.0f);
	GL11.glVertex3f(-1.0f,-1.0f,-1.0f);
	GL11.glVertex3f(-1.0f,-1.0f,1.0f);
	GL11.glVertex3f(1.0f,-1.0f,1.0f);
GL11.glEnd();
```


----------



## Aldimann (8. Feb 2010)

Vielen Dank für die vielen Antworten und sorry das ich jetzt erst schreibe. Habe nicht jeden Tag zeit und Lust mich mit sowas rum zu schlagen .


Ich habe jetzt mal die Sachen von Guest2 wie beschrieben implementiert! SUPER! Danke!

Bzgl. der JOGL Version war mir schon fast sowas klar. Ich wollte eigentlich schon Updaten nur irgendwie bin ich mit dem Download und der Installation nicht ganz klar gekommen.

Kann es sein, dass die neuen Versionen sich komplett anders installieren lassen als die alten? Da war ich mir dann immer nicht mehr sicher ob ich alles richtig mache .

Evil-Devil:

Hab auch deinen Code mal an der Stelle eingesetzt wo ich momentan mein Quadrat erstelle und habe meinen Code auskommentiert. Aber Bildschirm bleibt schwarz.

Hast du nen Link zu deinem Tut?


----------



## Evil-Devil (8. Feb 2010)

Öhm, Link nicht. Gibt zwar noch ne Online-Variante, aber anhängen ist einfacher. Ist aber wie oben schon gesagt auf LWJGL Basis, wobei sich das leicht nach JOGL portieren lassen sollte.


----------



## Guest2 (9. Feb 2010)

Aldimann hat gesagt.:


> Bzgl. der JOGL Version war mir schon fast sowas klar. Ich wollte eigentlich schon Updaten nur irgendwie bin ich mit dem Download und der Installation nicht ganz klar gekommen.
> 
> Kann es sein, dass die neuen Versionen sich komplett anders installieren lassen als die alten? Da war ich mir dann immer nicht mehr sicher ob ich alles richtig mache .



Also ich weiß nicht mehr wie die ganz alten JoGL Versionen eingebunden wurden (die die Du verwendest), aber "Installation" klingt schon falsch .

Ein Fehler ist es z.B. irgendetwas von JoGL in das JRE oder das JDK zu kopieren, da gehört das nicht hin. Am einfachsten legst Du in Deiner IDE ein Projekt an und kopierst die JoGL JAR Dateien in ein Unterverzeichnis Deines Projektes (z.B. in lib). Dasselbe mit den nativen (.dll / .so) (z.B. in native). 

Dann musst Du den java class path und den  java library path entsprechend setzen.

Für JoGL2 brauchst Du: gluegen-rt.jar, jogl.all.jar, nativewindow.all.jar, newt.all.jar
sowie: gluegen-rt.dll, jogl_gl2.dll, jogl_gl1es12.dll, nativewindow_awt.dll, nativewindow_jvm.dll, newt.dll (oder die entsprechenden *.so)

Die aktuellsten Dateien bekommst Du hier: Index of /media/jogl/builds/nightly/ 

Wenn Du Eclipse und Windows nutzt, kannst Du dir auch dieses Beispiel ansehen:

http://too-late.de/kskb/gl2sample04.zip

Nicht entpacken, sondern:
Eclipse -> File -> Import -> General -> Existing Projects into Workspace -> Select archive file -> Browse -> gl2sample04.zip auswählen -> Öffnen -> Finish

(Wenn Du kein Eclipse oder Windows nutzt, dann natürlich schon entpacken ).

In dem File ist ein fertiges JoGL Beispiel, incl. der aktuellen JoGL Version. Du musst das also nur importieren, sonst nichts. Wenn eine Fehlermeldung geworfen wird, dann liegt vermutliche eine alte JoGL Version im JRE/JDK (wo sie eben nicht hingehört  ).

Das Beispiel zeigt auch wie man einen Würfel mit einem Vertex Array zeichnet. Grundsätzlich stammt das glVertex3f() Gedöns nämlich noch aus einer Zeit als Grafikkarten keine Arrays kannten und noch mit Dampf betrieben wurden. Im Wesentlichen ist die Idee dahinter einfach nacheinander die x, y, z Koordinaten sowie die Farben r, g, b  in ein Array zu schreieben. Und dieses Array geschlossen on OpenGL zu übergeben. Alle weiteren Möglichkeiten Geometrie an OpenGL zu übergeben bauen dann später auch auf diesen Ansatz auf (z.B. VBOs).

Gruß,
Fancy


----------



## Aldimann (11. Feb 2010)

Guest2 hat gesagt.:


> Also ich weiß nicht mehr wie die ganz alten JoGL Versionen eingebunden wurden (die die Du verwendest), aber "Installation" klingt schon falsch .
> 
> Ein Fehler ist es z.B. irgendetwas von JoGL in das JRE oder das JDK zu kopieren, da gehört das nicht hin. Am einfachsten legst Du in Deiner IDE ein Projekt an und kopierst die JoGL JAR Dateien in ein Unterverzeichnis Deines Projektes (z.B. in lib). Dasselbe mit den nativen (.dll / .so) (z.B. in native).
> 
> ...



Viele dank erstmal für die genaue Erklärung!

Hatte mich vor ein paar Tagen nochmal ran gesetzt. Und du hattest recht die ganz alte Version hatte ich in die JRE kopiert :/. Wurde aber auch bei der neuen "Installation" eines besseren Belehrt und habe die Dateien nur im Java Build Path angegeben (benutze Eclipse und Windows   ) 

Die DLLs habe ich notdürftig erstmal mit in den Projekt Ordner gelegt, weil in der entsprechenden Anleitung stand das das auch ok wäre .

Hatte erst die 2.0 Beta irgendwas aber da waren die Änderungen einfach zu groß da gab es kein Rotate mehr etc. da hab ich nicht mehr durchgeblickt.

Also wieder downgrade auf 1.1.1 glaube. Da waren die Änderungen vertretbar und habe den Code angepasst.

Nichts desto trotz die Lernkurve bei JOGL geht nur sehr langsam nach oben :/ Hast du / habt ihr evtl noch ein paar Tips oder gute Tutorials whatever?!


----------



## Guest2 (12. Feb 2010)

Aldimann hat gesagt.:


> Hatte erst die 2.0 Beta irgendwas aber da waren die Änderungen einfach zu groß da gab es kein Rotate mehr etc. da hab ich nicht mehr durchgeblickt.



Doch, das glRotate gibt es da auch. Der Unterschied ist lediglich das mit JoGL2 unterschiedliche OpenGL Profile unterstützt werden. Dadurch musst Du angeben welches GL Du haben willst.

Sprich, in JoGL1:

```
GL gl = drawable.getGL();
```
 
Wird in JoGL2 zu:

```
GL2 gl = drawable.getGL().getGL2();
```

Und dann gibt es auch das gl.glRotatef() wieder. Das steht so übrigens auch in dem oben verlinkten gl2sample04.  



Aldimann hat gesagt.:


> Nichts desto trotz die Lernkurve bei JOGL geht nur sehr langsam nach oben :/ Hast du / habt ihr evtl noch ein paar Tips oder gute Tutorials whatever?!



Wenn Du einmal ein Fenster aufhast und einen GLEventListener hast, unterscheidet sich das OpenGL aus JoGL nicht mehr wesentlich von dem OpenGL aus z.B. C. Das heißt Du kannst auch problemlos ein OpenGL Tutorial in C lesen.

Für die Grundlagen kannst Du dir insbesondere NeHe Productions: Main Page  ansehen. Das ist zwar in C, aber die entsprechenden JoGL (imho JoGL1) Übersetzungen gibt es hier: Pepe & Lizzie’s Adventures  NeHe Java ports

Wenn Du einzelne OpenGL Anweisungen nicht verstehst, ist diese Funktionsübersicht sinnvoll:
OpenGL-Funktionsübersicht ? DGL Wiki


Wenn Du spezifische Fragen hast, kann ich aber ggf. auch ein Beispiel aus meinem Eclipse Workspace raussuchen.

Gruß,
Fancy


----------



## Aldimann (18. Feb 2010)

Hab jetzt mal ein wenig damit rumgespielt und wollte statt der ganzen dreherei den würfel so erzeugen.

Irgendwie bleibt dabei allerings alles schwarz.

drawSquareFace wird dann natürlich nur einmal aufgerufen und die glrotatef sind an der entsprechenden Stelle auskommentiert, sonst ist der code identisch.

Aber wieso bleibt der Display jetzt schwarz??



```
gl.glBegin(GL.GL_QUADS);
			
			//Seite Hinten
			gl.glColor3f(1, 0, 0);
			//ROT
			gl.glVertex3f(-0.1f, -0.1f, -0.1f);
			gl.glVertex3f(-0.1f, 0.1f, -0.1f);
			gl.glVertex3f(0.1f, 0.1f, -0.1f);
			gl.glVertex3f(0.1f, -0.1f, -0.1f);
			
			
			//Seite Vorn
			gl.glColor3f(0, 1, 0);
			//GRUEN
			gl.glVertex3f(-0.1f, -0.1f, 0.1f);
			gl.glVertex3f(-0.1f, 0.1f, 0.1f);
			gl.glVertex3f(0.1f, 0.1f, 0.1f);
			gl.glVertex3f(0.1f, -0.1f, 0.1f);
			
			//Seite Links
			gl.glColor3f(0, 0, 1);
			//BLAU
			gl.glVertex3f(-0.1f, -0.1f, -0.1f);
			gl.glVertex3f(-0.1f, 0.1f, -0.1f);
			gl.glVertex3f(-0.1f, 0.1f, 0.1f);
			gl.glVertex3f(-0.1f, -0.1f, 0.1f);
			
			//Seite Rechts
			gl.glColor3f(0, 1, 1);
			//GELB ? 
			gl.glVertex3f(0.1f, -0.1f, -0.1f);
			gl.glVertex3f(0.1f, 0.1f, -0.1f);
			gl.glVertex3f(0.1f, 0.1f, 0.1f);
			gl.glVertex3f(0.1f, -0.1f, 0.1f);
			gl.glEnd();
```


----------



## Evil-Devil (18. Feb 2010)

an welche Position ist der Würfel denn positioniert? Wenn er an 0/0/0 steht ist es klar, dass du nichts siehst


----------



## Aldimann (18. Feb 2010)

Evil-Devil hat gesagt.:


> an welche Position ist der Würfel denn positioniert? Wenn er an 0/0/0 steht ist es klar, dass du nichts siehst




Äh ich steh wahrscheinlich gerade irgendwie aufm Schlauch, aber ist das was ich oben als Code gepostet hab nich die positionierung des Würfels?

Also ich hatte auch schonmal was gesehen, aber nur Vorder- und Rückseite. Das wollte ich natürlich beheben und nach der implementierung der reshape Methode war es vorbei mit etwas sehen.

Vorher hab ich ein wenig mit dem rotate rumgespielt und mir ist aufgefallen, dass das Teil sich wesentlich schneller bei gleichem Wert dreht.

Mit drehen war es nach dem gl.glLoadIdentity() in der display Methode rum.

Nun bin ich ratlos :/.

Hier nochmal der Komplette Code:


```
import java.awt.Frame;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;

import com.sun.opengl.util.Animator;

public class NewJOGL {

	private static float angleX = 0;
	private static float angleY = 0;
	private static final int SIZE = 160;
	private static final int ROATION = 200;
	

	public static void main(String[] args) {
		new NewJOGL();
	}

	public NewJOGL() {
		GLCapabilities cap = new GLCapabilities();
		GLCanvas canvas = new GLCanvas(cap);
		JOGLImpl jogl = new JOGLImpl();
		canvas.addGLEventListener(jogl);
		Animator animator = new Animator(canvas);
		addCanvasToFrame(canvas, animator);
		canvas.addMouseMotionListener(new JOGLImpl());
		animator.start();
	}

	private void addCanvasToFrame(GLCanvas canvas, final Animator animator) {
		Frame f = new Frame();
		f.setSize(500, 500);
		f.add(canvas);
		f.setVisible(true);
		f.addWindowListener(new WindowAdapter() {
			@Override
			public void windowClosing(WindowEvent e) {
				animator.stop();
				System.exit(0);
			}
		});

	}

	class JOGLImpl implements GLEventListener, MouseMotionListener {
		
		boolean firstrun = true;
		int oldX = 0;
		int oldY = 0;

		private void drawCenteredCube(GL gl) {
//			gl.glColor4f(1, 0, 0, 0);
			drawSquareFace(gl);
//			gl.glColor4f(1, 1, 0, 0);
//			gl.glRotatef(90, 1, 0, 0);
//			drawSquareFace(gl);
//			gl.glColor4f(0, 0, 1, 0);
//			gl.glRotatef(90, 1, 0, 0);
//			drawSquareFace(gl);
//			gl.glColor4f(0, 1, 0, 0);
//			gl.glRotatef(90, 1, 0, 0);
//			drawSquareFace(gl);
//			gl.glColor4f(0, 1, 1, 0);
//			gl.glRotatef(90, 0, 1, 0);
//			drawSquareFace(gl);
//			gl.glColor4f(1, 0, 1, 0);
//			gl.glRotatef(180, 0, 1, 0);
//			drawSquareFace(gl);
			
			
			
		}

		private void drawSquareFace(GL gl) {
//			gl.glBegin(GL.GL_QUADS);
//			gl.glVertex3f(-SIZE / 2, -SIZE / 2, SIZE / 2);
//			gl.glVertex3f(-SIZE / 2, SIZE / 2, SIZE / 2);
//			gl.glVertex3f(SIZE / 2, SIZE / 2, SIZE / 2);
//			gl.glVertex3f(SIZE / 2, -SIZE / 2, SIZE / 2);
//			gl.glEnd();
		
			gl.glBegin(GL.GL_QUADS);
			
			//Seite Hinten
			gl.glColor3f(1, 0, 0);
			//ROT
			gl.glVertex3f(-0.1f, -0.1f, -0.1f);
			gl.glVertex3f(-0.1f, 0.1f, -0.1f);
			gl.glVertex3f(0.1f, 0.1f, -0.1f);
			gl.glVertex3f(0.1f, -0.1f, -0.1f);
			
			
			//Seite Vorn
			gl.glColor3f(0, 1, 0);
			//GRUEN
			gl.glVertex3f(-0.1f, -0.1f, 0.1f);
			gl.glVertex3f(-0.1f, 0.1f, 0.1f);
			gl.glVertex3f(0.1f, 0.1f, 0.1f);
			gl.glVertex3f(0.1f, -0.1f, 0.1f);
			
			//Seite Links
			gl.glColor3f(0, 0, 1);
			//BLAU
			gl.glVertex3f(-0.1f, -0.1f, -0.1f);
			gl.glVertex3f(-0.1f, 0.1f, -0.1f);
			gl.glVertex3f(-0.1f, 0.1f, 0.1f);
			gl.glVertex3f(-0.1f, -0.1f, 0.1f);
			
			//Seite Rechts
			gl.glColor3f(0, 1, 1);
			//GELB ? 
			gl.glVertex3f(0.1f, -0.1f, -0.1f);
			gl.glVertex3f(0.1f, 0.1f, -0.1f);
			gl.glVertex3f(0.1f, 0.1f, 0.1f);
			gl.glVertex3f(0.1f, -0.1f, 0.1f);
			gl.glEnd();
		
		}





		@Override
		public void display(GLAutoDrawable arg0) {
			GL gl = arg0.getGL();
			gl.glClear(GL.GL_COLOR_BUFFER_BIT);
			gl.glClear(GL.GL_COLOR_BUFFER_BIT|GL.GL_DEPTH_BUFFER_BIT);
			gl.glMatrixMode(GL.GL_MODELVIEW);
			gl.glLoadIdentity();


			// System.out.println(angle);
			gl.glRotatef(angleX / 120, 0, 1, 0);
			gl.glRotatef(angleY / 120, 1, 0, 0);
			drawCenteredCube(gl);
			
		}

		@Override
		public void displayChanged(GLAutoDrawable arg0, boolean arg1,
				boolean arg2) {
			// TODO Auto-generated method stub
			
		}

		@Override
		public void init(GLAutoDrawable arg0) {
			GL gl = arg0.getGL();
//			gl.glClearColor(0, 0, 0, 1);
			gl.glEnable(GL.GL_DEPTH_TEST);
			gl.glColor3f(0, 0, 0);
						
		}

		@Override
		public void reshape(GLAutoDrawable drawable, int x, int y, int width,
				int height) {
			GL gl = drawable.getGL();
			gl.glMatrixMode(GL.GL_PROJECTION);
			gl.glLoadIdentity();
			gl.glOrtho(-width, width, -height, height, -160, 160);
			// TODO
			
		}

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

		@Override
		public void mouseMoved(MouseEvent e) {
			int x = e.getX();
			int y = e.getY();
			if(firstrun){
				oldX = x;
				oldY = y;
				firstrun = false;
			}
			
			System.out.println("oldX:\t"+oldX+"\tnewX:\t"+x);
			
			//X-Achsen Drehung
			if(oldX >= x ){
				angleX = angleX + ROATION;
			}else{
				angleX = angleX - ROATION;
			}
			
			
			//Y-Achsen Drehung
			if(oldY >= y ){
				angleY = angleY + ROATION;
			}else{
				angleY = angleY - ROATION;
			}
			
				oldY = y;
				oldX = x;
//			System.out.println(angle);
		}

		

	}
}
```

Gar nich so einfach das alles :rtfm:???:L




€dit:

wobei mir grad auffällt, dass mein Code ziemlich ähnlich dem von dir (Evil-Devil) ist, wo ich ja glaube auch schonmal gesagt hatte das der nicht geht :/


----------



## Marco13 (18. Feb 2010)

Joa so fast... ändere mal den glOrtho-Aufruf in
            gl.glOrtho(-1,1,-1,1, -160, 160);


----------



## Evil-Devil (19. Feb 2010)

Aldimann hat gesagt.:


> wobei mir grad auffällt, dass mein Code ziemlich ähnlich dem von dir (Evil-Devil) ist, wo ich ja glaube auch schonmal gesagt hatte das der nicht geht :/


Hmm, das letzte Mal als ich den getestet hab ging der noch mit entsprechender LWJGL Version (0.99 afaik - Tut ist schon etwas betagt).

@Code: Ich sehe eine Reshape Funktion die einen Ortho Modus setzt...dabei zeichnest du einen perspektivischen Würfel. Das ist unpassend. Erzeugt JOGL per Default eine 3D Perspektive oder muss man die wie vermutet selbst setzen? Jedenfalls wäre dann vor dem zeichnen des Würfels ein glTranslate notwendig um überhaupt was zu sehen. Aktuell sitzt deine Kamera auf dem 0 Punkt und du siehst vom Würfel nichts, da du dich in selbigen befinden würdest, wenn du eine perspektivische Darstellung hast/hättest.


----------

