# Jogl Problem bei Darstellung



## Stacks (3. Jan 2010)

Hallo,
Ich habe zwei kleine Probleme mit einem Java Programm das ich im Moment mit Java Jogl versuche zu schreiben. Zum ersten habe ich ein Problem mit der Datenverwaltung. Da ich eine vielzahl von Gebäuden darstellen möchte habe ich eine ziemlich große Datenmenge die verarbeitet werden soll. Das laden und co funktioniert soweit einwandfrei, allerdings möchte ich mich bei diesen Gebäuden dann mit der Kameraperspektive bewegen können und das Problem ist das ich jedesmal die Daten neu lade bei jeder kleinen Bewegung. Leider weiß ich nicht so ganz wie ich das sonst realisieren soll. Hatte überlegt ob es vieleicht eine Art Container für Objekte gibt, damit man nur diesen neu laden muss. Hab aber im Internet nichts gefunden... Habe auch schon versucht die Gebäude in die "init"-Methode zu schreiben damit diese nur einmal am Anfang aufgerufen werden... Allerdings funktioniert dies genauso wenig.

Hier die relevanten Methoden:
Methode init:

```
public void init(GLAutoDrawable gLDrawable)
        {
        	gl = gLDrawable.getGL();

           //kartesische Kamerakoordinaten initialisieren
           eye_x = RADIUS*(float)Math.cos(theta)*(float)Math.cos(phi);
           eye_y = RADIUS*(float)Math.cos(theta)*(float)Math.sin(phi);
           eye_z = RADIUS*(float)Math.sin(theta);
           //Endpunkte der Kimme bestimmen
           view_up_end_x = eye_x + view_up_x;
           view_up_end_y = eye_y + view_up_y;
           view_up_end_z = eye_z + view_up_z;
           
           gLDrawable.addKeyListener(this);
                   
      	
       		// Bestimmung der Maximalwerte
       		int oneSetter=0;	
       		for(int i=0; i<data.Data.getSize();i++){
       			for(int j=0;j<data.Data.data.get(i).getSizeWall();j++){
       				for (int k=0;k<data.Data.data.get(i).wall.get(j).getSize();k++){		
       					data.Point nPoint=data.Data.data.get(i).wall.get(j).getWallPoints(k);
       					if(oneSetter==0){
       						xmin=nPoint.getX();
       						xmax=xmin;
       						ymin=nPoint.getY();
       						ymax=ymin;
       						zmin=nPoint.getZ();
       						zmax=zmin;
       						oneSetter++;
       					}else{
       						if(nPoint.getX()<xmin){
       						xmin=nPoint.getX();
       						}else if(nPoint.getX()>xmax){
       							xmax=nPoint.getX();
       						}
       						if(nPoint.getY()<ymin){
       							ymin=nPoint.getY();
       							}else if(nPoint.getY()>ymax){
       								ymax=nPoint.getY();
       							}
       						if(nPoint.getZ()<zmin){
       							zmin=nPoint.getZ();
       							}else if(nPoint.getZ()>zmax){
       								zmax=nPoint.getZ();
       							}
       					}
       				}
       			}
       			for(int j=0;j<data.Data.data.get(i).getSizeRoof();j++){
       				for (int k=0;k<data.Data.data.get(i).roof.get(j).getSize();k++){		
       					data.Point nPoint=data.Data.data.get(i).roof.get(j).getRoofPoints(k);
       						if(nPoint.getX()<xmin){
       						xmin=nPoint.getX();
       						}else if(nPoint.getX()>xmax){
       							xmax=nPoint.getX();
       						}
       						if(nPoint.getY()<ymin){
       							ymin=nPoint.getY();
       							}else if(nPoint.getY()>ymax){
       								ymax=nPoint.getY();
       							}
       						if(nPoint.getZ()<zmin){
       							zmin=nPoint.getZ();
       							}else if(nPoint.getZ()>zmax){
       								zmax=nPoint.getZ();
       					}
       				}
       			
       			
       			}
       		}
       		
       		//Bestimmung Länge der Seiten
     		xdiff= xmax-xmin;
     		ydiff= ymax-ymin;
     		zdiff= zmax-zmin;
     		
     		if(xdiff<ydiff){
     			xdiff=ydiff;
     		}
     		if(xdiff<zdiff){
     			xdiff=zdiff;
     		}
       		System.out.println("Ränder berechnen");	
        }
```

Methode Display

```
public void display(GLAutoDrawable gLDrawable){

          //  GL-Objekt holen
          gl = gLDrawable.getGL();
          //GLU- und GLUT-Instanzen erzeugen
          glu = new GLU();

          // Modellmatrix initialisieren
          gl.glLoadIdentity();
          // Kamera positionieren
          glu.gluLookAt(eye_x,eye_y,eye_z,0,0,0,view_up_x,view_up_y,view_up_z);
          //Berechnen und Ausgeben des Winkels zwischen view-up-Vektor und Blickrichtung
          float produkt = eye_x*view_up_x+eye_y*view_up_y+eye_z*view_up_z;
          float length_eye = (float)Math.sqrt(eye_x*eye_x+eye_y*eye_y+eye_z*eye_z);
          float length_view_up =
                         (float)Math.sqrt(view_up_x*view_up_x+view_up_y*view_up_y+view_up_z*view_up_z);
          float angle = (float)Math.acos(produkt/(length_eye*length_view_up));
          System.out.println("Winkel zwischen Blickrichtung und view-up-Vektor nach " + number_of_changes +
                             " Änderungen: " + angle/Math.PI*180);
         
          
          
    
          //--------------------------Bilden der Gebäude------------------------
     		

        	if ((gl instanceof GLJPanel)
     				&& !((GLJPanel) gl).isOpaque()
     				&& ((GLJPanel) gl)
     						.shouldPreserveColorBufferIfTranslucent()) {
     			gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
     		} else {
     			gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
     		}

     	
     		
     		//Transformation der Werte zwischen -1 und 1
     		
        	for(int i=0; i<data.Data.getSize();i++){
     			System.out.println("new Buidling");
     		
     			for(int j=0;j<data.Data.data.get(i).getSizeWall();j++){
     				//System.out.println("new Wall");
     				gl.glColor3f(1.0f, 1.0f, 0.0f);
     				gl.glBegin(GL.GL_POLYGON);
     				for (int k=0;k<data.Data.data.get(i).wall.get(j).getSize();k++){
     					data.Point nPoint=data.Data.data.get(i).wall.get(j).getWallPoints(k);
     					gl.glVertex3f((-1+(2*(nPoint.getX()-xmin))/xdiff), (-1+(2*(nPoint.getY()-ymin))/xdiff), (-1+(2*(nPoint.getZ()-zmin))/xdiff));	
     				//	System.out.print(nPoint.getX()+" "+nPoint.getY()+" "+nPoint.getZ()+", ");
     				}
     				
     				gl.glEnd();
     			}
     			
     			for(int j=0;j<data.Data.data.get(i).getSizeRoof();j++){
     				//System.out.println("new Roof");
     				gl.glColor3f(1.0f, 1.0f, 1.0f);
     				gl.glBegin(GL.GL_POLYGON);
     				for (int k=0;k<data.Data.data.get(i).roof.get(j).getSize();k++){
     					data.Point nkPoint=data.Data.data.get(i).roof.get(j).getRoofPoints(k);		
     					gl.glVertex3f((-1+(2*(nkPoint.getX()-xmin))/xdiff), (-1+(2*(nkPoint.getY()-ymin))/xdiff), (-1+(2*(nkPoint.getZ()-zmin))/xdiff));	
     				}
     				gl.glEnd();
     				}		
     		
     		}
            System.out.println("Gebäude zeichnen");           
             //Pufferinhalt weitergeben
             gl.glFlush();       
        }
```

Mein zweites Problem ist, wenn ich zu den Gebäuden hinein zoom verschwinden die ab nehm gewissen Abstand. Da habe ich leider auch keine Ahnung woran das liegen könnte. Denke mal das hängt zusammen mit der reshape-Methode. Allerdings womit genau weiss ich nicht.


```
public void reshape(GLAutoDrawable gLDrawable, int x, int y,
                            int width, int height){
        	GL gl = gLDrawable.getGL();
    		float h = (float) height / (float) width;
    		gl.glMatrixMode(GL.GL_PROJECTION);
    		System.err.println("GL_VENDOR: " + gl.glGetString(GL.GL_VENDOR));
    		System.err.println("GL_RENDERER: " + gl.glGetString(GL.GL_RENDERER));
    		System.err.println("GL_VERSION: " + gl.glGetString(GL.GL_VERSION));
    		gl.glLoadIdentity();
    		gl.glFrustum(-1.0f, 1.0f, -h, h, 5.0f, 60.0f);
    		gl.glMatrixMode(GL.GL_MODELVIEW);
    		gl.glLoadIdentity();
    		gl.glTranslatef(0.0f, 0.0f, -10.0f);
        }
```











Wäre echt super wenn mir da jemand helfen könnte. Da ich doch noch ein bisschen ein Anfänger bin was das angeht und mich nicht sio auskenne. 

Danke schonmal im Voraus.
Mit freundlichen Grüßen 
Stacks


----------



## Marco13 (3. Jan 2010)

:autsch: ... Bei so Zeilen wie [c]data.Data.data.get(i).wall.get(j).getSize()[/c] oder den [c]gl.glVertex3f(...);[/c] Aufrufen rollen sich einem ja die Fußnägel hoch... *schauder*... 

Niemand weiß, was diese Zeilen bedeuten (und ich glaube, ich WILL das auch gar nicht wissen). 

Bei neueren OpenGL-Versionen (und auch bei JOGL 2.0) ist die bevorzugte Methode, um "größere" Objekte darzusellen, die Verwendung von Buffern (Vertex buffer objects). Sowas wie "glBegin" und "glVertex3f" sind eigentlich schon "deprecated". Für die neueren Funktionen ist nopper.tv ein guter Einsteig, ist aber insgesamt ist OpenGL >3.1 nicht mehr ganz so... Einsteigerfreundlich und "zugänglich", wenn man "nur mal schnell was zeichnen" will (Joa, erstmal 'nen Shader selbst schreiben und so... :noe: ). 

Wenn du die "alten" OpenGL-Funktionen verwenden willst, könntest du dir eine ... "geeignete" Datenhaltung überlegen. Also, irgendwas, wo die Daten gespeichert sind, die wirklich gezeichnet werden sollen. Um das ganze dann "schnell" zu machen, könntest du dich mal in "OpenGL Display Lists" Chapter 7 - OpenGL Programming Guide einlesen. (Das alles ist nicht mehr sooo up to date, aber war beim alten OpenGL eben so...). 

Dazu kommen noch "offensichtliche" sachen, wie z.B. dass bei den Aufrufen

```
gl.glVertex3f((-1+(2*(nPoint.getX()-xmin))/xdiff), (-1+(2*(nPoint.getY()-ymin))/xdiff), (-1+(2*(nPoint.getZ()-zmin))/xdiff));
```
ziemlich viel (und SEHR unübersichtlich) sinnlos rumgerechnet wird: Was auch immer da mit den Punkten gemacht wird, man könnte (und sollte) es durch eine geeignete MODELVIEW-Matrix auf sowas wie

```
gl.glVertex3f(nPoint.getX(), nPoint.getY(), nPoint.getZ());
```
reduzieren...


----------



## Marco13 (3. Jan 2010)

Ach ja: Das "Verschwinden" der Gebäude hängt wohl mit den near/far Clipping Planes zusammen... kannst mal testweise die Zeile
gl.glFrustum(-1.0f, 1.0f, -h, h, 5.0f, 60.0f);
(die auch schon deprecated ist ) ändern in
gl.glFrustum(-1.0f, 1.0f, -h, h, 0.1f, 100.0f);
oder so...


----------



## Stacks (3. Jan 2010)

Vielen Dank erstmal für die schnelle Antwort, Marco. 

Ich weiss das ganze ist leider wirklich ziemlich unübersichtlich geworden, was leider auch von dem vielen probieren und hin und her kopieren kam. So sind leider auch wohl einige veraltete Sachen mit hinein gekommen weil ich eben oft speziell nach diesen Dingen im Internet und co gesucht habe. Aber ich werd mich mal in das nopper.tv hinein lesen. Super Hinweis, vielen Dank.  Wie gesagt, ich bin was das angeht wirklich ein blutiger Anfänger und habe da einfach mal versucht das zu realisieren.


Gruß Stacks


----------



## Marco13 (3. Jan 2010)

Naja, bevor du dich jetzt da drauf stürzt: Jetzt zu versuchen, das ganze auf OpenGL3.2 umzustellen, wäre vermutlich sehr schwierig ... bis unmöglich. Ich glaube, da liegt einiges im Argen, so dass du wohl erstmal das bestehende so weit aufräumen solltest, dass du einen Platz hast, wo die Daten liegen, die gerendert werden sollen - OHNE sowas wie data.data.data.getThis().getThat().getFoo().something.getX(). Das ganze später dann in ein VBO zu packen wäre der nächste Schritt...


----------



## Guest2 (3. Jan 2010)

Moin,

für den Fall das Dir der Einstieg in OpenGL 3.2 zu hart ist, das geht auch mit JoGL1 und OpenGL 2.1.
(Auch wenn ich wahrscheinlich der letzte bin der jemanden von 3.2 abhalten will   ) 

Am einfachsten ist es wenn Du Deine Geometriedaten in einem Vertex Array speicherst. Dann werden die Daten im nativen Teil des Hauptspeichers vorgehalten und mit einem einzigen OpenGL Befehl zur Grafikkarte übertragen und gezeichnet. Eine Variante davon ist der von Marco bereits angesprochene VBO, dann werden die Daten direkt im Speicher der Grafikkarte vorgehalten (ist etwas schneller, braucht aber auch ein paar Zeilen mehr Code  )

Wo die Daten später sichtbar sind hängt im wesentlichen von der ModelView Matrix ab (Du kannst die als eine art "Kamera" ansehen) (sowohl unter OpenGL 3.2 aus auch unter 2.1). Am einfachsten ist es, wenn Du die Eingaben von Tastatur und ggf. Maus abgreifst und daraus dann die ModelView Matrix selbst zusammenbaust. Die Grafikkarte transformiert dann die statischen Vertices mit Hilfe der übergebenen ModelView Matrix.

Hier mal ein einfaches Beispiel in OpenGL 2.1 mit JoGL 1. Das Haus ist nur ein einfacher Würfel und die "Kamera" verhält sich wie in einem Shooter. In OpenGL 3.2 sähe der Code annähernd identisch aus nur das eben zusätzlich die Shader geladen werden müssten. 


```
package late.blub;

import java.awt.Frame;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.nio.FloatBuffer;

import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;

import com.sun.opengl.util.Animator;
import com.sun.opengl.util.BufferUtil;


public class Main implements GLEventListener, KeyListener {

    // a cube as a very simple house (in real this should be loaded from on obj file or something)
    // 6 faces (quads) with 4 vertices (x, y, z)  
    private static final float[] house = new float[] {
        1.0f, 1.0f,-1.0f,  -1.0f, 1.0f,-1.0f,  -1.0f, 1.0f, 1.0f,   1.0f, 1.0f, 1.0f,
        1.0f,-1.0f, 1.0f,  -1.0f,-1.0f, 1.0f,  -1.0f,-1.0f,-1.0f,   1.0f,-1.0f,-1.0f,
        1.0f, 1.0f, 1.0f,  -1.0f, 1.0f, 1.0f,  -1.0f,-1.0f, 1.0f,   1.0f,-1.0f, 1.0f,
        1.0f,-1.0f,-1.0f,  -1.0f,-1.0f,-1.0f,  -1.0f, 1.0f,-1.0f,   1.0f, 1.0f,-1.0f,
       -1.0f, 1.0f, 1.0f,  -1.0f, 1.0f,-1.0f,  -1.0f,-1.0f,-1.0f,  -1.0f,-1.0f, 1.0f,
        1.0f, 1.0f,-1.0f,   1.0f, 1.0f, 1.0f,   1.0f,-1.0f, 1.0f,   1.0f,-1.0f,-1.0f };

    // vertex array to hold the house data at runtime
    private final FloatBuffer    va;
   
    // the "camera"
    private final Modelview      modelview;
    
    
    private final Frame          frame;

    private GL                   gl;
    private GLU                  glu;


    public Main(final Frame frame, final Modelview modelview) {

        this.frame = frame;
        this.modelview = modelview;

        // put the static house vertices in the vertex array
        va = BufferUtil.newFloatBuffer(house.length);
        va.put(house, 0, house.length);
        va.rewind();

    }


    @Override
    public void init(final GLAutoDrawable drawable) {

        gl = drawable.getGL();
        glu = new GLU();

        gl.glEnable(GL.GL_DEPTH_TEST);
        gl.glEnableClientState(GL.GL_VERTEX_ARRAY);

    }


    @Override
    public void display(final GLAutoDrawable drawable) {

        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

        // bind the modelview matrix to setup the "camera" view
        modelview.bind();

        // draw the house
        gl.glVertexPointer(3, GL.GL_FLOAT, 0, va);
        gl.glDrawArrays(GL.GL_QUADS, 0, va.capacity());

    }


    @Override
    public void reshape(final GLAutoDrawable drawable, final int x, final int y, final int width, int height) {

        if (height <= 0)
            height = 1;

        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glLoadIdentity();
        glu.gluPerspective(45.0f, (float) width / (float) height, 1.0, 1000.0);

    }
    

    @Override
    public void keyPressed(final KeyEvent e) {

        // esc close the window
        if (e.getKeyCode() == KeyEvent.VK_ESCAPE)
            frame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_CLOSING));

    }


    public static void main(final String[] args) {

        final Frame frame = new Frame();
        final GLCanvas canvas = new GLCanvas();
        final Animator animator = new Animator(canvas);
        final Modelview modelview = new Modelview(canvas);
        final Main main = new Main(frame, modelview);

        canvas.addGLEventListener(main);
        canvas.addKeyListener(main);

        frame.add(canvas);
        frame.setSize(900, 500);
        frame.addWindowListener(new WindowAdapter() {

            @Override
            public void windowClosing(final WindowEvent e) {

                new Thread(new Runnable() {
                    public void run() {

                        animator.stop();
                        System.exit(0);

                    }
                }).start();
            }
        });

        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        animator.start();

        canvas.requestFocusInWindow();
    }
    
    @Override public void displayChanged(final GLAutoDrawable drawable, final boolean modeChanged, final boolean deviceChanged) { }
    @Override public void keyReleased(final KeyEvent e) { }
    @Override public void keyTyped(final KeyEvent e) { }

}
```


```
package late.blub;

import java.awt.AWTException;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

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

public class Modelview implements KeyListener, MouseMotionListener, GLEventListener {

    private static final int            forward    = KeyEvent.VK_W;
    private static final int            backward   = KeyEvent.VK_S;
    private static final int            leftward   = KeyEvent.VK_A;
    private static final int            rightward  = KeyEvent.VK_D;

    private static final int            mouseSpeed = 3;
    private static final int            keySpeed   = 4;

    private static final int            rotVMax    = 1;
    private static final int            rotVMin    = -1;


    private final Map<Integer, Boolean> keys       = new ConcurrentHashMap<Integer, Boolean>();
    private final float[]               modelview  = new float[16];
    private final GLCanvas              canvas;
    private final Robot                 robot;

    private float                       rotX, rotY, rotZ, rotV;
    private float                       posX, posY, posZ;
    private int                         centerX, centerY;

    private long                        lastTime   = -1;

    private GL                          gl         = null;


    // a very simple first person shooter style camera
    public Modelview(final GLCanvas canvas) {

        // we need the robot to get full control over the mouse
        Robot robot = null;
        try {

            robot = new Robot();

        } catch (final AWTException e) {

            e.printStackTrace();

        }

        if (robot != null) {

            // hide the mouse pointer
            final BufferedImage cursorImg = new BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB);
            final Graphics2D gfx = cursorImg.createGraphics();
            gfx.setColor(new Color(0, 0, 0, 0));
            gfx.fillRect(0, 0, 16, 16);
            gfx.dispose();
            canvas.setCursor(canvas.getToolkit().createCustomCursor(cursorImg, new Point(), ""));

        }

        // setup the modelview matrix
        for (int i = 0; i < 4; i++)
            modelview[i * 5] = 1.0f;

        
        this.canvas = canvas;
        this.robot = robot;

        this.posZ = -10;
        this.posX = 0;

        canvas.addKeyListener(this);
        canvas.addMouseMotionListener(this);
        canvas.addGLEventListener(this);

    }


    public void bind() {

        // calculate the current modelview matrix
        calculatePosition();
        calculateModelview();

        // load the modelview matrix to the fixed function pipeline
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glLoadMatrixf(modelview, 0);

    }


    // calculate the current camera position (needs a little trigonometry)
    private void calculatePosition() {

        if (lastTime == -1)
            lastTime = System.nanoTime();

        final double speed = keySpeed * -((lastTime - (lastTime = System.nanoTime())) / 10E7);

        Boolean value = null;

        if ((value = keys.get(forward)) != null && value == true) {

            posX -= Math.sin(rotY) * speed;
            posZ += Math.cos(rotY) * speed;

        }

        if ((value = keys.get(backward)) != null && value == true) {

            posX += Math.sin(rotY) * speed;
            posZ -= Math.cos(rotY) * speed;

        }

        if ((value = keys.get(leftward)) != null && value == true) {

            posX += Math.cos(rotY) * speed;
            posZ += Math.sin(rotY) * speed;

        }

        if ((value = keys.get(rightward)) != null && value == true) {

            posX -= Math.cos(rotY) * speed;
            posZ -= Math.sin(rotY) * speed;

        }

    }


    // calculate the current modelview matrix (look at the OpenGL documentation)
    private void calculateModelview() {

        final float sinX = (float) Math.sin(rotX);
        final float sinY = (float) Math.sin(rotY);
        final float sinZ = (float) Math.sin(rotZ);

        final float cosX = (float) Math.cos(rotX);
        final float cosY = (float) Math.cos(rotY);
        final float cosZ = (float) Math.cos(rotZ);

        modelview[0] = cosY * cosZ + sinY * sinX * sinZ;
        modelview[1] = cosX * sinZ;
        modelview[2] = -sinY * cosZ + cosY * sinX * sinZ;
        modelview[4] = -cosY * sinZ + sinY * sinX * cosZ;
        modelview[5] = cosX * cosZ;
        modelview[6] = sinY * sinZ + cosY * sinX * cosZ;
        modelview[8] = sinY * cosX;
        modelview[9] = -sinX;
        modelview[10] = cosY * cosX;

        modelview[12] = modelview[0] * posX + modelview[4] * posY + modelview[8] * posZ;
        modelview[13] = modelview[1] * posX + modelview[5] * posY + modelview[9] * posZ;
        modelview[14] = modelview[2] * posX + modelview[6] * posY + modelview[10] * posZ;

    }
    
    @Override
    public void init(final GLAutoDrawable drawable) {

        gl = drawable.getGL();

    }


    // calculate the new frame center to hold the mouse at the center
    @Override
    public void reshape(final GLAutoDrawable drawable, final int x, final int y, final int width, final int height) {

        rotV = 0;

        final Rectangle r = canvas.getParent().getBounds();

        centerX = r.x + width / 2;
        centerY = r.y + height / 2;

        if (robot != null)
            robot.mouseMove(centerX, centerY);

    }


    // calculate the new viewing angels and put the mouse back to the center
    @Override
    public void mouseMoved(final MouseEvent e) {

        rotY -= (centerX - e.getXOnScreen()) / 1000.0 * mouseSpeed;
        rotV -= (centerY - e.getYOnScreen()) / 1000.0 * mouseSpeed;

        if (rotV > rotVMax)
            rotV = rotVMax;

        if (rotV < rotVMin)
            rotV = rotVMin;

        rotX = (float) Math.cos(rotY) * rotV;
        rotZ = (float) Math.sin(rotY) * rotV;

        if (robot != null)
            robot.mouseMove(centerX, centerY);

    }


    @Override
    public void mouseDragged(final MouseEvent e) {

        mouseMoved(e);

    }
    
    
    @Override
    public void keyPressed(final KeyEvent e) {

        keys.put(e.getKeyCode(), true);

    }


    @Override
    public void keyReleased(final KeyEvent e) {

        keys.put(e.getKeyCode(), false);

    }

    
    @Override public void keyTyped(final KeyEvent e) { }
    @Override public void display(final GLAutoDrawable drawable) { }
    @Override public void displayChanged(final GLAutoDrawable drawable, final boolean modeChanged, final boolean deviceChanged) { }

}
```

Gruß,
Fancy


----------



## Marco13 (4. Jan 2010)

Guest2 hat gesagt.:


> In OpenGL 3.2 sähe der Code annähernd identisch aus nur das eben zusätzlich die Shader geladen werden müssten.



... und glEnableClientState & Co wegfallen, und glMatrixMode nicht mehr existiert, und sich jeder seine Eigene Hilfsklasse basteln muss, die zwei float[16]-Matrizen miteinander multipliziert :autsch: (Ich find' das ja ziemlich krampfig....  ) ... aber naja... man fräst sich irgendwie rein...


----------



## Spacerat (4. Jan 2010)

Oh man... Den Thread seh ich ja jetzt erst. Wenn man sich den Code des TS so ansieht, scheint er gerade mal mit OGL angefangen zu haben und ihr präsentiert ihm gleich die "volle Ladung". Wäre es nicht sinnvoller, wenn er zunächst erstmal bei den guten alten Displaylisten ([c]gl.glGenList()[/c]) bleibt?


----------



## Marco13 (4. Jan 2010)

Das war ja auch meine erste "Empfehlung" (aber bitte auch erst, NACHDEM der bestehende Code einigermaßen aufgeräumt ist). Die "Empfehlung" aber mit dem Vorbehalt, dass das eben _eigentlich_ deprecated ist, und _eigentlich_ von keiner "Core" OpenGL-Implementierung mehr angeboten werden muss. (Es wird sicher nicht von heute auf morgen wegfallen - da würden die ganzen CAD-Hersteller den Grafikkartenleuten schon was husten  aber ... darauf Hinweisen sollte man IMHO schon...)


----------



## Guest2 (4. Jan 2010)

Marco13 hat gesagt.:


> ... und glEnableClientState & Co wegfallen, und glMatrixMode nicht mehr existiert, und sich jeder seine Eigene Hilfsklasse basteln muss, die zwei float[16]-Matrizen miteinander multipliziert :autsch: (Ich find' das ja ziemlich krampfig....  ) ... aber naja... man fräst sich irgendwie rein...



Ja, hätte ich wohl vermutlich genauer formulieren sollen. 
Worauf ich hinaus wollte war, das sowohl das Vertex Array als auch die Modelview Matrix in der obigen Form nicht depricated sind und damit vom Prinzip her fast genau so auch in einem OpenGL 3.2 Code eingebaut werden könnten. (Und viel mehr als VA und MV ist in dem obigen Code ja eh nicht  )

Nuja, der Vollständigkeit halber, wie es in JoGL2 / OpenGL 3.2 / GLSL 1.5 aussehen könnte:  
http://too-late.de/kskb/gl3sample00.zip

(Wie immer:
Eclipse -> File -> Import -> General -> Existing Projects into Workspace -> Select archive file -> Browse -> gl3sample00.zip auswählen -> Öffnen -> Finish)




Spacerat hat gesagt.:


> Wäre es nicht sinnvoller, wenn er zunächst erstmal bei den guten alten Displaylisten ([c]gl.glGenList()[/c]) bleibt?



Ich persönlich finde Vertex Arrays wesentlich einfacher als Displaylisten. Einfacher als x, y, z nacheinander in ein Array / Buffer zu schreiben geht ja nicht mehr. Außerdem brauchen Vertex Arrays keinen OpenGL Kontext während sie erstellt werden und können damit sauber irgendwo außerhalb der View generiert werden.


Gruß,
Fancy


----------

