Messages

76

Suggestions de nouvelles fonctionnalités / Re : Ajout d'une méthode == dans la classe sf::Event.

« le: Janvier 01, 2014, 12:12:48 pm »

En effet ce que je veux faire est assez spécifique, et les librairies de bases (SFML et std) ne me permettent pas de le faire car, ça se rapproche plutôt de ça :

]http://jlecomte.atspace.eu/c++/c++-faq-lite/pointers-to-members.html]



Et un event qui appelle le pointeur de fonction, un autre qui met fin à l'appel sur le pointeur de fonction.

Ok donc je vais garder mon code et ne pas modifier SFML, j'ai fais un tutoriel sur ce que j'ai fais à cette adresse : (dernière sous partie)

http://www.jeux-libres.com/tutoriaux/tuto-680-chapitre-entity-systeme-de-sfgl.php

Au cas ou ça te donnerais des pistes. 

Ce que je voudrais savoir c'est si SFML définis des valeurs spéciales si par exemple lors de la définition d'un event lorsque je clic sur un bouton de la souris, je n'ai pas spécifier quel bouton à été pressé. (Car je n'ai pas besoin de le savoir)

Si pas, je pense que je vais créer moi même des valeurs spéciales car ça serait embêter de se retrouver avec des valeurs indéterminées. :/ (Pour les structures SFML)

Il me semble que cette façon de gérer les évènements déclencheurs est un peu limitée en particulier lorsqu'il s'agit de détecter si la souris est dans une zone de la fenêtre. Il faudrait autant d'évènements déclencheurs que de pixels dans la zone. Il faut probablement que tu fasses ta propre classe pour les évènements déclencheurs.

Ou bien utiliser la classe System de SFGL.
(Si la souris est dans la zone, on émet le signal.)

Bref je vais faire les 2-3 dernières petites choses que je n'ai pas encore faîtes, c'est à dire : créer une classe qui lie des actions à un id, et créer un wrapper pour les fonctions membres.

Je trouve ça plus simple que de devoir faire de la méta-compilation.

Mais sinon oui pour vérifier si la souris est dans une zone de texte il y a moyen de le faire en faisant sa propre classe, ce sera le rôle des classes gui de SFGL. (Que j'implémenterai surement dans une version futur pour faire un système genre à Qt avec des boutons...)
Mais ce serait en effet bien de pouvoir faire une classe qui permet de créer ses propres événements déclencheurs et finaux.

Je vais surement implémenter ça dans une version futur de SFGL.

77

Suggestions de nouvelles fonctionnalités / Ajout d'une méthode == dans la classe sf::Event.

« le: Décembre 31, 2013, 08:44:52 am »

Salut, je voudrais faire ceci : un event qui déclenche un slot (ou des events qui déclenchent plusieurs fois le même slot) et un autre event correspondant pour terminer un déclenchement.

Alors j'ai décidé de stocker les event déclancheurs, les event terminateurs et le slot avec ses paramètres dans une classe Action et de comparer les events déclencheurs avec les events terminateurs afin de supprimer les events de la pile.
Cependant, l'opérateur == dans la classe sf::Event n'existe pas, alors, je dois le réimplémenter moi même, se serait bien de le rajouter :

 bool equalEvent (Event event, Event other) {
        if (event.type != other.type) {
            return false;
        }
        if (event.type == Event::Resized) {
            ...
        }
        //Même chose pour les autres type d'events.
    }
 

PS : j'ai aussi rajouté un booléen à ma fonction de comparaison, pour savoir si on compare aussi les paramètre des évènements, ou qu'on compare juste les types des évènements.

Ainsi je n'ai qu'à créer un sf::Event et lui passer un type (si je veux que par exemple si je relâche une touche du clavier l'event se termine) et si je veux que l'event se termine si une touche précise du clavier est enfoncée bah je créer un sf::Event en lui donnant un code de touche)

PS 2 : non j'ai rien dis, j'ai mis une valeur spéciale (par exemple la valeur Unknow pour sf::Keyboard::Key) lorsque je veux juste que l'action se termine si n'importe quel touche du clavier est pressée.

Bref se serait bien un code du genre :

 bool equalEvent (sf::Event event, sf::Event other) {
        if (event.type != other.type) {
            return false;
        }
        if (event.type == sf::Event::Resized) {
            return event.size.width == other.size.width && event.size.height == other.size.height;
        }
        if (event.type == sf::Event::TextEntered) {
            return event.text.unicode == other.text.unicode;
        }
        if (event.type == sf::Event::KeyPressed || event.type == sf::Event::KeyReleased) {
            if (event.key.code == sf::Keyboard::Key::Unknown)
                return true;
            return event.key.code == other.key.code;
        }
        if (event.type == sf::Event::MouseWheelMoved) {
            return event.mouseWheel.delta == other.mouseWheel.delta;
        }
        if (event.type == sf::Event::MouseButtonPressed || event.type == sf::Event::MouseButtonReleased) {
            return event.mouseButton.button == other.mouseButton.button;
        }
        if (event.type == sf::Event::MouseMoved) {
            return event.mouseMove.x == other.mouseMove.x && event.mouseMove.y == other.mouseMove.y;
        }
        if (event.type == sf::Event::JoystickButtonPressed || event.type == sf::Event::JoystickButtonReleased) {
            return event.joystickButton.joystickId == other.joystickButton.joystickId
                && event.joystickButton.button == other.joystickButton.button;
        }
        if (event.type == sf::Event::JoystickMoved) {
            return event.joystickMove.joystickId == other.joystickMove.joystickId
                && event.joystickMove.position == other.joystickMove.position;
        }
    }
 

Et voici ce à quoi ça pourrait servir :

keyHeldDownAction = new Action<sf::Keyboard::Key> (*slot2, false);
        sf::Event endEvent;
        sf::Event event;
        event.type == sf::Event::KeyPressed;
        event.key.code == sf::Keyboard::Key::Unknown;
        endEvent.type == sf::Event::KeyReleased;
        endEvent.key.code == sf::Keyboard::Key::Unknown;
        keyHeldDownAction->pushEndEvent(event, endEvent);
 

keyHeldDown est une action qui se déclenche si une touche du clavier est enfoncée et se termine si une touche du clavier est relevée.

keyHeldDown peut bien sûr contenir plusieurs sf::Event si plusieurs toutches sont enfoncées en même temps.

78

Fenêtrage / Re : Les évènements.

« le: Décembre 30, 2013, 02:29:05 pm »

Mwai non en fait je n'ai pas besoin de savoir si la touche X a été pressée, j'ai juste besoin de savoir si une touche à été pressée donc ça va. (Et je passe ainsi la touche en paramètre à mon slot)

79

Fenêtrage / Les évènements.

« le: Décembre 30, 2013, 12:46:38 pm »

Salut,

Je voudrais faire une fonction qui se charge d'appeler un slot (avec des paramètres) lorsqu'un évènements SFML précis est délclanché, lors d'une action.

Cependant, il y a un petit problème, sf::Keyboard(...) et event.type.key ne sont pas du même type on dirait car cela ne compile pas :

if (eventType == TYPE::OCCURED_ONCE_ENTERED
                    && sf::Keyboard::isKeyPressed(event.type.key))                
                    b();
 

Bref dommage ça aurait été bien..., je pense que de ce fait je vais devoir recoder une classe pour stocker les states de chaque touche du clavier et boutons de souris et joystick.

Bref, je trouve le système de gestion d'évènements de SFML pas très pratique. (Surtout si on veut faire une classe qui appelle un pointeur de fonction lorsque un ou plusieurs évènements sont déclenchés)

80

Projets SFML / Re : Framework

« le: Décembre 29, 2013, 01:55:54 pm »

Lol, juste lol, j'ai du remplacer les std::string par des char* pour les arguments de ma fonction f pour que ça marche. (Sinon ça crash)

Le temps est venu de revenir au C les amis. 

81

Projets SFML / Re : Framework

« le: Décembre 29, 2013, 10:00:41 am »

J'ai réussi! 

Par contre le code source n'est pas simple à comprendre.

#ifndef FUNCTION
#define FUNCTION

namespace sfgl {
namespace helper {
    template<int ...> struct seq {};

    template<int N, int ...S> struct gens : gens<N-1, N-1, S...> {};

    template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };
}
template<typename R> class Function {
    public :
    template <typename ...A>  Function (R(*f)(A...)) : function(&f) {

    }
    template <typename ...A> R operator()(A... args) {
        R(*func)(A...) = *reinterpret_cast<R**>(function);
        std::tuple<A...> params = std::make_tuple(args...);
        return  callFunc(typename helper::gens<sizeof...(A)>::type(), params);
    }
    template<int ...S,typename ...A>
    R callFunc(helper::seq<S...>, std::tuple<A...> params)    {
         R(*func)(A...) = *reinterpret_cast<R**>(function);
        return f(std::get<S>(params) ...);
    }
    private :
    R** function;
};
 

Ce que je voulais faire c'est wrapper n'importe quel type de pointeur sur fonction pour l'appeler plus tard.

Afin de wrapper ensuite ces pointeurs de fonctions dans un conteneur avec un id ainsi j'appelle le bon pointeur de fonction en passant l'id du pointeur de fonction au conteneur.

void f (std::string text, std::string text2) {
    std::cout<<"I'm a function "<<text<<" "<<text2<<endl;
}
int main () {
    std::map<std::string, Function<void>> ptrfunc;
    Function<void> f1 = &f;
    ptrfunc.insert(std::pair<std::string, Function<void>>("Fonction test", f1));
    std::map<std::string, Function<void>>::iterator it = ptrfunc.find("Fonction test");
    it->second("text1", "text2");
    return 0;
}
 

Ainsi je stocke tout mes signaux dans un conteneur en les liant à une action, et lors du déclenchement d'un event, j'appelle la bonne fonction suivant son id en lui passant les paramètres que je veux.

Je ne sais pas si cette technique peut marcher avec les fonctions membres par contre. (Faut que je continue mes tests)

Et d'après ce que j'ai pu lire, std::function et std::bind ne permettent pas de faire ça. :/ (Voilà de quoi je parlais quand je disais "faire mieux que std::function".)

82

Projets SFML / Re : Framework

« le: Décembre 28, 2013, 01:25:02 pm »

Je l'ai lue le peu de doc que j'ai trouvé sur ce sujet mais c'est bon je vais m'en sortir..., il faut juste que je fasse une classe qui lie un id à un signal, afin de faire un contenaire de signaux.
Et comme je te dis j'ai essayer de faire un pointeur sur une fonction quelconque afin de stocker et std::function<void()> et l'appeler plus tard en lui passant des arguments, mais, y'a pas moyen std::function<void()> en fait c'est juste un foncteur et pas une fonction.

Mais je ne sais pas ou tu l'a trouvé la doc sur std::function parce que moi j'en ai pas trouvé beaucoup.

83

Projets SFML / Re : Framework

« le: Décembre 27, 2013, 08:50:50 pm »

Ok, oui je sais que c'est faisable pour stocker les arguments je l'ai même fait, c'est pour stocker un pointeur sur une fonction quelconque que apparemment ce n'est pas faisable. (Ce que je trouve dommage)

84

Projets SFML / Re : Framework

« le: Décembre 27, 2013, 12:41:27 pm »

Avec std::function et std::bind y'a pas moyen non plus :

function<void()> func = std::bind(&f, placeholders::_1);
Signal s(func);
s.emit("text");
 

Ce code ne compile pas.

Le mien compile par contre avec -fpermissive mais provoque un crash.

Bref je pense que je vais devoir abandonner mon idée, et passer à un type de fonction bien précis.

Mais avant de faire ça, je vais finir la version 1.

85

Projets SFML / Re : Framework

« le: Décembre 27, 2013, 12:03:40 pm »

Bon, j'ai rien dis, je vais en revenir à std::function et à std::bind. 

Je pensais que ce code-ci s'exécuterait :

#ifndef FUNCTION
#define FUNCTION
namespace sfgl {
template<typename R> class Function {
    public :
    template <typename ...A>  Function (R(*f)(A...)) : function(&f) {

    }
    template <typename ...A> R operator()(A... args) {
        R(*func)(A...) = *reinterpret_cast<R**>(&function);

        return func(args...);
    }
    private :
    R* function;
};
 

Mais en fait non de plus j'ai du rajouté l'option -fpermissive pour que ça compile donc je sais pas si c'est une bonne idée de caster un void* en pointeur de fonction.

Voici ce que me donne le débugueur :

Code: [Sélectionner]

#0 0028FEBD ?? () (??:??)
#1 004010FD __mingw_CRTStartup () (??:??)
#2 00401295 mainCRTStartup () (??:??)

PS : de plus il me semble qu'on ne peut pas faire ça avec des fonctions membres.

86

Projets SFML / Re : Framework

« le: Décembre 26, 2013, 08:33:06 pm »

Voilà, je vais inclure bientôt des nouveautés inédites!
Qui permettront de gérer des évènements graphique très rapidement avec sfgl::function et sfgl::bind. (L'un permet de stocker une fonction quelconque (en spécifiant juste sont type de retour), l'autre permet de stocker une fonction et des arguments :

Function<void> ptrf (&f);
ptrf(args1, arg2, ....);
Bind<void>  b (&f, arg1, arg2, ....);
b();
 

Certains pointeurs de fonction seront à définir dans certaines classes comme par exemple la classe ResourceManager pour lui passer la fonction qui se chargera de charger les ressources.

D'autres devront être utilisé pour le système d'évènements avec les interfaces graphiques.

Je compte prévoir aussi un système de placeholders qui pemettra de ne pas devoir spécifier tout les arguments à bind dès la déclaration du pointeur de fonction.



 

87

Général / Re : Petit problème avec std::remove.

« le: Décembre 26, 2013, 07:40:10 pm »

Ok chef! 

De toute façon j'ai réussi à résoudre mon problème moi même, je vais moins fréquenter ce forum donc, car, je n'ai jamais beaucoup de réponses avant que je résolve le problème moi même de toute façon alors ça sert un peu à rien. ^^

88

Général / Re : Petit problème avec std::remove.

« le: Décembre 26, 2013, 04:11:06 pm »

Mwai non j'ai parlé trop vite, std::function<void()> = &f ne marche pas sans passer par std::bind et le code que j'ai posté ci-dessus non plus mais, j'ai trouvé un article intéressant :

http://sites.univ-provence.fr/wcpp/V1/Lecons/L21.pdf

Page 6.

J'essaye de faire la même chose avec des templates, alors j'ai essayer de redéfinir le template, avec un typedef, pour stocker le pointeur de fonction, pas de problème, mais pour appeler la fonction ça ne fonctionne pas :

#ifndef FUNCTION
#define FUNCTION

namespace sfgl {

template<typename T> class Function {
    public :

    template <typename R, typename ...A> Function (R(*f)(A...)) {
         typedef T R(A...);
         this->f = &f;
    }
    template <typename R, typename ...A> R operator() (A... args) {
        return f(args...);
    }
    private :
    T* f;
};
 

Function<void> func (&f);
func("text");
 

Code: [Sélectionner]

D:\Projets\Projets-c++\TestSFGL\main.cpp|39|error: no match for call to '(sfgl::Function<void>) (const char [5])'|

J'ai compris alors que Function::operator() devenait fonction<void>::operator à la compilation mais je ne sais pas comment résoudre ce problème en redéfinissant operator() en Function<T>::operator();

89

Général / Re : Petit problème avec std::remove.

« le: Décembre 26, 2013, 10:53:58 am »

Bon bah j'ai réussi  recoder std::function 

#define FUNCTION

namespace sfgl {

template<typename T> class Function {
    public :
    template <typename R, typename ...A> Function (R(*f)(A...)) {
        typename std::decay<R(A...)>::type function;
    }

    template <typename R, typename ...A> R operator()(A... args)
    {
        return f(args...);
    }
    using function = typename std::decay<T>::type;
};
 

Mais là je ne l'ai fait que pour les fonctions non membres, je vais faire la même chose pour les autres types de fonction, et ensuite ça sera bon. ^^

Pour recoder std::bind ce n'est pas très compliqué non plus :

template <typename R , typename ...A> struct Bind <R(A...)> {
        Bind (R(*f)(A...), A... args) : f(f)  {
            params = std::make_tuple(std::forward<A>(args)...);
        }
        Bind (R(*f)(A...)) : f(f)  {

        }
        template<int ...S>
        R operator ()() {
            return callFunc(typename helper::gens<sizeof...(A)>::type());
        }
        R operator()(A... args) {
            return f(args...);
        }
        template<int ...S>
        R callFunc(helper::seq<S...>)
        {
            return f(std::get<S>(params) ...);
        }
        std::tuple <A...> params;
        Function<R(A...)> f;
    };
 

Et le helper :

namespace sfgl {
namespace helper {
    template<int ...> struct seq {};

    template<int N, int ...S> struct gens : gens<N-1, N-1, S...> {};

    template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };
}
 

Bon, le code n'est pas encore tout à fait au point car il manque le std::decay pour ma classe bind, mais, en gros c'est ça. (Sans les placeholder du moins, avec les placeholders je ne sais pas trop comment ça fonctionne mais je n'en ai pas besoin)
Je pense que je vais simplement mettre un type à la place des arguments pour les place holders et remplacer  le tuple par les vrais arguments lors de l'appel à l'opérator().

Bref finalement ce n'étais pas si compliqué que ça.
Les codes source que j'ai trouvé sur internet étaient pas bons, pour ça que j'y ai passé des journées. :/ (A part le code source du helper pour ma classe bind)

90

Général / Re : Petit problème avec std::remove.

« le: Décembre 25, 2013, 05:34:22 pm »

Sinon un tutoriel sur decay, std::forward, etc... ne serait pas de refus, je n'ai jamais rien compris à ce genre de code :
http://stackoverflow.com/questions/14936539/how-stdfunction-works