Framework

[Lolilolight]

Re :

Dépôt git-hub remis à jour.

-Amélioration du système de gestion des ressources (Désormais on peut utiliser le nom de la ressource comme identifiant et on n'est plus obligé d'utiliser un alias) et ajout d'une classe ResourceCache pour gérer les ressources indépendamment de le classe application.
-Amélioration du système de dessin des entités, désormais, la classe entité dessine toutes les entités enfants qui lui sont ajoutée avec toutes les classes qui dérivent de Entity)
-Amélioration de la classe TileGround : celle-ci peut contenir un ensemble de tiles (un peu comme une tileMap) et plus une seule Tile.
-Amélioration de la classe map : Seuls les entités enfants des entités parents qui sont visibles à l'écran son récupérées, on peut récupérer n'importe quel type ou entités contenant un ensemble d'entités visible à présent et les afficher dans l'ordre qu'on veut. (Ceci combine la puissance des SceneNode et celle de la grille)
Et les ombres sont désormais compté comme des entités enfants et donc, ne sont plus gérée dans un conteneur à part dans la classe map.
-La classe world peut contenir n'importe quel type d'entity manager (et plus seulement des entity manager de type map si vous voulez faire un entity manager personnalisé. )
-Ajout d'un générateur de plateformes dans la classe map avec possibilité d'ajouter des murs sur le bords. (Mais je dois encore perfectionné ça)

(Mais je dois encore régler quelques bugs depuis que j'ai changé le système.)


Bref voilà la suite du développement du framework sera donc surtout de la correction de bugs, et de l'amélioration de code source. (Au niveau optimisation je ne pense plus qu'il y a grand chose à faire, à part, une classe qui gère un quadtree et une qui gère un BSP-Tree, et aussi un système de volume englobant hiérarchique pour la gestion de collisions, mais ce n'est que prévu pour la version 2)

Ici je vais finir de corriger les derniers bugs de la version 1, et rajouter juste une classe de base pour l'entity system avec un thread pour remettre à jour les entités en fonction du temps ou des événements utilisateurs et une variable de condition pour la synchronisation.

Ensuite je ferai les tutoriels et le site pour tenter de sortir la version 1.

Ce qui est prévu pour la version 2 :

-Un système de commandes qui permettra de lier une action (qui contiendra un pointeur de fonction) à un événement.
-La possibilité de créer des jeux en réseau de manière  sécurisée avec openssl.
-La prédiction de mouvement.
-La possibilité de créer des interfaces IG.
-Ajout d'un système de gestion de particules.

Et dans la version 3 :

-Ajout d'entité pour la 3D de haut niveau. (Face au lieu de Tile, Sphere à la place de Shape, etc...)
-Génération et chargement d'entité en 3D. (heightmap, .obj, etc...)
-Ajout d'un système d'éclairage et d'ombres pour la 3D.

Certains ajout de classes pour la version 2 et 3 du framework on été mises sur le dépôt mais elles ne sont pas encore tout à fait au point.

[cobra.one]

Avant de penser à la version 2, 3 ou 18, tu devrais déjà clarifier pas mal ton code, parce que c'est un peu (beaucoup ?) le bazar entre les .h et .cpp... Je vois des .h contenant toute l'implémentation, d'autres avec juste la déclaration, d'autres avec un bout d'implémentation, un bout de déclaration, bref.

[Lolilolight]

Ouais je sais je n'ai pas encore eu le temps de mettre de l'ordre dans tout ça.
Même chose pour les noms ou il y a des noms en français et en Anglais.

Mais pour les petits bout de code je trouve ça inutile de mettre l'implémentation dans un .cpp alors je l'ai mise dans un .h.

Mais j'avoue que je ne devrai pas faire les 2 avec une même classe, je devrai choisir entre l'un ou l'autre.

Parfois j'ai vraiment la flemme de recréer un fichier .cpp quand dans mon fichier.h il n'y a presque rien.

[Lolilolight]

Ha, j'ai enfin compris l'intérêt du pointeur de fonction pour le chargement des ressources, et je vais en rajouter un dans la sous classe Ressource pour charger une ressource, car, j'ai oublié que une ressource peut aussi être chargée autrement que par un fichier.

Il faut juste que j'apprenne à utiliser std::function. 

En y regardant de plus prêt, c'est vrai que on pourrait se passer des pointeurs de fonctions mais le fait que le c++ offre plus de possibilité que le java n'est pas mal du tout. ^^

(Ca me permettrait d'éviter de devoir rajouter un héritage...)

PS : j'ai découvert un bug en fait dans la classe Math, dans la fonction sqrt, il fallait rajouter std devant sqrt, sinon, il rappelait la fonction sqrt de la classe Math.

[Lolilolight]

Bon, je vois que std::bind permet de générer différents pointeurs de fonctions (utile si on veut définir différents fonctions pour charger un truc)

Mais il reste un problème dans mon cas : il faut quand même passer les arguments à la fonctions, pour l'appeler, et si je veux faire différentes fonctions load pouvant avoir un nombre variable d'argument, et passer une de ses fonctions à la classe ResourceManager pour charger une ressource, ça ne va pas marcher.

Alors j'ai réfléchi et je pense que je vais faire un fichier .cpp qui va écrire dans ce même fichier .cpp la fonction avec les noms des arguments.

(Ce sera du code source qui générera du code source un peu comme le fait Qt d'ailleurs qui génère du code c++ dans les .moc)

Mais je vais essayer de faire un système ou il ne faut pas générer de fichier .moc.

[Laurent]

Fais gaffe, tu parles encore tout seul.

[Lolilolight]

Bon, j'essaye de faire mon propre système de signaux et slot, l'idée est d'écrire dans un fichier source, donc j'ai essayer de faire un fichier source qui écrit dans un autre fichier source, comme ceci :

#ifndef RESOURCE_LOADER
#define RESOURCE_LOADER
#include <fstream>
namespace sfgl {
class Function {
    public :
    static void createFunction (std::string functionName, std::map<std::string, void*> args, std::string classType = "", std::string objectName = "", bool isPointer = false, std::string returnType = "void") {
        std::ifstream ifile("C:/SFGL/include/SFGL/Core/resourceLoader.h");
        std::string line;
        std::vector<std::string> fcontent;
        while (getline(ifile, line))
            fcontent.push_back(line);
        ifile.close();
        std::ostringstream content("\t");
        Function::returnType = returnType;
        if (returnType != "void" && objectName == "")
            content<<"return "<<functionName<<"(";
        else if (returnType == "void" && objectName == "")
            content<<functionName<<"(";
        else if (returnType == "void" && objectName != "")
            if (!isPointer)
                content<<objectName<<"."<<functionName<<"(";
            else
                content<<objectName<<"->"<<functionName<<"(";
        else if (returnType != "void" && objectName != "")
            if (!isPointer)
                content<<"return "<<objectName<<"."<<functionName<<"(";
            else
                content<<"return "<<objectName<<"->"<<functionName<<"(";
        std::map<std::string, void*>::iterator it;
        for (it = args.begin(); it != args.end();it++) {
            argsTypes.push_back(it->first) ;
            argsValues.push_back(it->second);
        }
        for (unsigned int i = 0; i < argsTypes.size(); i++) {
            content<<"argsValues["<<i<<"].get<argsTypes["<<i<<"]>()";
            if (i != argsTypes.size() - 1)
                content<<",";
        }
        content<<");";
        fcontent[invokeFunction] = content.str();
        content.str("\t");
        content<<"static "<<classType<<" "<<objectName<<";";
        fcontent[declareClass] = content.str();
        content.str("");
        if (!isPointer)
            content<<classType<<" Function::"<<objectName<<" = "<<classType<<"();";
        else
            content<<classType<<" Function::"<<objectName<<" = new "<<classType.substr(0, classType.size() - 1)<<"();"<<std::endl;
        fcontent[declareOtbject] = content.str();
        std::ofstream ofile ("C:/SFGL/include/SFGL/Core/resourceLoader.h", std::ios::trunc);
        for (unsigned int i = 0; i < fcontent.size(); i++) {
            ofile<<fcontent[i]<<std::endl;
        }
        ofile.close();
    }
    static void* invoke () {

    }
    private :

        static std::string returnType;
        static std::vector<std::string> argsTypes;
        static std::vector<void*> argsValues;
        static const int invokeFunction = 57;
        static const int declareClass = 60;
        static const int declareOtbject = 68;
};

std::string Function::returnType = "";
std::vector<std::string> Function::argsTypes = std::vector<std::string> ();
std::vector<void*> Function::argsValues = std::vector<void*> ();
}
#endif // RESOURCE_LOADER
 

Mais il faudrait que je trouve une solution pour passer carrément un pointeur de fonction à la fonction createFonction parce que là vous me direz surement que c'est pas le top.

Ha oui autre chose les tabulations avec \t ne marchent pas.

[Lolilolight]

Bon j'ai trouvé une solution à mon problème, mais je vais arrêter de poser des questions là car je parle dans le vide.

[Lolilolight]

Bah franchement avec le c++11 c'était tout simple de faire ça.

#ifndef FUNCTION
#define FUNCTION
#include <typeinfo>
#include <cstdarg>
namespace sfgl {

    template <typename S> class Function {
        public:

        template <typename R, typename... A> Function (typename std::result_of<R(A...)>::S func) {
            this->func = func;
            nbArgs = sizeof...(A);
        }
        //template <typename R, typename ...A> R operator() (A... args);
        template <typename R, typename... A> R operator()(A... args) {
            return func(&args ...);
        }
        private :
            unsigned int nbArgs;
            std::vector<void*> argTypes;
            S func;
            std::vector<std::string> typeNames;
    };
}
#endif // FUNCTION
 

int main () {    
    Function <void(string)> f();
    func("...");
    return 0;

}
 

Bon maintenant il ne reste plus qu'à faire la même chose mais avec des fonctions membres, et ensuite, j'attaquerai le système de signal et de slot, mais je ne suis pas sûr d'y arriver, car, il faut que je passe les paramètres de la fonction du signal à celle du slot et ensuite appeler le slot avec un foncteur...

Bref là en ce moment je m'amuse avec le c++11 ça devient tellement simple la méta-programmation. 

Bon ok j'ai quand même chercher longtemps..., avant de trouver le truc. (Pour déclarer n'importe quel type de pointeur de fonction puis l'appeler) parce que std::bind ne permet pas de faire ce genre de chose. (Vu qu'il déclare des pointeurs à la volée dont en plus on ne connait pas le type renvoyé par std::bind.)
Ca pue. :/

[Lo-X]

http://en.cppreference.com/w/cpp/utility/functional/function

[Lolilolight]

std::function est bien mais c'est juste que moi j'ai besoin d'un type précis pour faire une fonction de callback (comme le fait la librairie thor), std::function ne possède pas de type, il permet juste de définir différents pointeurs de fonctions.

Bref, un truc du genre :

Function <void()> callBack();
Slot (callBack);
 

Et je voudrais faire aussi bien avec des fonctions void que avec retour ainsi par exemple pour mon système de ressource, définir n'importe quel fonction callback pour charger une ressource et récupérer le booléen.

Je suis obligé de recréer la classe vu que std::function ne me permet pas de faire ça :

std::function<void()> f;
Slot (f);
 

Ou alors j'ai loupé quelque chose ?

PS : j'ai pensé à faire un template qui accepterais n'importe quel type de st::function mais la syntaxe serait trop lourde. :/

De plus avec un template je pourrais très bien envoyer autre chose qu'une fonction..., car, pas de std::result_of. :/

[Lolilolight]

En fait je voudrais faire quelque chose comme ceci :

Ex obj;    
Function<void(Ex::*)()> f = &Ex::of;  
 f(obj)();
 

J'ai essayé ceci :

#ifndef FUNCTION
#define FUNCTION
namespace sfgl {

    template <typename S> class Function {
        class FunctionMember;
        public:
        template <typename R, typename... A> Function (typename std::result_of<R(A...)>::S func) {
            this->func = func;
        }
        template <typename R, typename C, typename... A> Function (R(C::*function)(A...)) {
            this->func = function;
        }
        template <typename R, typename... A> R operator()(A... args) {
            return func(&args ...);
        }
        template <typename R, typename O, typename... A> R operator()(O object, A... args) {
            return object.func();
        }
        private :
            S func;
    };

}
#endif // FUNCTION
 

Mais ça ne fonctionne pas.

Je voudrais mettre la fonction membre dans S mais je sais pas trop comment faire donc si quelqu'un à une idée.

J'ai essayé avec un decltype mais ça ne marche pas :

template <typename R, typename C, typename... A> Function (R(C::*function)(A...)) {
            S = decltype(&C::function);
            this->func = function;
        }
 

[Laurent]

Avec std::function :

// toujours appelée avec obj
std::function<void()> f = std::bind(&Ex::of, obj);
f();

// l'objet est variable et spécifié lors de l'appel
std::function<void(Ex&)> f = std::bind(&Ex::of, std::placeholders::_1);
f(obj);

Avec des lambdas :

// toujours appelée avec obj
auto f = [&](){obj.of();};
f();

// l'objet est variable et spécifié lors de l'appel
auto f = [](Ex& o){o.of();};
f(obj);

Note que tu peux aussi stocker le résultat d'une lambda dans un std::function, tout comme utiliser "auto" pour le type de retour de std::bind.

[Lolilolight]

Ha ça va j'ai trouvé l'article qu'il me faillait. (Enfin!)

http://stackoverflow.com/questions/3534812/how-does-the-template-parameter-of-stdfunction-work-implementation

J'ai re-spécialisé la classe pour les fonctions normale, je crois que je vais également faire une spécialisation pour les fonctions membre statiques, ainsi que pour les foncteurs et les lambdas.

Ensuite je ferai une classe Signal qui se chargera de contenir plusieurs de ses fonctions et de les appeler en leur passant des paramètres. (des informations sur des events par exemple)
Et une classe pour connecter un signal à une fonction. ^^

[Lolilolight]

Re, j'ai une question au sujet du c++11, je voudrais savoir comment faire pour récupérer chaque élément d'un template pack. (Avec un boucle par exemple)

void function(A... args) {
       for (int i = 0; i < sizeof...(A); i++) {
            ????
       }
}
 

PS : en fait je voudrais faire une classe qui puisse contenir à la fois : des fonctions, des arguments de fonctions/objets ou bien des placeholders  et tout appeler avec l'operator () qui exécutera tout. (on aura le choix, soit on passera les arguemnts/objets à l'opérator() ou alors on les passera directement au constructeur de ma classe bind.

En gros se sera comme un signal auxquel on pourra connecter des slots. (fonctions, paramètres et objets)

Je connecterai ensuite ces signaux à des actions qui se déclencheront lors d'event et le binder appelera tout avec l'opérateur ().


PS : je crois que j'ai compris, il faut appeler la fonction récursivement en lui passant le paraméter pack.

Maintenant j'aimerais savoir si y'a moyen de stocker un paraméter pack dans une variable membre. (Afin de stocker un ensemble de valeurs d'arguments ou objets de fonction pour les appeler plus tards.