[OPENGL] Première application avec Newton Engine

**Bakura** · 28/09/2006, 22h44

Voilà, une petite source sur comment créer une petite scène avec un sol et plusieurs cubes tombant, grâce au moteur Newton Game Dynamics. Je pense que ça peut servir aux débutants, je trouve que la doc officielle est assez dur à utiliser (dans le sens ou elle fait appel à pleins d'autres classes,...). Je dois aller me coucher, je reviendrai demain corriger quelques trucs, en tout cas voici les sources (si quelqu'un veut que je fasse quelque chose de plus consistant pour mettre sur le site, avec des commentaires et tout, ya pas de problème, je peux faire ça

).

NB : j'ai volontairement créer une classe CVector simpliste plutôt qu'une structure, la seule méthode que j'ai trouvé pour passer une structure en paramètre est vraiment crado.

NB 2 : La génération des nombres aléatoires ne semblent pas marcher, je verrais ça demain.

NB 3 : J'utilise la SDL ainsi que le SDL_framerate (la lib sdl_gfx, merci fearyourself, j'ai connu ça grâce à ton tuto, c'est bien pratique !) :

MISE A JOUR 1 : la génération de chiffres aléatoires marche correctement. On a donc à chaque lancement un résultat différent.

MISE A JOUR 2 : création d'une classe virtuelle pure Objet (fait à la va vite, désolé si c'est pas très propre !), puis une classe Boite et Sphere qui en hérite. Ainsi on a des boites ET des sphères, ca fait vraiment très joli ^^

MISE A JOUR 3 : ajout des couleurs comme demandé !

main.cpp :

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
 
#include <iostream>
#include <ctime>
#include <SDL/SDL.h>
#include <GL/glew.h>
#include <SDL/SDL_framerate.h>
#include "Boite.h"
 
void Render ();
void Prepare ();
void InitSDL ();
void InitOGL ();
void InitScene ();
void Shutdown ();
void DessinerCube ();
void GetFPS ();
 
int main (int argc, char *argv [])
{
   InitSDL();
   InitOGL();
 
   SDL_Event event;
   bool bQuit = false;
 
   FPSmanager manager;
   SDL_initFramerate (&manager);
   SDL_setFramerate (&manager, 80); // On limite le fps à 60 img/s
 
   while (!bQuit)
   {
      Prepare ();
      Render ();
 
      SDL_framerateDelay (&manager);
 
      GetFPS ();
 
      if (SDL_PollEvent (&event))
      {
         switch (event.type)
         {
            case SDL_QUIT:
               Shutdown ();
               bQuit = true;
               break;
            default:
               break;
         }
      }
   }
 
   return EXIT_SUCCESS;
}
 
void GetFPS ()
{
   static char titleBar[25] = {0};
   static int FPS = 0;
   float nextSecond = 0.0f;
   static float prevSecond = 0.0f;
 
   FPS++;
 
   nextSecond = SDL_GetTicks() * 0.001f;
 
   if (nextSecond - prevSecond > 1.0f)
   {
         prevSecond = nextSecond;
 
         sprintf(titleBar, "%d FPS", FPS);
 
         SDL_WM_SetCaption (titleBar, NULL);
 
         FPS = 0;
   }
}
 
void InitSDL ()
{
   // Initialisation de SDL
   SDL_Init (SDL_INIT_VIDEO);
 
   SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); // On active le double buffering
 
   SDL_Surface * pEcran = SDL_SetVideoMode (640, 480, 32, SDL_OPENGL);
 
   if (pEcran == NULL)
   {
      std::cerr << "Erreur au paramètrage vidéo : " << SDL_GetError ();
   }
 
   atexit (SDL_Quit);
}
 
 
// PARTIE OPENGL
 
const GLint NOMBRE_BOITES = 30;
const GLint NOMBRE_SPHERES = 30;
 
// Variables globales pour Newton
NewtonWorld * nWorld = NULL; // Monde
Sphere * spheres [NOMBRE_SPHERES];
Boite * sol = NULL; // Pointeur vers un objet sol représentant,... le sol !
Boite * boites [NOMBRE_BOITES]; // Pointeur vers un objet boite1 représentant,... une boîte !
 
void InitNewton ();
 
void InitOGL ()
{
   glClearColor(0.0, 0.0, 0.3, 0.0);
   glClearDepth(1.0);
 
   GLenum err = glewInit();
 
   if (GLEW_OK != err)
      std::cerr << "Erreur dans GLEW.";
 
   glViewport (0, 0, 640, 480); // On règle le Viewport
 
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
   gluPerspective (60.0, 640.0 / 480.0, 0.1, 1000.0);
 
   glMatrixMode (GL_MODELVIEW);
   glLoadIdentity (); // On rétablit la matrice identité
 
   glEnable (GL_DEPTH_TEST);
   glEnable (GL_COLOR_MATERIAL);
   glEnable (GL_LIGHTING);
 
   glEnable (GL_LIGHT0);
   GLfloat LampeDiffuse [] = {1.0f, 1.0f, 1.0f};
   GLfloat LampeAmbient [] = {0.75f, 0.75f, 0.75f};
   GLfloat LampePosition [] = {6.0f, 10.0f, 5.0f, 1.0f};
 
   glLightfv (GL_LIGHT0, GL_DIFFUSE, LampeDiffuse);
   glLightfv (GL_LIGHT0, GL_SPECULAR, LampeDiffuse);
   glLightfv (GL_LIGHT0, GL_AMBIENT, LampeAmbient);
   glLightfv (GL_LIGHT0, GL_POSITION, LampePosition);
 
   // On initialise Newton
   InitNewton ();
}
 
void Prepare ()
{
   static GLfloat tempsPrecedent = 0.0f;
   GLfloat tempsActuel = 0.0f;
 
   tempsPrecedent = SDL_GetTicks () - tempsPrecedent;
   tempsActuel = SDL_GetTicks ();
 
   NewtonUpdate (nWorld, (tempsActuel - tempsPrecedent));
}
 
void Render ()
{
   glClearColor(0.0f, 0.0, 0.3, 0.0);
   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glLoadIdentity ();
 
   gluLookAt (0.0f, 0.0f, 20.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
 
   // Puis quelques rotations afin de bien voir le sol
   glRotatef(15, 1, 0, 0);
   glRotatef(45, 0, 1, 0);
 
   // On va d'abord dessiner le sol
   glColor3f (1.0f, 0.0f, 0.0f);
 
   sol->Dessiner ();
 
   // Puis la boîte
   for (int i = 0 ; i < NOMBRE_BOITES ; i++)
   {
      glColor3f (0.0f, 0.0f, 1.0f);
      boites [i]->Dessiner ();
   }
 
   for (int i = 0 ; i < NOMBRE_SPHERES ; i++)
   {
      spheres [i]->Dessiner ();
   }
 
   SDL_GL_SwapBuffers();
}
 
void Shutdown ()
{
   delete sol, sol = NULL;
 
   for (int i = 0 ; i < NOMBRE_BOITES ; i++)
      delete boites [i], boites [i] = NULL;
 
   for (int i = 0 ; i < NOMBRE_SPHERES ; i++)
      delete spheres [i], spheres [i] = NULL;
 
   NewtonDestroy (nWorld);
}
 
void InitNewton ()
{
   nWorld = NewtonCreate (NULL, NULL); // On initialise nWorld
 
   // On définit le sol
   CVector taille (10.0f, 0.5f, 10.0f);
   CVector position (-5.0f, 0.0f, 0.0f);
   CVector couleur (100, 100, 100);
 
   // On alloue la mémoire. Le troisième argument est false pour signifier qu'il sera
   // immobile et donc ne bougera pas
   sol = new Boite ();
   sol->SetColor (couleur);
   sol->Initialiser (nWorld, taille, position, false, 0.0f);
 
   srand (time (NULL));
 
   // A présent le cube
   for (int i = 0 ; i < NOMBRE_SPHERES ; i++)
   {
      GLfloat x, y, z;
      x = -10 + rand()%15;
      y = 1 + rand()%10;
      z = -10 + rand()%15;
 
      position.ReglerCoordonnees (x, y, z);
 
      // On sélectionne les trois couleurs
      couleur.x = rand() % 256;
      couleur.y = rand() % 256;
      couleur.z = rand() % 256;
 
      spheres [i] = new Sphere ();
      spheres [i]->Initialiser (nWorld, 1.0f, position, true, 15.0f);
      spheres [i]->SetColor (couleur);
   }
 
   // A présent le cube
   for (int i = 0 ; i < NOMBRE_BOITES ; i++)
   {
      GLfloat x, y, z;
      x = -10 + rand()%15;
      y = 1 + rand()%10;
      z = -10 + rand()%15;
 
      taille.ReglerCoordonnees (1.0f, 1.0f, 1.0f);
      position.ReglerCoordonnees (x, y, z);
 
      // On sélectionne les trois couleurs
      couleur.x = rand() % 256;
      couleur.y = rand() % 256;
      couleur.z = rand() % 256;
 
      boites [i] = new Boite ();
      boites [i]->Initialiser (nWorld, taille, position, true, 10.0f);
      boites [i]->SetColor (couleur);
   }
}

Boite.h :

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#ifndef BOITE_H
#define BOITE_H
 
#include <GL/glew.h>
#include <Newton/Newton.h> // Fichier d'include pour utiliser le Newton Engine
#include "CVector.h"
 
// Structure matrix
typedef struct
{
   GLfloat matrice [4][4];
} matrix;
 
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 () {}; // Classe pure
      virtual void Dessiner () = 0;
      virtual void SetColor (const CVector &) = 0;
 
   protected:
      NewtonBody * m_pBody; // Pointeur vers un NewtonBody
      matrix m_matrice; // Matrice de l'objet (pour sa position)
      GLfloat m_masse; // Masse de l'objet
      CVector m_couleur; // Couleur de l'objet
};
 
class Boite : public Objet
{
   public:
      Boite (); // Constructeur
      virtual ~Boite (); // Destructeur
 
      // Fonction se chargeant de l'initialisation de la boîte
      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 boîte
};
 
class Sphere : public Objet
{
   public:
      Sphere (); // Constructeur
      virtual ~Sphere (); // Destructeur
 
      // Fonction se chargeant de l'initialisation de la boîte
      virtual void Initialiser (NewtonWorld * nWorld, GLfloat, 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:
      GLfloat m_rayon;
      GLUquadric * m_sphere;
};
 
#endif // BOITE_H

Boite.cpp :

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
#include "Boite.h"
 
void ApplyForceAndTorqueCallback (const NewtonBody * nBody)
{
   // Cette fonction est une fonction Callback. Elle sera appelée à chaque fois
   // qu'une modification aura lieu sur le corps
   // On récupère en premier lieu la masse ainsi que l'inertie
   GLfloat masse; // Contiendra la masse de l'objet pris en paramètre par la fonction
   CVector inertie; // Contiendra l'inertie du corps
   CVector force; // Spécifiera la force appliquée sur le corps
 
   NewtonBodyGetMassMatrix (nBody, &masse, &inertie.x, &inertie.y, &inertie.z);
 
   force.x = 0.0f;
   force.y = -masse * 9.81; // 9.81 est l'attraction gravitationnelle de la Terre
   force.z = 0.0f;
 
   NewtonBodyAddForce (nBody, &force.x); // On ajoute la force au corps
}
 
 
Objet::Objet ()
   : m_pBody (NULL)
{
   // Ne fait rien
}
 
Objet::~Objet ()
{
   NewtonDestroyBody (NewtonBodyGetWorld (m_pBody), m_pBody);
}
 
Boite::Boite ()
   : Objet (), m_taille (NULL)
{
   // Ne fais rien
}
 
Boite::~Boite()
{
   // Ne fait rien, l'objet est détruit par 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 = new CVector (taille.x, taille.y, taille.z);
   m_taille->x *= 0.5f;
   m_taille->y *= 0.5f;
   m_taille->z *= 0.5f;
 
   // On définit la masse de l'objet
   m_masse = masse;
 
   // On initialise la matrice, qu'on définit comme matrice identité
   m_matrice.matrice [0][0] = m_matrice.matrice [1][1] = m_matrice.matrice [2][2] =
   m_matrice.matrice [3][3] = 1.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
   m_matrice.matrice [3][0] = position.x;
   m_matrice.matrice [3][1] = position.y;
   m_matrice.matrice [3][2] = position.z;
 
   // On initialise la collision box
   NewtonCollision * collision = NULL;
 
   // On créé la collision box aux dimensions de l'objet
   collision = NewtonCreateBox (nWorld, m_taille->x * 2, m_taille->y * 2, m_taille->z * 2, NULL);
 
   // On initialise le corps avec la collision box
   m_pBody = NewtonCreateBody (nWorld, collision);
 
   // On détruit la collision box, on n'en a plus besoin
   NewtonReleaseCollision (nWorld, collision);
 
   // Enfin, on assigne notre matrix (qui représente donc sa position dans l'espace)
   // à notre corps grâce à la fonction NewtonBodySetMatrix
   NewtonBodySetMatrix (m_pBody, &m_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 calcul 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);
   }
}
 
void Boite::SetColor (const CVector & couleur)
{
   m_couleur.x = couleur.x / 255;
   m_couleur.y = couleur.y / 255;
   m_couleur.z = couleur.z / 255;
}
 
void Boite::Dessiner ()
{
   // Toutes les modifications effectuées dans le Callback modifient la matrice de
   // l'objet, ce qui permet à l'objet de "bouger"
   NewtonBodyGetMatrix (m_pBody, &m_matrice.matrice [0][0]);
 
   glPushMatrix (); // On sauvegarde la matrice actuelle
      glMultMatrixf (&m_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
}
 
Sphere::Sphere ()
   : Objet (), m_sphere (NULL)
{
   // Ne fais rien
}
 
Sphere::~Sphere()
{
   gluDeleteQuadric (m_sphere);
}
 
void Sphere::Initialiser (NewtonWorld * nWorld, const GLfloat rayon,
                         const CVector position, GLboolean mobile, GLfloat masse)
{
   // On initialise la sphere
   m_sphere = gluNewQuadric ();
 
   m_rayon = rayon;
 
   // On définit la masse de l'objet
   m_masse = masse;
 
   // On initialise la matrice, qu'on définit comme matrice identité
   m_matrice.matrice [0][0] = m_matrice.matrice [1][1] = m_matrice.matrice [2][2] =
   m_matrice.matrice [3][3] = 1.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
   m_matrice.matrice [3][0] = position.x;
   m_matrice.matrice [3][1] = position.y;
   m_matrice.matrice [3][2] = position.z;
 
   // On initialise la collision box
   NewtonCollision * collision = NULL;
 
   // On créé la collision box aux dimensions de l'objet
   collision = NewtonCreateSphere (nWorld, m_rayon, m_rayon, m_rayon, NULL);
 
   // On initialise le corps avec la collision box
   m_pBody = NewtonCreateBody (nWorld, collision);
 
   // On détruit la collision box, on n'en a plus besoin
   NewtonReleaseCollision (nWorld, collision);
 
   // Enfin, on assigne notre matrix (qui représente donc sa position dans l'espace)
   // à notre corps grâce à la fonction NewtonBodySetMatrix
   NewtonBodySetMatrix (m_pBody, &m_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 calcul l'inertie du corps, en passant par une petite formule
      CVector inertie;
 
      inertie.x = inertie.y = inertie.z = 0.f * m_masse * rayon * rayon;
 
      // 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);
   }
}
 
void Sphere::SetColor (const CVector & couleur)
{
   m_couleur.x = couleur.x / 255;
   m_couleur.y = couleur.y / 255;
   m_couleur.z = couleur.z / 255;
}
 
void Sphere::Dessiner ()
{
   // Toutes les modifications effectuées dans le Callback modifient la matrice de
   // l'objet, ce qui permet à l'objet de "bouger"
   NewtonBodyGetMatrix (m_pBody, &m_matrice.matrice [0][0]);
 
   glPushMatrix (); // On sauvegarde la matrice actuelle
      glMultMatrixf (&m_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);
      gluSphere (m_sphere, m_rayon, 50, 50);
   glPopMatrix (); // On rétablit la matrice
}

CVector.h :

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
 
#ifndef CVECTOR_H
#define CVECTOR_H
 
#include <GL/glew.h>
 
class CVector
{
   public:
      CVector ();
      CVector (const GLfloat iX, const GLfloat iY, const GLfloat iZ);
      virtual ~CVector();
 
      void ReglerCoordonnees (const GLfloat iX, const GLfloat iY, const GLfloat iZ);
 
      GLfloat x, y, z;
};
 
#endif // CVECTOR_H

CVector.cpp :

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
#include "CVector.h"
 
CVector::CVector ()
   : x (0.0f), y (0.0f), z (0.0f)
{
   // Ne fait rien
}
 
CVector::CVector (const GLfloat iX, const GLfloat iY, const GLfloat iZ)
   : x (iX), y (iY), z (iZ)
{
   // Ne fait rien
}
 
CVector::~CVector()
{
   // Ne fait rien
}
 
void CVector::ReglerCoordonnees (const GLfloat iX, const GLfloat iY, const GLfloat iZ)
{
   x = iX;
   y = iY;
   z = iZ;
}

Screenshots :

Couleurs :

NB : ca tourne bien à 80 fps comme précisé avec la lib SDL_framerate, mais il faut quelques secondes à la fenetre pour se mettre à 80 fps...

**fearyourself** · 01/10/2006, 02h53

Est-ce possible (bien que pas obligatoire de mettre des couleurs aléatoires aux objets) ?

Cela rendrait l'esthétique de la scéne nettement plus sympa

Sinon bon boulot, je regarderais le code dès que j'ai un moment,
Jc

**Bakura** · 01/10/2006, 09h15

Pas de problème, je fais ça demain.

**Bakura** · 01/10/2006, 20h51

Voila, les couleurs sont ajoutés ! J'ai fait ça à l'arrache hein, ca montre vite les limites du programme (je tourne même pas aux 80 fps maximums sur mon PC, à 78-77

).

Sinon on remarque mieux avec les couleurs que certaines formes "rentrent" les unes dans les autres. C'est tout simplement que le champ de chiffre aléatoire est trop faible comparé aux nombres d'objets affichés, et certains "naissent" avec certaines coordonnées identiques.

**Bakura** · 02/10/2006, 20h09

Là avant de me replonger dans les autres fonctionnalités de Newton, je dois me mettre aux loader de fichiers 3D (j'aimerais commencer à créer un petit jeu quand même, depuis le temps

), mais si Laurent Gomila tu es intéressé pour que je fasse de ce code un petit tuto tu me le dis hein ^^.

**Laurent Gomila** · 02/10/2006, 20h15

mais si Laurent Gomila tu es intéressé pour que je fasse de ce code un petit tuto tu me le dis hein ^^

Si tu as le temps et que tu penses avoir suffisamment de recul pour en rédiger un bon tutoriel, je suis évidemment intéressé, et je ne serai pas le seul je pense

**Bakura** · 02/10/2006, 20h29

Envoyé par Laurent Gomila

Si tu as le temps et que tu penses avoir suffisamment de recul pour en rédiger un bon tutoriel, je suis évidemment intéressé, et je ne serai pas le seul je pense

Ok, j'essayerai de faire ça et je t'enverrai pour que tu me dises ce que tu en penses. Pas avant quelques jours tout de même, j'ai bcp de travail à l'école ces temps-ci

!

**Happy** · 11/10/2006, 20h56

Salut,

Vraiment sympa de ta part de nous aider avec ngd

.
Moi je serait intéréssé pour quand tu finira la partie de construction de mesh_statiques

Tu vas utiliser quel loader3d pour le tuto?

Si tu vas utiliser celuici , tu as déja le code source que j'ai mis ici pour créer les objets convexes 3d chargés avec ce loader 3ds lol.
Voici pour les intéréssés une tite video que j'ai fait, ce que ca donne les convex hulls,

:
video - link

**Bakura** · 11/10/2006, 21h45

As toi aussi tu utilises NGD ^^...

Pour l'instant je reste qu'avec la scène basique du code, j'ai écrit un tuto qui devrait normalement passer sur le site. Je pense en effet faire un prochain tutorial avec des fichiers 3D. Le truc c'est que pour l'instant je galère pour les charger. Merci pour le loader 3DS, je vais l'analyser, mais j'aime bien comprendre, donc en fait tant que je comprendrai pas parfaitement le loader, je reviendrai pas sur Newton ^^.

Donc un peu de patience, mais en tout cas je suis content, je suis quais le seul à avoir fait un truc sur ce super moteur physique !.

Par contre comment fait tu pour afficher les rectangles de collision des models ?

**Happy** · 11/10/2006, 22h10

Alors pour afficher un mode de débug avec NGD, j'utilise ce code;
Il vient de la lecon n* 7 du pack.

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
// ...
 
 
/// MAIN () ///
//{
 
  // ...
 int defaultID = NewtonMaterialGetDefaultGroupID (world);
 
int hightMap_debugCount;
dVector hightMap_debugLines[1024][2];
 
int  GenericContactBegin (const NewtonMaterial* material, const NewtonBody* body0, const NewtonBody* body1)
{
	// return one the tell Newton the application wants to proccess this contact
	return 1;
}
 
int  GenericContactProcess (const NewtonMaterial* material, const NewtonContact* contact)
{
	dFloat speed0;
	dFloat speed1;
	dVector normal;
 
	// Get the maximum normal speed of this impact. this can be used for positioning collision sound
	speed0 = NewtonMaterialGetContactNormalSpeed (material, contact);
 
	// get the maximum of the two sliding contact speed
	speed0 = NewtonMaterialGetContactTangentSpeed (material, contact, 0);
	speed1 = NewtonMaterialGetContactTangentSpeed (material, contact, 1);
	if (speed1 > speed0) {
		speed0 = speed1;
	}
 
	// the application can implement some kind of contact debug here
	if (show_debug) {
		if (hightMap_debugCount < 1024)
		{
			dVector point;
			dVector normal;
			NewtonMaterialGetContactPositionAndNormal (material, &point.m_x, &normal.m_x);
			hightMap_debugLines[hightMap_debugCount][0] = point;
			hightMap_debugLines[hightMap_debugCount][1] = point + normal.Scale (-3.0f);
			hightMap_debugCount++;
		}
	}
 
 
	// return one to tell Newton we want to accept this contact
	return 1;
}
 
// this function is call after all contacts for this pairs is processed
void  GenericContactEnd (const NewtonMaterial* material)
{
	#define MIN_CONTACT_SPEED 15
	#define MIN_SCRATCH_SPEED 5
}
 
static void DebugShowGeometryCollision(const NewtonBody* body, int vertexCount, const dFloat* faceVertec, int id)
{
	int i;
 
	i = vertexCount - 1;
	dVector p0 (faceVertec[i * 3 + 0], faceVertec[i * 3 + 1], faceVertec[i * 3 + 2]);
	for (i = 0; i < vertexCount; i ++) {
		dVector p1 (faceVertec[i * 3 + 0], faceVertec[i * 3 + 1], faceVertec[i * 3 + 2]);
		glVertex3f (p0.m_x, p0.m_y, p0.m_z);
		glVertex3f (p1.m_x, p1.m_y, p1.m_z);
 		p0 = p1;
	}
}
 
void  DebugShowBodyCollision (const NewtonBody* body)
{
	NewtonBodyForEachPolygonDo (body, DebugShowGeometryCollision);
}
 
static void  DebugShowCollision ()
{
	glDisable (GL_LIGHTING);
	glDisable(GL_TEXTURE_2D);
 
	glBegin(GL_LINES);
	glColor3f(1.0f, 1.0f, 0.0f);
	NewtonWorldForEachBodyDo (world, DebugShowBodyCollision);
	for (int i = 0; i < hightMap_debugCount; i ++)
	{
	    glColor3f(0,1,0);
		glVertex3f (hightMap_debugLines[i][0].m_x, hightMap_debugLines[i][0].m_y, hightMap_debugLines[i][0].m_z);
		glColor3f(1,1,1);
		glVertex3f (hightMap_debugLines[i][1].m_x, hightMap_debugLines[i][1].m_y, hightMap_debugLines[i][1].m_z);
	}
	glEnd();
	hightMap_debugCount = 0;
}
 
    /// LOOP ( boucle) ///
    {
       // ...
       glPolygonOffset(1,1);
       glEnable(GL_POLYGON_OFFSET_FILL);
       DebugShowCollision();
       // ...
   }
}

**Bakura** · 11/10/2006, 22h16

Merci ^^...

En tout cas je galère trop pour les models 3D, ça m'énèrve comme pas possible

! Je suis complètement perdu,... On m'a dit sur Gamedev qu'il était pratique de créer son format pour plus de facilité, mais je sais pas comment faire, et puis ça a l'air chiant (créer des exporters, je sais pas quoi,...)... Quant aux formats existants, MD2 c'est pas top niveua rendu, 3DS c'est trop complexe,... Et je trouve souvent que du code, sans explication...

fait chier

.

**Happy** · 11/10/2006, 23h00

Ben en fait c'est bien une longue route d'aventure qu'est de créer son propre loader de fichiers 3d + un plug-in d'export depuis ton modeleur, enfin bref

Moi franchement un laoder tout fait me satisfait plus que tout

Puis ce laoder 3ds, j'ai déja le code (pour créer le mesh_statique) qui m'as était donné sur le forum anglais, mais le truc c'est que ce loader charge 3 fois le modele! Pour avoir les 3 UP (axes), ce qui donne encore plus mal de tete quand on veut travailler avec

, mais une fois implémenté c'est que du bonheur

Et pour le code de debug, on peut normallement l'utiliser meme qu'avec une simple boite et un plane

(comme ca, si un nouveau sur ngd lis ceci, il le sera lol

)

**Bakura** · 22/10/2006, 22h16

Hop ^^

Voilà j'ai enfin réussi à faire un loader 3d fonctionnel (bon pour l'instant il est minimal, il charge vertices, normales, textures, faces avec quads, avec triangles, et c'est tout ^^).

J'ai pu essayer les CollisionTree, j'ai encore un petit problème mais ça marche plutôt bien, et c'est vraiment d'une facilité déconcertante

.

Mais d'après ce que j'ai compris sur la doc et mes petits tests, les collision tree ne sont pas pour les models mobiles, c'est que pour les trucs statics (un terrain,...).

Visibielment pour ça ce sont les convex hull !

**Happy** · 23/10/2006, 15h55

Excellent!

-J'ai trouvé aussi la solution pour le static user_mesh qui se passe comme ceci:
.Pour les objets 3d (convex_hull) qui bougent/colisionnent j'utilise le loader 3ds,
mais pour le static user_mesh je charge la map de collision avec un loader ASE juste pour la passer a newton game dynamcis (c'est plus facile à implementer qu'avec le 3ds), mais j'affiche toujours avec le loader 3ds qui est beaucoup plus rapide

)
.J'ai pu lire que c'est la meilleure solution que d'utiliser les convex_hull pour les objets complexes qui bougent

PS: As-tu essayé la technique de bouger les objets avec la mouse?

**Bakura** · 23/10/2006, 17h20

Pour l'instant je n'utilise que le loader ASE, c'est bien plus simple

.

Donc d'après ce que j'ai compris, les collisiontree c'est pour les décors (en tout cas c'est d'une simplicité déconcertante à mettre en oeuvre !), et pour les objets mouvants les convex hull !... Je règle quelques problèmes pour les collision tree, je poste une petite vidéo et je fais un tuto (alors Laurent, le premier ?

)

**Bakura** · 25/10/2006, 20h30

Trop content, mon loader ASE est presque fini ^^. J'ai implémenté aujourd'hui la possibilité de charger un modèle contenant plusieurs objets, je vais pouvoir m'amuser à afficher des niveaux !! Me reste plus qu'à gérer les textures pour quand il y a plus de deux objets, ajouter des normales aux objets ne les ayant pas, et le VBO ^^... Après j'essayerai Newton avec des niveaux plus complexes et je me remettrai sur mon problème que j'ai eu avec les collision tree !.

En tout cas quel fierté ! jamais j'aurais imaginer que j'arriverais à faire un loader rien qu'avec une doc du format

, sans aucune aide

.

**fearyourself** · 26/10/2006, 09h30

Envoyé par Bakura

Trop content, mon loader ASE est presque fini ^^. J'ai implémenté aujourd'hui la possibilité de charger un modèle contenant plusieurs objets, je vais pouvoir m'amuser à afficher des niveaux !! Me reste plus qu'à gérer les textures pour quand il y a plus de deux objets, ajouter des normales aux objets ne les ayant pas, et le VBO ^^... Après j'essayerai Newton avec des niveaux plus complexes et je me remettrai sur mon problème que j'ai eu avec les collision tree !.

Bon boulot, c'est pas une mince affaire

En tout cas quel fierté ! jamais j'aurais imaginer que j'arriverais à faire un loader rien qu'avec une doc du format

, sans aucune aide

.

Bienvenue dans le vrai monde de l'informatique.

Jc

**Bakura** · 26/10/2006, 10h24

Bienvenue dans le vrai monde de l'informatique.

C'est clair ! Bon le format ASE est pas trop compliqué, mais bon je suis quand même content de moi, c'est nettement plus gratifiant que de suivre un tuto tout fait.

Bon après faut voir la gueule du loader aussi

moins optimisé que ça tu meurs ^^