[segfault] Appel de RenderWindow::create()

[nicooomg]

Le truc c'est que mon code marchait parfaitement !
Bon je viens de recompiler Sfgui. La compilation = niquel.
Et mon programme n'a plus de sigsegv. Mais bon, ecran noir . Sfgui... 

[Laurent]

Si tu as changé de compilo il faut évidemment que tu recompiles absolument toutes les bibliothèques C++ que tu utilises.

[nicooomg]

Oui je savais pas ^_^

Bon eh bien maintenant passons a un truc plus simple ou tu pourras meclairer

int SplashScreen::Run()
{
    // Splash Screen loading
    sf::Texture splash;
    splash.loadFromFile("Data/gui/splash/splashscreen.jpg");
    sf::Sprite spr(splash);

    while(m_window->Running()) {
        // Clearing out the window
        m_window->Clear(); // RenderWindow::clear();

        m_window->Draw(spr); // RenderWindow::draw(...);

        m_window->Render(); // RenderWindow::display();
    }
    return -1;
}

Le fichier jpg est bien chargé.
Pourtant... ecran noir!

[Laurent]

Le fichier jpg est bien chargé.

Comment le sais-tu ? Tu ne gères pas la valeur de retour de loadFromFile.

Essaye aussi d'ajouter une boucle d'évènements (vide) dans ta boucle principale.

[nicooomg]

j'ai mis if(!splash.LoadFromFile...) { exit(0); } et mon programme ne se termine pas.
J'ai egalement ajouter une boucle d'evenements...

        while(m_window->GetEvent(event) ) {
            //desktop.HandleEvent( event );

            // If window is about to be closed, leave program.
            if(mWindow::Closing(event)) {
                exit(0);
            }
        }

Toujours ecran noir.

[Laurent]

Dans ce cas essaye de mettre ce code (sans les fioritures, avec les appels SFML directement) dans un code complet minimal, et vois si ça reproduit le problème. Si c'est le cas je pourrai alors le tester chez moi.

[nicooomg]

Ca marche !

    sf::RenderWindow window;
    window.create(sf::VideoMode(800, 600, 32), "Game");
    window.setFramerateLimit(60);
    sf::Texture splash;
    if(!splash.loadFromFile("Data/gui/splash/splashscreen.jpg"))
    {
        exit(0);
    }
    sf::Sprite spr(splash);
    sf::Event event;
    while(window.isOpen()) {
        // Clearing out the window
        window.clear();
        // Event processing.
        while(window.pollEvent(event) ) {
        }
        window.draw(spr);
        window.display();
    }

Donc le probleme vient de ma classe mWindow.

class mWindow
{
    public:
        /** Default constructor */
        mWindow(Perennials* per);
        /** Default destructor */
        ~mWindow();

        inline void Render()
        {
            window.display();
        }
        inline void RenderGUI(sfg::SFGUI& gui)
        {
            gui.Display(window);
        }
        inline void Clear()
        {
            window.clear();
        }
        inline const sf::RenderWindow& GetRenderWindow()
        {
            return window;
        }
        inline bool Running() const
        {
            return running && window.isOpen();
        }
        inline bool GetEvent(sf::Event& e)
        {
            return window.pollEvent(e);
        }
        inline void resetGLStates()
        {
            window.resetGLStates();
        }
        inline void popGLStates()
        {
            window.popGLStates();
        }
        static inline bool Closing(const sf::Event& e)
        {
            return e.type == sf::Event::Closed;
        }
        template<typename T>
        inline void Draw(const T& obj)
        {
            window.draw(obj);
        }
        inline const sf::Vector2u GetScreenSize() const
        {
            return window.getSize();
        }

        Perennials* GetPerennials() const { return perennial; }

    protected:
    private:

        bool running;
        sf::RenderWindow window;

        Perennials* perennial;

};
 

[Laurent]

Je ne vois rien de bizarre dans cette classe.

Puisque le code minimal fonctionne, remet des éléments de ton code original au fur et à mesure et vois à quel moment ça ne fonctionne plus. Par exemple, dans un premier temps remets la class mWindow. Puis la classe SplashScreen.

[nicooomg]

Etrange.

    Perennials* perenial = new Perennials();
    // sfml window
    mWindow* w = new mWindow(perenial);

    sf::Texture splash;
    if(!splash.loadFromFile("Data/gui/splash/splashscreen.jpg"))
    {
        exit(0);
    }
    sf::Sprite spr(splash);
    sf::Event event;
    while(w->Running()) {
        // Clearing out the window
        w->Clear();
        // Event processing.
        while(w->GetEvent(event)) {
        }
        w->Draw(spr);
        w->Render();
    }
 

Ce code marche... donc c'est dans SplashScreen.
Tu as la fonction Run(), voici le header.

class mWindow;
class ClientSocket;
class SplashScreen: public Screen
{
    public:
        SplashScreen(mWindow* wd, ClientSocket* tcps)
        {
            m_window = wd;
            m_tcpsocket = tcps;
        }
        ~SplashScreen() {}
        int Run ();

        static const int ID = 1;

    private:
        // Common structure
        sfg::SFGUI m_sfgui;
        sfg::Desktop desktop;
        sf::Event event;
        sf::Clock clock;
};

// et voici Screen
class mWindow;
class ClientSocket;
class Screen
{
    public :
        virtual int Run () = 0;

        mWindow* m_window;
        ClientSocket* m_tcpsocket;
        ClientSocket* m_udpsocket;
};
 

edit:
De plus, avec ce code quand je ferme l'appli je n'ai aucun probleme, avec l'original, je crash.  Mais ca c'est du a sfgui il me semble.

[Laurent]

Continue à mettre au fur et à mesure des éléments du code original, tu vas bien tomber sur un truc

[nicooomg]

J'ai supprimé ma classe mWindow, et dans la fonction Run je passe directement l'objet RenderWindow par reference.

int SplashScreen::Run(sf::RenderWindow& App)
{
    // Splash Screen loading
    sf::Texture splash;
    if(!splash.loadFromFile("Data/gui/splash/splashscreen.jpg"))
    {
        exit(0);
    }
    sf::Sprite spr(splash);
    while(App.isOpen()) {
        // Clearing out the window
        Ap.clear();
        // Event processing.
        while(App.pollEvent(event) ) {
            //desktop.HandleEvent( event );

            // If window is about to be closed, leave program.
            if(event.type == sf::Event::Closed) {
                exit(0);
            }
        }
        App.draw(spr);
        App.display();
    }
    return -1;
}

C'est donc une copie quasi egale à https://github.com/SFML/SFML/wiki/TutorialScreens

Toujours ecran noir.

[Laurent]

Puisque ce code fonctionne lorsqu'il est tout seul dans main(), le problème vient forcément de la gestion externe de SplashScreen.

[kimci86]

Bonjour,

J'ai lu le sujet rapidement et il me semble qu'il y a un léger problème là :

link options:
-lsfml-graphics-d
-lsfml-window-d
-lsfml-system-d
-lsfgui
-lopengl32

compile define:
SFML_STATIC
SFGUI_STATIC

En effet, il y a les defines pour compiler en statique alors que les bibliothèques dynamiques sont liées.
Il faut soit enlever les defines, soit lier avec les bibliothèques statiques (contenant "-s" ).

[nicooomg]

Non ceci est corrigé:

-lsfml-graphics-s-d
-lsfml-window-s-d
-lsfml-system-s-d
-lsfgui
-lopengl32

@LG:
Oui je m'en doute, mais je passe sf::RenderWindow directement. Qu'est-ce qui pourrait bien foirer le rendu ? :s

[Laurent]

Avec ça :

int main()
{
    sf::RenderWindow window(sf::VideoMode(800, 600), "test");
    SplashScreen sp;
    sp.Run(window);
    return 0;
}

... ça foire ?

Normalement non, donc il faut vraiment que tu te concentres sur la gestion du splash screen et non sur son code, qui lui est correct.