# Jogl-Animator - Inhalt ändert sich nicht



## Horschie (19. Jan 2009)

Hallo,

vlt kann mir ja hier jemand helfen: 

Habe ein FPSAnimator erzeugt. Dieser funktiooniert auch sehr gut. 
Zumindest wird die display Methode regelmäßig aufgerufen. 

In der display Methode fage ich eine bool-Variable ab, ob ein Koordinatenkreuz
gezeichnet werden soll. Die bool-VAriable ändert auch definitv ihren Wert. 

Nur die Sache ist die, das der Inhalt sich im GLJPanel nicht ändert. Auch nicht wenn
man die größe des Fenster ändert. 

Jmenad ne Idee? 


```
public void display(GLAutoDrawable arg0)
	{
		
		System.out.println("Renderer: display"); 
		
		GL gl = arg0.getGL(); 
		gl.glClear(GL.GL_ACCUM_BUFFER_BIT);
		//werkstueck.display(gl); 
		
		gl.glClear(GL.GL_COLOR_BUFFER_BIT); 
		gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
		
		if (this.drawKoordSys == true)
		{
			this.drawCoordSys(gl); 
		}
		
		gl.glBegin(GL.GL_LINES); 
		gl.glColor3f(0.8f,0.5f,0.5f); 
		for (int i = 0; i < lines.size(); i++)
		{
			Lines l = lines.get(i); 
			Point a = l.getA(); 
			Point b = l.getB(); 
			
			gl.glVertex3f(a.getX(), a.getY(), a.getZ()); 
			gl.glVertex3f(b.getX(), b.getY(), b.getZ()); 
		}
		gl.glEnd(); 
		
		arg0.swapBuffers();
	}
```


----------



## Horschie (20. Jan 2009)

Habe mein GLück noch ein wenig versucht. 

Der Wert wird in einer Methode gesetzt. Innerhalb dieser Methode ist der Wert auch geändert. Nur sobald die Display-Methode wieder aufgerufen wird, ist der Initial-Zustand der Variable wieder vorhanden.

Kemand ne Idee?


----------



## Soulfly (20. Jan 2009)

Also du solltest mehr von deinem Code zeigen. Spezielle Stellen und was dazu erklären. 

Wo wird die Variable gesetzt, wer hat/besitzt die Variable etc. 
Dein Codestück zeichnet nur und ist zur Problemlösung IMO nicht ausreichend...


----------



## Horschie (20. Jan 2009)

hmm...also der Trick an der Sache, den ich jetzt auch nur zufällig rausgefunden habe ist, dass die Variablen statisch sein *müssen*. Sonst wird eine Änderung nicht erkannt....

Zur Info dann mal noch der gesamte Code des "Renderers. Ist ne Rohfassung...also bitte nicht zu kritisch sein  


```
public class Renderer implements GLEventListener, MouseMotionListener, MouseListener
{
	static Vector<Point> points; // 3D-Punkte
	static Vector<Lines> lines;  // Linien aus 2x 3D-Punkt
	static Vector<Face> faces; 
	
	private Werkstueck werkstueck; 
	
	static boolean drawKoordSys = false;
	
	public Renderer(Werkstueck werkstueck)
	{
		this.werkstueck = werkstueck; 

		points = new Vector<Point>(); 

		points.add(new Point(0,0,0)); 
		points.add(new Point(0,50,0)); 
		points.add(new Point(25,50,0)); 
		points.add(new Point(25, 25,0)); 
		points.add(new Point(50, 25,0));
		points.add(new Point(50, 0,0));

		points.add(new Point(0,0,50)); 
		points.add(new Point(0,50,50)); 
		points.add(new Point(25,50,50)); 
		points.add(new Point(25, 25,50)); 
		points.add(new Point(50, 25,50));
		points.add(new Point(50, 0,50));
		
		this.addFace(0,1,2,3); 
		
		lines = new Vector<Lines>(); 
		
		lines.add(new Lines(points.get(0), points.get(1))); 
		lines.add(new Lines(points.get(1), points.get(2))); 
		lines.add(new Lines(points.get(2), points.get(3))); 
		lines.add(new Lines(points.get(3), points.get(4))); 
		lines.add(new Lines(points.get(4), points.get(5))); 
		lines.add(new Lines(points.get(5), points.get(0))); 
		
		lines.add(new Lines(points.get(6), points.get(7))); 
		lines.add(new Lines(points.get(7), points.get(8))); 
		lines.add(new Lines(points.get(8), points.get(9))); 
		lines.add(new Lines(points.get(9), points.get(10))); 
		lines.add(new Lines(points.get(10), points.get(11))); 
		lines.add(new Lines(points.get(11), points.get(6))); 
		
		lines.add(new Lines(points.get(0), points.get(6))); 
		lines.add(new Lines(points.get(1), points.get(7))); 
		lines.add(new Lines(points.get(2), points.get(8)));
		lines.add(new Lines(points.get(3), points.get(9))); 
		lines.add(new Lines(points.get(4), points.get(10))); 
		lines.add(new Lines(points.get(5), points.get(11)));
	}
	
	@Override
	public void display(GLAutoDrawable arg0)
	{
		GL gl = arg0.getGL();
		
		gl.glClear(GL.GL_ACCUM_BUFFER_BIT);
		gl.glClear(GL.GL_COLOR_BUFFER_BIT); 
		gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
		gl.glClear(GL.GL_STENCIL_BUFFER_BIT); 
		
		if (this.drawKoordSys)
		{
			this.drawCoordSys(gl); 
		}
		
		gl.glBegin(GL.GL_LINES); 
		gl.glColor3f(0.8f,0.5f,0.2f); 
		for (int i = 0; i < lines.size(); i++)
		{
			Lines l = lines.get(i); 
			Point a = l.getA(); 
			Point b = l.getB(); 
			
			gl.glVertex3f(a.getX(), a.getY(), a.getZ()); 
			gl.glVertex3f(b.getX(), b.getY(), b.getZ()); 
		}
		gl.glEnd(); 
		
		gl.glBegin(GL.GL_QUAD_STRIP);
		gl.glColor3f(0.8f,0.5f,0.5f); 
		for (int i = 0; i < faces.size(); i++)
		{
			Face f = faces.get(i); 
			
			Point a = f.getA(); 
			Point b = f.getB(); 
			Point c = f.getC(); 
			Point d = f.getD(); 
			
			gl.glVertex3f(a.getX(), a.getY(), a.getZ()); 
			gl.glVertex3f(b.getX(), b.getY(), b.getZ()); 
			gl.glVertex3f(c.getX(), c.getY(), c.getZ()); 
			gl.glVertex3f(d.getX(), d.getY(), d.getZ()); 
			
		}
		gl.glEnd(); 
	}

	private void drawCoordSys(GL gl)
	{ 
		gl.glBegin(GL.GL_LINES); 
		gl.glColor3f(0.5f,0.5f,0.5f);
		
		// X-Achse, rot
		gl.glColor3f(1.0f,0.0f,0.0f);
		gl.glVertex3f(0,0,0); 
		gl.glVertex3f(100,0,0); 
		
		// Y-Achse, grün
		gl.glColor3f(0.0f,1.0f,0.0f);
		gl.glVertex3f(0,0,0); 
		gl.glVertex3f(0,100,0); 
		
		// Z-Achse, blau
		gl.glColor3f(0.0f,0.0f,1.0f);
		gl.glVertex3f(0,0,0); 
		gl.glVertex3f(0,0,100); 
		
		gl.glEnd(); 
	}

	@Override
	public void displayChanged(GLAutoDrawable arg0, boolean arg1, boolean arg2)
	{
		System.out.println("Renderer: displayChanged"); 
		// TODO Auto-generated method stub
		
	}

	@Override
	public void init(GLAutoDrawable arg0)
	{
		System.out.println("Renderer: init"); 
	      GL gl = arg0.getGL();
	      GLU glu = new GLU(); 
	      gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	      gl.glMatrixMode(GL.GL_PROJECTION);
			gl.glLineWidth(2.0f);

			gl.glViewport(0,0, 250, 150);
			
			gl.glLoadIdentity();
			gl.glOrtho(-20,100,-20,100,-100,100);
			
			gl.glMatrixMode(GL.GL_MODELVIEW); 

			gl.glLoadIdentity(); 
			gl.glRotatef(-45, 1, 0, 0); 
			gl.glRotatef(20, 0,1,0) ;
			
			gl.glEnable(GL.GL_NORMALIZE); 
			
			gl.glShadeModel (GL.GL_SMOOTH) ;
	}

	@Override
	public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3,
			int arg4)
	{
		this.display(arg0) ;
		System.out.println("Renderer: reshaped"); 
	}

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

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

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

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

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

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

	@Override
	public void mouseReleased(MouseEvent arg0)
	{
		// TODO Auto-generated method stub
		
	}
	
	public boolean isDrawKoordSys()
	{
		return drawKoordSys;
	}

	public synchronized void setDrawKoordSys(boolean draw)
	{
		drawKoordSys = draw;
	}
	
	public void addFace(int a, int b, int c, int d)
	{
		if (faces == null)
			faces = new Vector<Face>(); 
		
		faces.add(new Face(points.get(a), points.get(b), points.get(c), points.get(d))); 
	}
}
```


----------



## Fancy (20. Jan 2009)

Moin,



			
				Horschie hat gesagt.:
			
		

> hmm...also der Trick an der Sache, den ich jetzt auch nur zufällig rausgefunden habe ist, dass die Variablen statisch sein *müssen*. Sonst wird eine Änderung nicht erkannt....



also das würde mich wundern. 


Auf die schnelle, Dein Code als KSKB:


```
package fancy.jf.horschie;

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 java.nio.FloatBuffer;
import java.nio.IntBuffer;

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 Sample implements GLEventListener, MouseListener {
    
    
    private static final float[] staticVertices   = new float[] {
        0.0f,  0.0f,  0.0f,
        0.0f, 50.0f,  0.0f,
       25.0f, 50.0f,  0.0f,
       25.0f, 25.0f,  0.0f,
       50.0f, 25.0f,  0.0f,
       50.0f,  0.0f,  0.0f,
        0.0f,  0.0f, 50.0f,
        0.0f, 50.0f, 50.0f,
       25.0f, 50.0f, 50.0f,
       25.0f, 25.0f, 50.0f,
       50.0f, 25.0f, 50.0f,
       50.0f,  0.0f, 50.0f
    };
    
    
    private static final int[] staticIndicesFaces = new int[] {
        0, 1, 2, 3
    };
    
    
    private static final int[] staticIndicesLines = new int[] {
        0, 1,   1, 2,   2, 3,   3,  4,    4,  5,    5,  0,
        6, 7,   7, 8,   8, 9,   9, 10,   10, 11,   11,  6,
        0, 6,   1, 7,   2, 8,   3,  9,    4, 10,    5, 11
    };    
    
    
    
    private GL                   gl                 = null;
    private GLU                  glu                = null;

    private FloatBuffer          vaVertices         = null;
    private IntBuffer            vaIndicesFaces     = null;
    private IntBuffer            vaIndicesLines     = null;

    private float                rotY               = 0;

    private boolean              drawKoordSys       = false;

    

    @Override
    public void init(final GLAutoDrawable drawable) {

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

        vaVertices = BufferUtil.newFloatBuffer(staticVertices.length);
        vaVertices.put(staticVertices, 0, staticVertices.length);
        vaVertices.rewind();

        vaIndicesFaces = BufferUtil.newIntBuffer(staticIndicesFaces.length);
        vaIndicesFaces.put(staticIndicesFaces, 0, staticIndicesFaces.length);
        vaIndicesFaces.rewind();

        vaIndicesLines = BufferUtil.newIntBuffer(staticIndicesLines.length);
        vaIndicesLines.put(staticIndicesLines, 0, staticIndicesLines.length);
        vaIndicesLines.rewind();

        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);
        gl.glLoadIdentity();

        glu.gluLookAt(0, 50, 200, 0, 25, 0, 0, 1, 0);
        
        gl.glRotatef(rotY, 0.0f, 1.0f, 0.0f);
        rotY += 1.1f;
        
        if(drawKoordSys) drawCoordSys();

        gl.glVertexPointer(3, GL.GL_FLOAT, 0, vaVertices);
        
        gl.glColor3f(0.8f,0.5f,0.5f);
        gl.glDrawElements(GL.GL_QUADS, staticIndicesFaces.length, GL.GL_UNSIGNED_INT, vaIndicesFaces);
        
        gl.glColor3f(0.8f, 0.5f, 0.2f);
        gl.glDrawElements(GL.GL_LINES, staticIndicesLines.length, GL.GL_UNSIGNED_INT, vaIndicesLines);
        
    }


    private void drawCoordSys() {

        gl.glBegin(GL.GL_LINES);
        gl.glColor3f(0.5f, 0.5f, 0.5f);

        // X-Achse, rot
        gl.glColor3f(1.0f, 0.0f, 0.0f);
        gl.glVertex3f(0, 0, 0);
        gl.glVertex3f(100, 0, 0);

        // Y-Achse, grün
        gl.glColor3f(0.0f, 1.0f, 0.0f);
        gl.glVertex3f(0, 0, 0);
        gl.glVertex3f(0, 100, 0);

        // Z-Achse, blau
        gl.glColor3f(0.0f, 0.0f, 1.0f);
        gl.glVertex3f(0, 0, 0);
        gl.glVertex3f(0, 0, 100);

        gl.glEnd();
        
    }


    @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, 500.0);
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glLoadIdentity();

    }
    
    
    @Override
    public void mouseClicked(final MouseEvent e) {

        drawKoordSys = !drawKoordSys;

    }


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

        final Sample main = new Sample();
        final Frame frame = new Frame();
        final GLCanvas canvas = new GLCanvas();
        final Animator animator = new Animator(canvas);
        canvas.addGLEventListener(main);
        canvas.addMouseListener(main);
        frame.add(canvas);
        frame.setSize(500, 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();
    }


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


    @Override
    public void mouseEntered(final MouseEvent e) {}


    @Override
    public void mouseExited(final MouseEvent e) {}


    @Override
    public void mousePressed(final MouseEvent e) {}


    @Override
    public void mouseReleased(final MouseEvent e) {}

}
```

Gruß,
Michael


----------

