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:

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)'

Voici mon code :

Enfin mon compilo parle des deux lignes qui font appel aux callbacks soit :

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

Pourriez-vous m'aider ?
Merci d'avance.

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"

Dernière modification par johnplayer (22-08-2012 16:57:39)

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 ?

Dernière modification par Kaze (22-08-2012 17:10:01)

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 :

mon newtonWorld a toujours été static, tout comme le newtonBody.

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;

Dernière modification par johnplayer (22-08-2012 20:04:59)

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 ?

EDIT : Je pense que c'est ma version 2.35 de newton qui est mal installée. Le problème est que je ne vois absolument pas comment faire avec tout ce qui est présent dans le fichier qu'on télécharge sur Newton Game Dynamics.

Il y a 2 fichiers qui ont pour noms newton.lib, il faut choisir lequel pour faire les linkages? Faut il linker tout les autres .lib en même temps?

Dernière modification par Kaze (22-08-2012 23:10:51)

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

Physics.cpp

#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

Pour info, main.hpp ne fait que l'inclusion d'irrlicht, d'iostream et de newton.

Grâce à des commentaires, j'ai pu déduire que l'erreur était dû au fonction newton.Cube. Si vous pouviez trouver pourquoi mon code s'execute mais ne veux rien afficher et plante. Je vais continuer à chercher de mon coté pendant ce temps.

Dernière modification par Kaze (23-08-2012 17:29:47)

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:

Mets le après chaque affectation de variable, bien tous tes pointeurs doivent être initialisé à NULL à la création de ta classe (pour les membres) ou de leur création (pour le reste du programme). Et bien sûr si tu veux afficher un entier ou autres, il y a juste à adapter. Le mieux serait que tu trouves tout seul parce que traquer une erreur sur un post, c'est galère! Tu places des printf un peu partout. Lorsque le programme plante, tu regardes la dernière ligne affichée et ça t'aideras à cibler l'endroit où ça plante. Une fois que tu auras ciblé la ligne à laquelle ça plante, dis-moi où ça plante et je pourrai t'aider.

Dernière modification par johnplayer (23-08-2012 17:50:51)

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 :

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:

Dernière modification par johnplayer (23-08-2012 17:59: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

Dernière modification par Kaze (23-08-2012 18:02:55)

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 ?