Discussion :

[SKone]

slt...

Je codes un moteur physique je m'attaques au soft-body mais un problème ce pose devine avec quoi ... L'integration d'euler que j'ai utilisé j'ai chargé un objet mis tout les ressorts et des qu'ils touche le sol il tremble et le système s'effondre et les triangles du mesh par dans tout les sens ...

Apres quelque recherche j'ai decouvert qu'il y avait une alternative l'integration de RK4 mais toute les implementations que j'ai vu c'est pour des cas particulier comme des pendules, ...

Et je voudrais que quelqu'un m'aiguilles pour que j'implementes mon truc pour un cas général voilà pour l'instant comment j'ai fais avec euler ...

Je disposes de l'ancienne position d'un particule de sa position courante et de sa masse ainsi que les forces exterieur qui s'applique sur cette dernière ... :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
// Definition d'une particule
// Particle definition
struct E_Particule
{
 fVector3D curPos; // Position courante de la particule
 fVector3D oldPos; // Position precedente de la particule
 fVector3D force; // Vecteur force des forces accumuler par la particule
 float mass; // Masse de la particule
 bool Static; // Particule static
};

et un ressort :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
// Un beau ressort
// A beautiful spring
struct E_Spring
{
 size_t A; // Index de la première particule
 size_t B; // Index de la seconde particule
 float Length; // Distance entre les 2 particules
 float Ks; // Facteur d'elasticité du ressort
};

Et voilà ma manière dont j'implemente ça :
l'integration :

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
 
// Integration
void Integrate(float dt)
{
 // recuperer le nombre de particule
 size_t S = ArrPrtcl.GetSize();
 // Appliquer l'integration à toute les particules
 for(size_t i = 0; i < S; ++i)
 {
  // recuperer une particule indexé en i		  E_Particule p = ArrPrtcl.GetParticuleAt(i);
  // verifier si la particule n'est pas statique	  if(p.Static == false)
  {
   fVector3D curPos = p.curPos;
   p.curPos += p.curPos - p.oldPos + p.force * dt * dt;
   p.oldPos = curPos;
   // Affecter la particule
   ArrPrtcl.SetParticuleAt(i, p);
  }
 }
}

et la satisfaction des contraintes [ressorts] ... :

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
 
// Satisfaire les contraites de ressort
void SatisfSpring()
{
 // Recuperer le nombre de ressort
 size_t S = ArrSprng.GetSize();
 for(size_t i = 0; i < S; ++i)
 {
  // recuperer la particule indexé en i
  E_Spring s = ArrSprng.GetSpringAt(i);
  // recuperer les particules
  E_Particule p1 = ArrPrtcl.GetParticuleAt(s.A);
  E_Particule p2 = ArrPrtcl.GetParticuleAt(s.B);
 
  // distance entre les 2 particules
  fVector3D delta = p2.curPos - p1.curPos;
  float deltaLengh = delta.Length();
  // difference entre la longueur en repos et la courante
  float diff = (deltaLengh - s.Length) / deltaLengh;
 
  // ...
  fVector3D off = delta * 0.5f * diff * s.Ks;
  p1.curPos += off;
  p2.curPos -= off;
  if(p1.Static == false)
  {
   ArrPrtcl.SetParticuleAt((s.A), p1);
  }
  if(p2.Static == false)
  {
   ArrPrtcl.SetParticuleAt((s.B), p2);
  }
 }
}

Enfin voilà je donnes pas tout ca pour que vous me fassiez tout mais juste pour me montrer sur quoi je boss et j'aimerais votre aide merci pour vos futur reponse ...

[mathieu_t]

Salut !

Tout d'abord, je te rappelle que le langage sms et la mine de fautes d'orthographe sont à éviter autant que possible sur ce forum...

Pour ce qui est d'euler, je ne vois pas où est la récurrence dans le bout de code que tu donnes...

Ensuite pour Runge Kutta d'ordre 4, ça ne s'applique pas qu'au pendule évidemment, ça résoud toute équation différentielle de base... Il suffit itérativement de calculer les 4 k (voir [url]http://mathworld.wolfram.com/Runge-KuttaMethod.html[/url) jusqu'à convergence...

Donne tes équations différentielles pour qu'on t'explique la méthode...

A+

[Matthieu Brucher]

Pas trouvé non plus
C'est à la fin que la convergence n'est plus assurée, c'est ça ? J'ai pas encore regardé RK4, mais tu ne peux pas détecter le moment où les coefficients varient peu et alors arrêter ? Si tu as un problème de convergence, c'est peut-être simplement parce que tu arrives aux limites de précision de ta machine ?

[SKone]

Dans la fonction integrate je determines pour une particule le vecteur vitesse en fonction de l'ancienne position et j'y applique les forces exterieur, et pour les ressorts j'appliques la loi de hook...

[Matthieu Brucher]

C'est pas récursif, ça, c'est itératif pour moi.

[SKone]

En effet mais mon systeme ma simulation reste instable vous n'avez pas de solution pour ca ... ?

[Matthieu Brucher]

Et ce que mathieu et moi t'avons proposé ne t'aide pas ?

[mathieu_t]

Pour ce qui est de ton code source j'ai pas le coeur de regarder ...

Ce qui serait cool, ça serait que tu donnes tes équations différentielles...
Pour l'instabilité comme te le dit Miles c'est sans doute dû au fait que tu ne t'arrêtes pas quand il faut ou ça peu être tout autre (genre un petit bug) de programmation qui fait tout sauter...

A+

[SKone]

Et bien la base comme equation :
acc = Fext / mass
vitesse += acc*dt
position += vitesse*dt

:

(vec3)sommeDesForces = (float)masse*(vec3)acceleration
(vec3)sommeDesCouples = (matrice)inertie*(vec3)variationVitesseDeRotation

(vec3)acceleration = (vec3)sommeDesForces / (float)masse
(vec3)vitesse += (vec3)acceleration *dt
(vec3)position += (vec3)vitesse*dt

et aussi je voudrais appliquer la loi de Hook pour les ressorts...

[Matthieu Brucher]

il vaut quoi, ton dt ?

[Rafy]

Salut
le dt c'est le temps écoulé entre 2 frame, enfin je crois
car chez moi c'est comme ca...

(je programme aussi un moteur physique)

[Rafy]

chez moi le dt, en release, est de l'ordre de 1e-4, parfois 1e-3 quand ça rame un peu (40 FPS)

[Rafy]

Ma partie moteur de particule de mon moteur tourne correctement.
j'utilise l'intégration d'Euler pourtant. (enfin j'ignorais que ça portait un nom)

Mes particules rebondissent correctement, se déplace correctement...
accepte d'être sousmise à des attracteurs ou des constraintes.

Les particules, chez moi sont gérées soit à "l'unité" (l'utilisateur crée particule par particule), soit en fontaines (l'utilisateur donne la quantité et le moteur place les particules)

[Rafy]

ton problème ne vient-il pas des collisions ?
Tu dis que c'est quand il touchent le sol... :

[Rafy]

j'ai eu des problème de tremblement, ca venait des collisions

[Rafy]

Si ca vous intéresse de vous creuser la tête sur un autre problème
http://www.developpez.net/forums/viewtopic.php?t=379219
(certain sont déjà passé, merci a eux)

[SKone]

Ben c'est pas un simple moteur a particule... C'est des mass-spring pour la gestion des corps deformable et ca viens des ressorts vous avez remarquer si on place la longueur d'un ressort su les ordonnées en fonction du temps on a une fonction sinusoïdale et vous pouvvez faire le teste vous mêmes avec une feuille de papier avec l'integration d'euler l'aproximation emplifie le mouvement ... :S Donc le problème ne vient pas des collisions mais de la lois d'hook pour mes ressorts et l'integration ...

[Rafy]

hum d'accord, Mon moteur ne gère pas la déformation, alors j'ai fait l'amalgamme Je ne peux pas trop t'aider, désolé.
Car j'utilise ta methode pour les intégrations...

[SKone]

Pour l'instant dt = 0.05 alors personne ... ?

[Matthieu Brucher]

Je pense que tu devrais utiliser un dt dépendant des variations de ton intégrale. La variation est lente -> gros dt. La variation est faible -> petit dt.
Par exemple, si tu dois calculer l'intégrale de x connaissant une équation différentielle, tu fais une première approximation de x, tu obtiens x' et tu prends dt = 1/x.