# JOGL und Texturen



## lumo (3. Jan 2008)

Hallo Java-Forum-User
bin zwar nicht ganz neu in belangen programmieren, hab aber gereade ein problem (hoffe ich sitz ned nur einfach so auf der leitung...)
und zwar... hab ich einen modelloader für die PSP (Playstation Portable) mittels SCE-GU geschrieben (c++)
den selben loader habe ich auch für Win32 (auch c++ und opengl/glut) implementiert

jetzt möchte ich den exakt selben loader noch für java umsetzen, allerdings verweigert mir JOGL das rendern von texturen.

das besorgen der daten ist keinerlei problem (u,v, x,y,z) hab ich alles geladen;
die textur, wird, so wie ich das sehe auch korrekt geladen und dann auch an jogl übergeben...
hier mal der sourcecode des renderers (Mesh <- das ist mein loader, stellt dann einfach eine vertexliste, eine faceliste und den texturnamen/textureId zur verfügung)



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

import com.sun.opengl.util.Animator;
import com.sun.opengl.util.texture.TextureIO;

import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;

public class JOGLRotatingCube {

	private static final int SIZE = 160;

	private static float angle = 0;
	private final int[] textureId = new int[1];
	private Mesh aMesh = null;
	private final String title = "lumo's Model Loader";
	private Frame frame = null;

	JOGLRotatingCube() {
		String filename = "C:\\JAVA\\workspace\\ModelLoader\\src\\data\\cube.cmsh";
		this.aMesh = new Mesh();
		this.aMesh.loadCMSH(filename);// send true if you want to debug, or leave it if you wont
		GLCanvas canvas = getGLCanvas();
		canvas.addGLEventListener(new RotatingCubeListener());
		Animator anim = new Animator(canvas);
		addCanvasToFrame(canvas, anim);
		anim.start();
	}

	private void addCanvasToFrame(GLCanvas canvas, final Animator anim) {
		frame = new Frame(title);
		frame.setSize(600, 400);
		frame.add(canvas);
		frame.setVisible(true);
		frame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				anim.stop();
				System.exit(0);
			}
		});
	}
	
	public void displayFPS(long fps) {
		this.frame.setTitle(title +" [@"+ fps+" FPS]");
	}

	private GLCanvas getGLCanvas() {
		GLCapabilities cap = new GLCapabilities();
		GLCanvas canvas = new GLCanvas(cap);
		return canvas;
	}

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

	public void defineTexture(GL gl) {
	     gl.glShadeModel(GL.GL_SMOOTH);
	     gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);

	     gl.glGenTextures(1, this.textureId, 0);
	     aMesh.textureID = this.textureId[0];
	     gl.glBindTexture(GL.GL_TEXTURE_2D, aMesh.textureID);
	           
	     File file = new File("C:\\JAVA\\workspace\\ModelLoader\\src\\data\\none.png");
	     try{
	    	 aMesh.texture = TextureIO.newTexture(file, true);
	    	 aMesh.texture.setTexParameteri(GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
	    	 aMesh.texture.setTexParameteri(GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
	     }catch(Exception e){
	         e.printStackTrace();
	     } 	     

	     //wir wollen, dass die Textur das aktuell verwendete Material
	     //ersetzt
	     gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_REPLACE);
	 }	
	
	private void drawMesh(GL gl) {
		gl.glCullFace(GL.GL_BACK); // Set Culling Face To Back Face
		gl.glDisable(GL.GL_CULL_FACE); // Enable Culling
		//you can enable the culling if you have models with correct facing!
		
		gl.glEnable(GL.GL_TEXTURE_2D);

		gl.glBindTexture(GL.GL_TEXTURE_2D, aMesh.textureID);
		
		gl.glBegin(GL.GL_TRIANGLES);
		//gl.glColor4f(1.0f, 1.0f, 0.0f, 0.0f);
		for (int i = 0; i < aMesh.faces.length; i++) {
			gl.glTexCoord2f(aMesh.vertices[aMesh.faces[i].v1()].u(), aMesh.vertices[aMesh.faces[i].v1()].v());
			gl.glVertex3f(aMesh.vertices[aMesh.faces[i].v1()].x() * SIZE,
					aMesh.vertices[aMesh.faces[i].v1()].y() * SIZE,
					aMesh.vertices[aMesh.faces[i].v1()].z() * SIZE);
			gl.glTexCoord2f(aMesh.vertices[aMesh.faces[i].v2()].u(), aMesh.vertices[aMesh.faces[i].v2()].v());
			gl.glVertex3f(aMesh.vertices[aMesh.faces[i].v2()].x() * SIZE,
					aMesh.vertices[aMesh.faces[i].v2()].y() * SIZE,
					aMesh.vertices[aMesh.faces[i].v2()].z() * SIZE);
			gl.glTexCoord2f(aMesh.vertices[aMesh.faces[i].v3()].u(), aMesh.vertices[aMesh.faces[i].v3()].v());
			gl.glVertex3f(aMesh.vertices[aMesh.faces[i].v3()].x() * SIZE,
					aMesh.vertices[aMesh.faces[i].v3()].y() * SIZE,
					aMesh.vertices[aMesh.faces[i].v3()].z() * SIZE);
		}
		gl.glEnd();
		gl.glDisable(GL.GL_TEXTURE_2D);
	}

	class RotatingCubeListener implements GLEventListener {
		private long fps = 0;
		private long timePassed = 0;
		private long oldTime = 0;
		
		public void init(GLAutoDrawable drawable, int i, int j, int k) {
		}

		public void displayChanged(GLAutoDrawable drawable, int i, int j,
				int k, int l) {
		}

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

		public void init(GLAutoDrawable drawable) {
			GL gl = drawable.getGL();
			gl.glClearColor(0.2f, 0.2666667f, 0.3294f, 1.0f); // erasing color
			gl.glColor3f(1.0f, 1.0f, 1.0f); // drawing color
			defineTexture(gl); // init the texture
			this.oldTime = System.currentTimeMillis();
		}

		public void display(GLAutoDrawable drawable) {
			GL gl = drawable.getGL();
			gl.glClear(GL.GL_COLOR_BUFFER_BIT);

			angle = angle + 5;
			gl.glMatrixMode(GL.GL_MODELVIEW);
			gl.glLoadIdentity();
			gl.glRotatef(-80, 1, 1, 0);
			gl.glRotatef(angle / 16, 1, -1, 1);
			drawMesh(gl);
			// calculate FPS
			long newTime = System.currentTimeMillis();
			long timeslice = newTime - this.oldTime;
			this.timePassed = this.timePassed+timeslice;
			this.oldTime = newTime;
			this.fps++;
			//System.out.println(this.timePassed);
			if (this.timePassed > 1000) { // one secon passed
				this.timePassed = this.timePassed - 1000;
				displayFPS(this.fps);
				this.fps = 0;
			}
		}

		public void reshape(GLAutoDrawable drawable, int x, int y, int width,
				int height) {
			GL gl = drawable.getGL();
			gl.glViewport(0, 0, width, height);
			gl.glMatrixMode(GL.GL_PROJECTION);
			gl.glLoadIdentity();
			gl.glOrtho(-width, width, -height, height, -SIZE, SIZE);
		}
	}
}
```
wäre super, wenn mich jemand auf den fehler hinweisen könnte (aber bitte nicht in rätseln)

vielen dank im voraus
lumo


----------



## lumo (4. Jan 2008)

so hab den fehler gefunden, obwohl er für mich recht unlogisch ist...


```
// why bind the textureObject and not the textureID???
		gl.glBindTexture(GL.GL_TEXTURE_2D, aMesh.texture.getTextureObject());
```
warum muss ich das texturobjekt binden und nicht die id?
die id wird doch als identifyer angelegt, während das objekt ja damit referenziert wird...
also warum liefert mir getTextureObject nen anderen wert, als die erzeugte TextureId??
(in meinem fall ist die id=1 und getTextureObject=2)

greets


----------



## Evil-Devil (4. Jan 2008)

Das kann dir vielleicht die Dokumentation zu der Mesh Klasse beantworten.


----------



## lumo (4. Jan 2008)

nope, denn... die id wird in der funktion
public void defineTexture(GL gl) übergeben, wo die textur generiert wird und die id dann übergeben wird...


```
gl.glGenTextures(1, this.textureId, 0);
        aMesh.textureID = this.textureId[0];
```
note: das darunterliegende bind funzt nicht!
hab den code jetzt weiterentwickelt und mit dem getTextureObject() klappts...
(auch wenn ich noch immer verwundert bin warum...)
hab aber noch andere nette "schräge" funktionen entdeckt
zb dass er culling macht, egal ob ich culling per gldisable abschalte oder nicht...
nur das resultat wie er cullt ist einanders, aber beidesmal isses falsch (elemente die hinten sein sollten, werden vorn angezeigt, total verdreht :S)


----------

