Newton Game Dynamics : premier programme

#ifndef CVECTOR_H
#define CVECTOR_H

#include <GL/GL.h> // Pour les GLfloat ; vous pouvez vous passer de cette inclusion de fichier en 
                   // remplacant les GLfloat par des float

class CVector
{
   public:
      CVector ();
      CVector (const GLfloat fX, const GLfloat fY, const GLfloat fZ);
      virtual ~CVector();

      void ReglerCoordonnees (const GLfloat fX, const GLfloat fY, const GLfloat fZ);

      GLfloat x, y, z;
};

#endif // CVECTOR_H

Voici le header pour notre classe CVector. Ceci est une classe vecteur très largement simplifiée. Il est évident que dans une application plus volumineuse, il vous faudra quelque chose de plus robuste. Toutefois, elle nous suffira pour notre usage.

Nous définissons donc un constructeur CVector ne prenant aucun paramètre et un second prenant en paramètres les trois coordonnées pour initialiser notre vecteur. La fonction ReglerCoordonnnes a ce même usage. Il permet de réutiliser plusieurs fois le même objet CVector sans en recréer plusieurs.

Enfin, les trois variables sont déclarées ici public, pour un souci de simplicité.

#include "CVector.h"

CVector::CVector ()
   : x (0.0f), y (0.0f), z (0.0f)
{
   // Ne fait rien
}

CVector::CVector (const GLfloat fX, const GLfloat fY, const GLfloat fZ)
   : x (fX), y (fY), z (fZ)
{
   // Ne fait rien
}

CVector::~CVector()
{
   // Ne fait rien
}

void CVector::ReglerCoordonnees (const GLfloat fX, const GLfloat fY, const GLfloat fZ)
{
   x = fX;
   y = fY;
   z = fZ;
}

Je ne pense pas que le reste de cette classe CVector ne vous pose de problème. On se charge juste d'initialiser toutes les valeurs.

Après la classe CVector qui était pour le moins très simple, voici à présent la classe Objet. Cette classe est une classe abstraite. Les classes suivantes en hériteront.

Nous incluons en premier lieu nos fichiers à utiliser :

#include <iostream>

#include <GL/GL.h>
#include <GL/glu.h>
#include <Newton/Newton.h> // Header pour utiliser le Newton Engine
#include "CVector.h"

L'en-tête pour iostream est obligatoire sans quoi vous aurez plein de messages d'erreurs. L'inclusion de l'en-tête fichier Newton.h sera peut-être différent chez vous. Moi, dans mon dossier include, j'y ai créé un dossier Newton ou j'y ai collé le fichier header. Si vous l'avez mis dans un dossier différent du mien, vous devrez changer cette ligne. Enfin le dernier en-tête à inclure nous permet d'utiliser notre classe vecteur créée précédemment.

Nous allons également avoir besoin d'une petite structure matrice, que nous définissons juste après les différents include :

// Structure matrix
struct matrix
{
GLfloat matrice [4][4];
};

Nous utilisons des matrices OpenGL, donc de 4*4. Celle-ci nous sera obligatoire pour gérer la physique. En effet, les translations, rotations et autres scaling sont gérés grâce à la matrice. Ainsi, chaque objet aura sa propre matrice, qui sera modifiée par la bibliothèque Newton à chaque fois que la position de l'objet sera changée.

Nous définissons ensuite notre classe abstraite Objet, qui se présente comme ceci :

class Objet
{
// Fonction amie qui se chargera d'appliquer les forces à l'objet.
// Elle sera utilisée en fonction Callback par le Newton Engine
friend void ApplyForceAndTorqueCallback (const NewtonBody * nBody);

   public:
      Objet (); // Constructeur
      virtual ~Objet (); // Destructeur

      virtual void Initialiser () {};
      virtual void Dessiner () = 0; // Classe pure
      virtual void SetColor (const CVector &) = 0;

   protected:
      NewtonBody * m_pBody; // Pointeur vers un NewtonBody
      GLfloat m_masse; // Masse de l'objet
      CVector m_couleur; // Couleur de l'objet
};

Celle-ci n'a rien de très compliqué, toutefois elle a de quoi vous surprendre peut-être un peu. Nous utilisons en effet une fonction amie nommée ApplyForceAndTorqueCallback, et prenant en paramètre un pointeur vers un objet NewtonBody. En effet, la bibliothèque Newton Game Dynamics utilise des callbacks. Il s'agit en fait d'une fonction qui sera systématiquement appelée pour chaque corps à chaque boucle de l'application, sauf si l'objet est inactif ou a atteint un état d'équilibre (dixit la doc). Le paramètre est justement le corps en question.

Nous avons ensuite un constructeur, et un destructeur virtuel. Nous avons ensuite une fonction virtuelle Initialiser, une fonction virtuelle Dessiner qui est déclarée pure (qui devra donc obligatoirement être substituée dans les classes filles), ainsi qu'une autre fonction pure prenant en paramètre une référence vers un objet CVector et qui nous permettra, à travers les trois valeurs du vecteur, de spécifier la couleur de l'objet (ici, xyz = RGB).

Concernant les variables membres (attention à bien les déclarer protected et non private pour que les autres classes puissent y accéder), nous avons un pointeur m_pBody de type NewtonBody. Voici la première nouveauté ! Chaque corps devra donc posséder sa propre variable NewtonBody. Nous avons ensuite la masse de l'objet spécifiée sous le type d'un entier flottant, et enfin un objet m_couleur de type CVector pour stocker la couleur de l'objet.

En voici à présent la définition :

Objet::Objet ()
: m_pBody (NULL)
{
   // Ne fait rien
}

Objet::~Objet ()
{
   NewtonDestroyBody (NewtonBodyGetWorld (m_pBody), m_pBody);
}

Rien de bien compliqué… Nous initialisons à NULL l'objet m_pBody, tandis que le destructeur se charge de détruire le corps. À noter comment nous détruisons le corps : la fonction NewtonDestroyBody prend en paramètre un objet de type NewtonWorld * (nous le verrons plus tard), et un pointeur vers le corps en question. Le monde auquel est rattaché le corps peut-être obtenu par la fonction NewtonBodyGetWorld. C'est ce que nous faisons ici.

Concernant la fonction ApplyForceAndTorqueCallback, je vous l'expliquerai un peu plus tard…

Après nous être mis en jambe, nous allons passer à quelque chose d'un peu plus costaud, à savoir la classe que j'ai nommée Boite. Cette classe hérite de la classe Objet par un héritage public. Nous devons donc y inclure le header de cette dernière. Mais voici sans attendre cette classe Boite :

class Boite : public Objet
{
   public:
      Boite (); // Constructeur
      virtual ~Boite (); // Destructeur

      // Fonction se chargeant de l'initialisation de la boite
      virtual void Initialiser (NewtonWorld * nWorld, const CVector &, const CVector &,
      GLboolean mobile = false, GLfloat masse = 1.0f);
      virtual void Dessiner (); // Dessine l'objet
      virtual void SetColor (const CVector &); // Règle les couleurs

   private:
      CVector m_taille; // Dimensions de la boite
};

Toujours un constructeur, un destructeur. Puis la fonction Initialiser qui est un peu plus complexe. Le premier paramètre est un pointeur vers un objet de type NewtonWorld. En effet , pour initialiser un corps, nous devons la première fois le « lier » à un monde. Puis nous disposons de deux références constantes vers des objets CVector (respectivement la taille et la position). Pas de nouveauté pour le reste, si ce n'est une nouvelle variable membre, m_taille, pour spécifier la taille du cube.

Boite::Boite ()
: Objet ()
{
   // Ne fait rien
}

Boite::~Boite()
{
   // Ne fait rien, l'objet est détruit par la classe de base
}

Les constructeurs et destructeurs ne font rien de spécial, si ce n'est que le constructeur appelle celui de la classe de base. Sinon, le corps n'est pas à détruire puisqu'il est détruit par le destructeur de la classe de base.

void Boite::Initialiser (NewtonWorld * nWorld, const CVector & taille, const CVector & position, 
                     GLboolean mobile, GLfloat masse)
{
   // On initialise le vecteur de dimensions
   m_taille.x = taille.x;
   m_taille.y = taille.y;
   m_taille.z = taille.z;

   // On définit la masse de l'objet
   m_masse = masse;

   matrix matrice; // On crée une matrice

   // On initialise la matrice, qu'on définit comme matrice identité
   for (int x = 0 ; x < 4 ; ++x)
      for (int y = 0 ; y < 4 ; y++)
      {
         if (x == y)
            matrice.matrice [x][y] = 1.0f;
         else
            matrice.matrice [x][y] = 0.0f;
       }

   // On définit la matrice de manière à ce que l'objet soit placé aux positions
   // spécifiées en utilisant la dernière colonne de la matrice
   matrice.matrice [3][0] = position.x;
   matrice.matrice [3][1] = position.y;
   matrice.matrice [3][2] = position.z;

   // On initialise la boite de collision
   NewtonCollision * collision = NULL;

   // On crée la boite de collision aux dimensions de l'objet
   collision = NewtonCreateBox (nWorld, m_taille.x, m_taille.y, m_taille.z, NULL);

   // On initialise le corps avec la boite de collision
   m_pBody = NewtonCreateBody (nWorld, collision);

   if (m_pBody == NULL)
      std::cerr << "Impossible d'initialiser le corps.";

   // On détruit la boite de collision, on n'en a plus besoin
   NewtonReleaseCollision (nWorld, collision);

   // Enfin, on affecte notre matrice (qui représente donc sa position dans l'espace)
   // à notre corps grâce à la fonction NewtonBodySetMatrix
   NewtonBodySetMatrix (m_pBody, &matrice.matrice [0][0]);

   // On initialise à présent les propriétés physiques de l'objet. Toutefois, donner
   // à un objet qui ne bougera pas une masse, lui associer un callback... n'a aucun
   // intêret, on vérifie donc si l'objet sera mobile ou immobile
   if (mobile == true)
   {
      // On calcule l'inertie du corps, en passant par une petite formule
      CVector inertie;

      inertie.x = 0.7f * m_masse * (m_taille.y * m_taille.y + m_taille.z * m_taille.z) / 12;
      inertie.y = 0.7f * m_masse * (m_taille.x * m_taille.x + m_taille.z * m_taille.z) / 12;
      inertie.z = 0.7f * m_masse * (m_taille.x * m_taille.x + m_taille.y * m_taille.y) / 12;

      // On définit ensuite la masse et l'inertie pour ce corps
      NewtonBodySetMassMatrix (m_pBody, m_masse, inertie.x, inertie.y, inertie.z);

      // On règle enfin le Callback, qui sera nécessaire pour que le corps bouge
      NewtonBodySetForceAndTorqueCallback (m_pBody, ApplyForceAndTorqueCallback);
   }

   m_taille.x *= 0.5f;
   m_taille.y *= 0.5f;
   m_taille.z *= 0.5f;
}

La fonction Initialiser est déjà plus imposante ! Les commentaires devraient être suffisants, mais voici quelques compléments pour mieux saisir : la variable m_taille est initialisée avec les valeurs passées en paramètres et divisées par deux.

Nous définissons ensuite la masse avec la valeur passée en paramètre (qui est par défaut à 0.0, soit un corps fixe). On crée ensuite une matrice, que nous initialisons à la matrice identité (où m[0][0] = m[1][1] = m[2][2] = m[3][3] = 1.0). Cette matrice permettra de gérer tout ce qui concerne les transformations. Il est inutile de définir la matrice comme une variable membre, car Newton en dispose une en interne, qu'il nous suffira de récupérer. Dans une application plus sérieuse, il serait évidemment mieux de créer une jolie classe et une fonction pour directement mettre à la matrice identité.

Ensuite, nous positionnons le cube avec les valeurs passées en paramètres. En effet, la dernière colonne de la matrice est dédiée aux transformations. Ainsi la case [3][0] définit la position x, [3][1] la position y et [3][2] la position z. Nous créons ensuite un pointeur vers un objet de type NewtonCollision. Ceci nous permet de créer le rectangle (ou sphère, ou d'autres formes, voir la doc de Newton) de collision qui englobera l'objet et permettra les collisions réalistes. On l'initialise avec la valeur de retour de la fonction NewtonCreateBox. Celle-ci prend comme premier paramètre un pointeur vers un objet NewtonWorld (passé en paramètre à la fonction Initialiser), puis la taille x, y, z de l'objet. Le dernier paramètre sera spécifié NULL afin de spécifier que la boite de collision sera centrée à l'origine de la boite.

Puis on initialise le corps (la variable m_pBody) avec la fonction NewtonCreateBody qui prend comme premier paramètre le monde associé et le rectangle de collision associé que nous avons créés précédemment. On vérifie ensuite que l'allocation s’est bien réalisée en testant le pointeur vers le corps. Si le pointeur vaut NULL, alors on écrit dans un fichier d'erreur. Il ne faut ensuite pas oublier de libérer l'objet de collision avec la fonction NewtonReleaseCollision. À noter qu'un même rectangle de collision peut-être utilisé plusieurs fois pour un même d'objet s'il possède la même taille.

Nous avons notre corps, nous lui assignons à présent sa propre matrice (qui définit donc sa position dans l'espace) avec la fonction NewtonBodySetMatrix, qui prend en premier paramètre le corps en question et en second la matrice.

On vérifie ensuite le booléen « mobile ». Les commentaires sont, je pense, assez explicites. Ceci permet d'éviter quelques appels de fonctions inutiles. Calculer ses valeurs d'inertie, lui affecter un callback… n'est d'aucune utilité si l'objet ne bouge pas. En revanche, s'il bouge, c'est très important ! Pour cette tâche, nous créons le vecteur d'inertie. Puis nous l'initialisons avec quelques calculs. Spécifier de bonnes valeurs pour l'inertie est important pour que le corps réagisse de manière réaliste. D'après la définition de Wikipédia : « L'inertie d'un corps découle de la nécessité d'exercer une force sur celui-ci pour modifier sa vitesse (vectorielle). Ainsi, un corps immobile ou en mouvement rectiligne uniforme (se déplaçant sur une droite à vitesse constante) n'est soumis à aucune force, et réciproquement. » Concernant le calcul, je l'ai retiré des exemples des tutoriels livrés avec le SDK. Contentez-vous de les appliquer.

Bref, une fois que nous avons tout ça, nous pouvons enfin dire à notre corps sa masse et son inertie (nul doute qu'il est très heureux !) grâce à la fonction NewtonBodySetMassMatrix. La fonction prend un pointeur vers le corps, puis la masse et les trois valeurs de l'inertie. Pour finir, nous appliquons à notre corps le fameux callback. Rappelons-le, la fonction spécifiée en callback sera appelée à chaque boucle pour effectuer les mises à jour sur le corps, jusqu'à ce qu'il soit immobile. On utilise pour cela la fonction NewtonBodySetForceAndTorqueCallback (rien que ça !). Celle-ci prend en premier paramètre le pointeur vers le corps et un pointeur de fonction vers notre fonction ApplyForceAndTorqueCallback (je l'ai appelée comme ça, mais vous pouvez l'appeler Force ou n'importe quel nom…).

Une petite précision : comme nous l'avons vu au-dessus, certains corps ne bénéficieront donc pas de callbacks (les objets immobiles). En effet, Newton peut également être utilisé comme un simple moteur de collisions, sans la gestion de la force. Il est donc tout à fait possible de ne spécifier qu'un simple rectangle de collision sans spécifier de callback.

C'en est fini avec notre if, toutefois il nous reste une dernière chose à régler. Nous allons diviser par deux toutes les tailles (donc x, y, z), de notre cube. En effet, lorsque nous dessinerons notre cube, nous ferons par exemple : glVertex3f (-m_taille.x, m_taille.y, m_taille.z). Nous dessinerons « des deux côtés », ainsi sur un carré de 1 de côté, nous dessinerons 0.5 à gauche et 0.5 à droite, plutôt que partir d'un point 0 et tracer jusqu'à 1.0. Si nous faisons ceci, les collisions ne marcheront pas (pour revenir sur un côté de 1.0, Newton délimite le rectangle de collision de manière à ce qu'il y ait 0.5 à gauche et 0.5 à droite, ce qui nous donne bien 1, plutôt que de tracer de 0.0 à 1.0 d'un coup). J'espère que je suis assez clair. Vous n'aurez qu'à faire quelques modifs sur ces lignes, vous comprendrez.

void Boite::SetColor (const CVector & couleur)
{
   m_couleur.x = couleur.x / 255;
   m_couleur.y = couleur.y / 255;
   m_couleur.z = couleur.z / 255;
}

La fonction SetColor n'a pas besoin de trop d'explications, je pense. Si ce n'est que nous divisons les valeurs par 255 pour se retrouver avec les valeurs en tant que float plutôt qu'en unsigned byte lors de l'appel à glColor.

void Boite::Dessiner ()
{
   // Toutes les modifications effectuées dans le Callback modifient la matrice de
   // l'objet, ce qui permet à l'objet de "bouger"
   matrix matrice;
   NewtonBodyGetMatrix (m_pBody, &matrice.matrice [0][0]);

   glPushMatrix (); // On sauvegarde la matrice actuelle
   {
      glMultMatrixf (&matrice.matrice [0][0]); // On multiplie la matrice actuelle
                                               // par la matrice du corps, ainsi
                                               // le corps sera dessiné au bon endroit
      glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
      glColor3f (m_couleur.x, m_couleur.y, m_couleur.z);
      glColorMaterial (GL_FRONT_AND_BACK, GL_SPECULAR);
      glColor3f (1.0f, 1.0f, 1.0f);
      glColorMaterial (GL_FRONT_AND_BACK, GL_EMISSION);
      glColor3f (0.0f, 0.0f, 0.0f);
      glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, 128);

      glBegin(GL_QUADS);
         // Devant
         glNormal3f (0.0f, 0.0f, 1.0f);
         glVertex3f (-m_taille.x, -m_taille.y, m_taille.z);
         glVertex3f (m_taille.x, -m_taille.y, m_taille.z);
         glVertex3f (m_taille.x, m_taille.y, m_taille.z);
         glVertex3f (-m_taille.x, m_taille.y, m_taille.z);

         // Derrière
         glNormal3f (0.0f, 0.0f, -1.0f);
         glVertex3f (-m_taille.x, -m_taille.y, -m_taille.z);
         glVertex3f (-m_taille.x, m_taille.y, -m_taille.z);
         glVertex3f (m_taille.x, m_taille.y, -m_taille.z);
         glVertex3f (m_taille.x, -m_taille.y, -m_taille.z);

         // Haut
         glNormal3f (0.0f, 1.0f, 0.0f);
         glVertex3f (-m_taille.x, m_taille.y, -m_taille.z);
         glVertex3f (-m_taille.x, m_taille.y, m_taille.z);
         glVertex3f (m_taille.x, m_taille.y, m_taille.z);
         glVertex3f (m_taille.x, m_taille.y, -m_taille.z);

         // Bas
         glNormal3f (0.0f, -1.0f, 0.0f);
         glVertex3f (-m_taille.x, -m_taille.y, -m_taille.z);
         glVertex3f (m_taille.x, -m_taille.y, -m_taille.z);
         glVertex3f (m_taille.x, -m_taille.y, m_taille.z);
         glVertex3f (-m_taille.x, -m_taille.y, m_taille.z);

         // Droite
         glNormal3f (1.0f, 0.0f, 0.0f);
         glVertex3f (m_taille.x, -m_taille.y, -m_taille.z);
         glVertex3f (m_taille.x, m_taille.y, -m_taille.z);
         glVertex3f (m_taille.x, m_taille.y, m_taille.z);
         glVertex3f (m_taille.x, -m_taille.y, m_taille.z);

         // Gauche
         glNormal3f (-1.0f, 0.0f, 0.0f);
         glVertex3f (-m_taille.x, -m_taille.y, -m_taille.z);
         glVertex3f (-m_taille.x, -m_taille.y, m_taille.z);
         glVertex3f (-m_taille.x, m_taille.y, m_taille.z);
         glVertex3f (-m_taille.x, m_taille.y, -m_taille.z);
      glEnd ();
   }
   glPopMatrix (); // On rétablit la matrice
}

Voilà enfin la fonction qui sert à dessiner tout ce beau monde. Nous commençons en premier lieu par récupérer la nouvelle matrice de l'objet (et par conséquent, sa position…) avec la fonction NewtonBodyGetMatrix. Nous lui passons en second paramètre notre matrice afin qu'elle la mette à jour. Cette étape est importante. En effet, le callback a directement modifié la matrice de l'objet, et il nous faut la récupérer afin de dessiner l'objet au bon endroit.

On sauvegarde ensuite la matrice actuelle, puis on la multiplie avec la matrice du corps. On spécifie les couleurs avec la fonction glColorMaterial puis on dessine l'objet. Enfin, on rétablit la matrice. Alors, ce n’est pas si compliqué ?