[C#- IrrlichtCP.net - Ode.net] Intégrer de la physique dans Irrlicht !
Proposé par kedu

le 28 October 2006 à 10h 24mn 06s

7071 visualisations



Compte tenu du succès du précédent tutorial sur ce même thème, je voulais livrer ici une version qui utiliserait plutôt le wrapper IrrlichtCP.net

...Un développeur .net qui découvre Irrlicht devrait tout de suite péférer IrrlichtCP.net ; Ce wrapper possède beaucoup d'avantages ; plus complet, performances identiques et mieux pensé.

A titre d'exemple, sur cette conversion de tuto, j'ai pu apprécier :

- Une syntaxe plus propre/conforme à .net
- Une super gestion des évènements (plus d'héritage bidons comme dans le wrapper officiel)
- Une gui réellement utilisable

Sur un projet plus poussé, j'imagine que la liste serait longue ! Mais revenons à notre tuto converti :

L'objectif de ce tutorial est de mettre au point une petite scène constituée d'un sol, d'un mur de brique et d'une balle ! Un bouton permettra d'appliquer une force à la balle afin que cette dernière percute le mur de brique. Tout un programme !



I) La partie graphique

Rien de difficile ici, nous faisons juste appel au passage à une fenêtre qui nous permet de recueillir les souhaits pour le paramétrage du driver d'Irrlicht. (choix de la résolution, du type de driver, etc.)

Je vous laisse vous reporter au contenu de cette "SetupDriverDialog" qui est on ne peut plus basique.

Code:

//Initialisation du driver video
SetupDriverDialog DriverDialog = new SetupDriverDialog();
DriverDialog.ShowDialog();

Voyons maintenant quelque chose de plus intéressant : nous avons initialisé la 3D, il serait peut être temps de penser à la physique !

Code:

//Initialisation et lancement de la physique
maPhysique = new Physique();
monThreadDeRenduPhysique = new Thread(new ThreadStart (maPhysique.PhysiqueRenderLoop));
monThreadDeRenduPhysique.Start();

Nous détaillerons dans la partie suivante cette classe qui gère notre physique. Néanmoins on voit ici que l'exécution de cette physique se fait dans un thread à part.

Voici les raisons qui expliquent ce choix :
- Nous évitons ici de calculer la physique dans notre boucle de rendu 3D d'Irrlicht. Cela n'est pas innocent ; ainsi une mauvaise performance dans le rendu 3D n'influera pas dans le calcul de notre physique. (et l'inverse est aussi vrai)
- Une autre raison réside dans le fait que nous devons bénéficier d'une "unité de temps" pour notre scène. (vous trouverez l'explication à cela dans la seconde partie)

Pour clore cette première partie, il nous reste à peupler notre scene d'un sol, d'un mur de cubes, d'une balle. A titre d'exemple voici le code de notre mur de cubes :

Code:

int NbsCubeSceneNode = 0;
for (float y = 0.0f; y <= 40.0f; y += 5.0f)
      {
           for (float x = -40f + y; x <= 40f - y; x += 5f)
           {
              CubeSceneNode[NbsCubeSceneNode] = device.SceneManager.AddCubeSceneNode(5, null, -1);
              CubeSceneNode[NbsCubeSceneNode].Position = new vector3d(x, y + 2.5f, 0);
              CubeSceneNode[NbsCubeSceneNode].SetMaterialTexture(0, device.VideoDriver.GetTexture("cube.jpg"));
              CubeSceneNode[NbsCubeSceneNode].SetMaterialFlag(MaterialFlag.Lighting, false);

              NbsCubeSceneNode++;
           }
       }

Rien de bien compliqué, il suffit juste d'apprécier la magie d'Irrlicht...

II) La physique

C'est bien entendu ici que réside la difficulté... Par où commencer ? Et bien nous avons deux choses à mettre en place rapidement. Il faut d'ailleurs comprendre que ces deux choses sont indépendantes pour ODE, notre librairie physique.
Il s'agit des "collisions" et des "corps".

a) Les collisions

Ces dernières peuvent se présenter sous la forme d'une boîte, d'une sphere par exemple ou bien d'un regroupement de Meshs. Dans l'espace de nom d'ODE, il s'agit des Geoms. Nous nous servirons donc de ODE.Geoms.Box et de ODE.Geoms.Sphere pour notre scène.

b) Les corps

Les corps sont plus complexes ; ils ont la charge de représenter toutes les propriétés physiques de nos objets dynamiques. (Nos cubes et notre balle dans le cas présent)

c) La création de notre physique - collisions & corps en action !

Dans la partie précédente nous avons créé nos cubes 3D à l'aide d'Irrlicht, nous devons donc créer maintenant les collisions & corps correspondants à ces cubes !

Code:

//81 cubes
int oNbsCube=0;
for (float y=0.0f;y<=40.0f;y+=5.0f)
{
  for(float x=-40f+y;x<=40f-y;x+=5f)
  {
  oBody[oNbsCube] = new Body(oWorld);
  oBody[oNbsCube].Mass = Mass.BoxTotal(5f,5,5,5);
  oBody[oNbsCube].Position = new Vector3(x,y+2.5f,0);
  oBody[oNbsCube].AutoDisable=true;
                    
  oGeomBox[oNbsCube] = new Box(5,5,5);
  oGeomBox[oNbsCube].RigidBody = oBody[oNbsCube];
  oSpace.Add(oGeomBox[oNbsCube]);
  oBody[oNbsCube].Enabled=false;
  oNbsCube++;
  }
}

d) La boucle de rendu de la physique

Il faut se poser ici les bonnes questions ; A quelle fréquence re calculer la physique ? Comment faire pour que la vitesse de jeu soit équivalente sur n'importe quel pc ?

Il n'y a pas qu'une unique et bonne façon de faire mais cela étant nous pouvons comprendre facilement que rien n'oblige à aligner la fréquence du rendu graphique avec celui de la physique. Rappelons nous que l'illusion du mouvement se produit à partir de 25 images/secondes. D'un autre côté avec une boucle rapide, la physique et les collisions seront de qualité. Il s'agit donc de tester et de choisir le meilleur compromis.

Voici notre boucle de rendu physique :

Code:

while (1 == 1)
{
  Stopwatch stopWatch = Stopwatch.StartNew();    
        
  oSpace.Collide();            
                
  oWorld.QuickStep(0.10f,10);

  oCollider.ClearContactJoints();

  if ( (vitesseBoucle - stopWatch.ElapsedMilliseconds) > 0)
  {
    try
    {
    System.Threading.Thread.Sleep((vitesseBoucle - Convert.ToInt16(stopWatch.ElapsedMilliseconds)));
    }
    catch  {}
  }

 }

Il faut comprendre à partir de ce code qu'ODE "déroule" les calculs liés à la physique étape par étape. Cela se produit avec la méthode : oWorld.QuickStep(0.10f,10);

Etant donné que nous souhaitons dérouler ces étapes de manière universelle (quelque soit le pc qui exécutera cette boucle) nous veillons à la régularité de la boucle qui s'exécutera ainsi à la fréquence précisée par la variable vitesseBoucle.

III) Conclusions et remerciements

Pour aller plus loin, il apparaitrait utile de se fabriquer une classe qui "encapsulerait" à la fois le mesh 3D d'Irrlicht, la géométrie de collision et les corps d'ODE. Avis aux codeurs intéressés ;-)

Un grand merci à Copland pour ce travail d'équipe et à DeusXL pour son wrapper aux petits oignons qui nous permet de vous proposer ici ce petit tutorial qui je l'espère vous servira pour vos réalisations personnelles.

Le source du projet : cliquer ici !


#1 

28-10-2006 15:31:14

DeusXL
Abonné
Lieu: Paris
Date d'inscription: 27-09-2006
Messages: 174

Il se trouve que j'étais sous Windows là donc j'en ai profité pour tester tout ça, c'est vraiment tout bon smile

Allez quelques petits commentaires du code :

monThreadDeRenduPhysique.Abort();


Ce thread devrait être déclaré comme un thread enfant (sauf erreur Thread.IsBackground = true, mais j'avoue ne plus me souvenir très bien) du thread principal (de rendu 3D). Ainsi, toute coupure du thread principal entraînerai le meurtre par celui-ci (kill en anglais...) du thread enfant.

GC.Collect();


Pas avec Irrlicht .NET CP, tu dois impérativement appeler "device.Dispose();" toi même à la fin de ton programme. Avec ça, toute la mémoire est libérée et surtout (surtout pensez à nous), le device libère l'espace sur Linux... Sinon on se retrouve avec la mort du serveur X qui nous oblige à le redémarrer et ça le fait rarement rire sad

Après avoir regardé ton tutoriel, j'ai l'impression que ODE est vraiment clean (j'avais trouvé Newton à la limite du bordélique) et j'aime bien la manière dont c'est fait.
D'ailleurs je n'exclue pas de m'attaquer un de ces 4 à un wrapper d'ODE qui fonctionnerait sous Nunux (d'autant plus que sauf erreur, ODE est à structure de type C donc pas besoin de faire un wrapper en C comme j'ai dû pour Irrlicht).

Dernière modification par DeusXL (28-10-2006 15:52:23)


Fanatique d'Irrlicht + Fanatique de Mono + Fanatique de Linux => Créateur d'Irrlicht .NET CP bien sûr !
Version actuelle d'Irrlicht .NET CP : 0.8, Version en test : 0.9.

Hors ligne


#2 

28-10-2006 23:00:19

kedu
Modérateur
Date d'inscription: 23-09-2006
Messages: 155

Merci d'avoir soulevé les erreurs dans le source de ce tuto ; la correction a été apportée au source et le zip mis à jour ;-)

Oui effectivement ODE est très bien pensé ; je l'ai testé également sur les joints en faisant rouler une petite voiture. Ca fonctionne pas mal je dois dire. (peut être l'objet d'un prochain tuto)

En tout cas si tu viens à te pencher sur un éventuel wrapper d'ODE multi-plateforme (je croise les doigts pour que ça arrive lol), saches qu'en ce moment avec Copland on réfléchit à quelques classes qui permettraient de lier IrrlichtCP.net à ODE.net(actuel) D'ici là il y aura peut être un retour sur expérience intéressant.

A suivre...

Hors ligne


#3 

20-03-2008 08:49:26

FMOON
Petit nouveau
Date d'inscription: 02-09-2007
Messages: 4

c'est très interesant smile
je voudrais que tu nous donne des petits ex sur les joints
je travail sur newton mais j'avais pas trouve un bon wrapper

merci d'avance

Hors ligne


Options Liens officiels Caractéristiques Statistiques Communauté
Corrections
irrlicht
irrklang
irredit
irrxml
xhtml 1.0
css 2.1
Propulsé par FluxBB
Traduit par FluxBB.fr
Analysé par
878 membres
1424 sujets
11113 messages
Dernier membre inscrit: ElmasOzer
10 invités en ligne
Aucun membre connecté
RSS Feed