Component based architecture

[Kromagg]

Bonjour

Est-ce que vous connaissez le modèle de programmation "Component-based programming" ? Voici un lien très intéressant sur le sujet Component-based game design

Je me demandais si on pouvais adapter ce modèle dans le développement d'un moteur 3D par exemple pour la gestion d'un graphe de scène. On aurait des components de ce genre

Code :

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
38
39
 
class Component
{
public:
     virtual ~Component();
     virtual void Initialize() = 0;
     virtual void Update() = 0;
     virtual void Shutdown() = 0;
};
 
class MeshComponent : public Component
{
public:
     virtual ~MeshComponent();
 
     virtual void Initialize();
     virtual void Update();
     virtual void Shutdown();
 
     void SetMeshData(MeshData* pMesh);
 
private:
     MeshData* m_pMesh;
};
 
class LightComponent : public Component
{
public:
     virtual ~LightComponent();
 
     virtual void Initialize();
     virtual void Update();
     virtual void Shutdown();
 
     void SetLightData(LightData* pLight);
 
private:
     LightData* m_pLight;
};

Et pour le graphe de scène on pourrait avoir ce genre d'acteurs :

Code :

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
 
class Actor : public Spatial
{
public:
     virtual ~Actor();
     template<class T> T* AddComponent<T>();
     void RemoveComponent(Component* pComponent);
     void RemoveAllComponents();
     template<class T> T* GetComponent<T>();
 
     void UpdateComponents(float dt);
 
protected:
     std::vector<Component*> m_vComponents;
};
 
class MeshActor : public Actor
{
public;
     MeshActor (MeshData* pMesh)
     {
          MeshComponent* pMeshComponent = this.AddComponent<MeshComponent>();
          pMeshComponent->SetMeshData( pMesh );
     }
};
 
class LightActor: public Actor
{
public;
     LightActor(LightData* pLight)
     {
          LightComponent* pLightComponent = this.AddComponent<LightComponent>();
          pLightComponent ->SetLightData( pLight);
     }
};

On pourrait ainsi construire facilement notre graphe de scène et créer nos propres acteurs (rigidbody, particules,...)

Kromagg

[LittleWhite]

Bonjour,

Ça ne fait pas un peu God Class, que les architectes C++ n'aiment pas vraiment ?
Sinon, êtes vous sur qu'il n'y a pas de moteurs 3D, Open source qui utilise déjà une architecture dans ce genre ?
Sauf que l'on ne dit pas Component, mais Node pour le scene graph, mais cela revient à donner la même faciliter pour la conception de l'arbre, je crois.

[Kromagg]

Envoyé par LittleWhite

Bonjour,

Ça ne fait pas un peu God Class, que les architectes C++ n'aiment pas vraiment ?
Sinon, êtes vous sur qu'il n'y a pas de moteurs 3D, Open source qui utilise déjà une architecture dans ce genre ?
Sauf que l'on ne dit pas Component, mais Node pour le scene graph, mais cela revient à donner la même faciliter pour la conception de l'arbre, je crois.

Pourquoi trouves-tu que ça fait God Class ? Pour moi chaque composant fait son travail en interne. Ils sont maintenus par un objet de type Actor.

Je sais que Unity fonctionne de cette manière mais via l'éditeur, comment ça se passe en derrière (node, meshscenenode...) je ne sais pas.

Heu dans mon cas je n'assimile pas un Component à un Node mais plutôt un Actor à un Node. Ici l'acteur n'est qu'un conteneur de Component et c'est justement via se mécanisme que l'on peut créer n'importe quel type d'Actor (mesh, light, rigidbody...) en ajoutant le composant adéquate à mon Actor

[LittleWhite]

Je n'arrive pas trop à saisir l'avantage, à part que tu sépare les données de ton arbre, ce qui est une bonne chose, je pense.

Si j'en crois l'article, l'idée est que l'on peut avoir un Component de position, un Component de Rendu, un Component ... et que du coup, lorsque tu crée un nouveau objet, au lieu de le faire hériter de mille classe, tu vas juste faire un Actor et lui ajouter des Component.

Dans le code de l'Actor, je pense que tu peux encore plus simplifié grâce au template

Qu'est ce que tu reprochais aux autres méthodes / implémentation des moteurs ? (et en quoi cette façon de faire est mieux ?)

[Kromagg]

Envoyé par LittleWhite

Je n'arrive pas trop à saisir l'avantage, à part que tu sépare les données de ton arbre, ce qui est une bonne chose, je pense.

Ca évite d'avoir tout un tas de classes (MeshActor, LightActor, CameraActor...), je peux créer autant d'Actor différents que je veux et les personnaliser plus facilement (bien que l'on peut fournir une panoplie d'Actor de base notamment les caméra, les meshes...). Et puis je peux également coder le comportement de mon Actor via des ScriptComponent (C++, Lua, JS...). Ces ScriptComponent auraient accès à tout un tas d'informations sur l'Actor (position, orientation...) plus accès aux autres Components. C'est vraiment comme ça que fonctionne Unity 3D. Si tu veux jetter un oeil à la documentation elle est vraiment très bien faite.
Unity Script Reference

Envoyé par LittleWhite

Si j'en crois l'article, l'idée est que l'on peut avoir un Component de position, un Component de Rendu, un Component ... et que du coup, lorsque tu crée un nouveau objet, au lieu de le faire hériter de mille classe, tu vas juste faire un Actor et lui ajouter des Component.

C'est exactement ça, cela évite d'avoir un tas de classe spécialisées (MeshNode, LightNode,...) qui peuvent être difficile à maintenir et à faire évoluer. Mais je me demande si je peux appliquer cette technique dans un graphe de scène.

Envoyé par LittleWhite

Dans le code de l'Actor, je pense que tu peux encore plus simplifié grâce au template

Ah bon comment ferais-tu ?

Envoyé par LittleWhite

Qu'est ce que tu reprochais aux autres méthodes / implémentation des moteurs ? (et en quoi cette façon de faire est mieux ?)

Ah non mais je ne dis pas que cette façon de faire est mieux Comme j'utilise pas mal Unity j'ai fait des recherches sur le Net et je suis tombé sur plusieurs articles concernant ce modèle de programmation. Et j'aimerai essayer de l'intégrer directement dans un graphe de scène au lieu de passer par tout un tas de classe SceneNode (light, mesh...). Maintenant je ne dis pas que c'est la bonne méthode, je cherche juste des avis

[LittleWhite]

Ah bon comment ferais-tu ?

C'est vraiment du sucre syntaxique, je doute que ça vaille le coup à long terme.

Code c :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template <class TComponent, class TData> 
class SpecialisedActor : public Actor
{
public:
     SpecialisedActor (TData* pData)
     {
          assert(pData);
 
          TComponent* pComponent = this.AddComponent<TComponent>();
          pComponent->SetData( pData );
     }
};
 
typedef SpecialisedActor<MeshComponent, MeshData> MeshActor;