[SFML 2.0 RC]problème d'affichage

[kamui]

Bonjour,

Petite erreur classique, mais j'ai tellement le nez dans le guidon que je ne pige pas :

J'ai un jeu de 54 cartes...

namespace Jeu_54_cartes
    {
        using namespace Cartes;
        static std::vector<Carte> Jeu;
        static void Init()
        {
            Jeu = {
                    {Deux, Carreau}, {Trois, Carreau}, {Quatre, Carreau}, {Cinq, Carreau},  {Six, Carreau},  {Sept, Carreau},
                    {Huit, Carreau}, {Neuf, Carreau},  {Dix, Carreau},    {Valet, Carreau}, {Dame, Carreau}, {Roi, Carreau}, {As, Carreau},
                    {Deux, Coeur},   {Trois, Coeur},   {Quatre, Coeur},   {Cinq, Coeur},    {Six, Coeur},    {Sept, Coeur},
                    {Huit, Coeur},   {Neuf, Coeur},    {Dix, Coeur},      {Valet, Coeur},   {Dame, Coeur},   {Roi, Coeur},   {As, Coeur},
                    {Deux, Pique},   {Trois, Pique},   {Quatre, Pique},   {Cinq, Pique},    {Six, Pique},    {Sept, Pique},
                    {Huit, Pique},   {Neuf, Pique},    {Dix, Pique},      {Valet, Pique},   {Dame, Pique},   {Roi, Pique},   {As, Pique},
                    {Deux, Trefle},  {Trois, Trefle},  {Quatre, Trefle},  {Cinq, Trefle},   {Six, Trefle},   {Sept, Trefle},
                    {Huit, Trefle},  {Neuf, Trefle},   {Dix, Trefle},     {Valet, Trefle},  {Dame, Trefle},  {Roi, Trefle},  {As, Trefle},
                    {Joker, Sans},   {Joker, Sans}
                  };
        };
    }
 

Une grosse texture (cartes.png) que je gère dans le même namespace que la classe Carte :

#ifndef CARTE_HPP
#define CARTE_HPP

#include <iostream>

#include <SFML/Graphics.hpp>

namespace Cartes
{
    enum Valeur {Deux=2, Trois, Quatre, Cinq, Six, Sept, Huit, Neuf, Dix, Valet, Dame, Roi, As, Joker};
    enum Couleur {Carreau, Coeur, Pique, Trefle, Sans};
    static sf::Texture Cartes;
    const int taille_carte_x = 72;
    const int taille_carte_y = 98;


    class Carte
    {
        public:
            Carte(Valeur v, Couleur c);
            ~Carte();

            inline Valeur Getv() { return v; }
            inline void Setv(Valeur val) { v = val; }
            inline Couleur Getc() { return c; }
            inline void Setc(Couleur val) { c = val; }
            sf::Sprite& Gets() { return s; }

        protected:
        private:

            Valeur v;
            Couleur c;
            sf::Sprite s;
    };

    static void InitTextureCartes()
    {
        if (!Cartes.loadFromFile("Cartes.png"))
              std::cout << "erreur lors du chargement de la texture" << std::endl;
    }
}
#endif // CARTE_HPP
 

le constructeur de Carte :

Carte::Carte(Valeur v, Couleur c) :
    v(v),
    c(c),
    s(sf::Sprite())
    {
        //InitTextureCartes(); //si je décommente OK, sinon, carré blanc
        s.setTexture(Cartes);
        s.setTextureRect(sf::IntRect(v*taille_carte_x,c*taille_carte_y,taille_carte_x,taille_carte_y));
        //ctor
    }
 

et dans mon main je créé une carte et je la draw.


Ce qui me fait chier, c'est que ça n'a pas de sens de charger à chaque construction la grosse planches avec toutes les cartes, mais si je fais l'InitTexturesCartes() dans mon main c'est un coup d'épée dans l'eau...

Vous voyez ce que je ne vois pas ?

[lezebulon]

 ben tu charges 1 fois dans le main ton gros truc et pis c'est bon... où est le probleme?

[Laurent]

mais si je fais l'InitTexturesCartes() dans mon main c'est un coup d'épée dans l'eau...

C'est-à-dire ? Quel est alors le problème ?

[kamui]

carré blanc^^

[lezebulon]

Y'a pas de raison pourtant...

[kamui]

je joue pas mal avec les namespaces ça vient peut-être de là (mais je suis tellement naze que j'arrive pas à suivre le cheminement )

[kamui]

Bon j'ai voulu vous faire un petit code minimal, pour que vous puissiez tester chez vous, mais dès que je mets tout le code dans le même fichier, plus de problème...je ne comprend plus rien... alors je vous donne la seule chose que je ne vous ai pas donné, mon main :

#include <iostream>
#include <SFML/Graphics.hpp>
#include "Carte.hpp"
#include "President.hpp"

using namespace std;
using namespace Cartes;
using namespace President::Jeu_54_cartes;

int main()
{

    //on initialise le jeu de 54 cartes
    Init();

    //on charge la texture
    InitTextureCartes();
    //on construit une carte
    Carte as_de_pique(As, Pique);


    sf::RenderWindow App(sf::VideoMode(800,600,32), "testSFML");

    while (App.isOpen())
    {
        sf::Event event;
        while (App.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                App.close();
        }
        App.clear();
        App.draw(as_de_pique.Gets());
        App.display();
    }

    return 0;
}


 

[Laurent]

Tu as un code qui marche, et le même mais qui ne marche pas. A partir de là, avec un peu de patience, ce n'est pas compliqué de trouver l'erreur. Il suffit de gommer petit à petit les différences entre les deux versions jusqu'à ce que le résultat change.

Allez hop au boulot

[kamui]

Bonjour, 

Je suis parti du code minimal, pour remonter jusqu'à ma version de base avec fichiers séparés :

• A la seconde ou je colle le ctor et le dtor de la classe Carte dans un fichier séparé : Carré blanc
• Tout le reste est à l'identique avec la version buggée
  
• du coup je penses que je foire avec les namespaces

la version qui marche

#ifndef CARTE_HPP
#define CARTE_HPP

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

namespace Cartes
{

    enum Valeur {As=0, Deux, Trois, Quatre, Cinq, Six, Sept, Huit, Neuf, Dix, Valet, Dame, Roi, Joker};
    enum Couleur {Trefle=0, Pique, Coeur, Carreau, Sans};
    const int taille_carte_x = 73;
    const int taille_carte_y = 98;
    static sf::Texture Cartes;


    static void InitTextureCartes()
    {
        if (!Cartes::Cartes.loadFromFile("Cartes.png"))
           std::cout << "erreur lors du chargement de la texture" << std::endl;
    }


    class Carte
    {
        public:
            Carte(Valeur v, Couleur c);
            ~Carte();

            inline Valeur Getv() { return v; }
            inline void Setv(Valeur val) { v = val; }
            inline Couleur Getc() { return c; }
            inline void Setc(Couleur val) { c = val; }
            sf::Sprite& Gets() { return s; }

        protected:
        private:

            Valeur v;
            Couleur c;
            sf::Sprite s;

    };


    Carte::Carte(Valeur v, Couleur c) :
    v(v),
    c(c)
    {
        s.setTexture(Cartes);
        s.setTextureRect(sf::IntRect(v*taille_carte_x,c*taille_carte_y,taille_carte_x,taille_carte_y));
        //ctor
    }

    Carte::~Carte()
    {
        //dtor
    }
}

 

et la version qui marche pas

#ifndef CARTE_HPP
#define CARTE_HPP

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

namespace Cartes
{

    enum Valeur {As=0, Deux, Trois, Quatre, Cinq, Six, Sept, Huit, Neuf, Dix, Valet, Dame, Roi, Joker};
    enum Couleur {Trefle=0, Pique, Coeur, Carreau, Sans};
    const int taille_carte_x = 73;
    const int taille_carte_y = 98;
    static sf::Texture Cartes;


     static void InitTextureCartes()
    {
        if (!Cartes::Cartes.loadFromFile("Cartes.png"))
           std::cout << "erreur lors du chargement de la texture" << std::endl;
    }


    class Carte
    {
        public:
            Carte(Valeur v, Couleur c);
            ~Carte();

            inline Valeur Getv() { return v; }
            inline void Setv(Valeur val) { v = val; }
            inline Couleur Getc() { return c; }
            inline void Setc(Couleur val) { c = val; }
            sf::Sprite& Gets() { return s; }

        protected:
        private:

            Valeur v;
            Couleur c;
            sf::Sprite s;

    };
}

 

#include "Carte.hpp"

namespace Cartes
{

    Carte::Carte(Valeur v, Couleur c) :
    v(v),
    c(c),
    s(sf::Sprite())
    {
        s.setTexture(Cartes);
        s.setTextureRect(sf::IntRect(v*taille_carte_x,c*taille_carte_y,taille_carte_x,taille_carte_y));
        //ctor
    }

    Carte::~Carte()
    {
        //dtor
    }
}

 

C'est pas comme ça qu'on gère les namespaces entre un header et son implé ?

Bon sinon est-ce que j'aurais un intérêt à faire du header-only là ? A part pour le fait que cela corrige le bug s'il n'y a que l'header je veux dire (d'ailleurs quand c'est pas pour des API c'est quoi l'intérêt du header-only ?).

[Laurent]

Le problème c'est ça :

static sf::Texture Cartes;

Le mot-clé static signifie que la variable doit rester privée dans le fichier dans lequel elle est déclarée. Or comme tu mets ça dans un en-tête, tu te retrouves avec une variable Cartes différente dans chacun des fichiers qui incluent cet en-tête.

Bon sinon est-ce que j'aurais un intérêt à faire du header-only là ? A part pour le fait que cela corrige le bug s'il n'y a que l'header je veux dire (d'ailleurs quand c'est pas pour des API c'est quoi l'intérêt du header-only ?).

Le header-only n'est souvent pas un choix, c'est une contrainte. Par exemple quand toutes tes classes sont templates. Après tu peux vouloir le faire pour tout inliner (si les performances sont importantes), ou si ton API est très simple et consiste en beaucoup plus de déclarations que de code.

Mais retiens bien que la règle de base, c'est de bien séparer son code entre .hpp et .cpp, pour réduire les dépendances et les temps de compilation.

[kamui]

Et comment je fais pour qu'elle soit statique "à la java" cette varibale (en enlevant le mot clé static et en la laissant dans un namespace ?) ?

Edit : sinon dès que j'enlève le static le compilo se plaint d'une multiple définition...


Edit :
C'est bon j'ai introduit la déclaration de la texture dans la classe Carte (en static), ainsi que la méthode d'Init,

et je n'ai eu plus qu'à définir la variable dans le main.



Edit : et tant qu'on y est je vais te demander (plutôt que de faire semblant de savoir de quoi tu parle ) :

Reduire quelles dépendences (parce que j'ai un projet en header-only (contraint)) ?
Pourquoi cela réduit les temps de compilation d'avoir les deux trucs séparés ?

[Laurent]

Pour ce qui est des namespaces / static / variables globales, tu devrais relire un bouquin ou cours en ligne, tu te mélanges trop là.

Reduire quelles dépendences (parce que j'ai un projet en header-only (contraint)) ?

Un truc qui se trouve dans un en-tête sera copié dans chaque autre fichier qui inclue cet en-tête. Du coup ces derniers se retrouvent à dépendre des dépendances des en-têtes qu'ils incluent, alors qu'ils n'en ont potentiellement pas besoin.
Alors qu'un truc qui se trouve dans un .cpp ne concernera que ce .cpp. Il reste caché dans son coin.

Pourquoi cela réduit les temps de compilation d'avoir les deux trucs séparés ?

Toujours pour la même raison : ce qui est dans un en-tête est copié partout où il est inclus. Donc compilé tout autant de fois.

[kamui]

Pour ce qui est des namespaces / static / variables globales, tu devrais relire un bouquin ou cours en ligne, tu te mélanges trop là.

je penses que je me mélange surtout entre les définitions du mot clé static dans les langages C++ et Java.

Un truc qui se trouve dans un en-tête sera copié dans chaque autre fichier qui inclue cet en-tête. Du coup ces derniers se retrouvent à dépendre des dépendances des en-têtes qu'ils incluent, alors qu'ils n'en ont potentiellement pas besoin.
Alors qu'un truc qui se trouve dans un .cpp ne concernera que ce .cpp. Il reste caché dans son coin.

Ok merci.

Toujours pour la même raison : ce qui est dans un en-tête est copié partout où il est inclus. Donc compilé tout autant de fois.

Ok c'était pour être sûr. Merci

[Laurent]

je penses que je me mélange surtout entre les définitions du mot clé static dans les langages C++ et Java.

C'est la même chose à l'intérieur d'une classe. Mais à l'extérieur, static a une toute autre définition (qu'on n'emploie d'ailleurs pas en C++, à la place on a les namespaces anonymes).

[kamui]

Ah ok je connaissais pas. Encode merci pour toutes ces infos