Discussion :

[Hybrix]

Bonjour,

Je travaille actuellement sur le moteur physique de mon jeu.

J'ai commencé le moteur physique en m'aidant de tutoriel sur la technique des axes séparateurs, la démonstration du moteur est disponible ici : Le lien ( Il arrive que sur certains ordinateurs ça ne fonctionne pas ).

J'aimerais organiser le moteur correctement pour ensuite lui ajouté de nouvelles possibilitées.

Le problème est que je ne voit pas trop comment organiser les classes entre elles.

Première contrainte :
J'aimerais pouvoir ajouter l'objet au moteur physique depuis lui même.

Exemple :
Objet.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
MonObjet::MonObject()
{
     AddDynamicObjet(this);
}

Objet.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
class Mon Objet : public PhysicListener
{
    public:
         Objet();
}

Seconde contrainte :
Afin d'éviter quelques tests inutile et de s'y repérer, je pense qu'il est préférable de séparer les objet en 2 catégories : Les statiques et les Dynamiques.


Première idée :
Pour le moment j'ai fait quelques tests, mais j'ai toujours le problème donnée à la première contrainte, je comptais faire ce genre d'architecture :



L'architecture est-elle correct ? Des choses sont à revoir ?

J'ai regarder le code source des rares moteur physique montrant leur code source, mais rien de concret.

Merci de m'avoir lus.
Hybrix.

[SKone]

Salut
Je fait aussi un moteur physique à "prétention" généraliste et pas seulement Temps réel. En ce qui concerne ta structure personnellement j'aurais plus fait un factory pour crée des objets. Comme ça tu n'aurais pas à gérer les objets statique et dynamique différement juste.

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Objet *obj = new DynamiqueObjet();
obj->create();
delete obj;
obj = new StaticObjet();
obj->create();
delete obj;

[Hybrix]

Merci d'avoir répondu,

Mais je ne comprend pas trop de le système présenter, serait-il possible d'avoir plus d'informations ?

[SKone]

Oui bien sur c'est le principe des factory (voir Design Pattern).
En gros tu as une classe abstraite des objets que tu veux crée exemple Vehicule ; cette classe a par exemple 2 filles Voiture et Moto.
Tu pourras crée des Motos et des Voitures en ayant les méthodes spécifique au voiture que tu utiliseras lorsque tu crées une voiture et spécifique au moto quand tu créeras une moto et aux méthode général au véhicule indépendamment de l'objet.

Par exemple

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
Vehicule *car = new Car();
Vehicule *moto = new Moto();
// Avancer tous les véhicules le fond alors
car.avancer();
moto.avancer();
// Mais le drift et les roues avant sont spécifiques que à l'un et l'autre
car.Drift();
moto.roue_avant();

Voilà j'espère avoir répondu corréctement... +

[Hybrix]

D'accord, merci pour ses précisions,

Mais ce que je demande, c'est comment je peut organiser mon moteur pour qu'un élément héritant d'un objet abstrait ( Ici PlListener ) puissent être ajouter dans la liste des objets à bouger, affecter par une masse, ....

En gros, je cherche à avoir la structure de mon moteur physique.

[SKone]

Si tu veux ajouter des objets qui hérite d'une classe abstraite tu fait une liste qui accepte la classe abstraite :
std::list<PlListener> TbObj;
Si PlListener est abstraite tu peux ajouter des objets de "Objet" qui est fille de PlListener voilà...

[Hybrix]

Désolé du retard, je n'ai pas pû répondre avant,

Je te remercie de ta réponse, mais je comptais déjà m'organiser de cette façon, pour faire simple voici un bout de code :


HxEngine.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
//////////////////////////
// HxEngine
//////////////////////////
class HxEngine
{
    public:
        HxEngine();
 
        void AddObject(HxListener *listener);
 
    private:
        std::vector<HxListener*> hxListener;
};

Hxlistener.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
//////////////////////////
// HxListener
//////////////////////////
class HxListener
{
    public:
        HxListener();
 
        virtual void onContact() = 0;
 
};

Object.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
//////////////////////////
// Object
//////////////////////////
class Object : public HxListener
{
    public:
        void onContact() {};
 
};

Ce que je souhaite, c'est que l'objet puisse appeller la fonction "AddObject" de la classe HxEngine, pour que l'objet soit ajouter dans le vector<HxListener>.

Je ne voit pas vraiment comment faire .

[SKone]

Je ne comprend pas comment tu a fait ton héritage quand A est une fille de B cela veut dire que A est B. Ici dans ton cas un Objet est une Listerne ??? Mais si tu veux quand même faire comme ça tu n'as qu'à faire :
Object *obj = new Object();
AddObjet(obj);
Et là tu auras un objet de plus dans ta liste

[Hybrix]

Objet est un listener, il est vraiqueje peut me passé de ça.

Le système que je souhaite faire, c'est que l'objet crée puisse d'ajouter dans le vector du HxEngine depuis lui-même :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
Object *voiture = new Voiture();
voiture->Init();
 
// La fonction init :
void objet::Init()
{
      AddObject(this);
}
 
// Lorsque lafonction "AddObject()" est appellé, l'objet s'ajoute dans la liste des objetsatteint par la physique.
// Dans la classe HxEngine :
hxListener.push_back(voiture);
 
// Donc la classe Hxeengine contient désormais l'objet
vector<Object*> hxlistener; // contient mantenant la voiture crée plus haut.

Voilà ce que j'essaye de faire comprendre depuis le début.
Je ne voit pas comment faire pour qu'un objet puisse s'ajouter dans la classe HxEngine.

Actuellement, je doit ajouter les objet depuis une autre classe ce qui pose pas mal de problème.

[bafman]

tu transforme ton engine en singleton, comme ca, il est accessible de partout, et, dans le constructeur de listener, tu ajoute automatiquement le listener au singleton.

ca c'est le cas ou tu n'a jamais qu'une seule instance d'Engine. Si tu souhaite avoir plusieurs instance, il faut passer le listener en paramètre soit de la fonction init, soit du constructeur. Une autre solution consiste a avoir un singleton qui stocke l'Engine courant, et dans ton constructeur de listener, tu n'a qu'a recuperer l'Engine courant et t'y ajouter.

P.S. Ajoute aussi un destructeur virtuel à ton listener

[Hybrix]

Merci d'avoir répondu,

La classe principale ( HxEngine ) ne pourra être instancier qu'une fois.
Voilà ce que j'ai fait :

HxListener.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
/***********************************************************
*            HxListener.hpp - 17/11/2007 - By Hybrix.
*
*    + Object need Physic activity need him.
*
***********************************************************/
 
#ifndef HX_HXLISTENER
#define HX_HXLISTENER
 
//////////////////////////
// Headers
//////////////////////////
 
//////////////////////////
// HxListener
//////////////////////////
class HxListener
{
    public:
        HxListener() {  AddObject(this);  };
 
        virtual ~HxListener();
 
        virtual void onContact() = 0;
 
};
 
#endif // HX_HXLISTENER

HxEngine.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
//////////////////////////
// HxEngine
//////////////////////////
class HxEngine  : public Singleton
{
    public:
        HxEngine();
 
        void AddObject(HxListener *listener);
 
    private:
        std::vector<HxListener*> hxListener;
};

Singleton.hpp ( Je me suis permis de prendre la class NonCopyablede l'API SFML )

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/* ---------------------------------------------------------------------
   (c) Hybrix 2007
 
   Singleton, NonCopyable class of SFML API.
   --------------------------------------------------------------------- */
 
#ifndef H_SINGLETON
#define H_SINGLETON
 
struct Singleton
{
protected :
 
    ////////////////////////////////////////////////////////////
    /// The default constructor won't be generated, so provide it
    ///
    ////////////////////////////////////////////////////////////
    Singleton() {}
 
private :
 
    ////////////////////////////////////////////////////////////
    /// Copy constructor : declare it private and don't implement
    /// it to prevent from calling it
    ///
    ////////////////////////////////////////////////////////////
    Singleton(const Singleton&);
 
    ////////////////////////////////////////////////////////////
    /// Assignment operator : declare it private and don't implement
    /// it to prevent from calling it
    ///
    ////////////////////////////////////////////////////////////
    Singleton& operator =(const Singleton&);
};
 
#endif

Mais ça ne fonctionne pas, le compilo ne trouve pas la fonction AddObject ( qui est présente dans la class HxEngine )

[SKone]

[Résolu] ?

[Hybrix]

Negatif, voir problème de dessus .

Le singleton n'est pas accessible depuis les autres classes.

[bafman]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
HxEngine::getInstance().AddObject(this);

ferait mieux l'affaire (modulo le fait de faire un vrai singleton, mais la, c'est un autre problème)

ici, ton singleton n'est pas un singleton, c'est juste une classe non copiable...

[Hybrix]

Arf merci beaucoup, je me souvient avor déjà utilisé le principe du Singleton ailleur.

Par contre j'ai rencontré une erreur, ça n'est pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
HxEngine::getInstance().AddObject(this);

mais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
HxEngine::getInstance()->AddObject(this);

Merci encore pour votre aide.

EDIT :
Petit problème,

J'ai voulus voir si l'objet s'ajouter correctement et ça n'est pas le cas, j'ai fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
////////////////////////////////////////////////////////////
/// Add object in listener list.
////////////////////////////////////////////////////////////
void HxEngine::AddObject(HxListener *listener)
{
    std::cout <<  hxListener.size() << endl;
    hxListener.push_back(listener);
    std::cout <<  hxListener.size() << endl;
}

Et j'ai remarquer que la fonction n'était pas appellée.
La première fois le vector ne compôrte rien et vaut 0 ce qui est normal.
Juste apres, le vector vaut 1 ce qui est la encore normal car l'objet est dedans.

Par contre, juste apres depuis le main à l'aide d'une fonction GetSize(), je regarde le nombre d'élément, et je me retrouve avec 0, comme si l'élement avait disparu du vector.

[Hybrix]

Me revoilà,

Je vous remercie pour votre aide, finalement je me suis passé du Singleton et j'ai revus toutes mon architecture.

Je vous explique mon projet, je l'ai baptisé le "Hx-Engine".
Mon but et celui de faire du Hx-Engine un moteur physique 2D simple d'utilisation et assez complet.

Le moteur sera multi-plateformes ( Unix, Mac, Windows ) et son code source sera publié.

Le truc est que je n'ai jamais fait de moteur physique et je n'en ai jamais utilisé.
J'aimerais donc savoir ce qui serait bien à mettre dans le Hx-Engine ?

Pour le moment, voici ses "caractéristiques" qui sont déjà faite ( mais pas encore mise dans le nouveau code ) :

- Possibilité d'ajouter des forces ( gravité, vent, impulsions, ... ).
Ajouter des centres de gravités, diverses forces, ... .

- Système de "mondes" :
L'utilisateur doit crée obligatoirement un monde, mais peut aussi en crées plusieurs si il le souhaite :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
hx::World mon_monde;

- Système d'objets :
L'utilisateur doit ensuite crée des objet ( Hx-Listener ).
Par exemple il souhaite crée une voiture ( basique ).
Il lui suffit de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
// La classe hérite de Hx_Listener
class Voiture : public Hx_listener
 
// Le constructeur de l'objet doit recevoir un pointeur vers le monde ou il veut  mettre l'objet ( Evite aussi la création d'une roue dans un monde puis le coque dans un autre )
Voiture::Voiture(hx::World *mon_monde)
{
// Il crée tout d'abort les roues
hx::Circle roue1;
hx::Circle roue2;
 
// Puis le "chassis"
hx::Bloc chassis;
 
// Les ajouter dans le monde
mon_monde.AddObject(roue1);
mon_monde.AddObject(roue2);
mon_monde.AddObject(chassis);
 
// Puis plus tard ( lorsque j'aurais crée le système ) les joindres
hx::Joint joinRoue1_chassis(roue1, chassis);
....
 
}

L'avantage est la création d'objets facilement.

- Système de collision :
Le jeu utilise la technique des axes séparateur, chaque objet possède une masse, une inertie, une vitesse, ....

Voilà je pense avoir dit le principal.
Voici maintenant ce que j'aimerais rajouté plus tard :

- Système de joints :
Coller les objets ensemble.

- Système de matériaux :
Chaque objet ou groupe d'objet aurait des caractéristiques différentes.

- Système de collision :
L'utilisateur pourrais choisir quel type de collision utilisé ( Bounding box, Pixel Perfect, Axes Séparateurs, ... ).

Maintenant j'aimerais savoir ce que vous aimez / n'aimez pas, aimeriez voir, ....
Merci de m'avoir lus.
Hybrix.