Discussion :

[BioKore]

Bonjour à tous,

Bien que je compte utiliser une bibliothèque pour ça par la suite, j'aimerais mieux comprendre le fonctionnement des *.obj afin de les charger dans OpenGL.

J'ai réalisé un loader simple mais fonctionnel, cependant, il me reste à comprendre comment réorganiser les données afin que les textures soient bien rendues. Comme je le comprends, nous ne pouvons utiliser qu'un seul "GL_ELEMENT_ARRAY_BUFFER", et les indices doivent donc correspondre aussi bien aux positions des vertex, que celles des Textures et des normales.
Cependant, les fichiers *.obj nous fournissent des indices séparés du type "f 1/11/2 7/14/2 5/12/2" (vertex, texture, normal). Je me suis alors dit qu'il suffisait de réorganiser les données, mais il se trouve que, dans les fichiers que j'ai, il n'est pas rare d'avoir un nombre de coordonnées des vertex différent du nombre de coordonnées de textures...

Pour cette raison, j'en appelle à votre connaissance : "comment, dans le fichier ci-dessous (pour l'exemple, en réalité, je charge des modèles bien plus complexes), je peux réorganiser les données afin que les indices correspondent (f 1/1/1 7/7/7 5/5/5) ?" Sinon, existe-t'il une méthode permettant d'afficher les textures selon un IBO différent de celui des vertex ?

Je vous remercie d'avance ! La source :

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
# cube.obj
#
o cube
v  0.0  0.0  0.0
v  0.0  0.0  1.0
v  0.0  1.0  0.0
v  0.0  1.0  1.0
v  1.0  0.0  0.0
v  1.0  0.0  1.0
v  1.0  1.0  0.0
v  1.0  1.0  1.0
vt 0.25 0.0
vt 0.5  0.0
vt 0    0.25
vt 0.25 0.25
vt 0.5  0.25
vt 0.75 0.25
vt 0.0  0.5
vt 0.25 0.5
vt 0.5  0.5
vt 0.75 0.5
vt 0.25 0.75
vt 0.5  0.75
vt 0.25 1.0
vt 0.5  1.0
vn  0.0  0.0  1.0
vn  0.0  0.0 -1.0
vn  0.0  1.0  0.0
vn  0.0 -1.0  0.0
vn  1.0  0.0  0.0
vn -1.0  0.0  0.0
f  1/11/2  7/14/2  5/12/2
f  1/11/2  3/13/2  7/14/2 
f  1/7/6  4/4/6  3/3/6 
f  1/7/6  2/8/6  4/4/6 
f  3/1/3  8/5/3  7/2/3 
f  3/1/3  4/4/3  8/5/3 
f  5/10/5  7/6/5  8/5/5 
f  5/10/5  8/5/5  6/9/5 
f  1/11/4  5/12/4  6/9/4 
f  1/11/4  6/9/4  2/8/4 
f  2/8/1  6/9/1  8/5/1 
f  2/8/1  8/5/1  4/4/1

[Kannagi]

je peux réorganiser les données afin que les indices correspondent (f 1/1/1 7/7/7 5/5/5) ?"

Ben en refaisant totalement ton index et c'est vachement lourd en calcul !
J'avais codé (il y'a longtemps )de transformer le .obj en index pour OpenGL , (plus exaxtement du Array en Index) , ça prend moins de 100 lignes de code :p

Pour ma part je n'utilise plus le .obj pour 4 raisons :
-long a parser
-gère pas vraiment les index
-ne gère pas non plus l'animation par squelette
-c'est un format texte donc un chargement plus long et des fichiers plus lourd

Je suis passé sur assimp (et pour mon moteur je gère un format perso en binaire , donc facile et rapide à charger ).

[BioKore]

Bonjour, et merci pour ce retour rapide !

C'est donc bien ce que je pensais, réaliser ce genre de boulot demande de la persévérance...

Sachant que les fins de mon moteur sont plus liés à de la simulation physique qu'à faire des rendus magnifiques (mais pourquoi ne pas lier l'utile à l'agréable ?), vers quel format dois-je me tourner ? Les besoins sont simples :
- géométrie : besoin de récupérer ces infos pour du calcul (en plus de l'affichage)
- textures / matériaux
- pas de squelette (en tout cas, pas encore)
- génération facile depuis blender ou autres outils de modélisation courants


Enfin, j'anticipe mon passage à l'utilisation d'une bibliothèque, à part ASSIMP, la quelle pourriez-vous me conseiller, sachant que l'outil proposé doit être portable (Linux / BSD / Windows) ? Si cela existe en Header only ce serait parfait (pas besoin de compiler une lib à part, juste un .h à intégrer dans les sources et c'est réglé).

[Kannagi]

Difficile à dire parce que je me suis pas vraiment amuser à me plonger sur tout les formats existants !
Je te conseille de voir du coté du MD3 : http://icculus.org/~phaethon/q3a/formats/md3format.html (Mais il ne gère pas plus de 4096 vertex)
Le PMX : https://gist.github.com/felixjones/f8a06bd48f9da9a4539f
Et dans le jeux Vidéo le plus utilisé et le FBX (bon courage pour trouver une doc par contre).

Pour les libs , go chercher sur GitHub

Je met au cas où mon convertisseur (qui n'est pas fini et pas à jour) : https://github.com/Kannagi/BCMConvert
Il gère par forcément des matériaux , juste vertex , texture , normal et index (et légèrement l'animation par squelette mais j'ai pas encore bien défini les specs).
Ah et le code source est moche , mais ça c'est parce que j'avais commencé le code en C mais manque de doc sur le C , j'ai changer par le C++ donc ça fait un mélange C /C++ horrible

[dragonjoker59]

Un format qui monte est le glTF (https://www.khronos.org/gltf/).
Le FBX est très utilisé, et il y a un SDK qui te permet de loader les fichiers utilisant ce format (https://www.autodesk.com/developer-n...fbx-sdk-2019-0).

Je ne vois pas trop l'intérêt de faire ça par toi-même, car au final ton moteur utilisera un format perso, et Assimp fera l'affaire en attendant que tu te sois décidé sur ton format perso.
Ca n'a même strictement aucun intérêt pédagogique. (Dixit celui qui s'était fait chier à écrire des loaders pour : ASE, LWO, 3DS, OBJ, MD2, MD3, PLY et FBX, et qui les a tous droppés)

[BioKore]

Ok, merci pour ce retour. Je vais voir ce que donne ce fameux glTF.

Je vais suivre ton conseil et passer de suite via un loader existant ; ça me fera gagner du temps...