sa aurais besoin d'être un peut optimisé quand même
environs 1min pour faire le trimesh .... ( qui plus est marche pas *-* )

Bizarre, avec Newton je n'ai jamais eu ce soucis.

Tu pourrais poster juste la routine de récupération pour voir ou pourrais être les différences ...

voila :

creation de la physique :

    TerrainPhysique::TerrainPhysique(Physique*World,GameEngine::TerrainEngine::CTerrainNode*geom)
    {
        user = NULL;    Node = geom;    phy = World;
        btTransform Transform;
            Transform.setIdentity();
            Transform.setOrigin(btVector3(0,0,0));
        btDefaultMotionState *MotionState = new btDefaultMotionState(Transform);
        formCollide = new CollisionForm(phy->getDevice());
            formCollide->makeTerrain(geom);
        node = new btRigidBody(0.0f,MotionState,formCollide->getShape(),formCollide->getLocalInertia());
            node->setUserPointer((void*)(this));
        //setType(OTP_STATIC);// plante
        phy->getWorldPhysic()->addRigidBody(node);
        //setPosition(irr::core::vector3df(0,0,0));// plante aussi : |
        Kst = NULL;
    }

    void CollisionForm::makeTerrain(GameEngine::TerrainEngine::CTerrainNode*terrain)
    {
        btTriangleMesh *CollisionMesh = new btTriangleMesh();
        int j = 0;
        for(int i=0; i<terrain->numQuad; i++)
            meshBufferToPhysic(terrain->GetQuadNode(i)->mbuffer,CollisionMesh,terrain->getScale());
        Shape = new btBvhTriangleMeshShape(CollisionMesh, true);
        setOrigine(0.0f,terrain->getBoundingBox().getCenter());
    }

    void CollisionForm::meshBufferToPhysic(irr::scene::IMeshBuffer *TMeshBuffer, btTriangleMesh *TCollisionMesh, const irr::core::vector3df &TScale)
    {
        btVector3 TriangleVertices[3];
        irr::u16 *Indices = TMeshBuffer->getIndices();
        if(TMeshBuffer->getVertexType() == irr::video::EVT_STANDARD)
        {
            irr::video::S3DVertex *Vertices = (irr::video::S3DVertex*)TMeshBuffer->getVertices();
            for(irr::u32 i = 0; i < TMeshBuffer->getIndexCount(); i += 3)
            {
                TriangleVertices[0] = btVector3(Vertices[Indices[i]].Pos.X * TScale.X,Vertices[Indices[i]].Pos.Y * TScale.Y,Vertices[Indices[i]].Pos.Z * TScale.Z);
                TriangleVertices[1] = btVector3(Vertices[Indices[i+1]].Pos.X * TScale.X,Vertices[Indices[i+1]].Pos.Y * TScale.Y,Vertices[Indices[i+1]].Pos.Z * TScale.Z);
                TriangleVertices[2] = btVector3(Vertices[Indices[i+2]].Pos.X * TScale.X,Vertices[Indices[i+2]].Pos.Y * TScale.Y,Vertices[Indices[i+2]].Pos.Z * TScale.Z);
                TCollisionMesh->addTriangle(TriangleVertices[0], TriangleVertices[1], TriangleVertices[2],true);
            }
        }
        else
        {
            irr::video::S3DVertex2TCoords *Vertices = (irr::video::S3DVertex2TCoords*)TMeshBuffer->getVertices();
            for(irr::u32 i = 0; i < TMeshBuffer->getIndexCount(); i += 3)
            {
                TriangleVertices[0] = btVector3(Vertices[Indices[i]].Pos.X * TScale.X,Vertices[Indices[i]].Pos.Y * TScale.Y,Vertices[Indices[i]].Pos.Z * TScale.Z);
                TriangleVertices[1] = btVector3(Vertices[Indices[i+1]].Pos.X * TScale.X,Vertices[Indices[i+1]].Pos.Y * TScale.Y,Vertices[Indices[i+1]].Pos.Z * TScale.Z);
                TriangleVertices[2] = btVector3(Vertices[Indices[i+2]].Pos.X * TScale.X,Vertices[Indices[i+2]].Pos.Y * TScale.Y,Vertices[Indices[i+2]].Pos.Z * TScale.Z);
                TCollisionMesh->addTriangle(TriangleVertices[0], TriangleVertices[1], TriangleVertices[2],true);
            }
        }
    }

J'ausculte cela demain, et en rentrant je te donnerais mon sentiment

ok

Bon je viens un peu de regarder ton code (désolé pour le retard, journée longue et difficile).
Apparement, tout semble plutôt bien ficelé.

Je sais que suivant le taille du terrain, on arrive très vite à un nombre non négligeable de
triangle, mais finalement pas plus qu'avec un terrain généré par le moteur de terrain natif
d'Irrlicht.
Donc pourquoi cette lenteur ?

As-tu essayer en terme de vitesse le même code, mais en mettant de coté les lignes

                TCollisionMesh->addTriangle(TriangleVertices[0], TriangleVertices[1], TriangleVertices[2],true);

les triangles sont stocké dans un array propre au moteur physique, pour la lenteur, je viens d'essayer en m'étant false en dernier paramètre ... ses déjà mieux ... ( 2 à 3 sec )
le paramètre est sencé être pour enlevé les vertices en double

seul problème avec se que tu dit ses que si j'enlève 'addTriangle' je n'est plus de géométrie coté physique ...
mise a par ça les collision avec le terrain non toujours pas lieux, et les fonctions de base pour intérragir avec un cette objet plante ... pointeur invalid je suppose mais ou ? tout marche convenablement avec les objets 'normaux'

[edit] : qui plus est la géométrie récupéré semble ok, vue que les objets disparaisse pile a la rencontre du terrain ... a moins que le problème des polygones 'retournés' ? mais dans se cas il y aurais collision par en dessous ... mais non plus

C'est en effet très bizarre. As-tu testé la même chose, mais sur un terrain définit beuaoucps plus 'light', genre 4 Quads contenant chacun pas plus de
128 faces par exemple ?
Car, par rapport à d'autre objet, le terrain n'est rien d'autre qu'un maillage constitué de triangle...

j'utilise 16 quads contenant 16 face ... raisonnable donc ...
qui plus est cela est encore plus dur si gdb enlève les problèmes et supprime carrément les collisions du terrain ... donc intraçable
je vais demander à se bon vieux Copland aussi

Magun Ecris:

j'utilise 16 quads contenant 16 face ... raisonnable donc ...

j'ai un total de 131304 polygone
mais ma physique marche toujours pas

Si j'ai bien suivi, par contre, d'après ce que tu disais, si tu importe un mesh en forme de terrain, et que tu l'intègre à ta physique,
là ça marche, ?

normalement oui, j'ai déjà essayé mon trimesh il marche ( mise a par qu'il n'y a pas de collision trimesh vs trimesh )
ah mon avis j'ai oublier une ligne quelque par mais je voie pas où ...
ou alors bullet veut que tout les polygones soient relier ? dans se cas il me faudrait modifier un peut le terrain pour mettre 2 polygone qui relie les extrémités
sa me parait bizarre ...

je peut aussi faire un soft body de type "tissu" solide et je déforme suivant la hauteur du terrain
boff quand même ...

il y a aussi une class spécial terrain dans bullet mais je voie pas trop comment l'utiliser ...
"btHeightfieldTerrainShape (int heightStickWidth, int heightStickHeight, void *heightfieldData, btScalar maxHeight, int upAxis, bool useFloatData, bool flipQuadEdges)"
http://www.continuousphysics.com/Bullet/BulletFull/classbtHeightfieldTerrainShape.html

Encore moi
je t'embête uhn ?

y a un petit soucis, avec le frustum culling, si on utilise 2 terrain


en plus y a un gros soucis sur mon code, la physique ne marche que sur le deuxième terrain ...., ou alors il y a le problème, que je te parlais présédament, avec un seul ...

Je pense que c'est du au fait qu'à l'origine je n'ai pas vraiment prévu les déplacement de terrain, ce qui doit poser des
soucis sur les bonne position des box des quad.
Je vais bientôt revenir dessus, d'ici au début de la semaine en 8 normalement, car je vais intégrer ce moteur de terrain
dans mon projet, et donc va falloir que je corrige tous ces bug .

J'ai essayé d'utiliser le moteur de terrain mais j'obtiens des erreurs :

1>Jeu.obj : error LNK2019: symbole externe non résolu "public: void __thiscall CTerrainNode::setMaterialType(enum irr::video::E_MATERIAL_TYPE)" (?setMaterialType@CTerrainNode@@QAEXW4E_MATERIAL_TYPE@video@irr@@@Z) référencé dans la fonction _main
1>Jeu.obj : error LNK2019: symbole externe non résolu "public: void __thiscall CTerrainNode::setMaterialTexture(unsigned int,class irr::video::ITexture *)" (?setMaterialTexture@CTerrainNode@@QAEXIPAVITexture@video@irr@@@Z) référencé dans la fonction _main
1>Jeu.obj : error LNK2019: symbole externe non résolu "public: void __thiscall CTerrainNode::Construct(char *,float)" (?Construct@CTerrainNode@@QAEXPADM@Z) référencé dans la fonction _main
1>Jeu.obj : error LNK2019: symbole externe non résolu "public: void __thiscall CTerrainNode::SetValues(int,int,int)" (?SetValues@CTerrainNode@@QAEXHHH@Z) référencé dans la fonction _main
1>Jeu.obj : error LNK2019: symbole externe non résolu "public: __thiscall CTerrainNode::CTerrainNode(class irr::scene::ISceneNode *,class irr::scene::ISceneManager *,int)" (??0CTerrainNode@@QAE@PAVISceneNode@scene@irr@@PAVISceneManager@23@H@Z) référencé dans la fonction _main
1>d:\\Visual Studio 2008\\Projects\\Dreams and Fantasy\\Dreams and Fantasy\\\\Dreams and Fantasy.exe : fatal error LNK1120: 5 externes non résolus

C'est bon, j'ai résolu le probleme.

Je viens de tester... Ça fonctionne vraiment bien, l'exemple 4 me donne un 1800 FPS!!! Vraiment impressionnant!

ey TMyke
je code un éditeur de scene vite fait intergant un éditeur de terrain, j'ai un peut la flemme de coder une petit fonction pour enregistré le "nouveaux terrain" en format height map dans une IImage*
je me demandais si tu n'avais pas sa dans tes code ?

ps : l'editeur utilise mon scene manager que je vais bientot faire par ainssi que sont éditeur avec donc voila si je pouvais gagné un peut de temps ?

@christianclavet: cela faisait un moment que l'on ne m'avais pas parlé de mon petit terrain engine

@Magun: Je vais voir cela , je te tiens au courant...

merci d'avance

P'tite question: en fait, tu modife le terrain dynamiquement, et tu souhaiterais faire une sauvegarde ? Si ce n'est pas une image, est-ce grave pour toi ?

oui je le modifie dynamiquement, et bien pour l'image oui cela l'est plutôt étant donner que je le charge après je me base sur un système de sérialisation pour les scènes et donc plus pratique en format image

edit : oui sauvegarde

µOK, je vais étudier cela

j'ai modifier pas mal le moteur et puis je me suis dit que quelque nouveaux serait intéresser par ma dernier modif :] qui cherche toujours a faire se genre de petit chose :

dans la gestion des quads.h:

   irr::s32 debug_data; // ajouter la variable

               // dans le constructeur rajouter
                     debug_data = 0;
                void CQuadNode::setDebugDataVisible(irr::s32 stat)
                {
                    debug_data = stat;
                }
                void CQuadNode::RenderQuad(irr::scene::ISceneManager* mgr , unsigned short FrustumCode)
                {
                  if( m_pParent == NULL ) FrustumCode = 1; //FRUSTUM_INTERSECT;
                  else
                  {
                    if( FrustumCode ) //FRUSTUM_ALLIN
                    {
                        FrustumCode = m_pQuadTerrain->_isVisible(Box);
                        if( !FrustumCode  && m_pParent ) return;
                    }
                  }

                  if( m_pChildren[0] != NULL )
                  {
                      // pas nécessaire et crée un "bug" si l'on puis dire car les quads sont rendue plusieurs fois et se superpose sur le rendue ( visible en EMT_TRANSPARENT_ADD_COLOR )
                      //if( m_pChildren[0] ) m_pChildren[0]->RenderQuad(mgr, FrustumCode );
                      //if( m_pChildren[1] ) m_pChildren[1]->RenderQuad(mgr, FrustumCode );
                      //if( m_pChildren[2] ) m_pChildren[2]->RenderQuad(mgr, FrustumCode );
                      //if( m_pChildren[3] ) m_pChildren[3]->RenderQuad(mgr, FrustumCode );
                  }
                  else
                  {
                        ++m_pQuadTerrain->nQuad;
                        irr::video::SMaterial mat;
                            mat.Lighting = false;

                        irr::video::IVideoDriver* driver = mgr->getVideoDriver();
                        if(debug_data & scene::EDS_NORMALS)
                        {
                            core::vector3df normalizedNormal;
                            const f32 DebugNormalLength = 20.f;
                            const video::SColor DebugNormalColor(255,255,140,0);

                            const scene::IMeshBuffer* mb = mbuffer;
                            const u32 vSize = video::getVertexPitchFromType(mb->getVertexType());
                            const video::S3DVertex* v = ( const video::S3DVertex*)mb->getVertices();
                            const bool normalize = mb->getMaterial().NormalizeNormals;

                            driver->setMaterial(mat);
                            for (u32 i=0; i != mb->getVertexCount(); ++i)
                            {
                                normalizedNormal = v->Normal;
                                if (normalize) normalizedNormal.normalize();
                                driver->draw3DLine(v->Pos, v->Pos + (normalizedNormal * DebugNormalLength), DebugNormalColor);
                                v = (const video::S3DVertex*) ( (u8*) v+vSize );
                            }
                        }
                        if(Debug || debug_data & scene::EDS_BBOX_BUFFERS)
                        {
                            mat.FogEnable = false;
                            driver->setMaterial(mat);
                            driver->draw3DBox(Box, video::SColor(255,0,255,0));
                        }
                        if(debug_data & scene::EDS_MESH_WIRE_OVERLAY)
                        {
                            mat.Wireframe = true;
                            driver->setMaterial(mat);
                            driver->drawIndexedTriangleList(&mbuffer->Vertices[0],mbuffer->getVertexCount(),&mbuffer->Indices[0],mbuffer->getIndexCount()/3 );
                        }
                        mat = Material;
                        if(debug_data & scene::EDS_HALF_TRANSPARENCY) mat.MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;
                        driver->setMaterial(mat);
                        driver->drawIndexedTriangleList(&mbuffer->Vertices[0],mbuffer->getVertexCount(),&mbuffer->Indices[0],mbuffer->getIndexCount()/3 );
                  }
                }

                void CTerrainNode::setDebugDataVisible(s32 dbg)
                {
                    DebugDataVisible = dbg;
                    for(unsigned short j=0 ; j<max_grille; ++j)
                        grille[j]->setDebugDataVisible(dbg);
                }

     virtual void setDebugDataVisible(s32);