Discussion :

[supergrey]

Bonjour, si on veut déplacer un body à une position donnée (position et rotation) comment appliquer la bonne force et torque en tenant compte de la vélocité et omega ?
Merci

[Plomeg]

Pour déplacer totalement le solide (et non le faire bouger, je veux dire que Newton ne contrôle ce qui est sur la trajectoire avec cette méthode) il faut utiliser la matrice de l'objet. Attention, les matrices de Newton sont différentes de celles "standards". Leur ordre est le suivant

0 4 8 12
1 5 9 13
2 6 10 14
3 7 11 15

Ce qui veut dire que un nombre positionné à la case 4 normalement sur une matrice sera ici à la case 1 (de gauche à droite puis haut en bas).

Je n'utilise que la 2D avec Newton donc pour les rotations je ne saurai pas te dire niveau 3D.

Donc pour changer la position de l'objet (attention il gardera ses autres propriétés comme sa vitesse), il faut faire:

Code :

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

1
2
3
4
 
matrice[12] = x;
matrice[13] = y;
matrice[14] = z;

Pour les rotations, on peut utiliser : NewtonBodyGetOmega et NewtonBodySetOmega pour respectivement obtenir et régler la vitesse angulaire.

Voici la définition de la doc (demande si tu as besoin de détails sur ce point):

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
 
NewtonBodySetOmega
void NewtonBodySetOmega(
const NewtonBody* bodyPtr,
const dFloat* omega)
Set the global angular velocity of the body.
 
Parameters
 
const NewtonBody *bodyPtr 	- 	is the pointer to the body.
const dFloat *omega 	- 	pointer to an array of at least three floats containing the angular velocity vector.
 
 
NewtonBodyGetOmega
void NewtonBodyGetOmega(
const NewtonBody* bodyPtr,
dFloat* omega)
Get the global angular velocity of the body.
 
Parameters
 
const NewtonBody *bodyPtr 	- 	is the pointer to the body
dFloat *omega 	- 	pointer to an array of at least three floats to hold the angular velocity vector.

Sinon on peut régler manuellement l'orientation de l'objet par la matrice. Si tu en as besoin en 2D je pourrais t'aider mais pas si c'est pour de la 3D (pour le code exacte).

Par contre je peux te donner quelques conseils pour les matrices. Une rotation se fait du point que les coordonnées de la matrice (de l'objet tourné) ont pour origine. C'est assez laborieux à dire^^. Désolé. Mais pour résumer, si tu veux une rotation de l'objet sur lui-même, il faut multiplier des matrices avec des coordonnées nulles (stocker les vraies dans un coin et les remettre après). Voici mon code pour multiplier des matrices de 4*4 (je pense qu'il est pas super mais bon... remarque que multiplier des matrices de 3*3 suffirait pour effectuer la rotation, si on veut une rotation de l'objet sur lui-même, pas besoin des coordonnées):

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
float* multiplier_matrices(float matrice1[], float matrice2[])
{
        float *matrice3 = new float [16];
 
        for(int i =0; i<4; ++i)
        {
            for(int j =0; j<4; ++j)
            {
                matrice3[4*i+j] = matrice1[i*4]*matrice2[j]
                + matrice1[(i*4)+1]*matrice2[4+j]
                + matrice1[(i*4)+2]*matrice2[8+j]
                + matrice1[(i*4)+3]*matrice2[12+j];
            }
        }//*/
 
        return &matrice3[0];
}

J'espère que ça t'aidera^^. J'ai faillis la méthode pour récupérer et régler les matrices (cf la doc bien sûr):

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
NewtonBodyGetMatrix
void NewtonBodyGetMatrix(
const NewtonBody* bodyPtr,
dFloat* matrixPtr)
Get the transformation matrix of a rigid body.
 
Parameters
 
const NewtonBody *bodyPtr 	- 	pointer to the body.
const dFloat *matrixPtr 	- 	pointer to an array of 16 floats that will hold the global matrix of the rigid body.
 
Return
Nothing.
 
Remarks
The matrix should be arranged in row-major order 
(this is the way directX stores matrices). If you are
 using OpenGL matrices (column-major) you will need 
to transpose you matrices into a local array, before 
passing them to Newton.
 
 
NewtonBodySetMatrix
void NewtonBodySetMatrix(
const NewtonBody* bodyPtr,
const dFloat* matrixPtr)
Set the transformation matrix of a rigid body.
 
Parameters
 
const NewtonBody *bodyPtr 	- 	pointer to the body.
const dFloat *matrixPtr 	- 	pointer to an array of 16 floats containing the global matrix of the rigid body.
 
Return
Nothing.
 
Remarks
The matrix should be arranged in row-major order
 (this is the way directX stores matrices). If you are
 using OpenGL matrices (column-major) you will need
 to transpose you matrices into a local array, before
 passing them to Newton.

[supergrey]

Merci pour ta réponse, mais en fait mon problème n'est pas vraiment l'utilisation des matrices, que je commence à maîtriser assez bien.
Je sais aussi modifier le position d'un objet avec newton en faisant NewtonBodySetMatrix, mais ce n'est pas ce que je veux, j'ai besoin de faire la même chose mais en appliquant des forces uniquement.
Je l'ai déjà fait pour la position:

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
	D3DXVECTOR3 addforce;
 
	D3DXMATRIX mat;
	NewtonBodyGetMatrix(body,&mat._11);
	D3DXVECTOR3 curpos(mat._41,mat._42,mat._43); 
 
	D3DXVECTOR3 D=*newpos-curpos;
 
	float mass,ixx,iyy,izz;
	NewtonBodyGetMassMatrix(body,&mass,&ixx,&iyy,&izz);
	addforce=D*3600*mass;
 
	NewtonBodyGetVelocity(body,&D.x);
	D=D/1200*20*3600*mass;
	addforce+=-D;

Mais pour les rotation c'est une autre affaire, je suppose qu'il faudrait tenir compte des ixx, iyy et izz, mais en plus, sachant que la torque s'applique sur 3 axes il doit falloire commencer par récupérer l'omega sur ces 3 axes alors qu'une matrice a 9 valeurs pour les rotations, je suppose qu'il y a un moyen de convertir en 3 axes...

[Plomeg]

Le problème me semble la précision nécessaire pour obtenir la position exacte voulue (arrêter pile l'objet au bon endroit).

Tu peux facilement calculer la direction que tu veux par contre à l'aide des coordonnées (je suppose que tu as déjà trouvé ça).

Sinon pour l'angle je te conseille d'utiliser SetAngularVelocity. De même si tu ne veux pas te prendre la tête avec la masse et les forces, règle directement la vitesse de l'objet (selon un vecteur).

Au fait tu peux aussi faire :

Code :

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

1
2
3
4
5
6
 
addforce-=D;
 
//plutôt que
 
addforce+=-D;

par contre le smiley n'a plus de nez... mais il était mal placé de toute façon


Si tu as une idée de la vitesse que tu veux obtenir, utilise la relation suivante (formule de calcul de l'énergie cinétique):
Ec = 1/2 * m * v²
Ec en newton, m en Kg (attention sur ce point) et v en m/s

Avec ça, tu dois pouvoir calculer les x,y et z correspondant (selon l'angle).