NewtonBodySetUserData(body, cubeNode);

NewtonBodySetUserData(body,reinterpret_cast<void*>(cubeNode));

void GrNewton::SetMeshTransformMesh(const NewtonBody* body,const float* matrix,int threadIndex)
{
    // On retransforme le pointeur dans la bonne forme.
    ISceneNode*cubeNode = reinterpret_cast<ISceneNode*>(NewtonBodyGetUserData(body));
    if(cubeNode == 0)
        return;

    // Conversion et création de la bonne matrice, ...
    cubeNode->setPosition(mat.getTranslation());
    cubeNode->setRotation(mat.getRotationDegrees());
}

    ...ton code
    NewtonBodySetUserData(body, cubeNode);

    // Association d'une "Callback" (ici:SetMeshTransformMesh) à l'objet Newton,
    // elle sera appellée lorsque l'objet bougera selon le moteur Newton (il y a bcp d'exemple là dessus).
    NewtonBodySetTransformCallback(body,SetMeshTransformMesh);

NewtonBodyGetMatrix(body, mat.pointer());

void Systeme::rendu()
{
    /// variables pour le chronomètrage de l'execution des frames
    mTimeElapsed = 0;
    u32 startTime = 0;
    /// variable pour le rafraichissement de la physique
    u32 lastTime = 0;

    /// entrée dans la boucle
    while(mDevice->run())
    {
        /// on enregistre le temps de départ de la frame
        startTime = mDevice->getTimer()->getTime();
        /// update la physique
        if( startTime > (lastTime + TIME_STEP_MS) )
        {
            NewtonUpdate(mWorld, TIME_STEP_S );
            lastTime = startTime;
        }
        /// commence l'update de l'écran
        mDriver->beginScene(true, true, mBackgroundColor);
        /// dessine la scène
        mSmgr->drawAll();
        /// fin de l'update de l'écran
        mDriver->endScene();
        /// on calcule et enregistre le temps d'éxécution de la frame
        mTimeElapsed = mDevice->getTimer()->getTime() - startTime;

    #ifdef _DEBUG
    stringw str = L"My Game ["; str += mDriver->getName();str += "] ";
    str += "Temps de frame: "; str += mTimeElapsed; str += " ms";
    mDevice->setWindowCaption(str.c_str());
    #endif
    }
}

// Association d'une "Callback" (ici:SetMeshTransformMesh) à l'objet Newton,
    // elle sera appellée lorsque l'objet bougera selon le moteur Newton (il y a bcp d'exemple là dessus).
    NewtonBodySetTransformCallback(newBody,SetMeshTransformMesh);

    // Association d'une "Callback" (ici:ApplyForceAndTorqueEvent) à l'objet Newton,
    // elle sera appellée lorsque l'objet devra subir une force (il y a bcp d'exemple là dessus).
    NewtonBodySetForceAndTorqueCallback(newBody,ApplyForceAndTorqueEvent);

// rapport d'échelle 
#define NEWTON_TO_IRR 32.0f
#define IRR_TO_NEWTON (1.0f/NEWTON_TO_IRR)

/// cube irrlicht
ISceneNode *Node001 = smgr->addCubeSceneNode(200);
/// récupère la taille de la boundingbox du node pour la creation d'une collision de type "BOX" 
vector3df size = Node001->getBoundingBox().getExtent() * IRR_TO_NEWTON; // ADAPTATION DE L'ECHELLE AVEC UN COEF
/// créé le cube qui servira pour le calcul de collision
NewtonCollision* NC_Node001 = NewtonCreateBox(World, size.X, size.Y, size.Z, -1, NULL);

NewtonCollision* createTreeCollisionFromMesh(NewtonWorld* nWorld, IMesh* irr_mesh)
{
    //Create new (tree optimized) collision mesh
    NewtonCollision* collision_obj = NewtonCreateTreeCollision(nWorld,0);

    //Begin collision mesh construction
    NewtonTreeCollisionBeginBuild(collision_obj);

    u32 nMeshBuffer = 0; //Mesh Buffer count
    u16 v_index[3] = {0,0,0}; //vertex indices
    IMeshBuffer *mesh_buffer = 0;
    float array[9]; //Array to store 3 vertices

    //Get (irr_)mesh buffers and copy face by face to collision mesh
    for( nMeshBuffer=0 ; nMeshBuffer < irr_mesh->getMeshBufferCount() ; nMeshBuffer++ )
    {
        mesh_buffer = irr_mesh->getMeshBuffer(nMeshBuffer);

        //Get pointer to vertices and indices
        S3DVertex *vertices = (S3DVertex*)mesh_buffer->getVertices();
        u16 *indices = mesh_buffer->getIndices();

        //Fill collision mesh
        for(u32 i=0; i<mesh_buffer->getIndexCount(); i+=3)
        {
            v_index[0] = indices[ i ];
            v_index[1] = indices[i+1];
            v_index[2] = indices[i+2];

            // 1st position vertex
            array[0] = vertices[ v_index[0] ].Pos.X * IRR_TO_NEWTON;
            array[1] = vertices[ v_index[0] ].Pos.Y * IRR_TO_NEWTON;
            array[2] = vertices[ v_index[0] ].Pos.Z * IRR_TO_NEWTON;

            // 2nd position vertex
            array[3] = vertices[ v_index[1] ].Pos.X * IRR_TO_NEWTON;
            array[4] = vertices[ v_index[1] ].Pos.Y * IRR_TO_NEWTON;
            array[5] = vertices[ v_index[1] ].Pos.Z * IRR_TO_NEWTON;

            // 3rd position vertex
            array[6] = vertices[ v_index[2] ].Pos.X * IRR_TO_NEWTON;
            array[7] = vertices[ v_index[2] ].Pos.Y * IRR_TO_NEWTON;
            array[8] = vertices[ v_index[2] ].Pos.Z * IRR_TO_NEWTON;

            //Add new face to collision mesh
            NewtonTreeCollisionAddFace( collision_obj,  //collision mesh to add face to
                                        3,              //number of vertices in array
                                        (float*)array,  //pointer to vertex array
                                        3*sizeof(float),//size of each vertex
                                        1);             //ID of the face
        }
    }
    //End collision contruction , set 1 as 2dn param for optimization
    NewtonTreeCollisionEndBuild(collision_obj,0);

    return collision_obj;
}

/// IRRLICHT
#include "irrlicht.h"
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;

/// NEWTON
#include "newton.h"
#include "dMatrix.h"

/// Constantes
#define GRAVITY -9.8f
#define NEWTON_TO_IRR 32.0f
#define IRR_TO_NEWTON (1.0f/NEWTON_TO_IRR)


void  PhysicsApplyForceAndTorque (const NewtonBody* body, float, int)
{
    dFloat Ixx;
    dFloat Iyy;
    dFloat Izz;
    dFloat mass;

    NewtonBodyGetMassMatrix (body, &mass, &Ixx, &Iyy, &Izz);
    dVector force (0.0f, mass * GRAVITY, 0.0f);
    NewtonBodySetForce (body, &force.m_x);
}

// set the transformation of a rigid body
//You have to do this so that the Newton body and irrLicht scene node are in sync,
//and you actually see the changes created by the physics simulation
void  PhysicsSetTransform (const NewtonBody* body, const dFloat* matrix, int)
{
    scene::ISceneNode* primitive;

    // get the graphic object form the rigid body
    //Newton can store a pointer to the scene node in the body object.
    primitive = (scene::ISceneNode*) NewtonBodyGetUserData (body);

    // set the transformation matrix for this rigid body
    dMatrix& mat = *((dMatrix*)matrix);

    //Create a matrix to store the irrLicht transformation that will correspond
    //to the Newton transformation
    matrix4 irrMatrix;

    //There's no easy way to get the information from one to the other, so a memory copy is required.
    //The matrix is a 4x4 float
    memcpy (irrMatrix.pointer(), &mat, 16*sizeof(float));

    //In order to get the transform right, you have to apply the translation and the rotation
    //from the Newton body to the irrLicht scene node.
    vector3df position (irrMatrix.getTranslation());
    position *= NEWTON_TO_IRR;

    vector3df rotation;
    NewtonGetEulerAngle(irrMatrix.pointer(), &rotation.X);
    rotation = rotation * RADTODEG;

    primitive->setPosition (position);
    primitive->setRotation(rotation);
}


/// classe pour la gestion des événements
class MyEventReceiver : public IEventReceiver
{
    public:
        MyEventReceiver(IrrlichtDevice*dev) { device = dev; }
        IrrlichtDevice* device;

        virtual bool OnEvent(const SEvent& event)
        {
            if (event.EventType == EET_KEY_INPUT_EVENT)
            {
                if(event.KeyInput.PressedDown)
                {
                    switch(event.KeyInput.Key)
                    {
                        case KEY_ESCAPE:
                            device->closeDevice();                  // QUITTE L'APPLICATION
                            return true;
                        default:
                            break;
                    }
                }
            }
            /// aucun événement n'a été traité
            return false;
        }

};

int main(int argc, char** argv)
{
    /// Initialisation de NEWTON
    static NewtonWorld* World = NewtonCreate();
    NewtonSetPlatformArchitecture(World, 0);
    float minSize[3] = {-5000.0f, -5000.0f, -5000.0f};
    float maxSize[3] = {5000.0f, 5000.0f, 5000.0f};
    NewtonSetWorldSize(World, &minSize[0], &maxSize[0]);
    NewtonSetSolverModel(World, 1);
    NewtonSetFrictionModel(World, 1);
    /// materiau par défaut
    NewtonMaterialSetDefaultFriction( World, 0, 0, 0.5f, 0.5f);
    NewtonMaterialSetDefaultElasticity( World, 0, 0, 0.0f);
    NewtonMaterialSetDefaultSoftness( World, 0, 0, 1.0f);
    //NewtonMaterialSetDefaultCollidable( World, 0, 2, 1); // autorise les collisions entre le groupID 2 et 3, le 1 veut dire true

    /// Intitialisation d'IRRLICHT
    IrrlichtDevice *device = createDevice(EDT_OPENGL, dimension2du(1280, 720), 32, false, false, false, 0);
    device->setWindowCaption(L"Irrlicht Engine Essais");

    /// Créé et applique le gestionnaire d'événements
    MyEventReceiver receiver(device);
    device->setEventReceiver(&receiver);

    /// Créé les environnements
    IVideoDriver* driver = device->getVideoDriver();
    ISceneManager* smgr = device->getSceneManager();
    IGUIEnvironment* guienv = device->getGUIEnvironment();
    IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices();

    /// Créé la camera
    ICameraSceneNode *NodeCamera = smgr->addCameraSceneNodeFPS();
    NodeCamera->setFarValue(1000000.0f);
    //NodeCamera->setPosition(vector3df(-2300,20,2300));
    //NodeCamera->setTarget( vector3df(0,0,0) );
    device->getCursorControl()->setVisible(false);

    /// Créations


    /// CUBE symbolisant le sol
    ISceneNode *Node001 = smgr->addCubeSceneNode(500);
    if( Node001 )
    {
        Node001->setMaterialFlag(EMF_LIGHTING, false);
        Node001->setMaterialTexture(0, driver->getTexture("../MEDIAS/water.jpg"));
        Node001->setPosition( vector3df(0,-500,0) );

        /// ajout de la physique à Node002
        NewtonCollision* NC_Node001 = NULL;
        NewtonBody*  NB_Node001 = NULL;
        /// récupère la taille de la boundingbox du node pour la creation d'une collision de type "BOX"
        vector3df size = Node001->getBoundingBox().getExtent() * IRR_TO_NEWTON;
    #ifdef _DEBUG
        printf("Node001 - size Newton : X=%f; Y=%f; Z=%f;\n", size.X, size.Y, size.Z);
    #endif
        /// créé le cube qui servira pour le calcul de collision
        NC_Node001 = NewtonCreateBox(World, size.X, size.Y, size.Z, -1, NULL);
        if(NC_Node001)
        {
    #ifdef _DEBUG
            printf("Newton Collision - Node001 : OK\n");
    #endif
            /// transforme la matrice du node pour NEWTON
            matrix4 matrix = Node001->getRelativeTransformation();
            vector3df origin = Node001->getRelativeTransformation().getTranslation() * IRR_TO_NEWTON;
            matrix.setTranslation(origin);
            /// créé le corps pour l'application d'effets sur le node irrlicht
            NB_Node001 = NewtonCreateBody(World, NC_Node001, matrix.pointer());
            if(NB_Node001)
            {
    #ifdef _DEBUG
                printf("Newton Body - Node001 : OK\n");
    #endif
                ///
                NewtonReleaseCollision(World, NC_Node001);
                ///
                NewtonBodySetUserData(NB_Node001, Node001);
                ///
                NewtonBodySetTransformCallback(NB_Node001, PhysicsSetTransform);
                NewtonBodySetForceAndTorqueCallback(NB_Node001, PhysicsApplyForceAndTorque);
                /// définit la masse et l'inertie de l'objet
                NewtonBodySetMassMatrix (NB_Node001, 0.0f, 0.0f, 0.0f, 0.0f);
            }
    #ifdef _DEBUG
            else printf("Newton Body - Node001 : PROBLEME\n");
    #endif
        }
    #ifdef _DEBUG
        else printf("Newton Collision - Node001 : PROBLEME\n");
    #endif

#ifdef _DEBUG
        printf("Node001 : OK\n");
    }
    else
    {
        printf("Node001 : PROBLEME\n");
#endif
    }

    /// CUBE tombant sur le sol
    ISceneNode *Node002 = smgr->addCubeSceneNode(20);
    if( Node002 )
    {
        Node002->setMaterialFlag(EMF_LIGHTING, false);
        Node002->setMaterialTexture(0, driver->getTexture("../MEDIAS/water.jpg"));
        Node002->setPosition( vector3df(0,1000,0) );

        /// ajout de la physique à Node002
        NewtonCollision* NC_Node002 = NULL;
        NewtonBody*  NB_Node002 = NULL;
        /// récupère la taille de la boundingbox du node pour la creation d'une collision de type "BOX"
        vector3df size = Node002->getBoundingBox().getExtent() * IRR_TO_NEWTON;
    #ifdef _DEBUG
        printf("Node002 - size Newton : X=%f; Y=%f; Z=%f;\n", size.X, size.Y, size.Z);
    #endif
        /// créé le cube qui servira pour le calcul de collision
        NC_Node002 = NewtonCreateBox(World, size.X, size.Y, size.Z, -1, NULL);
        if(NC_Node002)
        {
    #ifdef _DEBUG
            printf("Newton Collision - Node002 : OK\n");
    #endif
            /// transforme la matrice du node pour NEWTON
            matrix4 matrix = Node002->getRelativeTransformation();
            vector3df origin = Node002->getRelativeTransformation().getTranslation() * IRR_TO_NEWTON;
            matrix.setTranslation(origin);
            /// créé le corps pour l'application d'effets sur le node irrlicht
            NB_Node002 = NewtonCreateBody(World, NC_Node002, matrix.pointer());
            if(NB_Node002)
            {
    #ifdef _DEBUG
                printf("Newton Body - Node002 : OK\n");
    #endif
                ///
                NewtonReleaseCollision(World, NC_Node002);
                ///
                NewtonBodySetUserData(NB_Node002, Node002);
                ///
                NewtonBodySetTransformCallback(NB_Node002, PhysicsSetTransform);
                NewtonBodySetForceAndTorqueCallback(NB_Node002, PhysicsApplyForceAndTorque);
                /// définit la masse et l'inertie de l'objet
                NewtonBodySetMassMatrix (NB_Node002, 1.0f, 0.0f, 0.0f, 0.0f);
            }
    #ifdef _DEBUG
            else printf("Newton Body - Node002 : PROBLEME\n");
    #endif
        }
    #ifdef _DEBUG
        else printf("Newton Collision - Node002 : PROBLEME\n");
    #endif

#ifdef _DEBUG
        printf("Node002 : OK\n");
    }
    else
    {
        printf("Node002 : PROBLEME\n");
#endif
    }

    /// Boucle de rendu
    int lastFPS = -1;
    u32 lastTime = 0;
    f32 timestepS = 0.017f; u32 timestepMS = timestepS * 500;
#ifdef _DEBUG
    printf("On entre dans la boucle de rendu.\n");
#endif
    while(device->run())
    {
        /// update la physique
        u32 courantTime = device->getTimer()->getTime();
        if( courantTime > (lastTime + timestepMS) )
        {
            NewtonUpdate(World, timestepS );
            lastTime = courantTime;
        }

        /// dessine la frame
        driver->beginScene(true, true, SColor(0,200,200,200));
        smgr->drawAll();
        guienv->drawAll();
        driver->endScene();

        /// affiche le nombre de fps dans la barre de titre
        int fps_int = driver->getFPS();
        if (lastFPS  != fps_int)
        {
            stringw str = L"Irrlicht Engine Essais [";
            str += driver->getName();
            str += "] FPS:"; str += fps_int;
            str += " | Triangles :"; str += driver->getPrimitiveCountDrawn();
            device->setWindowCaption(str.c_str());
            lastFPS = fps_int;
        }
    }

    /// libération de Newton
    NewtonDestroyAllBodies(World);
    NewtonDestroy (World);

    /// libération d'Irrlicht
    device->drop();

    /// sortie du programme
    return 0;
}

remplace :

NewtonBodyAddForce(body, force);
NewtonBodyAddTorque(body, torque); 

par :

NewtonBodySetForce(body, force);
NewtonBodySetTorque(body, torque);