Discussion :

[seeme]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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..