Salut, je ne sais pas si ça peut t'aider, moi j'utilise le code suivant dans VEM pour utiliser Newton et Irrlicht, ça fonctionne très bien. Regarde les paramètres des fonctions, c'est assez clair.

La méthode de Newton ne créé pas de forme concave, seulement convexe, il faut donc associer plusieurs formes convexes pour obtenir une concave, je fais ce traitement également et c'est plutôt cool.

NewtonCollision* GrNewton::createCollisionFromMesh(NewtonWorld *nWorld,
                                                   irr::scene::IMesh* irr_mesh,
                                                   float tolerance,
                                                   float scaleX,
                                                   float scaleY,
                                                   float scaleZ,
                                                   int shapeID,
                                                   const float* offsetMatrix)
{
    int nMeshBuffer = 0;    //Mesh Buffer count
    irr::scene::IMeshBuffer *mesh_buffer = 0;
    float *vertices;        //Array to store vertices

    irr::u32 nVertices = 0;

    //Get number of vertices
    for( nMeshBuffer=0 ; nMeshBuffer < irr_mesh->getMeshBufferCount() ; nMeshBuffer++ )
    {
        nVertices += irr_mesh->getMeshBuffer(nMeshBuffer)->getVertexCount();
    }

    //create buffer for vertices
    vertices = new float[nVertices * 3];
    irr::u32 tmpCounter = 0;

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

        //Get pointer to vertices and indices
        irr::video::S3DVertex *S3vertices = (irr::video::S3DVertex*)mesh_buffer->getVertices();

        //copy vertices from mesh to buffer
        for(int i=0; i<mesh_buffer->getVertexCount(); i++)
        {
            vertices[tmpCounter++] = S3vertices[i].Pos.X * scaleX / GrConstants::IRR_SCALE;
            vertices[tmpCounter++] = S3vertices[i].Pos.Y * scaleZ / GrConstants::IRR_SCALE;
            vertices[tmpCounter++] = S3vertices[i].Pos.Z * scaleY / GrConstants::IRR_SCALE;
        }
    }
    //Create Newton collision object
    NewtonCollision *collision_obj = NewtonCreateConvexHull(nWorld,nVertices,vertices,sizeof(float)*3,tolerance,shapeID,offsetMatrix);

    //delete vertices
    delete [] vertices;

    return collision_obj;
}

NewtonCollision* GrNewton::createTreeCollisionFromMesh(NewtonWorld* nWorld,
                                                       irr::scene::IMesh* irr_mesh,
                                                       float scaleX,
                                                       float scaleY,
                                                       float scaleZ)
{
    //Create new (tree optimized) collision mesh
    NewtonCollision* collision_obj = NewtonCreateTreeCollision(nWorld,0);

    //Begin collision mesh construction
    NewtonTreeCollisionBeginBuild(collision_obj);

    int nMeshBuffer = 0; //Mesh Buffer count
    int v_index[3] = {0,0,0}; //vertex indices
    irr::scene::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
        irr::video::S3DVertex *vertices = (irr::video::S3DVertex*)mesh_buffer->getVertices();
        irr::u16 *indices = mesh_buffer->getIndices();

        //Fill collision mesh
        for(int 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 * scaleX / GrConstants::IRR_SCALE;
            array[1] = vertices[ v_index[0] ].Pos.Y * scaleZ / GrConstants::IRR_SCALE;
            array[2] = vertices[ v_index[0] ].Pos.Z * scaleY / GrConstants::IRR_SCALE;

            // 2nd position vertex
            array[3] = vertices[ v_index[1] ].Pos.X * scaleX / GrConstants::IRR_SCALE;
            array[4] = vertices[ v_index[1] ].Pos.Y * scaleZ / GrConstants::IRR_SCALE;
            array[5] = vertices[ v_index[1] ].Pos.Z * scaleY / GrConstants::IRR_SCALE;

            // 3rd position vertex
            array[6] = vertices[ v_index[2] ].Pos.X * scaleX / GrConstants::IRR_SCALE;
            array[7] = vertices[ v_index[2] ].Pos.Y * scaleZ / GrConstants::IRR_SCALE;
            array[8] = vertices[ v_index[2] ].Pos.Z * scaleY / GrConstants::IRR_SCALE;

            //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;
}