petux a écrit 9 commentaires

Évidemment j'exporte de temps en temps (en fait une fois)
Par contre je ne savais pas que les plugins fonctionnaient en offline, donc merci :)

J'utilise lastpass.com (il y a un plugin pour chrome et firefox, et une appli android).
Le principe est que le seul mot de passe que l'on doit retenir est celui de lastpass.
Et ce mot de passe final, je l'ai généré à partir de ce site : http://www.passwordcard.org/fr

L'avantage : plus de mot de passe à retenir, lastpass remplit les champs tout seul !
L'inconvénient : Je ne connais plus aucun mot de passe :( si lastpass crash benh … j'irai me promener ;)

En fait le typage des entrées/sorties/paramètres permet juste de vérifier la pertinence des informations lors de l'enregistrement (vérifier que le type de sortie correspond au type d'entrée), mais le programme ne manipule pas d'instance a proprement dit correspondant a chaque ancre.

Le principe est de définir une structure virtuelle composé de modèles et d'ancres que l'on peut ensuite sérialiser.

Si par opérateurs tu entends spécifier les entrées/sorties/paramètres oui, dans le c++ il suffit de les spécifier de la façon suivante :

    Model& random = ctrl.add("model");
    random.input<int>("entree");
    random.parameter<int>("min") = 0;
    random.parameter<float>("max") = 3;
    random.output<float>("sortie");
    random.output<string>("sortie3");

On peut éditer la valeur des paramètres sur l'interface (uniquement float/int/string).
Je n'ai pas eu le temps de fixer un problème c'est dans la classe widget, j'ai deux listes de sous widgets qui sont concurrentes (une liste brute et une liste triée par type), il faudrait que je m'en occupe !)

Bonne remarque pour le Model::Data, en fait j'hésite toujours à inclure boost je trouve que c'est une grosse dépendance (bien que l'on pourrait arguer que ce ne sont que des headers généralement).

J'ai écrit il y a quelques semaines un éditeur de graphes en C++ basé sur SFML 2.1.
Par contre il utilise boost (je ne pouvais pas l'écrire en C++11).

Le principe est définir des modèles en (node/anchor) et de pouvoir spécialiser la sortie dans un fichier.

C'est par ici : https://github.com/bechu/sfml-flow

Ah oui en fait avec entityx, les id sont créés à l'appel de la méthode family,
il est donc possible d'appeler tous les composants :
Component < Position > ::family();
Component < Direction > ::family();
comme ça l'ordre est déterministe.

et l'exemple qui va passer cette fois-ci :
Entity e = createEntity();
e.assign < Position > (3, 2);
e.remove();

Effectivement l'ordre d'initialisation des statiques ne peut pas être déterminé. Cependant ce que l'on souhaite c'est sauvegarder les propriétés des composants et non pas l'id (qui pour moi peut être dynamique et définit en runtime). De tout manière il te faudra une méthode de sérialisation et de désérialisation, donc autant avoir un string d'identification, ce qui pourra rendre les fichiers générés plus lisible (je pense aux tags xml ou autre).

oui il manque des choses dans mon exemple, en fait cela s'inspire du code d'entityx :
Entity e = createEntity();
e.assign(3, 2);
e.remove();

Bravo pour cette explication du paradigme entity/system.
Je me suis intéressé aussi à ça il y a quelques semaines. J'ai donc regardé ton code rapidement (à l'époque j'ai regardé attentivement entityx).

J'ai quelques remarques d'ordre techniques :

• Je n'aime pas trop le fait de devoir spécifier l'id unique de chaque composant (static const es::ComponentType type = 3;), dans entityx, il utilise un système d'attribut statique qui dépend d'un template.

• Effectivement au sens strict une entité est juste un entier (j'ai eu du mal à comprendre pourquoi on ne stocke pas les composants directement dans entité, c'est en manipulant le concept que c'est devenu très clair : une entité est une structure abstraite et légère que l'on manipule entre les systèmes.), cependant, moi j'ai envie de manipuler les composants des entités comme cela par exemple :

  Entity e = createEntity();
  e.assign();

• Dernier point, une des caractéristique intéressante en C++11 est les pointeurs partagés, je pense que ce serait pas mal de les utiliser dans ton code.

En fait pour moi PC est un anglicisme :
http://en.wikipedia.org/wiki/Personal_computer