Bonjour, alors voilà j'ai un truc bizarre qui se passe, déjà quand je l'affiche avec les commandes openGL ça ne m'affiche pas la même chose que quand je les utilisent pas, quand je les utilise j'ai la texture bien plaquée mais en bleu, mais le personnage n'est pas bien tracé, notamment sont pied gauche et son bras droit.

Quand je le trace avec les commandes opengLG, là il est bien tracé entièrement mais tout bleu, on ne voit même plus les différentes parties de la texture.

Alors je n'arrive pas à trouver ou est l'erreur, en c++ j'ai jamais eu de problèmes, j'aimerais au moins qu'il m'affiche bien la texture avec les commandes openGL car c'est plus rapide.
Voilà donc je poste le code si quelqu'un voit une erreur, aider moi, merci d'avance ça fait plusieurs jours que je suis dessus.

package wotck.jeu;

import java.io.*;
import java.nio.*;
import java.nio.channels.*;

import javax.media.opengl.*;

import wotck.factory.UnsignedVarFactory;
import wotck.gui.TextureReader;




public class Model3D {
	private static final int MD2_IDENT_WIN = 844121161;	
	private static final int MD2_VERSION = 8;
	private static final int NUMNORMALS = 162;
	
	private int ident; //Numéro magique.
	private int version; //Vesion du fichier.
	private int skinWidth; //Largeur texture.
	private int skinHeight; //Hauteur texture.

	private int frameSize; //Taille d'une frame en octets.

	private int numSkins; //Nombre de textures.
	private int numVertices; //Nombre de sommets par frame.
	private int numCt; //nombre de coordonnées textures.
	private int numTris; //Nombre de triangles.
	private int glCommands; //Nombre de commandes openGL.
	private int numFrames; // Nombre de frames;
	
	private int offsetSkins; //Position des données sur les textures dans le fichier.
	private int offsetCt; //Position des données sur les coordonnées des textures.
	private int offsetTris; //Position des données sur les triangles.
	private int offsetFrames; //Position des données sur les frames.
	private int offsetCommands; //Position des données sur les commandes opengl.
	private int offsetEnd;
	private FileChannel fc;	
	
	private static Vec3t[]  anorms = new Vec3t[NUMNORMALS]; //Vecteur nomrmaux pour le caclul des lumières.	private MD2TexCoord[] texCoords;
	private String[] skinNames;
	private MD2TexCoord[] texCoords;
	private MD2Triangle[] triangles;
	private MD2Frame[] frames;
	private int[] glCmds;
	private float scale;
	private int textID;
	
	private String[] nameTextureFile; //Nom du fichier de la texture.
	public Model3D () {
		try {
			FileInputStream fis = new FileInputStream ("normals.txt");
			DataInputStream dis = new DataInputStream (fis);
			for (int i = 0; i < NUMNORMALS; i++) {
				anorms[i] = new Vec3t (dis.readFloat(), dis.readFloat(), dis.readFloat());				
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			System.out.println("Fichier normals.txt introuvable.");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			System.out.println("Erreur lors de la lecture des données.");
		}
	}
	public boolean loadMd2Model (String fileName) {
		FileInputStream fis = null;	
		
		ByteBuffer bBuff;
		try {
			fis = new FileInputStream (fileName);	
			fc = fis.getChannel();
			int size = (int) fc.size();
			bBuff = ByteBuffer.allocate(size);
			bBuff.order(ByteOrder.LITTLE_ENDIAN);
			fc.read(bBuff);
			bBuff.flip();
			//b = bBuff.array();			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			System.out.println("Fichier "+fileName+" introuvable");
			return false;
		} catch (IOException e) {
			System.out.println("Erreur lors de la lecture des données!");
			return false;
		}		
		ident = bBuff.getInt();
		version = bBuff.getInt();		
		if (ident != MD2_IDENT_WIN && version != MD2_VERSION)
			return false;
		skinWidth = bBuff.getInt();
		skinHeight = bBuff.getInt();
		frameSize = bBuff.getInt();
		
		numSkins = bBuff.getInt();
		numVertices = bBuff.getInt();
		numCt = bBuff.getInt();
		numTris = bBuff.getInt();
		glCommands = bBuff.getInt();
		numFrames = bBuff.getInt();
		
		offsetSkins = bBuff.getInt();
		offsetCt = bBuff.getInt();
		offsetTris = bBuff.getInt();
		offsetFrames = bBuff.getInt();
		offsetCommands = bBuff.getInt();
		offsetEnd = bBuff.getInt();
		
		skinNames = new String[numSkins];
		texCoords = new MD2TexCoord[numCt];
		triangles = new MD2Triangle[numTris];
		frames = new MD2Frame[numFrames];		
		glCmds = new int[glCommands];
		
		bBuff.position(offsetSkins);
		byte[] b = new byte[68];
		for (int i = 0; i < numSkins; i++) {			
			bBuff.get(b);
			skinNames[i] = new String(b);
		}
		bBuff.position(offsetCt);
		for (int i = 0; i < numCt; i++){
			texCoords[i] = new MD2TexCoord();
			texCoords[i].setS(bBuff.getShort());
			texCoords[i].setT(bBuff.getShort());
			
		}
		bBuff.position(offsetTris);
		byte[] us = new byte[2];
		for (int i = 0; i < numTris; i++) {
			triangles[i] = new MD2Triangle ();
			int x, y, z, ctx, cty, ctz;
			bBuff.get(us);
			x = UnsignedVarFactory.createUnsignedShort(us);	
			bBuff.get(us);
			y = UnsignedVarFactory.createUnsignedShort(us);	
			bBuff.get(us);
			z = UnsignedVarFactory.createUnsignedShort(us);	
			bBuff.get(us);
			ctx = UnsignedVarFactory.createUnsignedShort(us);	
			bBuff.get(us);
			cty = UnsignedVarFactory.createUnsignedShort(us);	
			bBuff.get(us);
			ctz = UnsignedVarFactory.createUnsignedShort(us);	
			triangles[i].setMd2TriangleVertex(x, y, z);
			triangles[i].setCt(ctx, cty, ctz);
		}
		bBuff.position(offsetFrames);
		for (int i = 0; i < numFrames; i++) {
			frames[i] = new MD2Frame (numVertices);
			float sx, sy, sz, tx, ty, tz;
						
			sx = bBuff.getFloat();
			sy = bBuff.getFloat();
			sz = bBuff.getFloat();
			tx = bBuff.getFloat();
			ty = bBuff.getFloat();
			tz = bBuff.getFloat();
			frames[i].setScale(new Vec3t(sx, sy, sz));
			frames[i].setTranslate(new Vec3t(tx, ty, tz));
			byte[] b2 = new byte[16];
			bBuff.get(b2);
			frames[i].setNameFrame(new String(b));
			MD2Vertex[] verts = new MD2Vertex[numVertices];
			byte[] ub = new byte[1];
			for (int k = 0; k < numVertices; k++) {
				verts[k]= new MD2Vertex();
				int vx, vy, vz, n;
				bBuff.get(ub);
				vx = UnsignedVarFactory.createUnsignedByte(ub);
				bBuff.get(ub);
				vy = UnsignedVarFactory.createUnsignedByte(ub);
				bBuff.get(ub);
				vz = UnsignedVarFactory.createUnsignedByte(ub);
				bBuff.get(ub);
				n = UnsignedVarFactory.createUnsignedByte(ub);
				verts[k].setV(new int[] {vx, vy, vz});
				verts[k].setNormalIndex(n);				
			}
			frames[i].setVerts(verts);
		}
		bBuff.position(offsetCommands);
		for (int i =0; i < glCommands; i++) {
			glCmds[i] = bBuff.getInt();
		}
		return true;
	}
	public void loadTexture (int textID) {
		this.textID = textID;				
	}
	public void renderFrame (GL gl, int iFrame) {
		int iMaxFrame = numFrames - 1;
		if (iFrame < 0 || iFrame > iMaxFrame)
			return;
		gl.glBindTexture (GL.GL_TEXTURE_2D, textID);
		gl.glBegin(GL.GL_TRIANGLES);
		
		for (int i = 0; i < numTris; i++) {
			for (int k = 0; k < 3; k++) {
				MD2Frame frame = frames[iFrame];
				MD2Vertex vertex = frame.getVerts()[triangles[i].getVertex()[k]];
				float s = (float) texCoords[triangles[i].getCt()[k]].getS() / skinWidth;
				float t = (float) texCoords[triangles[i].getCt()[k]].getT() / skinHeight;
				gl.glTexCoord2f(s, t);
				gl.glNormal3fv(FloatBuffer.wrap(anorms[vertex.getNormalIndex()].getVec3t()));	
				Vec3t v = new Vec3t (
						(frame.getScale().getVec3t()[0] * vertex.getV()[0] + frame.getTranslate().getVec3t()[0]) * scale,
						(frame.getScale().getVec3t()[1] * vertex.getV()[1] + frame.getTranslate().getVec3t()[1]) * scale,
						(frame.getScale().getVec3t()[2] * vertex.getV()[2] + frame.getTranslate().getVec3t()[2]) * scale);	
				gl.glVertex3fv(FloatBuffer.wrap(v.getVec3t()));				
			}
		}		
		gl.glEnd();
	}
	public void drawModelItp (GL gl, int iFrameA, int iFrameB, float fInterp) {
		int iMaxFrame = numFrames - 1;
		
		if (iFrameA < 0 || iFrameB < 0)
			return;
		if (iFrameA > iMaxFrame || iFrameB > iMaxFrame)
			return;
		gl.glBindTexture(GL.GL_TEXTURE_2D, textID);		
		gl.glBegin(GL.GL_TRIANGLES);		
		for (int i = 0; i < numTris; i++) {
			for (int k = 0; k < 3; k++) {
				MD2Frame frameA = frames[iFrameA];
				MD2Frame frameB = frames[iFrameB];				
				
				MD2Vertex vertA = frameA.getVerts()[triangles[i].getVertex()[k]];
				MD2Vertex vertB = frameB.getVerts()[triangles[i].getVertex()[k]];
				
				float s = (float) texCoords[triangles[i].getCt()[k]].getS() / skinWidth;
				float t = (float) texCoords[triangles[i].getCt()[k]].getT() / skinHeight;				
				gl.glTexCoord2f(s, t);
				
				Vec3t normA, normB, n;
				
				normA = new Vec3t (anorms[vertA.getNormalIndex()].getVec3t()[0],
						anorms[vertA.getNormalIndex()].getVec3t()[1],
						anorms[vertA.getNormalIndex()].getVec3t()[2]);
				normB = new Vec3t (anorms[vertB.getNormalIndex()].getVec3t()[0],
						anorms[vertB.getNormalIndex()].getVec3t()[1],
						anorms[vertB.getNormalIndex()].getVec3t()[2]);
				n = new Vec3t (normA.getVec3t()[0]	+ fInterp * (normB.getVec3t()[0] - normA.getVec3t()[0]),
						normA.getVec3t()[1]	+ fInterp * (normB.getVec3t()[1] - normA.getVec3t()[1]),
								normA.getVec3t()[2]	+ fInterp * (normB.getVec3t()[2] - normA.getVec3t()[2]));
				gl.glNormal3fv(FloatBuffer.wrap(n.getVec3t()));
				Vec3t vecA, vecB, v;
				vecA = new Vec3t (frameA.getScale().getVec3t()[0]  * vertA.getV()[0] + frameA.getTranslate().getVec3t()[0],
						frameA.getScale().getVec3t()[1]  * vertA.getV()[1] + frameA.getTranslate().getVec3t()[1],
						frameA.getScale().getVec3t()[2]  * vertA.getV()[2] + frameA.getTranslate().getVec3t()[2]);
				
				vecB = new Vec3t (frameB.getScale().getVec3t()[0]  * vertB.getV()[0] + frameB.getTranslate().getVec3t()[0],
						frameB.getScale().getVec3t()[1]  * vertB.getV()[1] + frameB.getTranslate().getVec3t()[1],
						frameB.getScale().getVec3t()[2]  * vertB.getV()[2] + frameB.getTranslate().getVec3t()[2]);
				
				v = new Vec3t ((vecA.getVec3t()[0] + fInterp * (vecB.getVec3t()[0] - vecA.getVec3t()[0])) * scale,
						(vecA.getVec3t()[1] + fInterp * (vecB.getVec3t()[1] - vecA.getVec3t()[1])) * scale,
						(vecA.getVec3t()[2] + fInterp * (vecB.getVec3t()[2] - vecA.getVec3t()[2])) * scale);
				
				gl.glVertex3fv(FloatBuffer.wrap(v.getVec3t()));
			}
		}
		gl.glEnd();		
	}
	public void renderFrameWithGLcmds (GL gl, int iFrame) {
		int iMaxFrame = numFrames - 1;
		if (iFrame < 0 || iFrame > iMaxFrame)
			return;
		gl.glBindTexture (GL.GL_TEXTURE_2D, textID);
		int n = 0;
		while (n < glCommands) {			
			int j = glCmds[n];
			if (j < 0) {
				gl.glBegin(GL.GL_TRIANGLE_FAN);
				j = -j;
			} else {
				gl.glBegin(GL.GL_TRIANGLE_STRIP);
			}
			n++;
			for ( ;j>0; j--, n+=3) {
				MD2GlCommand glCom = new MD2GlCommand ();
				glCom.setS(glCmds[n]);
				glCom.setT(glCmds[n+1]);
				glCom.setIndex(glCmds[n+2]);
				MD2Frame frame = frames[iFrame];
				MD2Vertex vert = frame.getVerts()[glCom.getIndex()];
				gl.glTexCoord2f((float) glCom.getS(),(float) glCom.getT());
				gl.glNormal3fv(FloatBuffer.wrap(anorms[vert.getNormalIndex()].getVec3t()));
				
				Vec3t v;
				v = new Vec3t ((frame.getScale().getVec3t()[0] * vert.getV()[0] + frame.getTranslate().getVec3t()[0]) * scale,
						(frame.getScale().getVec3t()[1] * vert.getV()[1] + frame.getTranslate().getVec3t()[1]) * scale,
						(frame.getScale().getVec3t()[2] * vert.getV()[2] + frame.getTranslate().getVec3t()[2]) * scale);
				
				gl.glVertex3fv(FloatBuffer.wrap(v.getVec3t()));
			}
			
			gl.glEnd();
		}		
	}
	public void drawModelItpWithGlCmds (GL gl, int iFrameA, int iFrameB, float fInterp) {
		int iMaxFrame = numFrames - 1;
		if (iFrameA < 0 || iFrameB < 0)
			return;
		if (iFrameA > iMaxFrame || iFrameB > iMaxFrame)
			return;
		gl.glBindTexture (GL.GL_TEXTURE_2D, textID);	
		int n = 0;
		while (n < glCommands) {			
			int j = glCmds[n];
			if (j < 0) {
				gl.glBegin(GL.GL_TRIANGLE_FAN);
				j = -j;
			} else {
				gl.glBegin(GL.GL_TRIANGLE_STRIP);
			}
			n++;
			for ( ;j>0; j--, n+= 3) {
				MD2GlCommand glCom = new MD2GlCommand ();
				glCom.setS(glCmds[n]);
				glCom.setT(glCmds[n+1]);
				glCom.setIndex(glCmds[n+2]);
				MD2Frame frameA = frames[iFrameA];
				MD2Frame frameB = frames[iFrameB];
				MD2Vertex vertA = frameA.getVerts()[glCom.getIndex()];
				MD2Vertex vertB = frameB.getVerts()[glCom.getIndex()];
				gl.glTexCoord2f((float) glCom.getS(),(float) glCom.getT());
				
				Vec3t normA, normB, no;
				normA = anorms[vertA.getNormalIndex()];
				normB = anorms[vertB.getNormalIndex()];
				no = new Vec3t (normA.getVec3t()[0] + fInterp * (normB.getVec3t()[0] - normA.getVec3t()[0]),
						normA.getVec3t()[1] + fInterp * (normB.getVec3t()[1] - normA.getVec3t()[1]),
						normA.getVec3t()[2] + fInterp * (normB.getVec3t()[2] - normA.getVec3t()[2]));
				gl.glNormal3fv (FloatBuffer.wrap(no.getVec3t()));
				Vec3t vecA, vecB, v;
				vecA = new Vec3t (frameA.getScale().getVec3t()[0]  * vertA.getV()[0] + frameA.getTranslate().getVec3t()[0],
						frameA.getScale().getVec3t()[1]  * vertA.getV()[1] + frameA.getTranslate().getVec3t()[1],
						frameA.getScale().getVec3t()[2]  * vertA.getV()[2] + frameA.getTranslate().getVec3t()[2]);
				
				vecB = new Vec3t (frameB.getScale().getVec3t()[0]  * vertB.getV()[0] + frameB.getTranslate().getVec3t()[0],
						frameB.getScale().getVec3t()[1]  * vertB.getV()[1] + frameB.getTranslate().getVec3t()[1],
						frameB.getScale().getVec3t()[2]  * vertB.getV()[2] + frameB.getTranslate().getVec3t()[2]);
				
				v = new Vec3t ((vecA.getVec3t()[0] + fInterp * (vecB.getVec3t()[0] - vecA.getVec3t()[0])) * scale,
						(vecA.getVec3t()[1] + fInterp * (vecB.getVec3t()[1] - vecA.getVec3t()[1])) * scale,
						(vecA.getVec3t()[2] + fInterp * (vecB.getVec3t()[2] - vecA.getVec3t()[2])) * scale);
				
				gl.glVertex3fv(FloatBuffer.wrap(v.getVec3t()));
			}
		
			gl.glEnd();
		}		
	}
	public static Vec3t[] getAnorms() {
		return anorms;
	}
	public static void setAnorms(Vec3t[] anorms) {
		Model3D.anorms = anorms;
	}
	public MD2Triangle[] getTirangles() {
		return triangles;
	}
	public void setTirangles(MD2Triangle[] tirangles) {
		this.triangles = tirangles;
	}
	public MD2Frame[] getFrames() {
		return frames;
	}
	public void setFrames(MD2Frame[] frames) {
		this.frames = frames;
	}
	public int[] getGlCmds() {
		return glCmds;
	}
	public void setGlCmds(int[] glCmds) {
		this.glCmds = glCmds;
	}
	public float getScale() {
		return scale;
	}
	public void setScale(float scale) {
		this.scale = scale;
	}
	public int getTextID() {
		return textID;
	}
	public void setTextID(int textID) {
		this.textID = textID;
	}
	public void setTexCoords (MD2TexCoord[] coord) {
		this.texCoords = coord;
	}
	public MD2TexCoord[] getTexCoords () {
		return texCoords;
	}
	private class Vec3t {
		private float[] vec3t;		
		public Vec3t (float x, float y, float z) {
			vec3t = new float[3];
			vec3t[0] = x;
			vec3t[1] = y;
			vec3t[2] = z;
		}		
		public float[] getVec3t () {
			return vec3t;
		}
	}
	private class MD2Vertex {
		private int[] v; //Position dans l'espace. (Relative au modèle)
		private int normalIndex; //Index normal du sommet.
		public  MD2Vertex () {
			v = new int[3];
		}
		
		public int[] getV() {
			return v;
		}
		public void setV(int[] v) {
			this.v = v;
		}
		public int getNormalIndex() {
			return normalIndex;
		}
		public void setNormalIndex(int normalIndex) {
			this.normalIndex = normalIndex;
		}	
		
	}
	private class MD2Triangle {
		private int[] vertex; //Indice vertex du triangle.
		private int[] ct; //Indice de coordonnée de la texture.
		public MD2Triangle () {
			vertex = new int[3];
			ct = new int[3];
		}
		public void setMd2TriangleVertex (int x, int y, int z) {
			vertex[0] = x;
			vertex[1] = y;
			vertex[2] = z;
		}
		public void setCt (int x, int y, int z) {
			ct[0] = x;
			ct[1] = y;
			ct[2] = z;
		}		
		public int[] getVertex () {
			return vertex;
		}
		public int[] getCt () {
			return ct;
		}
	}
	private class MD2TexCoord {
		private short s;
		private short t;
		public short getS() {
			return s;
		}
		public void setS(short s) {
			this.s = s;
		}
		public short getT() {
			return t;
		}
		public void setT(short t) {
			this.t = t;
		}		
	}
	private class MD2Frame {
		private Vec3t scale; //Vecteur de redimentionnement.
		private Vec3t translate; //Vecteur de translation.
		private String nameFrame; //Nom de la frame.
		private MD2Vertex[] verts; //liste des sommets.
		public MD2Frame (int numVerts) {
			verts = new MD2Vertex[numVerts];
		}
		public Vec3t getScale() {
			return scale;
		}
		public void setScale(Vec3t scale) {
			this.scale = scale;
		}
		public Vec3t getTranslate() {
			return translate;
		}
		public void setTranslate(Vec3t translate) {
			this.translate = translate;
		}
		public String getNameFrame() {
			return nameFrame;
		}
		public void setNameFrame(String nameFrame) {
			this.nameFrame = nameFrame;
		}
		public MD2Vertex[] getVerts() {
			return verts;
		}
		public void setVerts(MD2Vertex[] verts) {
			this.verts = verts;
		}
	}
	private class MD2GlCommand {
		private float s;
		private float t;
		private int index;
		public float getS() {
			return s;
		}
		public void setS(float s) {
			this.s = s;
		}
		public float getT() {
			return t;
		}
		public void setT(float t) {
			this.t = t;
		}
		public int getIndex() {
			return index;
		}
		public void setIndex(int index) {
			this.index = index;
		}		
	}
}

PS : j'ai corrigé pour la lecture, j'ai utiliser la méthode position pour me placer dans le flux à la bonne place.