salut le Zamis

j'ai trouvés deux lib réalisant une encapsulation haut niveau de ODE, EZPhysics et OPAL

http://ezphysics.org/index.htm

http://ox.slug.louisville.edu/~o0lozi01/opal_wiki/index.php/Main_Page

vous avez déja testé ? vous avez des conseils pour quelqu'un qui veux se lancer dans l'une des deux ?
des conseils pour choisir ?

voila, si personne a testé, je vous ferai un petit rapport avec mon avis quand j'en aurai un

J'ai commencé à utiliser OPAL depuis hier, et çà à l'air vraiment très bien. J'arrive à utiliser les primitives de base d'OPAL et à les rendre dans Irrlicht, par contre j'ai du mal à créer des objets "solides" à partir des meshs d'Irrlicht : les solides entrent bien en collision les uns avec les autres, mais ils finissent toujours par se traverser (un peu gênant pour les collisions avec le niveau... ). J'utilise ce code pour charger les meshs (il vient du site d'OPAL) :

//merely a wrapper that will iterate across an IMesh's buffers
bool IRRtoOPAL_AddMeshToSolid( opal::Solid* solid, irr::scene::IMesh * mesh )
{
    bool success = true;
    for ( int mb=0; mb < mesh->getMeshBufferCount() ; mb++ )
    {
        if ( !IRRtoOPAL_AddMeshBufferToSolid( solid, mesh->getMeshBuffer(mb) ) )
        {
            success = false;
            //still loads in more mesh buffers if there is an error
        }
    }
    return success;
}

//adds mesh shapes to an already created OPAL solid from an Irrlicht IMeshBuffer
bool IRRtoOPAL_AddMeshBufferToSolid( opal::Solid* solid, irr::scene::IMeshBuffer * meshBuffer )
{
    opal::MeshShapeData meshData;
    meshData.numVertices = 0;
    meshData.numTriangles = 0;

    meshData.numVertices = meshBuffer->getVertexCount();
    meshData.numTriangles = meshBuffer->getIndexCount()/3;

    meshData.vertexArray = new opal::real[3 * meshData.numVertices];
    meshData.triangleArray = new unsigned int[3 * meshData.numTriangles];

    // Copy vertex data.
    irr::video::S3DVertex*	normVerts = (irr::video::S3DVertex*)(meshBuffer->getVertices());
    irr::video::S3DVertex2TCoords* txrVerts =
        (irr::video::S3DVertex2TCoords*)(meshBuffer->getVertices());
    irr::video::S3DVertexTangents* tangyVerts =
        (irr::video::S3DVertexTangents*)(meshBuffer->getVertices());
    for (unsigned int i = 0; i < meshBuffer->getVertexCount(); ++i)
    {

        switch (meshBuffer->getVertexType())
        {
        case irr::video::EVT_STANDARD:
            {
                meshData.vertexArray[3 * i + 0] = normVerts[i].Pos.X;
                meshData.vertexArray[3 * i + 1] = normVerts[i].Pos.Y;
                meshData.vertexArray[3 * i + 2] = normVerts[i].Pos.Z;
            }
            break;
        case irr::video::EVT_2TCOORDS:
            {
                meshData.vertexArray[3 * i + 0] = txrVerts[i].Pos.X;
                meshData.vertexArray[3 * i + 1] = txrVerts[i].Pos.Y;
                meshData.vertexArray[3 * i + 2] = txrVerts[i].Pos.Z;
            }
            break;
        case irr::video::EVT_TANGENTS:
            {
                meshData.vertexArray[3 * i + 0] = tangyVerts[i].Pos.X;
                meshData.vertexArray[3 * i + 1] = tangyVerts[i].Pos.Y;
                meshData.vertexArray[3 * i + 2] = tangyVerts[i].Pos.Z;
            }
            break;
        default:
        {
            // you will need to handle the vertex type
            assert(false);
        }
        break;
        }
    }

    // Copy triangle data.
    uint16_t* meshIndices = (uint16_t*)meshBuffer->getIndices();
    for (unsigned int i = 0; i < meshData.numTriangles; ++i)
    {
        meshData.triangleArray[i*3 + 0] = meshIndices[i*3 + 0];
        meshData.triangleArray[i*3 + 1] = meshIndices[i*3 + 1];
        meshData.triangleArray[i*3 + 2] = meshIndices[i*3 + 2];
    }
    solid->addShape(meshData);

    return true;
}

void IRRtoOPAL_ReleaseSolidMeshData( opal::Solid* solid )
{
    if (solid)
    {
        //make sure to remove memory allocated for mesh objects
        opal::SolidData solidData = solid->getData();
        for (unsigned int i = 0; i < solidData.getNumShapes(); ++i)
        {
            if (solidData.getShapeData(i)->getType() == opal::MESH_SHAPE)
            {
                opal::MeshShapeData* meshData =
                    (opal::MeshShapeData*)solidData.getShapeData(i);
                delete [] meshData->vertexArray;
                delete [] meshData->triangleArray;
            }
        }
    }
}

Hello,
Je vais persister à dire que j'aime pas ses libs d'encapsulation ^_^.
Je trouve ça "con" d'utiliser une lib telle que Ode par l'intermédiaire d'une encapsulation qui risque de rajouter des bugs, qui va restreindre l'utilisateur à ce qu'elle propose et qui au final fera pas forcément gagner du temps.
Ca y est là j'ai mis le feu, la réplique de Jerry va être terrible .
Enfin ça reste mon avis personnel, je n'ai jamais réellement pris le temps non plus d'en utiliser une, mais pour l'instant ça me donne pas envie.

Donc mes questions sont les suivantes pour ceux qui testent :
Comment on gère le time stepping sous vos libs ?
Si je veux faire un effet de ralentissement à la matrix, ça reste aisé ?
Et enfin donné moi un excellent argument de vente avec se systeme plustôt que Ode en natif qui me permet une liberté totale de mon code ?

Comment on gère le time stepping sous vos libs ?

sim->simulate(temps écoulé depuis la dernière simulation);

Si je veux faire un effet de ralentissement à la matrix, ça reste aisé ?

Et enfin donné moi un excellent argument de vente avec se systeme plustôt que Ode en natif qui me permet une liberté totale de mon code ?

• les breakables joints : juste une propriété qui permet de casser automatiquement les joints entre 2 solides quand une force suffisamment importante lui est appliqué.
• les motors : on les paramètre au début, et après, on a juste à les activer/désactiver quand on veut (OPAL s'occupe tout seul d'ajouter les forces et torques nécessaires)
• j'aime bien le système de détection des collisions sous forme d'évênements, qui ressemble beaucoup au système de gestion des évênements dans Irrlicht. Dans ODE si je me trompes pas, faut passer par des callbacks : çà marche aussi bien, mais je trouve le code moins clair.
• la possibilité de sauver et de charger les paramètres des solides, des joints etc dans des fichiers xml

Copland Ecris:

Hello,
Je vais persister à dire que j'aime pas ses libs d'encapsulation ^_^.
Je trouve ça "con" d'utiliser une lib telle que Ode par l'intermédiaire d'une encapsulation qui risque de rajouter des bugs, qui va restreindre l'utilisateur à ce qu'elle propose et qui au final fera pas forcément gagner du temps.
Ca y est là j'ai mis le feu, la réplique de Jerry va être terrible .

Copland Ecris:

Comment on gère le time stepping sous vos libs ?

Copland Ecris:

Si je veux faire un effet de ralentissement à la matrix, ça reste aisé ?

Copland Ecris:

Et enfin donné moi un excellent argument de vente avec se systeme plustôt que Ode en natif qui me permet une liberté totale de mon code ?

Bon, pour en revenir à mon problème (si çà intéresse encore quelqu'un ), j'ai testé davantage et apparement le problème ne survient que pour les collisions entre 2 solides créés à partir de meshs d'Irrlicht (aucuns soucis pour les collisions entre un solide créé à partir d'un mesh d'Irrlicht et une primitive d'OPAL). Par contre, çà marche absolument pas à partir des heightmaps

Conclusion : j'utiliserais les fonctions de mon premier post uniquement pour les éléments statics de mon niveau, et les autres objets seront tous controllés par des primitives d'OPAL.

Perceval Ecris:

Conclusion : j'utiliserais les fonctions de mon premier post uniquement pour les éléments statics de mon niveau, et les autres objets seront tous controllés par des primitives d'OPAL.

Ben moi j'ai jamais voulu utiliser "ODE pur" sinon j'aurais pas télécharger OPAL