# Probleme mit JOGL/ LWJGL



## commic (7. April 2008)

Hallo allo zusammen,

ich habe ein bescheidenes Problem mit JOGL/ LWJGL mit SWT. Ich muss aber sagen, dass ich ein totaler Anfänger bin bzgl. OpenGL. OpenGL binge ich mir selber bei und mache dies aber in C++. Dabei ist mir aufgefallen, dass eine wichtige Sache nicht richtig funktioniert. Ich habe eine einfache 3-d-Szene erstellt. Darin habe ich 2 Flächen mit einen y-Abstand übereinander gelegt unterschiedlicher Farben. Die Szene ist durch einen Mouse-Action-Listener drehbar und skalierbar. Und hier kommt der Fehler: Egal wie ich die Szene drehe, die zuletzt gezeichnete Fläche überdeckt immer die jeweils davorgezeichnete Fläche. Ich habe den Code für das Zeichnen der Flächen in Visual-C++ ausprobiert, die Initialisierung ist ebenfalls identisch - funktioniert tadellos. Habe ich im Code vielleicht doch einen Fehler drin oder ist das nen bekannter Bug ? Nun der Code und anbei noch ein Screenshot.

```
package diagramtest.jogl;

import javax.media.opengl.GL;
import javax.media.opengl.GLContext;
import javax.media.opengl.GLException;

import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;

public class Cube extends GLScene {

	private SceneGrip grip;

	public Cube(Composite comp) {
		super(comp);
		this.grip = new SceneGrip();
		this.grip.setOffsets(0.0f, 0.0f, -15.0f);
		this.grip.setRotation(45.0f, -30.0f);

		this.getCanvas().addMouseListener(this.grip);
		this.getCanvas().addMouseMoveListener(this.grip);
		this.getCanvas().addListener(SWT.MouseWheel, this.grip);
		this.getCanvas().addKeyListener(this.grip);
	}

	protected void initGL() {
		super.initGL();
		try {
			if (GLContext.getCurrent() != this.getGLContext()) {
				this.getGLContext().makeCurrent();
			}
			float LightAmbient[]=		{ 0.5f, 0.5f, 0.5f, 1.0f };
			float LightDiffuse[]=		{ 1.0f, 1.0f, 1.0f, 1.0f };
			float LightPosition[]=	{ 0.0f, 0.0f, 2.0f, 1.0f };
			GL gl = getGLContext().getGL();
			gl.glShadeModel(GL.GL_SMOOTH);							// Enable Smooth Shading
			gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);				// Black Background
			gl.glClearDepth(1.0f);									// Depth Buffer Setup
			gl.glEnable(GL.GL_DEPTH_TEST);							// Enables Depth Testing
			gl.glDepthFunc(GL.GL_LEQUAL);								// The Type Of Depth Testing To Do
			gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);	// Really Nice Perspective Calculations

			gl.glLightfv(GL.GL_LIGHT1, GL.GL_AMBIENT, LightAmbient, 0);		// Setup The Ambient Light
			gl.glLightfv(GL.GL_LIGHT1, GL.GL_DIFFUSE, LightDiffuse, 0);		// Setup The Diffuse Light
			gl.glLightfv(GL.GL_LIGHT1, GL.GL_POSITION,LightPosition, 0);	// Position The Light
			gl.glEnable(GL.GL_LIGHT1);								// Enable Light One

			gl.glColor4f(1.0f, 1.0f, 1.0f, 0.5f);					// Full Brightness.  50% Alpha
			gl.glBlendFunc(GL.GL_SRC_ALPHA,GL.GL_ONE);					// Set The Blending Function For Translucency

			this.getGLContext().release();
		} catch (GLException ex) {
			ex.printStackTrace();
		}
	}

	@Override
	protected void drawScene() {
		try {
			if (GLContext.getCurrent() != this.getGLContext()) {
				this.getGLContext().makeCurrent();
			}
			GL gl = this.getGLContext().getGL();
			gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
			gl.glLoadIdentity();
			this.grip.adjust(gl);
	        
	        gl.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
	        gl.glBegin(GL.GL_QUADS);
	        gl.glVertex3f(-6.0f, 0.0f, -9.0f);
	        gl.glVertex3f(9.0f, 0.0f, -9.0f);
	        gl.glVertex3f(9.0f, 0.0f, 2.0f);
	        gl.glVertex3f(-6.0f, 0.0f, 2.0f);
	        gl.glEnd();
	        gl.glTranslatef(0.0f, -3.0f, 0.0f);
	        gl.glColor4f(1.0f, 0.0f, 0.0f, 0.5f);
	        gl.glBegin(GL.GL_QUADS);
	        gl.glVertex3f(-6.0f, 0.0f, -9.0f);
	        gl.glVertex3f(9.0f, 0.0f, -9.0f);
	        gl.glVertex3f(9.0f, 0.0f, 2.0f);
	        gl.glVertex3f(-6.0f, 0.0f, 2.0f);
	        gl.glEnd();
			this.getGLContext().release();
		} catch (GLException ex) {
			ex.printStackTrace();
		}
	}

}
```
Hier die Klasse für die Interaktion:

```
package diagramtest.jogl;

import javax.media.opengl.GL;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;

public class SceneGrip extends MouseAdapter implements MouseMoveListener, Listener, KeyListener{
	private float xrot;
    private float yrot;
    private float zoff;
    private float xoff;
    private float yoff;
    private float xcpy;
    private float ycpy;
    private boolean move;
    private int xdown;
    private int ydown;
    private int mouseDown;
    
    
    public SceneGrip() {
        this.init();
    }
    
    protected void init() {
        this.xrot = this.yrot = 0.0f;
        this.xoff = this.yoff = 0.0f;
        this.zoff = -8.0f;
    }
    
    public void mouseDown(MouseEvent e) {
        if (++ this.mouseDown == 1) {
            if ((this.move = e.button == 3)) {
                this.xcpy = xoff;
                this.ycpy = yoff;
                ((Control) e.widget).setCursor(e.widget.getDisplay().getSystemCursor(SWT.CURSOR_HAND));
            } else {
                this.xcpy = xrot;
                this.ycpy = yrot;
                ((Control) e.widget).setCursor(e.widget.getDisplay().getSystemCursor(SWT.CURSOR_SIZEALL));
            }
            
            this.xdown = e.x;
            this.ydown = e.y;
        }
    }
    
    public void mouseUp(MouseEvent e) {
        if (-- this.mouseDown == 0) {
            ((Control) e.widget).setCursor(e.widget.getDisplay().getSystemCursor(SWT.CURSOR_ARROW));
        }
    }
    
    public void mouseMove(MouseEvent e) {
        Point p = ((Control) e.widget).getSize();
        
        if (this.mouseDown > 0) {
            int dx = e.x - this.xdown;
            int dy = e.y - this.ydown;
            
            if (this.move) {
                yoff = this.ycpy + ((zoff + 1.0f)*dy)/(2.0f*p.y);
                xoff = this.xcpy - ((zoff + 1.0f)*dx)/(2.0f*p.x);
            } else {
                xrot = this.xcpy + dy/2.0f;
                yrot = this.ycpy + dx/2.0f;
            }
        }
    }
    
    public void handleEvent(Event event) {
        this.zoff += event.count/6.0f;
    }
    
    public void keyPressed(KeyEvent e) {
        switch (e.keyCode) {
        case SWT.ARROW_UP:
            if ((e.stateMask & SWT.CTRL) != 0) {
                this.xrot -= 0.5f;
            } else {
                this.yoff += 0.05f;
            }
            break;
        case SWT.ARROW_DOWN:
            if ((e.stateMask & SWT.CTRL) != 0) {
                this.xrot += 0.5f;
            } else {
                this.yoff -= 0.05f;
            }
            break;
        case SWT.ARROW_LEFT:
            if ((e.stateMask & SWT.CTRL) != 0) {
                this.yrot -= 0.5f;
            } else {
                this.xoff -= 0.05f;
            }
            break;
        case SWT.ARROW_RIGHT:
            if ((e.stateMask & SWT.CTRL) != 0) {
                this.yrot += 0.5f;
            } else {
                this.xoff += 0.05f;
            }
            break;
        case SWT.PAGE_UP:
            this.zoff += 0.05f;
            break;
        case SWT.PAGE_DOWN:
            this.zoff -= 0.05f;
            break;
        case SWT.HOME:
            this.init();
            break;
        }
    }
    
    public void keyReleased(KeyEvent e) {
    }
    
    public void adjust(GL gl) {
        gl.glTranslatef(this.xoff, this.yoff, this.zoff);
        gl.glRotatef(this.xrot, 1.0f, 0.0f, 0.0f);
        gl.glRotatef(this.yrot, 0.0f, 1.0f, 0.0f);
    }
    
    public void setOffsets(float x, float y, float z) {
        this.xoff = x;
        this.yoff = y;
        this.zoff = z;
    }
    
    public void setRotation(float x, float y) {
        this.xrot = x;
        this.yrot = y;
    }
}
```


Ich hoffe jemand kann mir hier weiterhelfen.


----------



## commic (7. April 2008)

Hier ich noch einmal,

also ich hab nun ein wenig rumgetestet. Dazu habe ich mir das Torus-Beispiel von Eclipse geschnappt und dort die scene-Grip-Klasse reingehackt. Fazit: Wenn alle Methoden sich in einer Klasse befinden, geht es. Ich denke daher, dass irgendwo in der GLScene- Klasse ein Fehler drin steckt. Ich poste mal meine Torus-Klasse und die GLScene-Klasse dazu. Wer einen Unterschied feststellen kann, der melde sich bitte.... Danke 

```
package ect.views;

import javax.media.opengl.GL;
import javax.media.opengl.GLContext;
import javax.media.opengl.GLDrawableFactory;
import javax.media.opengl.glu.GLU;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.opengl.GLCanvas;
import org.eclipse.swt.opengl.GLData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.ui.part.ViewPart;

import diagramtest.jogl.SceneGrip;

public class DiagramView extends ViewPart {
	private SceneGrip grip;
	public static String ID = "ect.views.DiagramView";
	public DiagramView() {
		// TODO Auto-generated constructor stub
	}

	@Override
	public void createPartControl(Composite parent) {
		this.grip = new SceneGrip();
		this.grip.setOffsets(0.0f, 0.0f, -30.0f);
		this.grip.setRotation(45.0f, -30.0f);
		final Composite comp = new Composite(parent, SWT.NONE);
		comp.setLayout(new FillLayout());
		GLData data = new GLData ();
		data.doubleBuffer = true;
		final GLCanvas canvas = new GLCanvas(comp, SWT.NONE, data);
		canvas.addMouseListener(this.grip);
		canvas.addMouseMoveListener(this.grip);
		canvas.addListener(SWT.MouseWheel, this.grip);
		canvas.addKeyListener(this.grip);
		canvas.setCurrent();
		final GLContext context = GLDrawableFactory.getFactory().createExternalGLContext();

		canvas.addListener(SWT.Resize, new Listener() {
			public void handleEvent(Event event) {
				Rectangle bounds = canvas.getBounds();
				float fAspect = (float) bounds.width / (float) bounds.height;
				canvas.setCurrent();
				context.makeCurrent();
				GL gl = context.getGL ();
				gl.glViewport(0, 0, bounds.width, bounds.height);
				gl.glMatrixMode(GL.GL_PROJECTION);
				gl.glLoadIdentity();
				GLU glu = new GLU();
				glu.gluPerspective(45.0f, fAspect, 0.5f, 400.0f);
				gl.glMatrixMode(GL.GL_MODELVIEW);
				gl.glLoadIdentity();
				context.release();
			}
		});

		context.makeCurrent();
		GL gl = context.getGL ();
		gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
		gl.glColor3f(1.0f, 0.0f, 0.0f);
		gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
		gl.glClearDepth(1.0);
		gl.glLineWidth(2);
		gl.glDisable(GL.GL_DEPTH_TEST);
		gl.glEnable(GL.GL_BLEND);
		gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE);		
		context.release();
		
		comp.getDisplay().asyncExec(new Runnable() {
			int rot = 0;
			public void run() {
				if (!canvas.isDisposed()) {
					canvas.setCurrent();
					context.makeCurrent();
					GL gl = context.getGL ();
					gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
					gl.glClearColor(.3f, .5f, .8f, 1.0f);
					gl.glLoadIdentity();
					//gl.glTranslatef(0.0f, 0.0f, -10.0f);
					float frot = rot;
					grip.adjust(gl);
					//gl.glRotatef(0.15f * rot, 2.0f * frot, 10.0f * frot, 1.0f);
					//gl.glRotatef(0.3f * rot, 3.0f * frot, 1.0f * frot, 1.0f);
					rot++;
					//gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_QUAD_STRIP);
					gl.glColor4f(0.9f, 0.9f, 0.9f, 0.2f);
					drawTorus(gl, 1, 1.9f + ((float) Math.sin((0.004f * frot))), 40, 40);
					drawQuads(gl);
					context.release();
					canvas.swapBuffers();
					comp.getDisplay().asyncExec(this);
				}
			}
		});
	}
	private void drawQuads(GL gl){
		//gl.glBindTexture(GL.GL_TEXTURE_2D, textures[filter]);
        gl.glColor4f(1.0f, 0.0f, 0.0f, 0.1f);
        gl.glBegin(GL.GL_QUADS);
        // Front Face
        gl.glNormal3f(0.0f, 0.0f, 1.0f);
       // gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(-1.0f, -1.0f, 1.0f);
        //gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(1.0f, -1.0f, 1.0f);
        //gl.glTexCoord2f(1.0f, 1.0f);
        gl.glVertex3f(1.0f, 1.0f, 1.0f);
        //gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(-1.0f, 1.0f, 1.0f);
        // Back Face
        gl.glNormal3f(0.0f, 0.0f, -1.0f);
       // gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(-1.0f, -1.0f, -1.0f);
        //gl.glTexCoord2f(1.0f, 1.0f);
        gl.glVertex3f(-1.0f, 1.0f, -1.0f);
        //gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(1.0f, 1.0f, -1.0f);
        //gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(1.0f, -1.0f, -1.0f);
        // Top Face
        gl.glNormal3f(0.0f, 1.0f, 0.0f);
        //gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(-1.0f, 1.0f, -1.0f);
        //gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(-1.0f, 1.0f, 1.0f);
        //gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(1.0f, 1.0f, 1.0f);
        //gl.glTexCoord2f(1.0f, 1.0f);
        gl.glVertex3f(1.0f, 1.0f, -1.0f);
        // Bottom Face
        gl.glNormal3f(0.0f, -1.0f, 0.0f);
        //gl.glTexCoord2f(1.0f, 1.0f);
        gl.glVertex3f(-1.0f, -1.0f, -1.0f);
        //gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(1.0f, -1.0f, -1.0f);
        //gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(1.0f, -1.0f, 1.0f);
        //gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(-1.0f, -1.0f, 1.0f);
        // Right face
        gl.glNormal3f(1.0f, 0.0f, 0.0f);
        //gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(1.0f, -1.0f, -1.0f);
        //gl.glTexCoord2f(1.0f, 1.0f);
        gl.glVertex3f(1.0f, 1.0f, -1.0f);
        //gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(1.0f, 1.0f, 1.0f);
        //gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(1.0f, -1.0f, 1.0f);
        // Left Face
        gl.glNormal3f(-1.0f, 0.0f, 0.0f);
        //gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(-1.0f, -1.0f, -1.0f);
        //gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(-1.0f, -1.0f, 1.0f);
        //gl.glTexCoord2f(1.0f, 1.0f);
        gl.glVertex3f(-1.0f, 1.0f, 1.0f);
        //gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(-1.0f, 1.0f, -1.0f);
        gl.glEnd();
        gl.glTranslatef(0.0f, 0.0f, 2.0f);
        gl.glColor4f(0.0f, 0.0f, 1.0f, 0.2f);
        gl.glBegin(GL.GL_QUADS);
        // Front Face
        gl.glNormal3f(0.0f, 0.0f, 1.0f);
       // gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(-1.0f, -1.0f, 1.0f);
        //gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(1.0f, -1.0f, 1.0f);
        //gl.glTexCoord2f(1.0f, 1.0f);
        gl.glVertex3f(1.0f, 1.0f, 1.0f);
        //gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(-1.0f, 1.0f, 1.0f);
        gl.glEnd();
	}
	private void drawTorus(GL gl, float r, float R, int nsides, int rings) {
		float ringDelta = 2.0f * (float) Math.PI / rings;
		float sideDelta = 2.0f * (float) Math.PI / nsides;
		float theta = 0.0f, cosTheta = 1.0f, sinTheta = 0.0f;
		for (int i = rings - 1; i >= 0; i--) {
			float theta1 = theta + ringDelta;
			float cosTheta1 = (float) Math.cos(theta1);
			float sinTheta1 = (float) Math.sin(theta1);
			gl.glBegin(GL.GL_QUAD_STRIP);
			float phi = 0.0f;
			for (int j = nsides; j >= 0; j--) {
				phi += sideDelta;
				float cosPhi = (float) Math.cos(phi);
				float sinPhi = (float) Math.sin(phi);
				float dist = R + r * cosPhi;
				gl.glNormal3f(cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi);
				gl.glVertex3f(cosTheta1 * dist, -sinTheta1 * dist, r * sinPhi);
				gl.glNormal3f(cosTheta * cosPhi, -sinTheta * cosPhi, sinPhi);
				gl.glVertex3f(cosTheta * dist, -sinTheta * dist, r * sinPhi);
			}
			gl.glEnd();
			theta = theta1;
			cosTheta = cosTheta1;
			sinTheta = sinTheta1;
		}
	}

	

	@Override
	public void setFocus() {
		// TODO Auto-generated method stub

	}

}
```
Und hier die GLScene: eigentlich schön entkuppelt alles. Wäre toll, wenn es auch noch funktionieren würde zusammen mit Jogl.

```
package diagramtest.jogl;

import javax.media.opengl.GL;
import javax.media.opengl.GLContext;
import javax.media.opengl.GLDrawableFactory;
import javax.media.opengl.GLException;
import javax.media.opengl.glu.GLU;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.opengl.GLCanvas;
import org.eclipse.swt.opengl.GLData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
@author: Bo Majewski
public abstract class GLScene implements Listener {
	private GLCanvas canvas;
	private GLContext context;
	protected GLU glu;

	public GLScene(Composite comp) {
		comp.setLayout(new FillLayout());
		GLData data = new GLData();
		data.doubleBuffer = true;
		this.canvas = new GLCanvas(comp, SWT.NONE, data);
		this.canvas.addDisposeListener(new DisposeListener() {
            public void widgetDisposed(DisposeEvent e) {
                dispose();
            }
        });
        this.init();
        Rectangle clientArea = comp.getClientArea();
        this.canvas.setSize(clientArea.width, clientArea.height);
		canvas.setCurrent();
	}

	// *************** OpenGL Functions *******************//

	public void init() {
		this.initGLContext();
		this.initGL();
	}

	protected void initGLContext() {
		this.glu = new GLU();
		try {
			this.context = GLDrawableFactory.getFactory()
					.createExternalGLContext();
			this.canvas.addListener(SWT.Resize, this);
		} catch (GLException ex) {
			ex.printStackTrace();
		}
	}

	protected void initGL() {
		try {
			if (GLContext.getCurrent() != this.context) {
				this.context.makeCurrent();
			}
			GL gl = context.getGL();
			gl.glShadeModel(GL.GL_SMOOTH);                            //Enables Smooth Color Shading
	        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);               //This Will Clear The Background Color To Black
	        gl.glClearDepth(1.0);                                  //Enables Clearing Of The Depth Buffer
	        gl.glEnable(GL.GL_DEPTH_TEST);                            //Enables Depth Testing
	        gl.glDepthFunc(GL.GL_LEQUAL);                             //The Type Of Depth Test To Do
	        gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
			this.context.release();
		} catch (GLException ex) {
			ex.printStackTrace();
		}
	}
	
	abstract protected void drawScene();

	// *************** Basic Functions *******************//

	protected void dispose() {
		if (context != null) {
			context.destroy();
			context = null;
		}
	}

	/**
	 * Returns whether or not this scene is disposed.
	 * 
	 * @return Whether or not the scene is disposed.
	 */
	public boolean isDisposed() {
		return this.context == null || this.canvas.isDisposed();
	}

	/**
	 * Causes the receiver to have the <em>keyboard focus</em>,
	 * 
	 * @return Whether or not the control got focus.
	 */
	public boolean setFocus() {
		return this.canvas.setFocus();
	}

	/**
	 * Provides direct access to this canvas GL Context.
	 * 
	 * @return The GL context of this scene.
	 */
	protected GLContext getGLContext() {
		return this.context;
	}

	/**
	 * Returns the drawable used by the GLContext to render GL scenes.
	 * 
	 * @return The canvas used by the GL context.
	 */
	protected GLCanvas getCanvas() {
		return this.canvas;
	}

	public Display getDisplay() {
		return this.canvas.getDisplay();
	}

	// *************** Public API *******************//

	public void render() {
		this.canvas.setCurrent();
		this.context.makeCurrent();
		this.drawScene();
		this.canvas.swapBuffers();
		
	}

	// *************** Resize Function *******************//
	@Override
	public void handleEvent(Event event) {
		if (event.widget == this.canvas) {
			Rectangle bounds = canvas.getBounds();
			float fAspect = (float) bounds.width / (float) bounds.height;
			canvas.setCurrent();
			try {
				if (GLContext.getCurrent() != this.context) {
					this.context.makeCurrent();
				}
				context.makeCurrent();
				GL gl = context.getGL();
				gl.glViewport(0, 0, bounds.width, bounds.height);
				gl.glMatrixMode(GL.GL_PROJECTION);
				gl.glLoadIdentity();
				glu.gluPerspective(45.0f, fAspect, 0.5f, 400.0f);
				gl.glMatrixMode(GL.GL_MODELVIEW);
				gl.glLoadIdentity();
				context.release();
			} catch (GLException ex) {
				ex.printStackTrace();
			}
		}
	}
	
	// -------------------------------------------------------------------------
    // Utilities
    // -------------------------------------------------------------------------
    
    // texture procedure if it is needed

}
```
Und noch der Refresher dazu:

```
package diagramtest.jogl;

public class Refresher implements Runnable {
public static final int DELAY = 20;
    
    private GLScene scene;
    
    public Refresher(GLScene canvas) {
        this.scene = canvas;
    }
    
    public void run() {
        if (this.scene != null && !this.scene.isDisposed()) {
            this.scene.render();
            this.scene.getDisplay().asyncExec(this);
        }
    }

}
```


----------



## martin_x (29. April 2008)

Hallo, 
ich weiss nicht genau, ob es das gleiche Problem ist. 

Ich habe nun eine ganze Weile mit jogl und SWT herumprobiert, 
aber was ich auch immer versucht habe, depth testing hat nie 
funktioniert. Wann immer ich zwei Körper oder Flächen malen lasse, 
und die Szene rotiere, bleibt das zuletzt gemalte Objekt im 
Vordergrund. Dabei ist depth testing aktiviert, die Buffer sind geleert, 
das Licht ist sauber aufgesetzt und die Perspektive stimmt auch.

Hat das schon mal jemand hier sauber zum Laufen bekommen, oder 
ist es vielleicht einfach ein Fehler ?  

Gruss, 
Martin


----------



## commic (29. April 2008)

Hallo auch,

der Beitrag ist ja nun schon eine Weile her. Mittlerweile hab ich es bei mir zum Laufen bekommen. Wichtig beim Depthtest ist vorallem, dass du Blend deaktiviert hast. Weiterhin muss auch ein Depth-Funktion festgelegt werden. Also ich hab hier mal ein Beispiel. Als erstes initialisiere ich mit Blending. Während der Anwendung habe ich noch eine Taste belegt um Depth-Test einzuschalten and dafür dann eben Blending zu deaktivieren (ganz wichtig). Sonst tritt dieser Fehler auf. Funktioniert bei mir soweit

init mit Blending:

```
context.makeCurrent();
		GL gl = context.getGL();
		gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
		gl.glColor3f(1.0f, 0.0f, 0.0f);
		gl.glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
		gl.glClearDepth(1.0);
		gl.glEnable(GL_LINE_SMOOTH);
		gl.glShadeModel(GL_SMOOTH);
		gl.glDisable(GL_DEPTH_TEST);
		gl.glDepthFunc(GL_LESS);
		gl.glEnable(GL_BLEND);
		gl.glBlendFunc(GL_SRC_ALPHA, GL.GL_ONE);
		gl.glEnable(GL_COLOR_MATERIAL);
		gl.glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
		context.release();
```
init mit Depth-Test:

```
context.makeCurrent();
		GL gl = context.getGL();
		gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
		gl.glColor3f(1.0f, 0.0f, 0.0f);
		gl.glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
		gl.glClearDepth(1.0);
		gl.glEnable(GL_LINE_SMOOTH);
		gl.glShadeModel(GL_SMOOTH);
		gl.glDepthFunc(GL_LESS);
		gl.glDisable(GL_BLEND);
	        gl.glEnable(GL_DEPTH_TEST);
		gl.glDisable(GL_LIGHTING);
		context.release();
```

Ich kann auf jeden Fall das OpenGL-Tutorial von gamedev empfehlen. Das ist zwar C, ist aber auch nicht viel anders. Man findet auch java-code. Jedoch ist dieser mit sehr viel älteren Bibliotheken gemacht. Daher muss man manchmal ein wenig improvisieren. Aber man kann sich viel Ideen holen. Auf jeden Fall ein Klick wert.;-)

ciao,
micha


----------



## martin_x (30. April 2008)

Hallo Micha, 

danke für deinen Post. Leider geht das bei mir auch nicht. Ich habe nun so einige Tutorials und Bücher durchsucht, aber irgendwie scheint es nicht zu gehen. Vielleicht sollte ich nioch hinzufügen, dass ich das Ganze auf einem Apple G4 Powerbook versuche. Möglicherweise liegt da das Problem. Ich hänge mal ein Code Snipplet an, 
in dem eine kleine Kugel um eine grosse kreisen soll; und wenn du Zeit hättest kurz drüber zu schauen, wäre ich dankbar. Aber wirklich nur kurz. Ich werde schauen, ob ich nicht besser mit Java3D und der AWT/SWT Bridge weiter mache. 

Danke dir, 
Martin


```
package org.fnm.jogl.glu.bugTest;

import javax.media.opengl.GL;
import javax.media.opengl.GLContext;
import javax.media.opengl.GLDrawableFactory;
import javax.media.opengl.glu.GLU;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.opengl.GLCanvas;
import org.eclipse.swt.opengl.GLData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;

import com.sun.opengl.util.GLUT;

public class Test {
	
	public static void main(String [] args) {
		
		final Display display = new Display();
		
		Shell shell = new Shell(display);
		shell.setLayout(new FillLayout());
		Composite comp = new Composite(shell, SWT.NONE);
		comp.setLayout(new FillLayout());
		
		GLData data = new GLData ();
		data.doubleBuffer = true;
		final GLCanvas canvas = new GLCanvas(comp, SWT.NONE, data);

		canvas.setCurrent();
		final GLContext context = GLDrawableFactory.getFactory().createExternalGLContext();

		canvas.addListener(SWT.Resize, new Listener() {
			
			public void handleEvent(Event event) {
			
				Rectangle bounds = canvas.getBounds();
				float fAspect = (float) bounds.width / (float) bounds.height;
				canvas.setCurrent();
				
				context.makeCurrent();
				
				GL gl = context.getGL();
				gl.glViewport(0, 0, bounds.width, bounds.height);
				
				GLU glu = new GLU();
				
				gl.glMatrixMode(GL.GL_PROJECTION);
				gl.glLoadIdentity();
				
				glu.gluPerspective(45.0f, fAspect, 1, 10);
				glu.gluLookAt(0, 0, 6, 0, 0, 0, 0, 1, 0);
				
				context.release();
			}
		});

		// 
		context.makeCurrent();
		
		// initialize 
		GL gl = context.getGL ();
		gl.glClearColor(.3f, .5f, .8f, 1.0f);
		gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
		gl.glClearDepth(1.0);
		gl.glEnable(GL.GL_LINE_SMOOTH);
		gl.glShadeModel(GL.GL_SMOOTH);
		gl.glDepthFunc(GL.GL_LESS);
		gl.glDisable(GL.GL_BLEND);
	    gl.glEnable(GL.GL_DEPTH_TEST);
		gl.glDisable(GL.GL_LIGHTING);
	    
		/*gl.glEnable(GL.GL_COLOR_MATERIAL);
		gl.glColorMaterial(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE);
		
		// setup material
		float mat_ambient[] = { 0.3f, 0.3f, 0.3f, 1f };
		float mat_specular[] = { 0.f, 0.4f, 0.4f, 1f };
		float mat_shininess[] = { .2f };

		gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, mat_ambient, 0);
		gl.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, mat_specular, 0);
		gl.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, mat_shininess, 0);
		
		// setup light
		gl.glEnable(GL.GL_LIGHTING);

		float light_position[] = { 3, 3, 10, 1.0f };
		float model_ambient[] = { 0.5f, 0.5f, 0.5f, 1.0f };

		gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_position, 0);
		gl.glLightModelfv(GL.GL_LIGHT_MODEL_AMBIENT, model_ambient, 0);
		gl.glEnable(GL.GL_LIGHT0); */
		
		context.release();
		
		// set shell properties
		shell.setText("SWT/JOGL Example");
		shell.setSize(640, 480);
		shell.open();

		display.asyncExec(new Runnable() {
			
			int rot = 0;
			
			public void run() {
			
				if (!canvas.isDisposed()) {
					
					canvas.setCurrent();
					context.makeCurrent();
					
					GL gl = context.getGL();	
					
					gl.glClear(GL.GL_COLOR_BUFFER_BIT); 
					gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
					
					gl.glMatrixMode(GL.GL_MODELVIEW);
					gl.glLoadIdentity();
					
					GLUT glut = new GLUT(); 
					
					gl.glPushMatrix();
					gl.glRotatef(rot, 0, 1, 0);
					gl.glColor3f(1, 0, 0); 
					glut.glutSolidSphere(1, 20, 16);
					gl.glTranslatef(2,0,0);
					gl.glRotatef(rot, 0, 1, 0); 
					gl.glColor3f(0, 1, 0); 
					glut.glutSolidSphere(0.3, 10, 8); 
					gl.glPopMatrix();

					canvas.swapBuffers();
					context.release();
					
					rot++; 
					
					try {
						Thread.sleep(50);
					} catch (InterruptedException e) {
						e.printStackTrace();
					} 
					
					display.asyncExec(this);
				}
			}
		});

		while (!shell.isDisposed()) {
			if (!display.readAndDispatch())
				display.sleep();
		}
		display.dispose();
	}
}
```


----------



## commic (1. Mai 2008)

Hallo auch ,

so. Ich hab dein Code mal kurz in 2min gedebuggt und einfach mal kleine Auszüge von meinem Code in deinem ersetzt. das betrifft den resize-handler und die GL-init.


```
package grafic;

import static javax.media.opengl.GL.GL_AMBIENT;
import static javax.media.opengl.GL.GL_AMBIENT_AND_DIFFUSE;
import static javax.media.opengl.GL.GL_BLEND;
import static javax.media.opengl.GL.GL_COLOR_MATERIAL;
import static javax.media.opengl.GL.GL_DEPTH_TEST;
import static javax.media.opengl.GL.GL_FRONT;
import static javax.media.opengl.GL.GL_LESS;
import static javax.media.opengl.GL.GL_LIGHT1;
import static javax.media.opengl.GL.GL_LIGHTING;
import static javax.media.opengl.GL.GL_LINE_SMOOTH;
import static javax.media.opengl.GL.GL_MODELVIEW;
import static javax.media.opengl.GL.GL_NICEST;
import static javax.media.opengl.GL.GL_PERSPECTIVE_CORRECTION_HINT;
import static javax.media.opengl.GL.GL_POSITION;
import static javax.media.opengl.GL.GL_PROJECTION;
import static javax.media.opengl.GL.GL_SMOOTH;
import static javax.media.opengl.GL.GL_SRC_ALPHA;

import javax.media.opengl.GL;
import javax.media.opengl.GLContext;
import javax.media.opengl.GLDrawableFactory;
import javax.media.opengl.glu.GLU;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.opengl.GLCanvas;
import org.eclipse.swt.opengl.GLData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;

import com.sun.opengl.util.GLUT;

public class Test {
	
	public static void main(String [] args) {
		
		final Display display = new Display();
		
		Shell shell = new Shell(display);
		shell.setLayout(new FillLayout());
		Composite comp = new Composite(shell, SWT.NONE);
		comp.setLayout(new FillLayout());
		
		GLData data = new GLData ();
		data.doubleBuffer = true;
		final GLCanvas canvas = new GLCanvas(comp, SWT.NONE, data);

		canvas.setCurrent();
		final GLContext context = GLDrawableFactory.getFactory().createExternalGLContext();

		canvas.addListener(SWT.Resize, new Listener() {
			
			public void handleEvent(Event event) {
			
				Rectangle bounds = canvas.getBounds();
				float fAspect = (float) bounds.width / (float) bounds.height;
				canvas.setCurrent();
				context.makeCurrent();
				GL gl = context.getGL();
				gl.glViewport(0, 0, bounds.width, bounds.height);
				gl.glMatrixMode(GL_PROJECTION);
				gl.glLoadIdentity();
				GLU glu = new GLU();
				glu.gluPerspective(45.0f, fAspect, 0.5f, 400.0f);
				gl.glMatrixMode(GL_MODELVIEW);
				gl.glLoadIdentity();
				context.release();
			}
		});

		// 
		context.makeCurrent();
		GL gl = context.getGL();
		gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
		gl.glColor3f(1.0f, 0.0f, 0.0f);
		gl.glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
		gl.glClearDepth(1.0);
		gl.glEnable(GL_LINE_SMOOTH);
		gl.glShadeModel(GL_SMOOTH);
		gl.glEnable(GL_DEPTH_TEST);
		gl.glDepthFunc(GL_LESS);
		gl.glDisable(GL_BLEND);
		gl.glBlendFunc(GL_SRC_ALPHA, GL.GL_ONE);
		gl.glLightfv(GL_LIGHT1, GL.GL_DIFFUSE, new float[] { 1.0f, 1.0f,
				1.0f, 1.0f }, 0);
		gl.glLightfv(GL_LIGHT1, GL_AMBIENT, new float[] { 0.5f, 0.5f,
				0.5f, 1.0f }, 0);
		gl.glLightfv(GL_LIGHT1, GL_POSITION, new float[] { -40.f, 50.0f,
				100.0f, 1.0f }, 0);
		gl.glEnable(GL_LIGHT1);
		gl.glEnable(GL_LIGHTING);
		gl.glEnable(GL_COLOR_MATERIAL);
		gl.glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
		context.release();
		
		// set shell properties
		shell.setText("SWT/JOGL Example");
		shell.setSize(640, 480);
		shell.open();

		display.asyncExec(new Runnable() {
			
			int rot = 0;
			
			public void run() {
			
				if (!canvas.isDisposed()) {
					
					canvas.setCurrent();
					context.makeCurrent();
					
					GL gl = context.getGL();	
					
					gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
					gl.glClearColor(.3f, .5f, .8f, 1.0f);
					gl.glLoadIdentity();
					gl.glTranslatef(0.0f, 0.0f, -10.0f);
					
					GLUT glut = new GLUT(); 
					
					gl.glPushMatrix();
					gl.glRotatef(rot, 0, 1, 0);
					gl.glColor3f(1, 0, 0); 
					glut.glutSolidSphere(1, 20, 16);
					gl.glTranslatef(2,0,0);
					gl.glRotatef(rot, 0, 1, 0); 
					gl.glColor3f(0, 1, 0); 
					glut.glutSolidSphere(0.3, 10, 8); 
					gl.glPopMatrix();

					canvas.swapBuffers();
					context.release();
					
					rot++; 
					
					display.asyncExec(this);
				}
			}
		});

		while (!shell.isDisposed()) {
			if (!display.readAndDispatch())
				display.sleep();
		}
		display.dispose();
	}
}
```

Dann musste ich dein Threading am Ende rausnehmen, sonst ging bei mir gar nichts. Aßerdem habe ich den Resize-Handler mal durch meinen ersetzt, da ich nicht mit Lookat arbeite (sollte man aber, habs mir bis jetzt aber noch nicht angeschaut). In dem Beispiel kannst du auch ruhig einmal Depthtest deaktivieren und Blend aktivieren. Funktioniert beides wunderbar (zumindest bei mir unter Windows). 

@Apple: Ich habe leider absolut keine Erfahrung wie es unter deinem Mac läuft. Aber bei mir läuft es super. 

Viel Spaß dann noch mit dem Code.

ciao,
micha


----------



## martin_x (1. Mai 2008)

Hallo Micha, 

oh, dann ist es klar. Wenn der Code, den du geposted hast, unter Windosw läuft, 
dann ist es ein Mac SWT Problem. Bei mir geht es nicht. Das würde auch erklären, 
warum alles andere, was ich versucht habe, auch nicht ging. Mal schauen, was die SWT Entwickler dazu sagen werden. Ich bin dir zu grossem Dank verpflichtet. Echt. 

Gruss, 
Martin


----------



## commic (1. Mai 2008)

Hallo Martin,

ja. Mit Problem von SWT und Mac bzgl. OpenGL habe ich ebenfalls gelesen. Das kommt daher, dass für jedes Betriebssystem die Window-Implementierung speziell ist. OpenGL läuft mit SWT auch bei mir nicht einwandfrei. Nach einigen Sekunden bzw. Klicks in anderen Fenstern meines RCP-Plugins verliert der Canvas den Focus und mein GLContext is nicht mehr da und erlangt das OpenGL-Fenster wieder den Focus, geht es eben trotzdem nicht und meine Animation bleibt stehen. Grund ist, dass JOGL im Herzen noch auf AWT aufbaut bzw. für diese GUI-API dementsprechend implementiert wurde (hier ein Dank an Sun, welche die Hand über dem Jogl-Projekt haben -.-). Das Jogl-Projekt für SWT ist leider schon seit langer Zeit nicht mehr weiter vorangetrieben worden.  Hab auch schoin dementsprechend was ins jogl-Forum gepostet und hoffe nun auf eine Antwort. Du kannst es noch einmal mit swt/awt brücke probieren, ob es dann besser läuft.

gruß,
micha


----------

