Partage
  • Partager sur Facebook
  • Partager sur Twitter

voiture irrlicht/newton

Marco565
    5 décembre 2007 à 20:20:11

    bonjour je suis entrain de faire un test avec une voiture mais voila quand je lui dit d'avencer celle ci ne repond pas et pourtant l'event est bien traité (je l'ai verifié)

    voici le code:

    main.cpp
    1. #include <iostream>
    2. #include "Voiture.h"
    3. #include <IRR/Irrlicht.h>
    4. #include <newton/newton.h>
    5. NewtonWorld *world = NewtonCreate(0,0);
    6. using namespace std;
    7. using namespace irr;
    8. int main()
    9. {
    10.     //Le support de tout le programme
    11.     IrrlichtDevice *device = createDevice(video::EDT_DIRECT3D9, core::dimension2d<s32>(800,600), 32, false, true, false);
    12.     //scene Manager
    13.     scene::ISceneManager *scenegraph = device->getSceneManager();
    14.     //video driver
    15.     video::IVideoDriver *driver = device->getVideoDriver();
    16.     //une petite camera
    17.     scene::ICameraSceneNode *camera = scenegraph->addCameraSceneNodeFPS(0, 80,50);
    18.     camera->setPosition(core::vector3df(0,0,-20));
    19.     //Un tapis de sol euuu non un plato
    20.     NewtonCollision *collision = NewtonCreateBox(world, 1000,1,1000,0);
    21.     NewtonBody *body = NewtonCreateBody(world, collision);
    22.     NewtonReleaseCollision(world, collision);
    23.     core::matrix4 mat;
    24.     mat.setTranslation(core::vector3df(0,-50,0));
    25.     NewtonBodySetMatrix(body, mat.M);
    26.     scene::IAnimatedMesh *mesh = scenegraph->addHillPlaneMesh("truc", core::dimension2d<f32>(20,20), core::dimension2d<u32>(40,40));
    27.     scene::ISceneNode *plan = scenegraph->addMeshSceneNode(mesh->getMesh(0));
    28.     plan->setPosition(core::vector3df(0,-50,0));
    29.     plan->setMaterialTexture(0,driver->getTexture("Asphalt_09.jpg"));
    30.     scenegraph->getMeshManipulator()->makePlanarTextureMapping(mesh->getMesh(0), 0.008f);
    31.     //petite lumiere (ben oui sinon il fait nuit)
    32.     scene::ILightSceneNode *lumiere = scenegraph->addLightSceneNode(0,core::vector3df(0,130,0), video::SColor(255,255,255,255), 600);
    33.     //On ajoute une voiture et la classe
    34.     Voiture *car = new Voiture();
    35.     car->init(world, scenegraph);
    36.     device->setEventReceiver(car);
    37.     //Une petite montre
    38.     ITimer *timer = device->getTimer();
    39.     int lastTime = 0;
    40.     while(device->run())
    41.     {
    42.         driver->beginScene(true, true, video::SColor(255,128,128,128));
    43.         scenegraph->drawAll();
    44.         if(timer->getTime() -lastTime > 10)
    45.         {
    46.             car->aff();
    47.             NewtonUpdate(world, 1);
    48.             lastTime = timer->getTime();
    49.         }
    50.         driver->endScene();
    51.     }
    52.     device->drop();
    53.     return 0;
    54. }



    voiture.h
    1. #ifndef VOITURE_H_INCLUDED
    2. #define VOITURE_H_INCLUDED
    3.     #include <iostream>
    4.     #include <IRR/Irrlicht.h>
    5.     #include <newton/newton.h>
    6.     class Voiture : public irr::IEventReceiver
    7.     {
    8.         public:
    9.             Voiture();
    10.             void init(NewtonWorld *pWorld, irr::scene::ISceneManager *scene);
    11.             void aff();
    12.             bool OnEvent(const irr::SEvent& event);
    13.             void addTire(irr::core::vector3df pos, irr::core::vector3df taille, int id);
    14.         private:
    15.             NewtonBody *chassis;
    16.             NewtonJoint *vehicle;
    17.             NewtonWorld *world;
    18.             void *tire[4];
    19.             bool move, left;
    20.             irr::scene::ISceneManager *scenegraph;
    21.             irr::scene::ISceneNode *chassisN, *roueN[4];
    22.     };
    23.     void addForce(const NewtonBody *nBody);
    24.     void setTransform(const NewtonBody* body, const float* matrix);
    25. #endif // VOITURE_H_INCLUDED



    voiture.cpp
    1. #include "Voiture.h"
    2. using namespace std;
    3. using namespace irr;
    4. Voiture::Voiture()
    5. {
    6.     chassisN = 0;
    7.     move = false;
    8.     left = false;
    9.     for(int i=0;i<4;i++)
    10.         roueN[i] = 0;
    11. }
    12. void Voiture::init(NewtonWorld *pWorld, irr::scene::ISceneManager *scene)
    13. {
    14.     world = pWorld;
    15.     scenegraph = scene;
    16.     //On bosse le chassis de la voiture
    17.     chassisN = scenegraph->addCubeSceneNode(1);
    18.     chassisN->setScale(core::vector3df(4,1.5,3));
    19.     core::matrix4 mat;
    20.     mat.setTranslation(core::vector3df(0,0,0));
    21.     //On cree un chassis
    22.     chassis = NewtonCreateBody(world, NewtonCreateBox(world, 4,1.5,3,0));
    23.     //On ajoute une masse au chassis
    24.     NewtonBodySetMassMatrix(chassis, 200, 0,0,0);
    25.     //On met un node dans le chassis
    26.     NewtonBodySetUserData(chassis, chassisN);
    27.     //on modifie la matrice du chassis
    28.     NewtonBodySetMatrix(chassis, mat.M);
    29.     //on fait interagir une force sur le chassis
    30.     NewtonBodySetForceAndTorqueCallback(chassis, addForce);
    31.     //on modifie la position du node
    32.     NewtonBodySetTransformCallback(chassis, setTransform);
    33.     //on ne bloque pas le chassis s'il ne bouge pas
    34.     NewtonBodySetAutoFreeze(chassis, 0);
    35.     //le joint
    36.     float upDir[3] = {0,1,0};
    37.     vehicle = NewtonConstraintCreateVehicle(world, upDir, chassis);
    38.     //On ajoute des roues :p
    39.     addTire(core::vector3df(1.5,-1.5,-2), core::vector3df(0.5,0.5,0.2), 0);
    40.     addTire(core::vector3df(-1.5,-1.5,-2), core::vector3df(0.5,0.5,0.2), 2);
    41.     addTire(core::vector3df(1.5,-1.5,2), core::vector3df(0.5,0.5,0.2), 1);
    42.     addTire(core::vector3df(-1.5,-1.5,2), core::vector3df(0.5,0.5,0.2), 3);
    43. }
    44. void Voiture::addTire(irr::core::vector3df pos, irr::core::vector3df taille, int id)
    45. {
    46.     core::matrix4 mat;
    47.     mat.setTranslation(pos);
    48.     float pin[3] = {0,0,1};
    49.     roueN[id] = scenegraph->addSphereSceneNode(1);
    50.     roueN[id]->setScale(taille);
    51.     roueN[id]->setPosition(pos);
    52.     //On ajoute une roue
    53.     tire[id] = NewtonVehicleAddTire(vehicle, mat.M, pin, 20, taille.Z, taille.Y, 300,2000,1.5, roueN[id],id);
    54. }
    55. bool Voiture::OnEvent(const irr::SEvent& event)
    56. {
    57.     if(event.EventType == irr::EET_KEY_INPUT_EVENT && event.KeyInput.Key == irr::KEY_KEY_Z)
    58.     {
    59.         if(event.KeyInput.PressedDown == true)
    60.             move = true;
    61.         else if(event.KeyInput.PressedDown == false)
    62.             move = false;
    63.         return true;
    64.     }
    65.     if(event.EventType == irr::EET_KEY_INPUT_EVENT && event.KeyInput.Key == irr::KEY_KEY_D)
    66.     {
    67.         if(event.KeyInput.PressedDown == true)
    68.             left = true;
    69.         else if(event.KeyInput.PressedDown == false)
    70.             left = false;
    71.         return true;
    72.     }
    73.     return false;
    74. }
    75. void addForce(const NewtonBody *nBody)
    76. {
    77.     float mass, ix, iy, iz;
    78.     //On recupere la masse et l'inertie du corp
    79.     NewtonBodyGetMassMatrix(nBody, &mass, &ix, &iy, &iz);
    80.     float force[3] = {0}; //on cree une force tridimentionelle
    81.     force[1] = mass * -9.81; //on ajoute l'apesenteur sur l'axe des Y
    82.     //On les envoi au corps
    83.     NewtonBodyAddForce(nBody, force);
    84. }
    85. void setTransform(const NewtonBody* body, const float* matrix)
    86. {
    87.     core::matrix4 mat;
    88.     mat.setM(matrix);
    89.     scene::ISceneNode *tmp = 0;
    90.     tmp = (scene::ISceneNode *)NewtonBodyGetUserData(body);
    91.     if(tmp == 0)
    92.         cout<<"pas bon"<<endl;
    93.     tmp->setPosition(mat.getTranslation());             // set position
    94.     tmp->setRotation(mat.getRotationDegrees()); // and rotation
    95. }
    96. void Voiture::aff()
    97. {
    98.     for(int i=0; i<4; i++)
    99.     {
    100.         core::matrix4 mat;
    101.         NewtonVehicleGetTireMatrix(vehicle, tire[i], mat.M);
    102.         NewtonVehicleSetTireSteerAngle(vehicle, tire[i], 0);
    103.         scene::ISceneNode *tmp;
    104.         tmp = (scene::ISceneNode *)NewtonVehicleGetTireUserData(vehicle, tire[i]);
    105.         tmp->setRotation(mat.getRotationDegrees());
    106.         tmp->setPosition(mat.getTranslation());
    107.         if(move)
    108.         {
    109.             float v[3] = {0}; //on cree une force tridimentionelle
    110.             v[0] = 20; //on ajoute l'apesenteur sur l'axe des Y
    111.             //On les envoi au corps
    112.             //NewtonBodySetVelocity(chassis, v);
    113.             //NewtonVehicleReset(vehicle);
    114.             NewtonVehicleSetTireTorque(vehicle, tire[i], 600);
    115.         }
    116.         if(left)
    117.             NewtonVehicleSetTireSteerAngle(vehicle, tire[i/2], 3.14/6);
    118.         else
    119.             NewtonVehicleSetTireSteerAngle(vehicle, tire[i/2], 0);
    120.     }
    121. }



    Edit:
    La fonction qui devrais faire tourner les roues se trouve a la ligne 167 de voiture.cpp
    • Partager sur Facebook
    • Partager sur Twitter
    bakura10
      5 décembre 2007 à 22:57:00

      Salut,

      Comme tous les ajouts de force extérieures avec Newton, elles doivent être effectuées dans un callback. Quand tu souhaites ajouter le poids d'un objet, tu ajoutes cette force dans un callback dédié (de type NewtonApplyForceAndTorque), via la fonction NewtonBodyAddForce.

      Pour les véhicules, c'est pareil. Les fonctions NewtonVehicleSetTireTorque, NewtonVehicleSetTireSteerAngle... doivent être appelées dans le callback de type NewtonVehicleTireCallback (que tu spécifies via la fonction NewtonVehicleSetTireCallback).

      Bonne soirée ;).
      • Partager sur Facebook
      • Partager sur Twitter
      Marco565
        6 décembre 2007 à 6:58:21

        ok merci mais je sait pas comment dire a la fonction torque d'aller voir dans le callBack

        merci de ta reponce
        • Partager sur Facebook
        • Partager sur Twitter
        bakura10
          6 décembre 2007 à 12:56:44

          C'est à dire ?

          Tu créé un callback :

          void TireCallback (const NewtonJoint * vehicle)
          {
          // Tu rajoutes tes forces ici, par exemple :
          NewtonVehicleSetTireTorque(vehicle, tire[i], 600);
          }

          Et tu n'oublies pas de dire à Newton d'appeler ce callback, grâce à la fonction suivante :

          NewtonVehicleSetTireCallback (vehicle, TireCallback);
          • Partager sur Facebook
          • Partager sur Twitter
          Marco565
            6 décembre 2007 à 18:29:44

            ok merci sa marche
            • Partager sur Facebook
            • Partager sur Twitter

            voiture irrlicht/newton

            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
            × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
            • Editeur ●
            • Markdown