Discussion :

[drcd]

Bonjour à tous,

Je cherche depuis quelques temps à intégrer Newton à mon loader de md2 sans succès.

Pour vous donner une idée de l'organisation des données de mon loader voici la méthode qui affiche une frame:

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
 
void Md2Model::renderFrameImmediate (int frame)
{
    // Compute max frame index
 
    int maxFrame = _header.num_frames - 1;
 
 
    // Check if the frame index is valid
 
    if ((frame < 0) || (frame > maxFrame))
 
 
        return;
 
    // Bind to model's texture
    if (_tex)
        _tex->bind ();
 
    glBegin (GL_TRIANGLES);
    // Draw each triangle
    for (int i = 0; i < _header.num_tris; ++i)
    {
        // Draw each vertex of this triangle
	for (int j = 0; j < 3; ++j)
	{
	     Md2Frame_t *pFrame = &_frames[frame];
	     Md2Vertex_t *pVert = &pFrame->verts[_triangles[i].vertex[j]];
	     Md2TexCoord_t *pTexCoords = &_texCoords[_triangles[i].st[j]];
 
	     // Compute final texture coords.
	     GLfloat s = static_cast<GLfloat>(pTexCoords->s) / _header.skinwidth;
	     GLfloat t = static_cast<GLfloat>(pTexCoords->t) / _header.skinheight;
 
	     glTexCoord2f (s, 1.0f - t);
 
	     // Send normal vector to OpenGL
	     glNormal3fv (_kAnorms[pVert->normalIndex]);
 
	     // Uncompress vertex position and scale it
	     vec3_t v;
 
	     v[0] = (pFrame->scale[0] * pVert->v[0] + pFrame->translate[0]) * _scalex;
	    v[1] = (pFrame->scale[1] * pVert->v[1] + pFrame->translate[1]) * _scaley;
	    v[2] = (pFrame->scale[2] * pVert->v[2] + pFrame->translate[2]) * _scalez;
 
	    glVertex3fv (v);
	  }
      }
  glEnd();
}

Je suis le tutorial de developpez.com sur les enveloppes convexes. Je me suis donc dit que en reprenant le code d'affichage d'une frame et en considérant que mon objet 3D equivaux à un mesh, j'arriverais à faire intéragir mes objets avec la physique.

Voici la fonction à laquelle je suis arrivé:

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
 
void Md2Player::CreateNewtonModel(Md2ModelPtr model)
{
	NewtonCollision * nCollision = NULL;
	std::vector <NewtonCollision *> enveloppeConvexe;
 
	NewtonWorld *nWorld=GSEPhysic->GetWorld();
	vector<GSEPOINT3D> triangle;
 
	for (int i = 0; i < model->_header.num_tris; ++i)
	{
		// Draw each vertex of this triangle
 
		for (int j = 0; j < 3; ++j)
		{
			Md2Frame_t *pFrame = &model->_frames[0];
			Md2Vertex_t *pVert = &pFrame->verts[model->_triangles[i].vertex[j]];
 
			vec3_t v;
 
			v[0] = (pFrame->scale[0] * pVert->v[0] + pFrame->translate[0]) * model->_scalex;
			v[1] = (pFrame->scale[1] * pVert->v[1] + pFrame->translate[1]) * model->_scaley;
			v[2] = (pFrame->scale[2] * pVert->v[2] + pFrame->translate[2]) * model->_scalez;
 
			GSEPOINT3D point=GSEPOINT3D(v[0],v[1],v[2]);
 
			triangle.push_back(point);
		}
	}
 
	nCollision = NewtonCreateConvexHull (nWorld, triangle.size(), &triangle[0].x, sizeof (GSEPOINT3D)* 3 , NULL);
 
	enveloppeConvexe.push_back (nCollision);
 
	nCollision = NewtonCreateCompoundCollision (nWorld, model->_header.num_tris, &enveloppeConvexe[0]);
 
	m_pBody = NewtonCreateBody (nWorld, nCollision);
 
	if (m_pBody == NULL)
   {
      std::cerr << "Impossible de créer le corps Newton";
   }
 
	int size=enveloppeConvexe.size();
 
	for(int i=0;i<size;i++)
	{
		NewtonReleaseCollision(nWorld,enveloppeConvexe[i]);
	}
 
	NewtonReleaseCollision (nWorld, nCollision);
}

Mais lorsque j'execute ce code, le programme plante sur la ligne:

Code :

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

nCollision = NewtonCreateConvexHull (nWorld, triangle.size(), &triangle[0].x, sizeof (GSEPOINT3D)* 3 , NULL);

sans explications apparentes (nWorld a une valeur, triangle.size() vaut 1761,...)

J'ai donc modifié ma fonction et j'ai considéré que 1 mesh = 1 triangle. Meme résultat plantage sur la méthode NewtonCreateConvexHull.

J'ai donc réalisé un programme de test. Ce programme charge dans Newton 4 vertices et passe ces vertices dans la fonction NewtonCreateConvexHull. Et là surprise ca marche. J'ai ensuite retiré du chargement un des 4 vertex et là plantage à nouveau.

J'ai fais des recherche sur google de mon problème. Le résultat a été des liens vers des topics du forum de Newton mais tous les liens sont mort.

Il y a peut etre un bug dans la fonction NewtonCreateConvexHull mais j'en doute. Je pense plutot que j'utilise mal les fonctions et c'est donc pour ca que je sollicite votre aide. J'aimerais donc savoir comment je peux charger correctement dans Newton un modèle md2?

Merci.

[bafman]

ca ne va pas résoudre ton problème, mais vouloir integrer de la physique avec des MD2, c'est la mort assuré... le MD2 est un type de modèle par key frame, ce qui et est donc représenté par des mesh, sans structure hierarchique. Généralement, on utilise soit une simplification (shpere, capsule), soit des modèles avec squelette qui ont une hierarchie permettant de s'integrer plus facilement avec des formes de base bien plus rapides et permettant de faire du ragdoll

[drcd]

Ben en fait pour l'histoire des key frame, je comptait faire une approximation en ne faisant qu'un corps pour la premiere frame et utiliser ce corps quelle que soit la frame en cours d'affichage. Pour l'approximation par une sphere ou une bounding box, comment je peux connaitre le rayon de la sphere ou les dimensions de la bounding box?

[Syl_20]

comment je peux connaitre le rayon de la sphere ou les dimensions de la bounding box?

je fais comme ca dans mon loader md2:

j'ai un vecteur bboxMax et un vecteur bboxMin

pour chaque vertex (l__position)

Code :

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

1
2
3
4
5
6
7
 // calcul du vecteur d'encombrement: determination du vecteur min et du vecteur max
if (bboxMax.mX < l__position.mX) {   bboxMax.mX = l__position.mX;  }
if (bboxMin.mX > l__position.mX) {   bboxMin.mX = l__position.mX;  }
if (bboxMax.mY < l__position.mY) {   bboxMax.mY = l__position.mY;  }
if (bboxMin.mY > l__position.mY) {   bboxMin.mY = l__position.mY;  }
if (bboxMax.mZ < l__position.mZ) {   bboxMax.mZ = l__position.mZ;  }
if (bboxMin.mZ > l__position.mZ) {   bboxMin.mZ = l__position.mZ;  }

et à la fin

Code :

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

1
2
3
// calcul du vecteur d'emcombrement
dimension = bboxMax - bboxMin;
m__centre = (bboxMax + bboxMin)/2.0f;

dimension vecteur3 contenant la taille de la bbox en x,y,z et m__centre centre de la bbox dans le repert local

[drcd]

Ok je vois. Donc si je comprends bien je peux faire un truc du genre (en pseudo code):

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
 
POINT3D vecteur;
 
Pour chaque vertex v
debut de la boucle
 
v.x=abs(v.x);
v.y=abs(v.y);
v.z=abs(v.z);
 
if(v[0]>vecteur.x)
{
    vecteur.x=v[0];
}
 
if(v[1]>vecteur.y)
{
	vecteur.y=v[1];
}
 
if(v[2]>vecteur.z)
{
	vecteur.z=v[2];
}
 
fin de la boucle
 
//Si creation d'une bounding box
vecteur*=2;// Pour obtenir les dimensions de la box
 
...
 
nCollision = NewtonCreateSphere(nWorld, vecteur.x, vecteur.z, vecteur.y, NULL);

[marco565]

oula faire une enveloppe convexe avec des md2 laisse tomber il faudrais que tu fasse une enveloppe pour chaque frame imagine le nombre de calculs, et en plus de cela sa ne vas pas etre du tout optimisé, soit tu fais avec une sphere (plus pratique que une capsule) soit ben tu passe aux ragdoll en changent de model ....