[OpenGL] Utilisation de gluLookAt

Bonsoir,

Pour un petit projet perso, j'essaye de charger et d'afficher (puis d'animer) un fichier au format md5 (doom3) sous Android.

Pour le moment, le chargement du fichier à l'air bon, mais impossible de visualiser quoi que ce soit... La routine gluLookAt n'a pas l'air de réagir comme je le voudrais..

Si vous pouviez m'aider, à savoir me dire si déjà la structure de ce code est bonne (place/ordre des appels OGL), et si je ne fais pas de bêtises avec gluLookAt.

Merci d'avance.
Seeme

Un VertexArray

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
 
package md5Loader;
 
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
 
public class VertexArray {
	private FloatBuffer vertex;
	private ShortBuffer indexes;
	private short size;
 
	public short getSize() {
		return size;
	}
 
	public VertexArray(float[] vert){
		size = (short) vert.length;
 
		short[] index = new short[vert.length];
 
		for(short i = 0; i < vert.length; i++){
			index[i] = i;
		}
 
		ByteBuffer vbb = ByteBuffer.allocateDirect(vert.length * 3 * 4);
		vbb.order(ByteOrder.nativeOrder());
		vertex = vbb.asFloatBuffer();
		vertex.put(vert);
 
		ByteBuffer ibb = ByteBuffer.allocateDirect(vert.length * 2);
		ibb.order(ByteOrder.nativeOrder());
		indexes = ibb.asShortBuffer();
		indexes.put(index);
 
		indexes.position(0);
		vertex.position(0);
	}
 
	public FloatBuffer getVertex() {
		return vertex;
	}
 
	public ShortBuffer getIndexes() {
		return indexes;
	}
}

Organise et renvoie un VertexArray (pas optimisé, mais le but pour le moment, c'est vraiment l'affichage).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
public VertexArray getVertexArray(){
		if(vArray == null){
 
			Vert[] tmp = new Vert[triangles.length * 3];
			for(int i = 0; i < triangles.length; i++){
				tmp[3*i] = vertices[triangles[i].vertices.x];
				tmp[3*i+1] = vertices[triangles[i].vertices.y];
				tmp[3*i+2] = vertices[triangles[i].vertices.z];
			}
 
			vertices = tmp;
 
			float[] out = new float[getVertices().length * 3];
			for(int i = 0; i < getVertices().length; i++){
				out[3*i] = getVertices()[i].position.x;
				out[3*i + 1] = getVertices()[i].position.y;
				out[3*i + 2] = getVertices()[i].position.z;
			}
			vArray = new VertexArray(out);
		}
 
		return vArray; 
	}

Et le Renderer:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
package org.plissken.ogl;
 
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
 
import md5Loader.Md5Model;
import md5Loader.Vect3f;
import md5Loader.VertexArray;
import android.opengl.GLU;
import android.opengl.GLSurfaceView.Renderer;
 
public class MainRenderer implements Renderer{
 
	private Md5Model mdl = null;
	private Vect3f viewFrom;
	private Vect3f viewTo;
 
 
	public void setModel(Md5Model m){
		mdl = m;
	}
 
	@Override
	public void onDrawFrame(GL10 gl) {
		gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
		gl.glMatrixMode(GL10.GL_MODELVIEW);
		gl.glLoadIdentity();
 
		GLU.gluLookAt(gl, viewFrom.x, viewFrom.y, viewFrom.z, viewTo.x, viewTo.y, viewTo.z, 0, 0, 1);
 
		float[] fx = {0f, 0f, 0f, 100f, 0f, 0f};
		VertexArray vx = new VertexArray(fx);
 
		float[] fy = {0f, 0f, 0f, 0f, 100f, 0f};
		VertexArray vy = new VertexArray(fy);
 
		float[] fz = {0f, 0f, 0f, 0f, 0f, 100f};
		VertexArray vz = new VertexArray(fz);
 
		gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vx.getVertex());
		gl.glColor4f(1.f, 0f, 0f, 1.f);
		gl.glDrawElements(GL10.GL_LINES, 2, GL10.GL_UNSIGNED_SHORT, vx.getIndexes());
 
		gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vy.getVertex());
		gl.glColor4f(0.f, 1, 0, 1.f);
		gl.glDrawElements(GL10.GL_LINES, 2, GL10.GL_UNSIGNED_SHORT, vy.getIndexes());
 
		gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vz.getVertex());
		gl.glColor4f(0.f, 0, 1f, 1.f);
		gl.glDrawElements(GL10.GL_LINES, 2, GL10.GL_UNSIGNED_SHORT, vz.getIndexes());
 
		gl.glColor4f(1f, 1f, 0, 1f);
		gl.glPointSize(3f);
		if(mdl != null){
			drawVertexArray(gl, GL10.GL_TRIANGLES, mdl.getMeshes()[0].getVertexArray());
			drawVertexArray(gl, GL10.GL_TRIANGLES, mdl.getMeshes()[1].getVertexArray());
			drawVertexArray(gl, GL10.GL_TRIANGLES, mdl.getMeshes()[2].getVertexArray());
			drawVertexArray(gl, GL10.GL_TRIANGLES, mdl.getMeshes()[3].getVertexArray());
			drawVertexArray(gl, GL10.GL_TRIANGLES, mdl.getMeshes()[4].getVertexArray());
			drawVertexArray(gl, GL10.GL_TRIANGLES, mdl.getMeshes()[5].getVertexArray());
		}	
	}
 
	@Override
	public void onSurfaceChanged(GL10 gl, int width, int height) {
		gl.glViewport(0, 0, width, height);
	}
 
	@Override
	public void onSurfaceCreated(GL10 gl, EGLConfig config) {
		gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
		viewFrom = new Vect3f(0, 100, 1);
		viewTo = new Vect3f(0, 0, 0);
	}
 
	public Vect3f getViewFrom() {
		return viewFrom;
	}
 
	public void setViewFrom(Vect3f viewFrom) {
		this.viewFrom = viewFrom;
	}
 
	public Vect3f getViewTo() {
		return viewTo;
	}
 
	public void setViewTo(Vect3f viewTo) {
		this.viewTo = viewTo;
	}
 
	public void drawVertexArray(GL10 gl, int mode, VertexArray va){
		gl.glVertexPointer(3, GL10.GL_FLOAT, 0, va.getVertex());
		gl.glDrawElements(mode, va.getSize(), GL10.GL_UNSIGNED_SHORT, va.getIndexes());
	}
 
	public void TouchScreen(float x, float y){
		viewTo.z+=.1f;
	}
}

Merci d'avance, je voudrais vraiment avancer..