Sujets

1

Discussions générales / Forum français

« le: Avril 06, 2014, 02:24:29 pm »

Salut à tous,

Bon, il fallait bien que quelqu'un évoque ce sujet à un moment ou un autre, alors je me lance.
Ça fait pas mal de temps déjà que le forum français est moribond, s'agissant du moins de la partie générale.
Ce sujet à été par le passé débattu, avant le changement de forum, mais les conclusions d'alors ne sont plus applicables aujourd'hui suite à la baisse de fréquentation.
On voit bien aujourd'hui que le forum anglophone a bien rattrapé le forum français, de part le nombre d'inscrits, le nombre de postages en berne et les fréquentations.
Les francophones postent quasiment toujours pour leurs projets dans la partie anglophone et ensuite dans la partie francophone, mais on voit bien que les débats ce font toujours en anglais.
Je sais que certains d'entre nous sont des quiches en anglais, mais je pense que dans le domaine de la programmation, mieux vaut s'y mettre ou sinon c'est se priver d'une très riche documentation potable sur le sujet. Historiquement la partie francophone existe car le développeur de la SFML est français. Certes, mais la SFML c'est fortement internationalisé depuis, et des portugais, russes, allemands et j'en passe ne comprendrai pas vraiment pourquoi privilégier le français à toutes leurs langues pour des forums officiels. Enfin, il est agaçant d'avoir à consulter deux forums tous les jours, de peur de manquer quelque chose d’intéressant. La communauté y gagnerait vraiment de se ressouder sur ce point.

J'espère que mon message fera cogiter.
A bon entendeur.

2

Graphique / [Résolu] Meilleure technique de clipping ?

« le: Février 09, 2014, 05:24:57 pm »

Salut chère communauté ! 

Je travaille actuellement sur un gros projet, mais je bloque malheureusement sur une technique en particulier.
Il s'agit d'utiliser une classe Canevas, dérivant de sf::Drawable et sf::Transformable et pouvant contenir d'autres sf::Drawable, donc potentiellement d'autres Canevas.
Le but est d'obtenir des espaces de dessin pouvant être décris les uns par rapport aux autres, jusque là, rien de sorcier.
Là ou je bloque, c'est pour la gestion du clipping. En effet, je souhaiterai que cet espace de dessin soit "fermé", qu'aucune entité dessinable enfant (peu importe son degrés de parenté), n'en sorte.

Après quelques recherches voici les pistes qui me sont données :

- Utiliser sf::View et son viewport : d'un côté ça m'arrange d'ajouter le système des vues à Canevas, d'un autre je n'ai jamais réussi à l'adapter correctement à mon problème malgré la doc.,
- Utiliser comme il sera présenté par la suite la fonction glScissor de openGL, solution intéressante mais néanmoins limitée dans mon cas, puisque dans mon exemple, seul le dernier appel à cette fonction est effectif,
- Utiliser les clipPlanes de openGL, mais parait-il ils sont très gourmands en ressources,
- Utiliser le stencil buffer, solution conseillée sur de nombreux forums.

J'ai donc simplifié le tout pour faire un exemple minimal directement compilable, utilisant la fonction glScissor :

#include <SFML/Graphics.hpp>
#include <SFML/OpenGL.hpp>

struct Canevas : public sf::Drawable, public sf::Transformable {

        std::vector<sf::Drawable*> drawables;
        sf::FloatRect clipping;

protected:

        void draw(sf::RenderTarget& target, sf::RenderStates states) const
        {
                states.transform.combine(getTransform());

                sf::Vector2f pos = states.transform.transformPoint({clipping.left, clipping.height + clipping.top});

                glPushAttrib(GL_SCISSOR_BIT);
                glEnable(GL_SCISSOR_TEST);
                glScissor(pos.x, target.getSize().y - pos.y, clipping.width, clipping.height);

                for( auto& drawable : drawables )
                        target.draw(*drawable, states);

                glDisable(GL_SCISSOR_TEST);
                glPopAttrib();
        }
};

int main()
{
        sf::RenderWindow window(sf::VideoMode(400, 400, 32), "Test");
        window.setVerticalSyncEnabled(true);

        /// CANEVAS 1 ///

        sf::RectangleShape shape1;
        shape1.setFillColor(sf::Color::Blue);
        shape1.setSize({200, 200});

        Canevas canevas1;
        canevas1.setPosition({50, 50});
        canevas1.clipping = {0, 0, 200, 200};
        canevas1.drawables.push_back(&shape1);

        /// CANEVAS 2 ///

        sf::RectangleShape shape2;
        shape2.setFillColor(sf::Color::Green);
        shape2.setSize({200, 200});

        sf::RectangleShape shape3;
        shape3.setPosition(50, 50);
        shape3.setFillColor(sf::Color::Red);
        shape3.setSize({200, 200});

        Canevas canevas2;
        canevas2.setPosition({50, 50});
        canevas2.clipping = {0, 0, 200, 200};
        canevas2.drawables.push_back(&shape2);
        canevas2.drawables.push_back(&shape3);

        /// CANEVAS 2 -> CANEVAS 1 ///

        canevas1.drawables.push_back(&canevas2);

        while( window.isOpen() )
    {
        sf::Event event;
     
        while( window.pollEvent(event) )
        {    
            if( event.type == sf::Event::Closed )
                window.close();
         
            else if( event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape )
                window.close();
        }

        window.clear();
        window.draw(canevas1);
        window.display();
    }

    return 0;
}

La vignette du milieu présente le résultat de l'exemple minimal, celle de gauche est le résultat du clipping désactivé et celle de droite le résultat attendu.

Quelle est d'après-vous la meilleure technique à employer, sachant que je recherche simplicité et performances avant-tout ?

Merci de votre soutien ! 

3

Python / Merci

« le: Novembre 03, 2013, 10:55:18 am »

Voilà, je voulai juste remercier le créateur de pySFML pour ce magnifique portage (et Laurent pour la SFML, mais on le remercie assez comme ça ^^) ! Le Python m'a redonné goût à la programmation et avec la facilité d'emploi de pySFML je me met à faire un jeu de façon étonnamment simple ! Félicitations ! 

4

Général / Problème de métaprogrammation

« le: Février 27, 2013, 05:09:44 pm »

Bonjour à tous,

Je ne sais pas si c'est possible, mais j'essaye actuellement de créer un gestionnaire de ressources sous la forme d'une classe template variadique, possédant une méthode templatisée de création d'une ressource d'un type donné, permettant grâce à une expression constante et une assertion statique de vérifier si le type de ressource spécifié est autorisé par la classe (en le comparant aux types du template variadique) et d'interrompre la compilation dans le cas contraire.

Le problème est que je sèche sur le code de la méthode de vérification du type de ressource.
Voici un bout de code (simplifié) pour vous donner une idée :

template<typename... Types>
class Manager
{
public:

   template<typename Type, typename... Arguments>
   size_t create(Arguments... arguments)
   {
      static_assert(testTypes<Type>(), "Template function does not allow this type !");

      Type* ptr = new Type(Arguments...);
      ...

      return nextId();
   }

   template<typename Type>
   constexpr bool testTypes(); // méthode de vérification du type de ressource

  size_t nextId()
  {
      static size_t id;
      return id++;
  }

   ...
};

typedef Manager<sf::Texture, sf::Font, sf::SoundBuffer> ResourceManager;

ResourceManager resources();
resources.create<sf::Texture>(); // Compilation OK
resource.create<sf::Sprite>(); // Compilation ERROR
 

J'ai quelques pistes pour le code de la méthode testTypes() :

- Pour obtenir le nombre de type passés en template j'utilise -> sizeof...(Types)
- Pour vérifier que deux types sont les mêmes j'utilise -> std::is_same<Type1, Type2>
- Je peut normalement décompresser Types avec l'opérateur ... -> Types...

Maintenant il reste à créer une boucle en méta-programmation (je sais pas si c'est possible),
afin de balayer les types grâce au code :

template <int N, typename... Args> struct ElementType;
 
template <int N, typename T, typename... Args>
struct ElementType<N, T, Args...> {
        static_assert(N < sizeof...(Args) + 1, "overflow!");
        typedef typename elementType<N - 1, Args...>::type type;
};
 
template <typename T, typename... Args>
struct ElementType<0, T, Args...> {
        typedef T type;
};

// Par exemple :

elementType<1, sf::Texture, sf::Font, sf::SoundBuffer>::type>::value // donnera le type sf::Font
 

J'espère que je suis assez clair, et désolé par avance sinon, le sujet est assez difficile je trouve...