Discussion :

[grand's]

Heu juste une petite question

j'ai trouvé un fichier avec une extension .x representant un objet que j'aimerai incorporé à mon environnement.
Seulement, je ne connais pas ce genre de fichier et il vient d'un prog sous DirectX.
Est-il possible de l'utiliser avec OpenGL et comment ?

merci

[grand's]

voila j'ai trouvé en partie
un fichier .x est un fichier directX (heu arreter moi si je me trompe)

donc ma question se modifie:
est-il possible de convertir un fichier .x en un fichier utilisable avec OpenGL ?

merci

[Bob.Killer]

soit tu fais un parser .X pour loader en opengl ce qui est pas trop dur à faire si le fichier est en txt (en binaire g rien compris aux explications de microsoft) sinon bas d'originie opengl ne connais aucun format de mesh lol donc voilà ! moi pour convertir les fichier 3D j utilise deep exploration il te permetra de convertir le fichier en .cpp et .h exploitable sous GL

[grand's]

deep exploration pas bien, meme pas une version d'evaluation gratuite
par contre j'ai trouvé 3d OBJECT CONVERTER (en version d'evaluation)
et la terrible, 410 formats differents.
et mon .x, je l'ai ouvert, j'ai juste eu un "save as" a faire en selectionnant le format OpenGL, et je me suis retrouvé avec un magnifique code dessinant mon objet.
Aussi possible de convertir plusieurs fichier en meme temps

pour ceux que ca interresse il est ici

[Omfraax]

Bon, moi je me suis fait un importateur 'maison' de fichier .x, c'esta ssez pratique, avec quelques modifs du fichier et puis ensuite des fscanf bien placés.

Seulement, j'ai eu un problème avec les coordonnées UV, c'est que le format .x en donne 1 par point. Or quand on texture un objet, il est éclaté sur la texture et donc deux polygones qui joignent sur le modèle peuvent se retrouver disjoints sur la texture. Ces polygones joints ont des points en commun mais ces points se retrouvent alors à des coord UV différentes sur la texture. Donc il doit en prendre une des deux et ça aboutit à une merde monumentale au niveau de la texture.
Pour le moment, je n'ai rien vu d'autre que d'utiliser une fonction 'Dissocier' de mon modeleur qui créé autant de points qu'il faut pour qu'un point ne soit que sur un seul polygone.
La ça marche mais ça crée beaucoup de points dont les coordonnées 3d et les normales sont redondantes donc je pense qu'on peut ensuite bidouiller pour économiser de la place et ramener le nombre de vertices et de normales au nombre habituel, mais en ayant toutes les coord UV qu'il faut. J'ai déja changé ma structure de données pour que ça marche...

Si quelqu'un veut plus d'informations, je suis prêt à mieux détailler et expliquer.


J'utlise OpenGL en C sous MacOSX avec Xcode

[Bob.Killer]

si tu veux économiser de la place ne lis pas les normales, calcules les à partir des polygones et fait un lissage

[Omfraax]

C'est ce que j'ai fait pour mon terrain( avec des montagnes et tout !) mais justement, certain objets ont des lissages particuliers (si par exemple je veux faire quelque chose d'anguleux) donc vaut mieux prendre les normales du modèle

[grand's]

salut

concernant mon import de .h, avec 3d OBJECT CONVERTER, je ne convertis que le dessin de l'objet.

j'ai donc essayé avec 3DWin5, et la je recupere apparemment tout
il créé un header et un .cpp avec des light, des normales et tout et tout.

Mais je fais comment pour utiliser ca ?

[Omfraax]

C'est à dire qu'il te créee un fichier avec une suite de glNormal3f et autre glVertex3f ???

Je pense que pour avoir une utlisation plus souple de modèles 3d (notemment pour en avoir plusieurs, etc), il vaut mieux tout bien ranger (points,polygones, normales, coordUV) dans une structure de données et lors de l'affichage, les récupérer.

[grand's]

en fait voila j'ai ca dans le .h

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
 
extern float WorldBoundMin[3];
extern float WorldBoundMax[3];
 
#define SCENE_NAME "plane2.x"
/* BackGround Definitions */
extern float background[3];
/* Light Definitions */
typedef struct
{
	float		color[3];
	float		position[3];
	int			isSpot;
	float		direction[3];
	float		radius;
	float		falloff;
}Light_Def;
#define MAX_LIGHTS (3)
extern Light_Def lights[MAX_LIGHTS];
/* Material Definitions */
typedef struct
{
	float ambient[3];
	float diffuse[3];
	float specular[3];
	float emission[3];
	float alpha;
	int   texture;
}Material_Def;
#define MAX_MATERIALS (8)
extern Material_Def materials[MAX_MATERIALS];
/* Texture Map Definitions */
typedef struct
{
	char *name;
	int  id;
}Map_Def;
#define MAX_TEXTUREMAPS (0)
extern Map_Def texture_maps[1];
/* Object Definitions */
typedef struct 
{
	char  *obj_name;
	int   *face_indicies;
	int   face_number;
	float *verticies;
	int   vertex_number;
	float *normals;
	int   normal_number;
	float *textures;
	int   texture_number;
	int   mat_ref;
}Object_Def;
#define MAX_OBJECTS (7)
extern Object_Def objects[MAX_OBJECTS];

puis dans le .cpp j'ai ca

... mais non je vais pas tout mettre

exemple:

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
 
#include "scene.h"
 
float WorldBoundMin[3] = {-3.394680f, -1.170782f, -1.526865f};
float WorldBoundMax[3] = {3.395026f, 1.265182f, 3.832220f};
 
/* BackGround */
float background[3] = { 0.000000f, 0.000000f, 0.000000f};
/* Lights */
Light_Def lights[MAX_LIGHTS] = 
{
/* PointLight: light0*/
	{{0.800000f, 0.800000f, 0.800000f},{6.308231f, 10.973077f, 7.664440f},0,{0.000000f, 0.000000f, 0.000000f},0.000000f,0.000000f},
/* PointLight: light1*/
	{{0.700000f, 0.700000f, 0.700000f},{-12.615943f, 0.047200f, 7.664440f},0,{0.000000f, 0.000000f, 0.000000f},0.000000f,0.000000f},
/* PointLight: light2*/
	{{0.600000f, 0.600000f, 0.600000f},{6.308231f, -10.878677f, 7.664440f},0,{0.000000f, 0.000000f, 0.000000f},0.000000f,0.000000f}
};
/* Materials */
Material_Def materials[MAX_MATERIALS] = 
{
/* Material: DEFAULT*/
	{{0.300000f, 0.300000f, 0.300000f},{0.600000f, 0.600000f, 0.600000f},{0.300000f, 0.300000f, 0.300000f},{0.000000f, 0.000000f, 0.000000f},1.000000f,-1},
/* Material: Cylinder_13Mate0rial0*/
	{{0.300000f, 0.300000f, 0.300000f},{0.600000f, 0.600000f, 0.600000f},{0.300000f, 0.300000f, 0.300000f},{0.000000f, 0.000000f, 0.000000f},1.000000f,-1},
/* Material: Cylinder_13Mate0rial1*/
	{{0.300000f, 0.300000f, 0.300000f},{0.600000f, 0.600000f, 0.600000f},{0.300000f, 0.300000f, 0.300000f},{0.000000f, 0.000000f, 0.000000f},1.000000f,-1},
/* Material: Cylinder_13Mate0rial2*/
	{{0.300000f, 0.300000f, 0.300000f},{0.600000f, 0.600000f, 0.600000f},{0.300000f, 0.300000f, 0.300000f},{0.000000f, 0.000000f, 0.000000f},1.000000f,-1},
/* Material: Cylinder_13Mate0rial3*/
	{{0.300000f, 0.300000f, 0.300000f},{0.600000f, 0.600000f, 0.600000f},{0.300000f, 0.300000f, 0.300000f},{0.000000f, 0.000000f, 0.000000f},1.000000f,-1},
/* Material: Cylinder_13Mate0rial4*/
	{{0.300000f, 0.300000f, 0.300000f},{0.600000f, 0.600000f, 0.600000f},{0.300000f, 0.300000f, 0.300000f},{0.000000f, 0.000000f, 0.000000f},1.000000f,-1},
/* Material: Cylinder_13Mate0rial5*/
	{{0.300000f, 0.300000f, 0.300000f},{0.600000f, 0.600000f, 0.600000f},{0.300000f, 0.300000f, 0.300000f},{0.000000f, 0.000000f, 0.000000f},1.000000f,-1},
/* Material: Cylinder_13Mate0rial6*/
	{{0.300000f, 0.300000f, 0.300000f},{0.600000f, 0.600000f, 0.600000f},{0.300000f, 0.300000f, 0.300000f},{0.000000f, 0.000000f, 0.000000f},1.000000f,-1}
};
/* Texture Maps*/
Map_Def texture_maps[1] = 
{
	 0
};

puis ca defini plusieurs chose de cette facon

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
/* Object: Cylinder_13Mesh1*/
/* Vertices */
#define MAX_VERTICES_0 (986)
float verticies_0[MAX_VERTICES_0 * 3] = 
{
	-0.089393f, -0.053572f, 3.625227f ,
	-0.068418f, -0.098988f, 3.625228f ,
	-0.037028f, -0.129334f, 3.625228f ,
	0.000000f, -0.139991f, 3.625228f ,
....
....
....

puis pareil pour les normals, textures ....
et ce pour chaque objet.

le code se termine par la definitions des objetd

Code :

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

1
2
3
4
5
6
7
 
Object_Def objects[MAX_OBJECTS] = 
{
	{"Cylinder_13Mesh1", face_indicies_0, MAX_FACE_INDICES_0, verticies_0, MAX_VERTICES_0, normals_0, MAX_NORMALS_0, textures_0, MAX_TEXTURES_0, DEF_MAT_REF_0 },
...
...
}

si j'ai bien compris, tout est defini pour chaque objet, puis on cré un tableau d'objet.
donc il n'y aurais plus qu'a lancer une commande pour restituer le modele
mais je fais ca comment

[Omfraax]

En tout cas, ça al'air d'être le bordel !!. Avec la moitié du code mis entre comment (/* */). Parce que là, si t'include ces fichiers chaque fois que tu veux charger un objet, ça risque d'être franchement dur.

Sinon, dans la structure objet, tu récupère en fait les tableaux où sont stockés les informations. Je pense que les polygones sont enregistrés sous la forme (au vu du reste)

Code :

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

1
2
3
4
5
 
float face_entities_0[MAX_FACE_INDICES_0*3]= {
      (indice_du_premier_point),(indice du deuxieme point),(indice du troisieme point);
      //..pareil pour les autres polys
}

Donc pour loader ton objet, il faut déja que tu récupère quels tableaux utiliser.

Code :

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

1
2
 
    mespoints=monobjet.verticies //on récupère le pointeur en fait ici

Dans la suite, je prendrai leur truc verticies_0 et autres machin_0

Code :

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

1
2
3
4
5
6
7
8
 
 
 for (i=0;i<MAX_FACE_INDICES_0*3;i+=3) {  //parcourt les polys
      for (j=i;j<i+3;j++) {                                 //parcourt les 3 points du polys
            indice=face_indicies_0[j];                 //recupere l'indice
            glVertex3f(verticies_0[indice], verticies_0[indice+1], verticies_0[indice+2]);    //les 3 coordonnées sont à la suite dans verticies
      }
}

Bon, c'est le corps du truc, après, tu fais pareil avec les normales, les coordUV et hop !!

Remarque: c'est vraiment pratique qu'ils strockent tout à la suite dans leur tableau, z'auraient pu faire un tableau à deux dimensions.
[/code]

[Ekinoks]

grand's> He... si, il y a une version d'évaluation gratuite de deep exploration :^/

Bob.Killer> tu as dit que tu utilisé deep exploration... j'aurais une question...
J’ai installé ce programme et j'ai convertie un objet en code c++. Malheureusement, je ne sais pas trop comment faire ensuite pour l'utilisé.

Je me retrouve avec ces trois fonctions ainsi que divers structure :

Code :

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

1
2
3
4
 
GLint Gen3DObjectList();
void SelectMaterial(int i);
void MyMaterial(GLenum mode,GLfloat *f,GLfloat alpha);

j'ai essayé de l'utilisé en faisant un appelle de "Gen3DObjectList()" a l'endroit ou je devrai normalement créé mes objets mais cela n'a pas marcher...

serais tu comment faire ?

Merci

[Bob.Killer]

re

alors si je me souviens bien "Gen3DObjectList()" te renvoie l'identifiant d'une liste opengl (ça date de lgtps c connaissances...)

tu fait juste un call de ta liste pour qu il te l affiche

Code :

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

glCallList("identifiant");

[grand's]

Merci Ekinoks, j'ai effectivement trouvé une version d'evaluation (mais pas sur leur site).
Bon OK c'est seulement un viewer (enfin je crois) mais je peut convertir mes fichiers quand meme.

[Ekinoks]

grad's> de rien

Bob.Killer> ha oui, exacte cela marche =) merci.
Et he... tu ne serais pas aussi si Deep Exploration arrive a exporté en plus des objets de la texture ? Car que j'exporte mon objet texturer et que je l'affiche dans ma scène opengl, seul l'objet est la, pas la texture :^/
Faut-il passer par un autre programme ?

Merci