IrrLicht / Newton

Salut a tous et bien venu dans mon tuto.

Pour commencer , je ne vais pas refaire ce que d'autre on fait. Bref je ne vais pas vous apprendre Irrlicht , il y a déja un autre qui vous a réserver.

Donc avant de commencer a lire ce tuto , commencez par celui ci :
http://www.siteduzero.com/tutoriel-3-5690-petit-guide-d-irrlicht.html

Si vous conaissez deja Irrlicht , alors allons y .

On va tous utiliser Made in IRRLicht ( les matrices , les vecteurs ... ).

Alors si vous vous sentez un peut fatigué , buvez un petit PEPSI .

Sommaire du chapitre :

Premier Pas(Partie Irrlicht)
Premier pas ( Partie Newton )
Premier pas ( Partie Union )
Nouvelle sous-partie
Nouvelle sous-partie
Nouvelle sous-partie

Premier Pas(Partie Irrlicht)

J'attends que vous soyez pret.

Donc , et d'abord , comme vous l'aviez vu dans le tuto du site du zero , on doit d'abord créer le device , et tous ...

En voici le code :

Code :

#include <cstdlib>
#include <iostream>
#include <IRR/irrlicht.h>

using namespace std;

using namespace irr;
using namespace core;
using namespace gui;
using namespace io;
using namespace scene;
using namespace video;

int main(int argc, char **argv)
{
// Initialisation // ---------------------------------------------------------
IrrlichtDevice *irrDev = createDevice (EDT_OPENGL, dimension2d<s32>(800,600), 32, false, true, false, 0);
IVideoDriver* driver = irrDev->getVideoDriver ();
ISceneManager *scene = irrDev->getSceneManager ();
scene->addCameraSceneNode (0, core::vector3df (0,0,0), core::vector3df (5,0,0));

// Creation d'une lumiere ambiente // ----------------------------------------
driver->setAmbientLight(video::SColorf(1.0, 1.0, 1.0,0.0));

// Creation d'une camera FPS // ----------------------------------------------
ICameraSceneNode *camera = scene->addCameraSceneNodeFPS (0,100,10);
camera->setPosition(vector3df(0,1,-5));

// La boucle principale du rendu // -----------------------------------------
while (irrDev->run ())
{
//On indique qu'on démarre la scène
driver->beginScene (true, true, video::SColor (255,255,255,255));
scene->drawAll ();
driver->endScene ();
}
return 0 ;
}

Peut etre que vous voyez quelque chose de différent dans ce code. Y a plusieurs usingnamespace
C'est mieux , car ça evite de réécrir a chaque fois "io::" ou "core::" ou "scene" ou autres...

Si vous n'avez pas compris ce code , c'est que vous n'aviez pas trés bien compris le tuto du
site du zero

Et pourtant il suffit de lire simplement les deux premiers chapitres.

Mais bon , y en a comme meme plusieurs qui le trouve un délicieu gateau .

Maintenant on va commencer par la plus simple géométrie a controller , c'est le cube .

Hé , Mais comment je vais créer un cube , je ne l'ais pas vu dans l'autre tuto ?

Ok , vous ne connaissez pas mais vous allez vite savoir comment faire .

Mais normalement , il y a tous dans la doc.
Aaaa , je sais , vous étes partisant du moindre éffort
Moi aussi !

Continuons . Alors voici la ligne qui nous permet de créer un cube :

Code :

ISceneNode*cube1 = scene->addCubeSceneNode(1);

-> La valeur 1 , c'est la taille du cube .

-> Cette fonction n'a pas qu'un seul paramétre . Voici la fonction avec tous ces paramétres :

Code :

addCubeSceneNode ( f32 size = 10.0f,
ISceneNode * parent = 0,
s32 id = -1,
const core::vector3df & position = core::vector3df(0, 0, 0),
const core::vector3df & rotation = core::vector3df(0, 0, 0),
const core::vector3df & scale = core::vector3df(1.0f, 1.0f, 1.0f)
)

Et puis , on passe a la texture :

Code :

cube1->setMaterialTexture(0, driver->getTexture("t351sml.jpg"));

Et pourquoi ne pas faire un autre cube comme celui ci :

Code :

ISceneNode*cube2 = scene->addCubeSceneNode(1);
cube2->setMaterialTexture(0, driver->getTexture("t351sml.jpg"));

Bien sure quand vous executerai , vous ne verez qu'un seul cube , parceque les deux cube sont a la meme position .

Donc , on aura un peut ça :

Code :

#include <cstdlib>
#include <iostream>
#include <IRR/irrlicht.h>

using namespace std;

using namespace irr;
using namespace core;
using namespace gui;
using namespace io;
using namespace scene;
using namespace video;

int main(int argc, char **argv)
{
// Initialisation // ---------------------------------------------------------
IrrlichtDevice *irrDev = createDevice (EDT_OPENGL, dimension2d<s32>(800,600), 32, false, true, false, 0);
IVideoDriver* driver = irrDev->getVideoDriver ();
ISceneManager *scene = irrDev->getSceneManager ();
scene->addCameraSceneNode (0, core::vector3df (0,0,0), core::vector3df (5,0,0));

// Creation d'une lumiere ambiente // ----------------------------------------
driver->setAmbientLight(video::SColorf(1.0, 1.0, 1.0,0.0));

// Creation d'une camera FPS // ----------------------------------------------
ICameraSceneNode *camera = scene->addCameraSceneNodeFPS (0,100,10);
camera->setPosition(vector3df(0,1,-5));

ISceneNode*cube1 = scene->addCubeSceneNode(1);
cube1->setMaterialTexture(0, driver->getTexture("t351sml.jpg"));

ISceneNode*cube2 = scene->addCubeSceneNode(1);
cube2->setMaterialTexture(0, driver->getTexture("t351sml.jpg"));

// La boucle principale du rendu // -----------------------------------------
while (irrDev->run ())
{
//On indique qu'on démarre la scène
driver->beginScene (true, true, video::SColor (255,255,255,255));
scene->drawAll ();
driver->endScene ();
}
return 0 ;
}

Et voila ce qu'on obtient :

Et voila , on tous ce qui nous faut pour passer au moteur physique ( Newton ).

Premier pas ( Partie Newton )

Telechargement et Installation

Pour commencer on va telecharger Newton ici :

http://www.newtongamedynamics.com

Ensuite ... ba y a pas de suite vous etes tres grands et vous pouvez tres bien

installer la librairie et configurer le projet.

Y a juste une petite chose pour les fichiers lib et dll , les vrais sont dans le sous

dossier -> ".../NewtonSDK/sdk/dll/"

Une autre chose : Je préfére que vous métiez le fichier Newton.h dans un nouveau dossier nommé Newton.

Les etapes a suivre

Alors vous etes pret ?.

Donc la premiére des chose a faire est d'inclure le fichier Newton.h

Et Créer un monde made in Newton comme ceci :

Code :

#include <cstdlib>
#include <iostream>
#include <IRR/irrlicht.h>

#include <Newton/Newton.h>

using namespace std;

using namespace irr;
using namespace core;
using namespace gui;
using namespace io;
using namespace scene;
using namespace video;

int main(int argc, char **argv)
{
// Initialisation Newtoniénne // ---------------------------------------------------------
NewtonWorld*world = NewtonCreate(0,0);

// Initialisation Irrlichiénne // ---------------------------------------------------------
IrrlichtDevice *irrDev = createDevice (EDT_OPENGL, dimension2d<s32>(800,600), 32, false, true, false, 0);
IVideoDriver* driver = irrDev->getVideoDriver ();
ISceneManager *scene = irrDev->getSceneManager ();
scene->addCameraSceneNode (0, core::vector3df (0,0,0), core::vector3df (5,0,0));

// Creation d'une lumiere ambiente // ----------------------------------------
driver->setAmbientLight(video::SColorf(1.0, 1.0, 1.0,0.0));

// Creation d'une camera FPS // ----------------------------------------------
ICameraSceneNode *camera = scene->addCameraSceneNodeFPS (0,100,10);
camera->setPosition(vector3df(0,1,-5));

ISceneNode*cube1 = scene->addCubeSceneNode(1);
cube1->setMaterialTexture(0, driver->getTexture("t351sml.jpg"));

ISceneNode*cube2 = scene->addCubeSceneNode(1);
cube2->setMaterialTexture(0, driver->getTexture("t351sml.jpg"));

// La boucle principale du rendu // -----------------------------------------
while (irrDev->run ())
{
//On indique qu'on démarre la scène
driver->beginScene (true, true, video::SColor (255,255,255,255));
scene->drawAll ();
driver->endScene ();
}
return 0 ;
}

Maintenant il faut créer un body ( corp en français ) pour chaque node ( chaque cube ).

Les étapes a suivre pour créer un corp ( body en anglais ).

1-> Créer le corp .
2-> L'initialiser on mui donnant une forme géométrique ( un cube dans notre cas ).
3-> Lui assigner une matrice .
4-> Configurer la mass et l'inertie .
5-> Lui affecter les force qui faut surtout la gravité ( P-> )

Et c'est partie :

Code :

// Créer le corp // ------------------
NewtonBody*body1 ;
// On Initialise le corp // ----------
body1 = NewtonCreateBody(world,NewtonCreateBox(world,1,1,1,0)) ;
// On lui assigne une matrice // -----
matrix4 mat1 ;
NewtonBodySetMatrix(body1,&mat1.M[0]);
// Configurer la mass et l'inertie //-
NewtonBodySetMassMatrix(body1,10,2,2,2);

Hé chef , y manque pas une étape ?

Non je l'ais en considération . Mais pour cette étape il faut créer une petite fonction , en voici sont code :

Code :

void ApplyForce(const NewtonBody *nbody)
{
float mass, ixx, iyy, izz;
NewtonBodyGetMassMatrix(nbody, &mass, &ixx, &iyy, &izz);
float force[3] = {0, mass * -90.82, 0};
NewtonBodyAddForce(nbody, force);
}

Et puis en reviens a la dérniére étape :

Code :

// On affecte au corp la force de gravité // ---
NewtonBodySetForceAndTorqueCallback(body1, ApplyForce);

Oooof , et voila enfin .

Maintenant c'est a vous de faire le 2eme corp pour le 2eme cube.

Voici le code pour que je soit sure que vous n'avait pas fait d'erreurs.

Code :

// Créer le corp2 // ------------------
NewtonBody*body1 ;
// On Initialise le corp2 // ----------
body1 = NewtonCreateBody(world,NewtonCreateBox(world,10,10,10,0)) ;
// On lui assigne une matrice // -----
matrix4 mat1 ;
NewtonBodySetMatrix(body1,&mat1.M[0]);
// Configurer la mass et l'inertie //-
NewtonBodySetMassMatrix(body1,10,2,2,2);
// Force de gravité // -----------------
NewtonBodySetForceAndTorqueCallback(body1, ApplyForce);

Et enfin vous devez avoir ce code la :

Code :

#include <cstdlib>
#include <iostream>
#include <IRR/irrlicht.h>

#include <Newton/Newton.h>

using namespace std;

using namespace irr;
using namespace core;
using namespace gui;
using namespace io;
using namespace scene;
using namespace video;

void ApplyForce(const NewtonBody *nbody)
{
float mass, ixx, iyy, izz;
NewtonBodyGetMassMatrix(nbody, &mass, &ixx, &iyy, &izz);
float force[3] = {0, mass * -90.82, 0};
NewtonBodyAddForce(nbody, force);
}

int main(int argc, char **argv)
{
// Initialisation Newtoniénne // ---------------------------------------------------------
NewtonWorld*world = NewtonCreate(0,0);

// Initialisation Irrlichiénne // ---------------------------------------------------------
IrrlichtDevice *irrDev = createDevice (EDT_OPENGL, dimension2d<s32>(800,600), 32, false, true, false, 0);
IVideoDriver* driver = irrDev->getVideoDriver ();
ISceneManager *scene = irrDev->getSceneManager ();
scene->addCameraSceneNode (0, core::vector3df (0,0,0), core::vector3df (5,0,0));

// Creation d'une lumiere ambiente // ----------------------------------------
driver->setAmbientLight(video::SColorf(1.0, 1.0, 1.0,0.0));

// Creation d'une camera FPS // ----------------------------------------------
ICameraSceneNode *camera = scene->addCameraSceneNodeFPS (0,100,10);
camera->setPosition(vector3df(0,1,-5));

// Créer le corp1 // ------------------
NewtonBody*body1 ;
// On Initialise le corp1 // ----------
body1 = NewtonCreateBody(world,NewtonCreateBox(world,10,10,10,0)) ;
// On lui assigne une matrice // -----
matrix4 mat1 ;
NewtonBodySetMatrix(body1,&mat1.M[0]);
// Configurer la mass et l'inertie //-
NewtonBodySetMassMatrix(body1,10,2,2,2);
// Force de gravité // -----------------
NewtonBodySetForceAndTorqueCallback(body1, ApplyForce);
// Initialisation Irr pour le cube1 // --------
ISceneNode*cube1 = scene->addCubeSceneNode(1);
cube1->setMaterialTexture(0, driver->getTexture("t351sml.jpg"));

// Créer le corp2 // ------------------
NewtonBody*body1 ;
// On Initialise le corp2 // ----------
body1 = NewtonCreateBody(world,NewtonCreateBox(world,10,10,10,0)) ;
// On lui assigne une matrice // -----
matrix4 mat1 ;
NewtonBodySetMatrix(body1,&mat1.M[0]);
// Configurer la mass et l'inertie //-
NewtonBodySetMassMatrix(body1,10,2,2,2);
// Force de gravité // -----------------
NewtonBodySetForceAndTorqueCallback(body1, ApplyForce);
// Initialisation Irr pour le cube2 // --------
ISceneNode*cube2 = scene->addCubeSceneNode(1);
cube2->setMaterialTexture(0, driver->getTexture("t351sml.jpg"));

// La boucle principale du rendu // -----------------------------------------
while (irrDev->run ())
{
//On indique qu'on démarre la scène
NewtonBodyGetMatrix(body1,&mat1.M[0]);
cube1->setPosition(mat1.getTranslation());
cube1->setRotation(mat1.getRotationDegrees());
NewtonUpdate(world,1/80);
driver->beginScene (true, true, video::SColor (255,255,255,255));
scene->drawAll ();
driver->endScene ();
}
return 0 ;
}

Et voila , maintenant executez et admirez .

Ah j'ais oublier , vous aurez la meme rendu qu'avant .

Mais pourquoit ?

Pourquoi Direction le chapitre suivant !!!

Premier pas ( Partie Union )

POURQUOI

Alors vous me dites pourquoi !

Récapitulons ce qu'on a fait depuis le début :

1-> Créer fenetre .
2-> Créer monde Newton .
3-> Créer 2 Cube .
4-> Créer 2 Corps .
5-> Executer la boucle de Irrlicht .

Ben voila les cube ne bouge pas parcequ'on a pas demander au programme de le faire .

Et si on voulez le faire , vous savez le meilleur endroit ou le placer ?!!!

Normalement vous trouverez . Avec le bold qui y a au-dessus

Alors tous va se jouer dans la boucle maintenant .

Les chose a faire sont simple .

Regardez a notre monde réél : Qu'est ce qu'un objet peut faire .

1-> Bouger ( Traslation , changer de position )
2-> Rotationner ( faire une rotation d'un tel angle )

Y a un autre mais on en a pas besoins .

Mais si vous voulez comme meme le savoir alors voila :

C'est le changement de forme : exemple : Une feuille de papier , un drapeau , un liquide ...

Donc , on va aller au corp et lui demandre de nous donner sa position et sa rotation qu'on va stoker dans la matrice , puis on confis ces information aux Cubes

Et voila on commence :

Code :

while (irrDev->run ())
{
NewtonBodyGetMatrix(body1,&mat1.M[0]);
cube1->setRotation(mat1.getRotationDegrees());
cube1->setPosition(mat1.getTranslation());

NewtonBodyGetMatrix(body2,&mat2.M[0]);
cube2->setRotation(mat2.getRotationDegrees());
cube2->setPosition(mat2.getTranslation());

NewtonUpdate ( world, 1 / 60 ) ;

//On indique qu'on démarre la scène
driver->beginScene (true, true, video::SColor (255,255,255,255));
scene->drawAll ();
driver->endScene ();
}

Maintenant , vous devez voir un cube qui tombre. Trés bien maintenant , on va mettre un cube comme sol et l'autre qui tombe sur lui.

Pour obtenir un sol : il faut mettre la masse et l'inertie du corp a 0.
Pour obtenir l'autre cube qui tombe on a qu'a le mettre un peut plus haut.

Ce sont de simple modifications que vous meme vous pouvez les faire.

Voici le code final :

Code :

#include <cstdlib>
#include <iostream>
#include <IRR/irrlicht.h>

#include <Newton/Newton.h>

using namespace std;

using namespace irr;
using namespace core;
using namespace gui;
using namespace io;
using namespace scene;
using namespace video;

void ApplyForce(const NewtonBody *nbody)
{
float mass, ixx, iyy, izz;
NewtonBodyGetMassMatrix(nbody, &mass, &ixx, &iyy, &izz);
float force[3] = {0, mass * -90.82, 0};
NewtonBodyAddForce(nbody, force);
}

int main(int argc, char **argv)
{
// Initialisation Newtoniénne // ---------------------------------------------------------
NewtonWorld*world = NewtonCreate(0,0);

// Initialisation Irrlichiénne // ---------------------------------------------------------
IrrlichtDevice *irrDev = createDevice (EDT_OPENGL, dimension2d<s32>(800,600), 32, false, true, false, 0);
IVideoDriver* driver = irrDev->getVideoDriver ();
ISceneManager *scene = irrDev->getSceneManager ();
scene->addCameraSceneNode (0, core::vector3df (0,0,0), core::vector3df (5,0,0));

// Creation d'une lumiere ambiente // ----------------------------------------
driver->setAmbientLight(video::SColorf(1.0, 1.0, 1.0,0.0));

// Creation d'une camera FPS // ----------------------------------------------
ICameraSceneNode *camera = scene->addCameraSceneNodeFPS (0,100,10);
camera->setPosition(vector3df(0,1,-5));

// Créer le corp1 // ------------------
NewtonBody*body1 ;
// On Initialise le corp1 // ----------
body1 = NewtonCreateBody(world,NewtonCreateBox(world,1,1,1,0)) ;
// On lui assigne une matrice // -----
matrix4 mat1 ;
mat1.setTranslation(vector3df(0.52,3,0));
NewtonBodySetMatrix(body1,&mat1.M[0]);
// Configurer la mass et l'inertie //-
NewtonBodySetMassMatrix(body1,10,2,2,2);
// Force de gravité // -----------------
NewtonBodySetForceAndTorqueCallback(body1, ApplyForce);
// Initialisation Irr pour le cube1 // --------
ISceneNode*cube1 = scene->addCubeSceneNode(1);
cube1->setMaterialTexture(0, driver->getTexture("t351sml.jpg"));

// Créer le corp2 // ------------------
NewtonBody*body2 ;
// On Initialise le corp2 // ----------
body2 = NewtonCreateBody(world,NewtonCreateBox(world,1,1,1,0)) ;
// On lui assigne une matrice // -----
matrix4 mat2 ;
NewtonBodySetMatrix(body2,&mat2.M[0]);
// Configurer la mass et l'inertie //-
NewtonBodySetMassMatrix(body2,0,0,0,0);
// Initialisation Irr pour le cube2 // --------
ISceneNode*cube2 = scene->addCubeSceneNode(1);
cube2->setMaterialTexture(0, driver->getTexture("t351sml.jpg"));

// La boucle principale du rendu // -----------------------------------------
while (irrDev->run ())
{
NewtonBodyGetMatrix(body1,&mat1.M[0]);
cube1->setRotation(mat1.getRotationDegrees());
cube1->setPosition(mat1.getTranslation());

NewtonBodyGetMatrix(body2,&mat2.M[0]);
cube2->setRotation(mat2.getRotationDegrees());
cube2->setPosition(mat2.getTranslation());

NewtonUpdate ( world, 1 / 60 ) ;

//On indique qu'on démarre la scène
driver->beginScene (true, true, video::SColor (255,255,255,255));
scene->drawAll ();
driver->endScene ();
}
return 0 ;
}

Bien sur , ceci n'est qu'un simple teste .
Vous pouvez faire encore mieux . En voici un bon exemple :

Maitenant on va passer a la POO ( programmation orientée objet ).

Comme vous avez vu , il faut écrir un immense nombre de lignes juste pour faire de cubes. La POO est la pour ça.

Nouvelle sous-partie

Rédigé par OSasuke

Plateforme de création de jeux vidéo (Le site est en cours de création / réorganisation)

Les Tutoriaux Les Forums Les Liens

IrrLicht / Newton

Premier Pas(Partie Irrlicht)

Premier pas ( Partie Newton )

Telechargement et Installation

Les etapes a suivre

Premier pas ( Partie Union )

POURQUOI

Nouvelle sous-partie

Nouvelle sous-partie

Nouvelle sous-partie