Lire un fichier binaire structuré.

**Plaigon** · 27/11/2017, 22h48

Bonjour, j'espère que vous allez bien ? Je suis nouveau ici, mais je programme en Java depuis 2 bonnes années, je pense donc avoir les bases, même si l'OpenGL reste encore un peu flou pour moi. En effet, je me suis mis en tête, depuis plusieurs semaines, de lire un fichier de modèle 3d animé au format mdl (format utilisé par le vieux jeux-vidéo Quake I). Un tutoriel en Français explique très bine comment s'y prendre, mais le langage utilisé ici est le C, or je n'y ai jamais touché. J'ai donc essayé de retranscrire à ma manière, un code aux effets semblables, cette fois-ci en Java. Voici le lien du tutoriel, et ici mon début de code.
J'ai donc parfaitement réussi à lire la partie "header" du fichier binaire en question. Mais dès qu'il s'agit de lire la variable data du type GLUbyte, c'est la catastrophe ! J'ai cru comprendre qu'en Java, on pouvait l'interpréter comme un tableau de byte, mais rien à faire, je ne parviens à la lire. Des pistes ? Merci d'avance !

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
package fr.plaigon.mdlloader;
 
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
 
import com.google.common.io.LittleEndianDataInputStream;
 
import fr.plaigon.md5loader.GLApp;
 
public class MDLReader
{
    public String filepath = "";
    public String filename = "";
 
    public MDLReader(String fileName)
    {
        loadobject(fileName);
    }
 
    public void loadobject(String objfilename)
    {
        if (objfilename != null && objfilename.length() > 0)
        {
            String[] pathParts = GLApp.getPathAndFile(objfilename);
            filepath = pathParts[0];
            filename = pathParts[1];
 
            try
            {
                loadobject(GLApp.getInputStream(objfilename));
            }
            catch (Exception e)
            {
                System.out.println("MDLReader.loadobject(): Failed to read file: " + objfilename + " " + e);
            }
        }
    }
 
    public void loadobject(InputStream in)
    {
        if (in != null)
        {
            int skinWidth, skinHeight;
            FileInputStream fis = (FileInputStream)in;
            try
            {
                LittleEndianDataInputStream dis = new LittleEndianDataInputStream(fis);
 
                //Header start
 
                System.out.println(dis.readInt());//ident or "magical number"
                System.out.println(dis.readInt());//version
 
                //Scale model vector coordinates
                System.out.println(dis.readFloat());
                System.out.println(dis.readFloat());
                System.out.println(dis.readFloat());
 
                //Translation model vector coordinates
                System.out.println(dis.readFloat());
                System.out.println(dis.readFloat());
                System.out.println(dis.readFloat());
 
                System.out.println(dis.readFloat());//Sphere radius
 
                //Eyes model vector coordinates
                System.out.println(dis.readFloat());
                System.out.println(dis.readFloat());
                System.out.println(dis.readFloat());
 
                System.out.println(dis.readInt());//num_skins
                System.out.println(skinWidth = dis.readInt());//skinwidth
                System.out.println(skinHeight = dis.readInt());//skinheight
                System.out.println(dis.readInt());//num_verts
                System.out.println(dis.readInt());//num_tris
                System.out.println(dis.readInt());//num_frames
                System.out.println(dis.readInt());//synctype
                System.out.println(dis.readInt());//flags
                System.out.println(dis.readFloat());//average size of triangles
 
                System.out.println(dis.readInt());
                for(int i = 0; i < skinWidth * skinHeight; i++)
                    System.out.println(dis.readByte());
 
                //Header end
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
 
    }

**bouye** · 06/12/2017, 00h24

Quelques petites questions/remarques :

Il serait bon de faire remonter l'exception dans la méthode appelante :

Code :

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

1
2
3
public void loadobject(InputStream in) throws IOException {
    [...] // Enlever le try et le catch dans le code.
}

Tu utilises LittleEndianDataInputStream qui n'est pas une classe standard de l'API, tu utilises Guava ? Dans ce cas tu n'as pas besoin de caster ton InputStream en FileInputStream ce qui t’évitera des soucis dans le futur si tu est amené a lire un fichier sur le réseau/le net/en streaming.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
LittleEndianDataInputStream dis = new LittleEndianDataInputStream(in);
```
Est-il possible d'avoir un petit fichier mdl de référence/de test et avoir les valeurs principales qui vont être retournées pour que ceux qui vont tenter de répondre a ta question puissent t'aider.
GLubyte ce sont juste des byte non-signes ou c'est autre chose ?

Et je te rappelle également que les flux doivent être fermés après lecture du fichier. Ce qui est être fait automatiquement en faisant :

Code :

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

1
2
3
try (final InputStream input = GLApp.getInputStream(objfilename)) {
     loadobject(input);
}

Accessoirement, en fouillant bien on peut trouver des apps/libs pour lire des fichiers MDL (ici pour du MD2, le format de Quake 2 ou encore ici pour le format MD3 de Quake 3 par exemple) au cas ou tu préférerai ne pas implémenter la tienne. Bon souvent c'est du code assez ancien par contre.

**bouye** · 06/12/2017, 04h13

A noter la methode readFully() dans la classe LittleEndianDataInputStream de Guava qui permet de lire un tableau d'octet intégralement.

**Plaigon** · 06/12/2017, 16h33

Salut bouye,
premièrement merci de ta réponse, ensuite je viens d'ajouter les fermetures de flux, merci de me l'avoir rappelé. Ensuite, je n'ai pas de fichier type mdl, dans la mesure où je ne sais pas quelles sont les valeurs de mon modèle, peut-être devrais-je essayer de le lire en C comme dans le tuto, mais ça m'embête d'aller apprendre ce lange pour si peu :/
GLuByte, c'est un byte non-signé d'après mes rapides recherches, ouep. Après je ne vois pas comment compléter la méthode readFully. Du coup je peux me contenter de LittleEndianDataInputStream#readUnsignedByte, avec ma boucle for ?

**bouye** · 06/12/2017, 23h58

Ah un moment il va quand meme falloir lire quelque chose histoire de verifier que cela marche et que la version Java sort les memes valeurs que la version C

EDIT -

Après je ne vois pas comment compléter la méthode readFully.

Ben c'est quoi le soucis ???

EDIT 2 -

Ah rien n'indique la taille du tableau / taille de la texture ? Dans ce cas est-ce que c'est sensé se terminer par le caractère null ? si oui effectivement il faudra libre octet par octet.

EDIT 3 -

time est un tableau de dimension nb et data est un tableau de nb tableaux de dimensions skinwidth * skinheight.

Ben tu connais la taille du tableau donc tu peux le pré-initialiser et utiliser la méthode...

**Plaigon** · 07/12/2017, 21h43

Certes mais c'est dans le cas d'un "mdl_groupskin_t", que data suit cette indication, or moi je suis sur un "mdl_skin_t". J'ai vite fait le programme dans code::blocks, et quand je print la variable data, avec ce code:
https://pastebin.com/ZWqy6Tre
la console me renvoie la valeur: 163588216. Du coup comment dois-je m'y prendre pour retrouver ça dans eclipse ? Je dois faire un readFully, ou une boucle for avec readUnsignedByte ? Merci d'avance ! =)

EDIT: J'ai réussi à print mon tableau de byte, mais l'adresse mémoire de celui-ci affiché par la console eclipse est le suivant: [B@77afea7d. Comment comparer celui-ci à 163588216, sorti par code::blocks, pour vérifier qu'ils sont bien tous les deux identiques ??

**bouye** · 07/12/2017, 23h45

Code C :

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

1
2
3
4
5
struct mdl_skin_t
{
  int group;      /* 0 = simple, 1 = groupe */
  GLubyte *data;  /* données texture */
};

M'enfin y a pas 36 solutions, ou il a une taille décrite qq part ou il finit par un caractère spécial. Donc ça serait bien de trouver si c'est l'un ou l'autre. Et pour ce que j'en vois dans le code C il s'agit bien d'une image qui utilise les dimensions skinwidth * skinheight données précédemment (ici le code qui transforme la texture 8 bit en image 24 bit) :

Code C :

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

1
2
3
4
5
6
7
8
9
10
 GLubyte *pixels = (GLubyte *)
    malloc (mdl->header.skinwidth * mdl->header.skinheight * 3);
 
/* Convert indexed 8 bits texture to RGB 24 bits */
  for (i = 0; i < mdl->header.skinwidth * mdl->header.skinheight; ++i)
    {
      pixels[(i * 3) + 0] = colormap[mdl->skins[n].data[i]][0];
      pixels[(i * 3) + 1] = colormap[mdl->skins[n].data[i]][1];
      pixels[(i * 3) + 2] = colormap[mdl->skins[n].data[i]][2];
    }

C'est juste que dans mdl_groupskin_t tu en as plusieurs (d'ou le tableau de tableaux) alors que dans mdl_skin_t tu dois juste en avoir une (toute l'image 2D est mise dans un tableau 1D).

Ben dans un cas en Java tu as l'affichage habituel d'un tableau et dans le cas C ca doit afficher soit l’adresse mémoire du pointeur, soit la toute première valeur du tableau (j'ai pas fait de C récemment donc... c'est loin). Dans les deux cas il te faut parcourir skinwidth * skinheight et afficher le contenu pour vérifier ce qu'il y a dedans..

**bouye** · 07/12/2017, 23h53

Trouve ailleurs sur le net

The model skins are flat pictures that represent the texture that should be applied on the model. There can be more than one skin. You will find the first skin just after the model header, at offset baseskin = 0x54. There are numskins skins to read. Each of these model skins is either in 8-bit palettized (type == 0), in 16-bit 565 format (type == 2) or 16-bit 4444 format (type == 3). The skin structure in the MDL3 and MDL4 format is:

Code C :

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

1
2
3
4
5
6
typedef byte unsigned char;
 
typedef struct {
  long skintype; // 0 for 8 bit (bpp == 1), 2 for 565 RGB, 3 for 4444 ARGB (bpp == 2)
  byte skin[skinwidth*skinheight*bpp]; // the skin image
} mdl_skin_t;

Sachant qu'en MDL de base tu as une texture 8 bit donc bpp vaut 1.

**Plaigon** · 08/12/2017, 21h03

Salut, alors j'ai finalement réussi pour le tableau data, tout marche nikel ! Voici mon code actuel:
https://pastebin.com/BQKm47q3
en revanche pour la structure mdl_texcoord_t, il est écrit qu'elle est sous forme de short, or je ne comprends pas très bien, comment "retranscrire" cela en Java. Un short est une variable primitive, je ne peux pas y faire contenir les autres variables onseam, s et t, comme s'il s'agissait d'une classe, que faire alors ? Merci d'avance, je poursuis mes recherches =)

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
package fr.plaigon.mdlloader;
 
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
 
import com.google.common.io.LittleEndianDataInputStream;
 
import fr.plaigon.md5loader.GLApp;
 
public class MDLReader
{
	public String filepath = "";
	public String filename = "";
 
	public MDLReader(String fileName)
	{
		loadobject(fileName);
	}
 
	public void loadobject(String objfilename)
	{
		if (objfilename != null && objfilename.length() > 0)
		{
			String[] pathParts = GLApp.getPathAndFile(objfilename);
			filepath = pathParts[0];
			filename = pathParts[1];
 
			try
			{
				loadobject(GLApp.getInputStream(objfilename));
			}
			catch (Exception e)
			{
				System.out.println("MDLReader.loadobject(): Failed to read file: " + objfilename + " " + e);
			}
		}
	}
 
	public void loadobject(InputStream in)
	{
		if (in != null)
		{
			int skinWidth, skinHeight;
			FileInputStream fis = (FileInputStream)in;
			try
			{
				LittleEndianDataInputStream dis = new LittleEndianDataInputStream(fis);
 
				//Header start
 
				System.out.println(dis.readInt());//ident or "magical number"
				System.out.println(dis.readInt());//version
 
				//Scale model vector coordinates
				System.out.println(dis.readFloat());
				System.out.println(dis.readFloat());
				System.out.println(dis.readFloat());
 
				//Translation model vector coordinates
				System.out.println(dis.readFloat());
				System.out.println(dis.readFloat());
				System.out.println(dis.readFloat());
 
				System.out.println(dis.readFloat());//Sphere radius
 
				//Eyes model vector coordinates
				System.out.println(dis.readFloat());
				System.out.println(dis.readFloat());
				System.out.println(dis.readFloat());
 
				System.out.println(dis.readInt());//num_skins
				System.out.println(skinWidth = dis.readInt());//skinwidth
				System.out.println(skinHeight = dis.readInt());//skinheight
				System.out.println(dis.readInt());//num_verts
				System.out.println(dis.readInt());//num_tris
				System.out.println(dis.readInt());//num_frames
				System.out.println(dis.readInt());//synctype
				System.out.println(dis.readInt());//flags
				System.out.println(dis.readFloat());//average size of triangles
				//Header end
 
				System.out.println(dis.readInt());//0 = simple, !0 = groupe
 
				byte[] test = new byte[skinWidth * skinHeight];
				dis.readFully(test);
				System.out.println(test[262143]);//data
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
		}
	}
}

EDIT: Finalement, après avoir crée une classe TexCoord avec les 3 variables, tout marche parfaitement. Je continue le tuto !

**Plaigon** · 09/12/2017, 19h24

D'accord, désolé je me servirai des balises la prochaine fois.
En revanche, j'ai encore un étrange souci. Comment suis-je censé lire les structures de vecteur de mon fichier binaire, ou plutôt leur triplet de coordonnées sous la forme d'un tableau de float ? Car j'ai essayé tout bêtement trois dis.readFloat à la suite, mais ça ne marche pas toujours. Je m'explique, le vecteur des yeux est le bon, le même que celui indiqué par le logiciel qme31, mais pas le même que celui sous code::blocks. Et par ailleurs mes vecteurs translate et scale ne sont pas les mêmes que ceux sous code::blocks, et ça m'empêche de dessiner les sommets de mes triangles :/
Une idée s'il faut mieux lire les coordonnées avec des readFloat, auquel cas, je serai exact dans mes résultats sous eclipse, mais code::blocks, non (étrange car le tuto me dessine bien le modèle en C ??), ou faudrait-il mieux lire de tableau de float avec un truc du genre dis.readFully ? Je ne sais lire que des tableaux de byte, et pas de float. Une idée ? Besoin de mon code ou d'images pour mieux illustrer ? Merci d'avance =)

EDIT: Même en me servant de ce site: https://www.scadacore.com/tools/prog...hex-converter/, je retrouve bien les valeurs données par eclipse. Par exemple les trois coordonnées du vecteur scale, sont les float suivants selon eclipse:
2.5021698
3.1418574
3.0550067

Tandis que code::blocks m'indique cela:
-1610612736
536870912
1610612736

Une idée, peut-être ai-je mal print les valeurs sur le code C, non ?

**bouye** · 11/12/2017, 09h47

Ben déjà c'est pas des flottants dans code::blocks donc si ce sont sensé être des nombres à virgule y a comme une soucis dans la config du déboggeur C

Lire un fichier binaire structuré.

avec Java

Discussions similaires

Partager

Partager