Alors j'ai modifié ce que tu as dit et le rendu n'est pas modifié. Mais je ne comprend pas pourquoi la force que je leurs attribue est identique alors que leurs masses est différentes et que la force en question dépend de la masse. Je pense que c'est la variable de masse de mon callback qui ne fonctionne pas. Je vais essayer de modifier ça, si vous trouvez autre chose.

Essaie en implémentant un 2ème callback (ApplyForceAndTorqueEvent2(...) par exemple, mets des valeurs fixes pour les forces de chaque callback. Et ensuite, tu donnes le nouveau callback à un de tes 2 cubes. Comme ça tu seras sur que les forces sont bien différentes.

ça fonctionne avec deux forces différentes et deux callbacks mais j'ai l'impression que Newton ne prend pas en compte le coefficient de friction qui est censé être placé par défaut.

Le coef de friction, ce n'est pas entre 2 body? Donc il n'y aurait pas de friction avec l'air.

Bonjour, cela fait une paye que j'ai pas touché à Newton, mais il me semble que tu soit obliger de définir une taille du monde à Newton,
En cherchant dans mes archives, j'ai retrouvé ce bout de code:

 ///INITIALISATION NEWTON
    NewtonWorld* World;
	World = NewtonCreate();
	NewtonSetPlatformArchitecture(World, 0);
	dVector minSize(-500.0f, -500.0f, -500.0f);
	dVector maxSize(500.0f, 500.0f, 500.0f);
	NewtonSetWorldSize(World, &minSize[0], &maxSize[0]);
	NewtonSetSolverModel(World, 1);

Tiens, j'ai retrouvé un bout de code que j'avais écrit pour tester Newton avec irrlicht, je te l'ai mis en download si tu veux le tester, dedans tu auras le code et le tout compilé pour tester, appuis sur "Espace", "X", "P" ou "C" pour faire tombé des croix, cube, cône ou pyamide sur le sol.

http://www.mediafire.com/?kt9prc70nmzpdfp

Ca va déjà te donner une idée.
Bon courage.

Oui sauf que tu utilises la version 2.0 (au minimum) alors que je suis sur la version 1.53 et que je n'arrive pas à installer les versions suivantes. Et pour le coef de friction, je sais pas comment faire dans ce cas là pour créer "l'air".

Je ne pense pas que tu puisses faire la friction avec l'air. Ce serait super compliqué de gérer ça étant donné que ça dépend de la vitesse, la surface de contact et plein d'autres choses. Applique des forces différentes ça suffira. Par exemple, tu utilises NewtonBodyAddForce() pour ajouter de la vélocité à ton node et le faire descendre plus vite.

OK merci beaucoup à tous pour m'avoir aider.

J'ai de nouveau un problème que je ne comprend pas. J'ai créer un programme qui fais la collision de deux cubes (un de masse nul et un autre). J'ai créer un code en un fichier (.cpp + .hpp) mais j'ai voulu séparer la partie physique du main en créant une classe. Mon problème est que cette classe ne fonctionne pas, mon compilo me dit :

argument of type `void (Physics::)(const NewtonBody*, const float*, int)' does not match `void (*)(const NewtonBody*, const float*, int)' 
argument of type `void (Physics::)(const NewtonBody*, float, int)' does not match `void (*)(const NewtonBody*, float, int)'

#include "twentieth.hpp"

Physics::Physics(irr::IrrlichtDevice *device, irr::video::IVideoDriver *driver, irr::scene::ISceneManager *sceneManager){                   
    newtonDevice = device;
    newtonDriver = driver;
    newtonSceneManager = sceneManager;
    
    newtonWorld = NewtonCreate(); // 2.0
    newtonNode = 0;
}

Physics::~Physics(){
    NewtonDestroy(newtonWorld);
}

void Physics::Cube(irr::core::vector3df position, irr::core::vector3df taille, float masse){
    
    irr::scene::IMesh* cubeMesh = newtonSceneManager->getMesh("data/smallcube.3ds");
    newtonNode = newtonSceneManager->addMeshSceneNode(cubeMesh);
    newtonNode->setMaterialTexture(0, newtonDriver->getTexture("data/crate.jpg"));
    newtonNode->setMaterialFlag(irr::video::EMF_LIGHTING, false);
    
    NewtonCollision* collision;
    
    collision = NewtonCreateBox(newtonWorld, taille.X, taille.Y, taille.Z, 0, NULL); // 2.00
    
    newtonBody = NewtonCreateBody(newtonWorld, collision, NULL); // 2.00
    NewtonReleaseCollision(newtonWorld, collision);  
    
    NewtonBodySetUserData(newtonBody,reinterpret_cast<void*>(newtonNode));
    
    if(masse == 0.0){newtonNode->setPosition(position);}
    
    if(masse != 0.0){
        irr::core::vector3df inertie;
        inertie.X = (masse/12)*(pow(taille.Y,2)+pow(taille.Z,2));
        inertie.Y = (masse/12)*(pow(taille.X,2)+pow(taille.Z,2));
        inertie.Z = (masse/12)*(pow(taille.X,2)+pow(taille.Y,2));
        NewtonBodySetMassMatrix (newtonBody, masse, inertie.X, inertie.Y, inertie.Z);
        
        NewtonBodySetTransformCallback(newtonBody, SetMeshTransformEvent);
	    NewtonBodySetForceAndTorqueCallback(newtonBody, ApplyForceAndTorqueEvent);
    }
    
    irr::core::matrix4 mat;
    mat.setTranslation(position);
    NewtonBodySetMatrix(newtonBody, mat.pointer());
}

void Physics::Update(){
   
    if (newtonDevice->getTimer()->getTime() > lasttick + 10)
    {   
        lasttick = newtonDevice->getTimer()->getTime();
        NewtonUpdate(newtonWorld, 0.01f);
    }
}

// CALLBACKS -------------------------------------------------------------------

// 2.00

void Physics::SetMeshTransformEvent(const NewtonBody* newtonBody, const float* matrix, int)
{
	irr::core::matrix4 mat;
	memcpy(mat.pointer(), matrix, sizeof(float)*16);

	irr::scene::ISceneNode *newtonNode = (irr::scene::ISceneNode *)NewtonBodyGetUserData(newtonBody);
	if (newtonNode)
	{
		newtonNode->setPosition(mat.getTranslation());
		newtonNode->setRotation(mat.getRotationDegrees());
	}
}

void Physics::ApplyForceAndTorqueEvent(const NewtonBody* newtonBody, float, int)
{ 
    float masse; 
    float inertieX; 
    float inertieY; 
    float inertieZ; 
    float force[3]; 
    float torque[3]; 
    
    NewtonBodyGetMassMatrix (newtonBody, &masse, &inertieX, &inertieY, &inertieZ); 
    
    force[0] = 0.0f; 
    force[1] = -9.81 * masse; 
    force[2] = 0.0f; 
    
    torque[0] = 0.0f; 
    torque[1] = 0.0f; 
    torque[2] = 0.0f; 
    
    NewtonBodyAddForce(newtonBody, force); 
    NewtonBodyAddTorque(newtonBody, torque); 
}

// -----------------------------------------------------------------------------

Il te demande un pointeur sur fonction et tu lui envoie une fonction membre. Il y a une différence entre (void*)(fonction) et (void*)(Classe::fonction), les pointeurs ne sont pas les même car il faut une donnée en plus pour spécifié à quelle classe appartient la fonction. Du coup, tu lui donne un pointeur ayant un format différent.

essaie ça mais je ne pense pas que ça marche je ne me suis pas penché sur les pointeurs de fonctions membre :

NewtonBodySetTransformCallback(newtonBody, NomDeTaClasse::SetMeshTransformEvent);
NewtonBodySetForceAndTorqueCallback(newtonBody, NomDeTaClasse::ApplyForceAndTorqueEvent);

Et aussi mets "NomDeTaClasse::SetMeshTransformEvent()" et "NomDeTaClasse::ApplyForceAndTorqueEvent()" en fonction statique.

J'ai vu ça ici, si ça peut t'aider :
lien vers tuto "pointeur fonction membre"

J'ai l'impression que tu as raison avec le fait de rajouter le nom de ma classe devant l'appel du callback mais en rajoutant static en plus mon compilo m'a listé une suite d'erreur de linkage :

[Linker error] undefined reference to `Physics::newtonWorld'
[Linker error] undefined reference to `Physics::newtonBody'

et un :

more undefined references to `Physics::newtonWorld' follow

Mais je ne comprend pas pourquoi car j'ai linker newton.lib de la version 2.0 et rien d'autre ( avec irrlicht bien sur ) . Y-a-t-il autre chose à linker ? Ou je n'ai pas linker le bon fichier ?

Regarde le tuto que je t'ai donné. Puisque tes fonctions sont statiques, les membres qu'elles utilisent doivent l'être aussi donc "static NewtonWorld* Physics::newtonWorld;" avec l'initialisation du pointeur à NULL surtout.

J'ai pas très bien compris vu que dans mon main j'ai :

#ifndef TWENTIETH_HPP
#define TWENTIETH_HPP

#include "main.hpp"

class Physics
{
    public :
    
    Physics(irr::IrrlichtDevice *device, irr::video::IVideoDriver *driver, irr::scene::ISceneManager *sceneManager);
    ~Physics();
    
    void Cube(irr::core::vector3df position, irr::core::vector3df taille, float masse);
    void Update();
    
    // Callbacks ---------------------------------------------------------------
    
    // 1.53
    /*
    static void SetMeshTransformEvent(const NewtonBody* newtonBody, const float* matrix);
    static void ApplyForceAndTorqueEvent(const NewtonBody* body);
    */
    // 2.00
    
    static void SetMeshTransformEvent(const NewtonBody* body, const float* matrix, int);
    static void ApplyForceAndTorqueEvent(const NewtonBody* body, float, int);
    
    // -------------------------------------------------------------------------
    
    private :
    
    irr::IrrlichtDevice* newtonDevice;
    irr::video::IVideoDriver* newtonDriver;
    irr::scene::ISceneManager* newtonSceneManager;
    
    static NewtonWorld* newtonWorld;
    static NewtonBody* newtonBody;
    irr::scene::ISceneNode* newtonNode;
    
    unsigned int lasttick;
    
};

#endif

Edit : Si tu mets newtonWorld et newtonBody publique, est-ce que ça lui va?

Edit 2 : Au fait, dans ton .cpp tu as bien initialisé newtonWorld et newtonBody comme suit :

NewtonWorld * Physics::newtonWorld = NULL;
NewtonBody * Physics::newtonBody = NULL;

Alors pour le premier edit, ça ne change rien si je met newtonWorld et newtonBody en publique. Pour le second, comme c'est montré dans mon code, pour le constructeur de Physics, j'écrit : newtonWorld = NewtonCreate();

Faut-il que je code ?

NewtonWorld * Physics::newtonWorld = NULL;
NewtonBody * Physics::newtonBody = NULL;
newtonWorld  = NewtonCreate();

Je crois que n'as pas compris ce que je voulais dire, utilise ce code :

Physics.hpp

#ifndef PHYSICS_HPP
#define PHYSICS_HPP

#include "main.hpp"

class Physics
{
    public :
   
    Physics(irr::IrrlichtDevice *device, irr::video::IVideoDriver *driver, irr::scene::ISceneManager *sceneManager);
    ~Physics();
   
    void Cube(irr::core::vector3df position, irr::core::vector3df taille, float masse);
    void Update();
   
    // Callbacks ---------------------------------------------------------------
   
    // 1.53
    /*
    static void SetMeshTransformEvent(const NewtonBody* newtonBody, const float* matrix);
    static void ApplyForceAndTorqueEvent(const NewtonBody* body);
    */
    // 2.00
   
    static void SetMeshTransformEvent(const NewtonBody* body, const float* matrix, int);
    static void ApplyForceAndTorqueEvent(const NewtonBody* body, float, int);
   
    // -------------------------------------------------------------------------
   
    private :
   
    irr::IrrlichtDevice* newtonDevice;
    irr::video::IVideoDriver* newtonDriver;
    irr::scene::ISceneManager* newtonSceneManager;
   
    static NewtonWorld* newtonWorld;
    static NewtonBody* newtonBody;
    irr::scene::ISceneNode* newtonNode;
   
    unsigned int lasttick;
   
};

#endif

#include "Physics.hpp"

// sans ces lignes les variables statiques sont mal déclarées d'où le "undefined reference"
NewtonWorld * Physics::newtonWorld = NULL;
NewtonBody * Physics::newtonBody = NULL;

Physics::Physics(irr::IrrlichtDevice *device, irr::video::IVideoDriver *driver, irr::scene::ISceneManager *sceneManager){                   
    newtonDevice = device;
    newtonDriver = driver;
    newtonSceneManager = sceneManager;
   
    newtonWorld = NewtonCreate(); // 2.0
    newtonNode = 0;
}Physics::~Physics(){
    NewtonDestroy(newtonWorld);
}

void Physics::Cube(irr::core::vector3df position, irr::core::vector3df taille, float masse){
   
    irr::scene::IMesh* cubeMesh = newtonSceneManager->getMesh("data/smallcube.3ds");
    newtonNode = newtonSceneManager->addMeshSceneNode(cubeMesh);
    newtonNode->setMaterialTexture(0, newtonDriver->getTexture("data/crate.jpg"));
    newtonNode->setMaterialFlag(irr::video::EMF_LIGHTING, false);
   
    NewtonCollision* collision;
   
    collision = NewtonCreateBox(newtonWorld, taille.X, taille.Y, taille.Z, 0, NULL); // 2.00
   
    newtonBody = NewtonCreateBody(newtonWorld, collision, NULL); // 2.00
    NewtonReleaseCollision(newtonWorld, collision); 
   
    NewtonBodySetUserData(newtonBody,reinterpret_cast<void*>(newtonNode));
   
    if(masse == 0.0){newtonNode->setPosition(position);}
   
    if(masse != 0.0){
        irr::core::vector3df inertie;
        inertie.X = (masse/12)*(pow(taille.Y,2)+pow(taille.Z,2));
        inertie.Y = (masse/12)*(pow(taille.X,2)+pow(taille.Z,2));
        inertie.Z = (masse/12)*(pow(taille.X,2)+pow(taille.Y,2));
        NewtonBodySetMassMatrix (newtonBody, masse, inertie.X, inertie.Y, inertie.Z);
       
        NewtonBodySetTransformCallback(newtonBody, SetMeshTransformEvent);
        NewtonBodySetForceAndTorqueCallback(newtonBody, ApplyForceAndTorqueEvent);
    }
   
    irr::core::matrix4 mat;
    mat.setTranslation(position);
    NewtonBodySetMatrix(newtonBody, mat.pointer());
}

void Physics::Update(){
   
    if (newtonDevice->getTimer()->getTime() > lasttick + 10)
    {   
        lasttick = newtonDevice->getTimer()->getTime();
        NewtonUpdate(newtonWorld, 0.01f);
    }
}

// CALLBACKS -------------------------------------------------------------------

// 2.00

void Physics::SetMeshTransformEvent(const NewtonBody* newtonBody, const float* matrix, int)
{
    irr::core::matrix4 mat;
    memcpy(mat.pointer(), matrix, sizeof(float)*16);

    irr::scene::ISceneNode *newtonNode = (irr::scene::ISceneNode *)NewtonBodyGetUserData(newtonBody);
    if (newtonNode)
    {
        newtonNode->setPosition(mat.getTranslation());
        newtonNode->setRotation(mat.getRotationDegrees());
    }
}

void Physics::ApplyForceAndTorqueEvent(const NewtonBody* newtonBody, float, int)
{
    float masse;
    float inertieX;
    float inertieY;
    float inertieZ;
    float force[3];
    float torque[3];
   
    NewtonBodyGetMassMatrix (newtonBody, &masse, &inertieX, &inertieY, &inertieZ);
   
    force[0] = 0.0f;
    force[1] = -9.81 * masse;
    force[2] = 0.0f;
   
    torque[0] = 0.0f;
    torque[1] = 0.0f;
    torque[2] = 0.0f;
   
    NewtonBodyAddForce(newtonBody, force);
    NewtonBodyAddTorque(newtonBody, torque);
}

// -----------------------------------------------------------------------------

Ai-je le droit de t'appeler dieu ?! Non parce que ça marche et je suis content !!!!!!!

EDIT : maintenant le problème est pour integrer la physique. En clair j'ai créer un code qui utilise la classe Physics pour fabriquer deux cubes et les faire ce rentrer dedans. Voici mon code pour main.cpp (twentieth.cpp et twentieth.hpp sont les mêmes) :

main.cpp

#include "main.hpp"

int main(){
    
    irr::IrrlichtDevice *device = irr::createDevice(irr::video::EDT_OPENGL, irr::core::dimension2d<irr::u32>(640,480), false);
    irr::video::IVideoDriver *driver = device->getVideoDriver();
    irr::scene::ISceneManager *sceneManager = device->getSceneManager();
    sceneManager->addSkyBoxSceneNode(driver->getTexture("data/irrlicht2_up.bmp"),driver->getTexture("data/irrlicht2_dn.bmp"),driver->getTexture("data/irrlicht2_rt.bmp"),driver->getTexture("data/irrlicht2_lf.bmp"),driver->getTexture("data/irrlicht2_ft.bmp"),driver->getTexture("data/irrlicht2_bk.bmp"));
    
    device->setWindowCaption(L"Test de separation des fichiers physiques.");
    
    // Caméra
    irr::scene::ICameraSceneNode* camera = sceneManager->addCameraSceneNode();
    camera->setPosition(irr::core::vector3df(100,0,0));
    camera->setTarget(irr::core::vector3df(0,0,0));
    
    // Installation de la physique.
    Physics newton(device, driver, sceneManager);
    
    // Création d'un cube soumis à la gravité.
    
    irr::core::vector3df position = irr::core::vector3df(0,0,0);
    irr::core::vector3df taille = irr::core::vector3df(40,40,40);
    float masse = 100.0;
    newton.Cube(position, taille, masse);
    
    
    // Création d'un cube non soumis à la gravité.
    
    irr::core::vector3df positionS = irr::core::vector3df(0,0,0);
    irr::core::vector3df tailleS = irr::core::vector3df(40,40,40);
    float masseS = 0.0;
    //newton.Cube(positionS, tailleS, masseS);
    
    
    while(device->run())
    {
        newton.Update();
        driver->beginScene(true, true, irr::video::SColor(255,255,255,255));
        sceneManager->drawAll();
        driver->endScene();
    }
    
    device->drop();
    return 0;
}

C'est super! Surtout retiens bien le principe pour les variables statiques :
1/ déclaration dans la classe,
2/ initialisation hors classe (généralement dans le .cpp avec l'implémentation des fonctions).

Si tu oublie l'étape 2, c'est comme utiliser une fonction sans l'avoir implémentée, l'erreur qui s'en suit est donc la même : "undefined reference".

Maintenant que ce petit problème est résolu, tu vas pouvoir avancer. Bonne prog!

Edit : Tu as ajouter un problème quand j'écrivais^^.
Pour mieux cerner ton probleme, utilise printf:

#ifdef _DEBUG
printf("pointeur_variable valide? %s\
", (pointeur_variable)?"VALIDE":"NULL");
#endif

Par rapport au précédant code, j'ai pu déterminer que le problème est dû à la fonction :

newtonBody = NewtonCreateBody(newtonWorld, collision, NULL); // 2.35

qui se trouve dans la méthode Physics::Cube.

Pourtant j'ai trouver cette fonction dans le newton.h :

NEWTON_API NewtonBody* NewtonCreateBody (const NewtonWorld* const newtonWorld, const NewtonCollision* const collision, const dFloat* const matrix);

newtonWorld est statique donc précise le nom de la classe devant. Pareil pour newtonBody. Ajoute "Physics::".
Tu mets NULL pour l'argument matrix mais dans la version 2.xx de newton ça ne marche pas.
Mets:

irr::core::matrix4 mat;
Physics::newtonBody = NewtonCreateBody(Physics::newtonWorld, collision, mat.pointer()); // 2.35

Alors j'ai remplacé tous les newtonBody et newtonWorld de mon fichier twentieth.cpp par Physics::newtonBody et Physics::newtonWorld. Mais le problème est toujours présent.

PS : On arrête de se croiser ! C'est super dur pour comprendre

Et pour conclure, tout marche correctement. Merci BEAUCOUP

Oui, c'est dur mais plus rapide. Après si tu veux, je mets heure entre chaque post^^.

Dernier croisement de la série alors.^^ Bonne prog! (J'ai une impression de déjà dit!

Maintenant j'ai un autre type de questions qui me viennent à l'esprit vu que mon programme marche :

Si je veux que mon programme saute quand j'appuie sur une touche, je vais utiliser la fonction NewtonBodyAddForce mais si je le fais dans le callback, mon cube va s'envoler. Faut il écrire une fonction avec à l'intérieur, juste la fonction NewtonBodyAddForce ou faut il créer une fonction similaire à un callback ?

Ou si je désire qu'en appuyant sur la flèche de droite, mon cube avance, faut il mieux déplacer le cube ou lui appliquer une force dans la bonne direction ?

Pourriez-vous m'aider ?