Salut, j'ai repris l'exemple de Kedu et moi même en .Net pour le passer sous irrlicht avec ode en c++ sous linux.
Bon ici y'a pas les gestion des threads car je ne maîtrise pas encore assez le C++ mais le code est pleinement fonctionnel.
Il vous faudra télécharger Ode 0.7 et le compiler pour essayer se code.

Voilou Bon code et @+

Salut ça a l'air tout bon ça,
Je n'ai pas encore pu tester mais sache que la gestion des threads sous UNIX (POSIX) c'est avec la fonction "fork()".
Concrètement, tu fais :

#include <unistd.h>
//Code
pid_t i = fork();
if(i > 0)
 //Premier thread principal, la variable i contient l'ID du thread fils
else if(i == 0)
 //thread secondaire
else
 //bug

Enfin ça c'est des souvenirs vieux de 3 ans donc j'espère que c'est bien ça.

Bravo pour ce code, les amateurs de c++ apprécieront ;-)

fork() ne cree pas des threads mais des processus... ce qui est bien different...
La creation d'un processus fils est beaucoup plus gourmande en temps et memoire, car il y a une recopie du contexte d'execution du processus pere.
=> man fork

Merci de la précision HeavyMetal ! Aurais-tu la possibilité de proposer une version corrigée du code avec de "vrais" threads ?

J'en aurai surtout pas le temps.
Je vous conseille le tutorial (trouve' vite fait grace a google) :
http://yolinux.com/TUTORIALS/LinuxTutor … reads.html
Cela va ensuite poser des problemes de portabilites sous Windows.
Je ne pense pas que la libpthread soit portee sous windows...
Quoique, il faudrait creuser du cote' de http://sourceware.org/pthreads-win32/

Heavymetal :

fork() ne cree pas des threads mais des processus... ce qui est bien different...
La creation d'un processus fils est beaucoup plus gourmande en temps et memoire, car il y a une recopie du contexte d'execution du processus pere.
=> man fork

Autant pour moi, je me souvenais de cette histoire que fork ne créait pas des threads cependant il m'avait semblé comprendre que dans ce cas c'était souvent conseillé...

Maintenant toute solution autre peut être plus commode, je n'en doute pas *s'en va réviser ses bases de la programmation Linux*

Salut,
très interressant.
je regarde de long en large je viens de me peter les dents sur newton avec une terrain et un bete objet dessus.
alors on va voir avec ogre et cette exemple ci.

thx

Metos :

Salut,
très interressant.
je regarde de long en large je viens de me peter les dents sur newton avec une terrain et un bete objet dessus.
alors on va voir avec ogre et cette exemple ci.

thx

Je suppose que tu voulais dire ODE

Quand à Ogre, j'aime aussi. Simplement son wrapper c# est a la traine.

Au fait ... ce code sert à quoi exactement ? Il montre comment intégrer un moteur physique ( en l'occurence ode ) à irrlicht ?

Yep Dekron, un code qui permet de faire fonctionner Ode et Irrlicht ensemble.
C'est juste un petit essai simple avec un mur de briques et une boule (également programmé par duke et moi même en C# avec thread).

tres sympa ca, justement moi qui me demandait comment on faisait pour itégrer un moteur physique à un moteur graphique

salut,

je réagit a la discussion sur les threads Unix, il faut bien faire la différence entre un fork (création d'un nouveau processus) et un thread
il est inexact de dire que l'équivalent d'un thread windows est un fork, les deux existent sous linux, en fait l'ordonancement des threads se fait directement dans le noyau, alors que windows ne le prévoit pas nativement

pour faire des threads portables linux/windows, le mieux est d'utiliser des threads Posix, pour lesquels il existe une dll

je poste quelques examples des que je remet la main dessus

Dernière modification par Jerry Kan (09-12-2006 21:51:55)

Les thread posix s'utilise avec pthread.h. Je vais vous passer un header très sympathique qui permet d'utiliser les thread sous win et linux.

#ifndef MY_THREAD_H

#define MY_THREAD_H



//Ces macros servent à uniformiser certaines fonctionnalités entre Windows et Linux.

#ifdef WIN32 //macro version Windows



#   include <windows.h>



    //definition des threads



#   define callback_t                       unsigned long __stdcall



#   define thread_t                         HANDLE*

#   define thread_create(thrd, fct, param)  thrd = new HANDLE;\

                                            *(thrd) = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(fct),(param),0,NULL)

#   define thread_delete(thrd)              CloseHandle(*(thrd));\

                                            delete (thrd);

#   define thread_wait_close(thrd)          WaitForMultipleObjects(1, *thrd, TRUE, INFINITE)



    //definition des semaphores et mutex



#   define mutex_t                          CRITICAL_SECTION

#   define mutex_init(mutex)                InitializeCriticalSection((mutex))

#   define mutex_lock(mutex)                EnterCriticalSection((mutex))

#   define mutex_unlock(mutex)              LeaveCriticalSection((mutex))

#   define mutex_delete(mutex)              DeleteCriticalSection((mutex))



#   define semaphore_t                      HANDLE

#   define semaphore_init(sema, max, place) ((sema) = CreateSemaphore(NULL, (max), (place), NULL))

#   define semaphore_lock(sema)             WaitForSingleObject((sema), INFINITE)

#   define semaphore_unlock(sema)           ReleaseSemaphore((sema), 1, NULL)

#   define semaphore_delete(sema)           CloseHandle(sema)



#else //macro version Linux



    //definition des threads



#   include <pthread.h>



#   define callback_t                       void * 



#   define thread_t                         pthread_t*

#   define thread_create(thrd, fct, param)  (thrd) = new pthread_t;\

                                            pthread_create((thrd), NULL, (fct), (param))

#   define thread_delete(thrd)              delete (thrd);

#   define thread_wait_close(thrd)          pthread_join(*thrd, NULL)



    //definition des semaphores et mutex



#   include <semaphore.h>



#   define mutex_t                          pthread_mutex_t *

#   define mutex_init(mutex)                (mutex) = new pthread_mutex_t;\

                                            pthread_mutex_init ((mutex), NULL)

#   define mutex_lock(mutex)                pthread_mutex_lock((mutex))

#   define mutex_unlock(mutex)              pthread_mutex_unlock((mutex))

#   define mutex_delete(mutex)              pthread_mutex_destroy((mutex));\

                                            delete ((mutex))



#   define semaphore_t                      sem_t*

#   define semaphore_init(sema, max, place) (sema) = new sem_t;\

                                            sem_init ((sema), (max), (place))

#   define semaphore_lock(sema)             sem_wait((sema))

#   define semaphore_unlock(sema)           sem_post((sema))

#   define semaphore_delete(sema)           sem_destroy((sema));\

                                            delete ((sema))



#endif



#endif

pour creer un thread vous faite:

//la fonction lancer dans le thread
callback_t mafonc(void* ptr);

//dans la fonc main
int main()
{
    pthread_t thrd;
    thread_create(thrd, mafonc, 'ptr');
    //'ptr' est un pointeur qui sera envoyer en parametre (ne pas oublier de le caster)
    //il peut etre egal a NULL
    
    return 0;
}

Les mutex et les semaphore son des macro qui permette de rentrer dans des section critique.(les semaphore permette a plusieurs processus de rentrer en section critique. Il doivent être global par rapport au fonction threader

il suffit de creer le type

mutex_t mutex;    //en global
mutex_init(mutex);    //dans la fonction main

pour entrer en section critiques

mutex_lock(mutex);

pour en sortir

mutex_unlock(mutex);

pour supprimer le thread;

mutex_delete(mutex)

pour les semaphores s'est la même chose mais 'max' represente le maximum d'entrer en section critique et 'place' a combien est initialisé le conteur.

Je ne dit pas que s'est parfait. Car elle n'est pas entièrement tester mais sa marche pas mal

Dernière modification par smeagol (10-12-2006 12:11:56)

@ smeagol : tu pourrais peut être créer un nouveau thread ca me paraît bien utile tout ça

je n'est pas trop le temps aujourd'hui je vous fait une tuto pour vendredi au plus tard.

je tient à préciser l'importance des mutex et sémaphore. Example:

dons un server multi thread. une position d'un joueur est en x=0 et y=0

un thread va déplacer de 5 sur x
puis un autre thread de 2.
et enfin un dernier de -7

si tout c'est bien passer on retourne en position initial.

mais il faut savoir que le processeur de vos machine peux permuter à n'importe quel moment.
clos si il permute pendant qu'il n'a pas fini d'ajouter 5 qu'il fait -7 mais la encore il n'a pas terminé qu'il permute aussi et il fait +2. Pendant qu'il fait plus 2 il revient au thread 1 et le termine sauf que la valeur dans la mémoire est à 2.

on se retrouve donc à faire un 2+2+2  et la position final est 6.

on apel l'objet de position une section critique

Comment faire donc pour éviter ces section critique. et bien de déclarer un mutex global au thread. Et faire un lock avant de rentrer en section critique. Ainsi 1 seul thread (Ou plusieurs avec les sémaphore) peu entrer dedans.

je tiens à préciser que seul les outils prédéfinis par  C/C++ comme le mutex ou autre sont fiable. tous les autres créer pas vous même on des chances de créer des interblocages ou autres problèmes. Un mutex utilise des instructions spécials sur le processeur.

Copland, tu aurai la ligne de commande qui compile ton programme ?

j'ai fait quelques essais et j'ai des trucs manquants, et les exemples fournis par ode sont compilés avec 3 ligne de charabia

Je l'ai compilé sous Code::Blocks si mes souvenirs sont bon, c'est plus facile pour parramettrer l'ide façon Visual C++.

ok, si je trouve je posterai,

pour l'instant ca compile sans histoire mais ca me fait une erreur de segmentation, a l'initialisation, ya un truc que j'ai pas du lier