Erreur avec sf::Font et OpenGL

Bonjour,
Au moment où je quitte mon programme, j'ai une fenêtre qui s'affiche que mon programme a cessé de fonctionner, comme s'il avait planté. Dans les faits ce n'est pas dérangeant puisque je voulais justement quitter le programme, mais ce n'est pas très propre.
Quand j'essaie de debugger, lorsque je quitte le programme, l'erreur suivante s'affiche 6 fois dans la console :
An internal OpenGL call failed in Texture.cpp (95) : GL_INVALID_OPERATION, the specified operation is not allowed in the current state
Mon code :

(click to show/hide)

#include "Window.h"

using namespace glan;

int main()
{
    sf::Font font; font.loadFromFile("resources/LETTERS_.ttf");
    CheckButton btn("resources/normal.png", "resources/coche.png", *new sf::Text("test", font));

    ButtonsList lis;
    lis.addButton(&btn);

    Window fen;
    fen.useBtnsList(fen.addBtnsList(&lis));

    fen.show();

    return 0;
}
 

(click to show/hide)

#ifndef ABSBUTTON_H
#define ABSBUTTON_H


#include <SFML/Graphics.hpp>

#include <iostream>



namespace glan
{

enum ButtonType
{
    None, Normal, CheckBox, Special
};

class absButton : public sf::Sprite
{
    public:
        absButton() = delete;
        absButton(std::string adressN,
                std::string adressF = std::string(), std::string adressP = std::string(), std::string adressD = std::string());
        // Arguments :
        //
        // adressN : the adress of the texture shown when the Button is in normal state (not focused, not pressed, not disabled).
        //
        // adressF : the adress of the texture shown when the Button is focused.
        // If the default value is used, Tfocused is set to Tnormal.
        //
        // adressP : the adress of the texture shown when the Button is pressed.
        // If the default value is used, Tpressed is set to Tnormal.
        //
        // adressD : the adress of the texture show when the Button is disabled.
        // If the default value is used, Tdisabled is set to Tnormal.
        virtual ~absButton();

        ButtonType getType();
        // Returns 'type' member.

        virtual void checkClicked(sf::Event const& event, sf::Window const& relativeTo) = 0;
        // Pure virtual function.
        // Checks if the buttons is focused, pressed or released.
        // Returns false if the button does not have focus and is not pressed neither, else returns true.
        // If the button is clicked (focused and released), the member std::function 'effect' il executed.

    protected:
        ButtonType type;
        bool resetRect, hasFocus, isPressed, enabled, hidden;
        sf::Texture Tnormal, Tfocused, Tpressed, Tdisabled;
};

} // namespace glan

#endif // ABSBUTTON_H
 

(click to show/hide)

#include "absButton.h"


namespace glan
{

absButton::absButton(std::string adressN, std::string adressF, std::string adressP, std::string adressD) :
                    Sprite(), type(None),
                    hasFocus(false), isPressed(false), enabled(true), hidden(false), Tnormal(), Tfocused(), Tpressed(), Tdisabled()
{
    Tnormal.loadFromFile(adressN);

    if(adressF.empty() || !Tfocused.loadFromFile(adressF))
        Tfocused=Tnormal;

    if(adressP.empty() || !Tpressed.loadFromFile(adressP))
        Tpressed=Tnormal;

    if(adressD.empty() || !Tdisabled.loadFromFile(adressD))
        Tdisabled=Tnormal;

    setTexture(Tnormal);
}

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


//////////////////////////////////////////////////////////////////////////////

ButtonType absButton::getType()
{
    return type;
}

} // namespace glan
 

(click to show/hide)

#ifndef CHECKBUTTON_H
#define CHECKBUTTON_H

#include "absButton.h"


namespace glan
{

class CheckButton : public absButton
{
    public:
        CheckButton(std::string adressN, std::string adressC, sf::Text accText,
                    std::string adressF = std::string(), std::string adressP = std::string(), std::string adressD = std::string(),
                    std::string adressCF = std::string(), std::string adressCP = std::string(), std::string adressCD = std::string());
        // Arguments :
        //
        // adressN : the adress of the texture shown when the Button is in normal state (not focused, not pressed, not disabled).
        //
        // adressC : the adress of the texture shown when de Button is only checked (not focused, not pressed, not disabled).
        //
        // adressF : the adress of the texture shown when the Button is focused.
        // If the default value is used, Tfocused is set to Tnormal.
        //
        // adressP : the adress of the texture shown when the Button is pressed.
        // If the default value is used, Tpressed is set to Tnormal.
        //
        // adressD : the adress of the texture show when the Button is disabled.
        // If the default value is used, Tdisabled is set to Tnormal.
        //
        // adressCF : the adress of the texture shown when the Button is focused and checked.
        // If the default value is used, TcheckedFocused is set to Tchecked.
        //
        // adressCP : the adress of the texture shown when the Button is pressed and checked.
        // If the default value is used, TcheckedPressed is set to Tchecked.
        //
        // adressCD : the adress of the texture show when the Button is disabled and checked.
        // If the default value is used, TcheckedDisabled is set to Tchecked.
        ~CheckButton();

        virtual void checkClicked(sf::Event const& event, sf::Window const& relativeTo);
        // Checks if the buttons is focused, pressed or released.
        // Returns false if the button does not have focus and is not pressed neither, else returns true.
        // If the button is clicked (focused and released), the member std::function 'effect' il executed.

        virtual void updateText();
        // Updates the position ans the size of the 'text' member.

    protected:
        bool checked;
        sf::Texture Tchecked, TcheckedFocused, TcheckedPressed, TcheckedDisabled;

    private:
        sf::Text text;
};

} // namespace glan

#endif // CHECKBUTTON_H
 

(click to show/hide)

#include "CheckButton.h"


namespace glan
{

CheckButton::CheckButton(std::string adressN, std::string adressC, sf::Text accText,
                         std::string adressF, std::string adressP, std::string adressD,
                         std::string adressCF, std::string adressCP, std::string adressCD) :
                        absButton(adressN, adressF, adressP, adressD),
                        checked(false), Tchecked(), TcheckedFocused(), TcheckedPressed(), TcheckedDisabled(), text(accText)
{
    type = CheckBox;

    Tchecked.loadFromFile(adressC);

    if(adressCF.empty() || !TcheckedFocused.loadFromFile(adressCF))
        TcheckedFocused=Tchecked;

    if(adressCP.empty() || !TcheckedPressed.loadFromFile(adressCP))
        TcheckedPressed=Tchecked;

    if(adressCD.empty() || !TcheckedDisabled.loadFromFile(adressCD))
        TcheckedDisabled=Tchecked;

    setTexture(Tnormal);

    text.setCharacterSize(Tnormal.getSize().y);
}

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


//////////////////////////////////////////////////////////////////////////////

void CheckButton::checkClicked(sf::Event const& event, sf::Window const& relativeTo)
{
    if(!enabled)
        return;

    if(event.type == sf::Event::MouseMoved)
    {
        if(getGlobalBounds().contains(((sf::Vector2<float>)sf::Mouse::getPosition(relativeTo))))
        {
            hasFocus=true;
            if(isPressed)
            {
                if(checked)
                    setTexture(TcheckedPressed);
                else
                    setTexture(Tpressed);
            }
            else
            {
                if(checked)
                    setTexture(TcheckedFocused);
                else
                    setTexture(Tfocused);
            }
        }
        else
        {
            hasFocus=false;
            if(isPressed)
            {
                if(checked)
                    setTexture(TcheckedFocused);
                else
                    setTexture(Tfocused);
            }
            else
            {
                if(checked)
                    setTexture(Tchecked);
                else
                    setTexture(Tnormal);
            }
        }
    }
    else if(event.type == sf::Event::MouseButtonPressed)
    {
        if(hasFocus)
        {
            isPressed=true;
            if(checked)
                setTexture(TcheckedPressed);
            else
                setTexture(Tpressed);
        }
    }
    else if(event.type == sf::Event::MouseButtonReleased)
    {
        if(event.mouseButton.button == sf::Mouse::Left && isPressed)
        {
            isPressed=false;
            if(hasFocus)
            {
                if(checked)
                {
                    checked=false;
                    setTexture(Tfocused);
                }
                else
                {
                    checked=true;
                    setTexture(TcheckedFocused);
                }
            }
            else
            {
                hasFocus=false;
                if(checked)
                    setTexture(Tchecked);
                else
                    setTexture(Tnormal);
            }
        }
    }
}

//////////////////////////////////////////////////////////////////////////////

void CheckButton::updateText()
{
    text.setPosition(getPosition().x + Tnormal.getSize().x, getPosition().y);
    text.setCharacterSize(getTexture()->getSize().y);
}

} // namespace glan
 

(click to show/hide)

#ifndef BUTTONSLIST_H
#define BUTTONSLIST_H



#include "CheckButton.h"

#include <string>
#include <vector>
#include <stdexcept>


namespace glan
{

class ButtonsList
{
    public:
        ButtonsList(bool delBtns = true);
        ~ButtonsList();
        // Destructor. If 'deleteButtons' is true, deletes all Button* in 'buttons' vector member.

        ButtonsList& operator=(const ButtonsList& other);
        absButton* operator[](unsigned int index);
        // Returns the Button pointer at the 'index' position of 'buttons' vector member, without bounds checking.

        absButton* at(unsigned int index);
        // Returns the Button pointer at the 'index' position of 'buttons' vector member, with bounds checking.
        // Note that this pointer can be null, so be careful.
        //
        // Exceptions :
        // std::out_of_range if the 'index' position is out of range.

        int size();
        // Returns buttons.size(). ('buttons' is a vector member)

        int addButton(absButton* newButton);
        // Adds the button pointer 'newButton' in the 'buttons' vector member and returns its position.
        // If the Button* was already in 'buttons', its position is returned even though.

        bool clear(bool deleteThem = true);
        // Clears the 'buttons' vector member. If deleteThem is true, all Button are deleted before.
        // Returns false if 'buttons' was already empty, else returns true.

    private:
        bool deleteButtons;
        std::vector<absButton *> buttons;
};

} // namespace glan

#endif // BUTTONSLIST_H
 

(click to show/hide)

#include "ButtonsList.h"


namespace glan
{

ButtonsList::ButtonsList(bool delBtns) : deleteButtons(delBtns), buttons()
{
    //ctor
}

ButtonsList::~ButtonsList()
{
    if(deleteButtons)
        clear();
}


//////////////////////////////////////////////////////////////////////////////

ButtonsList& ButtonsList::operator=(const ButtonsList& rhs)
{
    if (this == &rhs) return *this; // handle self assignment
    //assignment operator
    return *this;
}


//////////////////////////////////////////////////////////////////////////////

absButton* ButtonsList::operator[](unsigned int index)
{
    return buttons[index];
}


//////////////////////////////////////////////////////////////////////////////

absButton* ButtonsList::at(unsigned int index)
{
    try
    {
        absButton *temp(buttons.at(index));
        return temp;
    }
    catch(std::out_of_range const& expt)
    {
        std::cerr<<expt.what()<<std::endl;
        throw expt;
        return nullptr;
    }
}

//////////////////////////////////////////////////////////////////////////////

int ButtonsList::size()
{
    return buttons.size();
}


//////////////////////////////////////////////////////////////////////////////

int ButtonsList::addButton(absButton* newButton)
{
    if(buttons.empty())
    {
        buttons.push_back(newButton);
        return 0;
    }

    int Max(buttons.size());

    for(int i(0) ; i < Max ; i++) // Checks if the Button* 'newButton' is already in the ButtonsList.
    {
        if(newButton == buttons[i])
            return i;
    }

    for(int i(0) ; i < Max ; i++) // If not, searches if there is a free place in...
    {
        if(buttons[i] == nullptr)
        {
            buttons[i]=newButton;
            return i;
        }
    }

    buttons.push_back(newButton); // ...else create a new one.
    return Max;
}


//////////////////////////////////////////////////////////////////////////////

bool ButtonsList::clear(bool deleteThem)
{
    if(buttons.empty())
        return false;

    if(deleteThem)
        for(int i(0) ; i < (int)buttons.size() ; i++)
            delete buttons[i];
    buttons.clear();
    buttons.shrink_to_fit();
    return true;
}

} // namespace glan
 

(click to show/hide)

#ifndef ABSWINDOW_H
#define ABSWINDOW_H


#include "ButtonsList.h"

namespace glan
{


// A class to handle a window and its buttons and event loop.
// The constructor does NOT show the window. Add :
// window.create(windowVideoMode, windowTitle, windowStyle, windowSettings);
// in your show() function.

class absWindow : sf::NonCopyable
{
    public:
        absWindow(bool destrDeleteButtons = true,
                  int x = 800, int y = 600, sf::String const& title = "Window",
                  sf::Uint32 style = sf::Style::Default, sf::ContextSettings const& settings = sf::ContextSettings());
        // Arguments :
        //
        // x : the height of the window.
        //
        // y : the width of the window.
        //
        // title : the title shown in the title bar of the window.
        //
        // destrDeleteButtons : sets deleteButtons, which defines if the destructor deletes the buttons of the 'buttons' member.

        virtual ~absWindow() = 0;
        // Destructor. If 'resetRect' member is true, deletes all glan::Button in 'buttons' member.


        virtual void show();
        // Shows the window.
        // When you'll add it int your inherited class, do not forget to put this line of code :
        // window.create(windowVideoMode, windowTitle, windowStyle, windowSettings);

        void close();
        // Closes the window and destroys this.

        bool isOpen() const;
        // Returns true if 'window' member is open, else returns false.

        int addBtnsList(ButtonsList *newList);
        // Adds the glan::ButtonsList 'newList' int the 'buttonsLists' vector member and returns its position.
        // If  the ButtonsList* was already in 'buttonsLists', its position is returned even thought.
        // You can use the following code :
        /*
            glan::absWindow window;
            glan::ButtonsList newList;
            window.useBtnsList( window.addBtnsList(newList) );
        */

        bool useBtnsList(int index = -1);
        // Sets 'btnsVectShown' member at 'index', resulting by the diplaying of the Buttons in the ButtonsList at 'index' position of the 'buttonsLists' vector member.
        // If 'index' is out of range, the window will not use any ButtonsList and the function will return false (else returns true).
        // You can use the following code :
        /*
            glan::absWindow window;
            glan::ButtonsList newList;
            window.useBtnsList( window.addBtnsList(newList) );
        */

        virtual void updateDisp();
        // Should call updateButtons().

    protected:
        void updateButtons();
        // Draw all glan::Button contained in 'buttons' vector member at 'btnsVectShown' (member) position, excepts these which are hidden.
        // If buttons[btnsVectShown] is out of range, no button is drawn.

        // Basic memebers :
        bool deleteButtons;
        int btnsListShown;
        std::vector<ButtonsList *> buttonsLists;
        sf::RenderWindow window;
        sf::Event event;

        // Members which hold the properties of the window
        sf::VideoMode windowVideoMode;
        std::string windowTitle;
        sf::Uint32 windowStyle;
        sf::ContextSettings windowSettings;
};

} // namespace glan

#endif // ABSWINDOW_H
 

(click to show/hide)

#include "absWindow.h"


namespace glan
{

absWindow::absWindow(bool destrDeleteButtons, int x, int y, sf::String const& title, sf::Uint32 style, sf::ContextSettings const& settings) :
    deleteButtons(destrDeleteButtons), btnsListShown(-1), buttonsLists(),
    window(), event(),
    windowVideoMode(x, y), windowTitle(title), windowStyle(style), windowSettings(settings)
{

}

absWindow::~absWindow()
{
    if(deleteButtons)
    {
        for(int i(0) ; i < (int)buttonsLists.size() ; i++)
            buttonsLists[i]->clear();
    }
}


//////////////////////////////////////////////////////////////////////////////

void absWindow::show()
{
    window.create(windowVideoMode, windowTitle, windowStyle, windowSettings);

    while(window.isOpen())
    {
        updateDisp();
        while(window.pollEvent(event))
        {
            updateDisp();
            if(event.type == sf::Event::Closed)
                window.close();
        }
    }
}


//////////////////////////////////////////////////////////////////////////////

void absWindow::close()
{
    window.close();
    delete this;
}


//////////////////////////////////////////////////////////////////////////////

bool absWindow::isOpen() const
{
    return window.isOpen();
}


//////////////////////////////////////////////////////////////////////////////

int absWindow::addBtnsList(ButtonsList *newList)
{
    if(buttonsLists.empty())
    {
        buttonsLists.push_back(newList);
        return 0;
    }

    int Max(buttonsLists.size());

    for (int i(0) ; i < Max ; i++) // Checks if the ButtonsList* 'newList' is already in 'buttonsLists' vector member.
    {
        if(newList == buttonsLists[i])
            return i;
    }

    for(int i(0) ; i < Max ; i++) // If not, searches a free place for it...
    {
        if(buttonsLists[i] == nullptr)
        {
            buttonsLists[i]=newList;
            return i;
        }
    }

    buttonsLists.push_back(newList); // ...else create a new one.
    buttonsLists.shrink_to_fit();
    return Max;
}


//////////////////////////////////////////////////////////////////////////////

bool absWindow::useBtnsList(int index)
{
    try
    {
        if(buttonsLists.at(index) != nullptr)
        {
            btnsListShown=index;
            return true;
        }
    }
    catch(std::out_of_range const& expt)
    {
        std::cerr<<expt.what()<<std::endl;
        btnsListShown=-1;
    }
    return false;
}


//////////////////////////////////////////////////////////////////////////////

void absWindow::updateDisp()
{
    window.clear();
    updateButtons();
    // Other drawings...
    window.display();
}


//////////////////////////////////////////////////////////////////////////////

void absWindow::updateButtons()
{
    ButtonsList *temp;
    try
    {
        temp=buttonsLists.at(btnsListShown);
    }
    catch (std::out_of_range const& expt)
    {
        std::cerr<<expt.what()<<std::endl;
        return;
    }

    for(int i(0) ; i < (int)temp->size() ; i++)
    {
        if(temp->at(i) != nullptr)
        {
            if(temp->at(i)->isEnabled())
                temp->at(i)->checkClicked(event, window);

            if(!temp->at(i)->isHidden())
            {
                window.draw(*temp->at(i));
                if(temp->at(i)->getType() == ButtonType::CheckBox)
                {
                    ((CheckButton*)temp->at(i))->updateText();
                    window.draw(((CheckButton*)temp->at(i))->getText());
                }
            }
        }
    }
}

} // namespace glan
 

(click to show/hide)

#ifndef WINDOW_H
#define WINDOW_H


#include "absWindow.h"


class Window : public glan::absWindow
{
    public:
        Window();
        ~Window();

        void show();
        void updateDisp();
    protected:
    private:
};

#endif // WINDOW_H
 

(click to show/hide)

#include "Window.h"

Window::Window() : absWindow()
{
    //ctor
}

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

void Window::show()
{
    window.create(windowVideoMode, windowTitle, windowStyle, windowSettings);

    int i(btnsListShown);

    while(window.isOpen())
    {
        updateDisp();

        while(window.pollEvent(event))
        {
            updateDisp();

            if(event.type == sf::Event::Closed)
                window.close();

            if(event.type == sf::Event::KeyPressed)
            {
                switch(event.key.code)
                {
                case sf::Keyboard::Left:
                    buttonsLists[i]->at(0)->move(-3,0);
                    break;
                case sf::Keyboard::Right:
                    buttonsLists[i]->at(0)->move(3,0);
                    break;
                case sf::Keyboard::Up:
                    buttonsLists[i]->at(0)->move(0,-3);
                    break;
                case sf::Keyboard::Down:
                    buttonsLists[i]->at(0)->move(0,3);
                    break;
                default:
                    break;
                }
            }
        }
    }
}

void Window::updateDisp()
{
    window.clear();
    updateButtons();
    window.display();
}
 

Merci d'avance pour votre aide.

[Cmdu76]

Tu nous donnes un peu trop de code là ...

Enlève-nous les fonctions qui ne sont pas utilisées dans le cas de ton bug

[Glân de Brylan]

C'est bon, j'ai retiré le maximum possible.

[Laurent]

Lorsque tu debug et que ça plante, ça plante où ? Quelle est la pile d'appels ?

Ça plante au moment où je quitte le programme (étrange...).

(click to show/hide)

#0 7737EEC9   ?? () (??:??)
#1 7733D289   ?? () (??:??)
#2 773DF7CD   ?? () (??:??)
#3 7737E99C   ?? () (??:??)
#4 7733D289   ?? () (??:??)
#5 75209A15   msvcrt!free() (C:\Windows\SysWOW64\msvcrt.dll:??)
#6 00800000   ?? () (??:??)
#7 68EE2D0A   FT_GlyphLoader_Reset() (C:\Users\Jules\Desktop\DOCUME~1\C__~1\PROJET~2\SFMLGU~1\bin\Debug\sfml-graphics-d-2.dll:??)
#8 68EE2E0F   ft_glyphslot_done() (C:\Users\Jules\Desktop\DOCUME~1\C__~1\PROJET~2\SFMLGU~1\bin\Debug\sfml-graphics-d-2.dll:??)
#9 68EE2E96   destroy_face() (C:\Users\Jules\Desktop\DOCUME~1\C__~1\PROJET~2\SFMLGU~1\bin\Debug\sfml-graphics-d-2.dll:??)
#10 68EE3FB4   FT_Done_Face() (C:\Users\Jules\Desktop\DOCUME~1\C__~1\PROJET~2\SFMLGU~1\bin\Debug\sfml-graphics-d-2.dll:??)
#11 68EC25DC   sf::Font::cleanup(this=0x28f854) (D:\developpement\sfml\sfml\src\SFML\Graphics\Font.cpp:350)
#12 68EC1999   sf::Font::~Font(this=0x28f854, __in_chrg=<optimized out>) (D:\developpement\sfml\sfml\src\SFML\Graphics\Font.cpp:96)
#13 0040560A   main() (C:\Users\Jules\Desktop\Documents\C++\Projets SFML\SFML GUI\main.cpp:18)

Dans la pile d'appels, pendant l'exécution, j'ai cette ligne qui est surlignée en rouge :
#11 68EC25DC   sf::Font::cleanup(this=0x28f854) (D:\developpement\sfml\sfml\src\SFML\Graphics\Font.cpp:350)
Heu, la ligne 350 de Font.cpp, c'est le commentaire qui sépare getKerning() et getLineSpacing(). Je pige pas tout.
Autre truc bizarre, il veut absolument accéder au disque D, mais D:, c'est le lecteur CD. Le problème vient probablement de là ? J'ai pourtant bien linké mes bibliothèques...c'est un bug de la SFML ?

[Laurent]

Difficile à debugger, il reste plein de code superficiel. Essaye de reproduire le bug avec un code vraiment minimal. On se fiche que ça fasse toujours la même chose, avec des fenêtres et des listes de boutons, le problème semble venir de ta gestion des polices

[Glân de Brylan]

Alors j'ai essayé avec ce code là :

#include <SFML/Graphics/RenderWindow.hpp>
#include <SFML/Window/Event.hpp>
#include <SFML/Graphics/Text.hpp>

using namespace sf;

int main()
{
    Font font;
    font.loadFromFile("LETTERS_.ttf");
    Text txt("test", font);

    RenderWindow window(VideoMode(800,600), "Feunaitr");
    Event event;

    while(window.isOpen())
    {
        window.clear();
        window.draw(txt);
        window.display();

        while(window.pollEvent(event))
        {
            if(event.type == Event::Closed)
                window.close();

            if(event.type == sf::Event::KeyPressed)
            {
                switch(event.key.code)
                {
                case sf::Keyboard::Left:
                    txt.move(-3,0);
                    break;
                case sf::Keyboard::Right:
                    txt.move(3,0);
                    break;
                case sf::Keyboard::Up:
                    txt.move(0,-3);
                    break;
                case sf::Keyboard::Down:
                    txt.move(0,3);
                    break;
                default:
                    break;
                }
            }
        }
    }

    return 0;
}
 

Mais là ça se fait sans problème. Pourtant ma seule utilisation des polices dans le code d'avant c'est :

    sf::Font font; font.loadFromFile("resources/LETTERS_.ttf");
    CheckButton btn("resources/normal.png", "resources/coche.png", *new sf::Text("test", font));

Je ne comprends pas. J'ai essayé d'enlever le *new et de réellement créer un sf::Text puis de le passer en paramètres mais ça ne change rien.

Ce que je trouve vraiment bizarre c'est que d'après la pile d'appels (même avec le code simplifié qui foncitonne), il semble vouloir accéder à l'emplacement
D:\developpement\sfml\sfml\src\SFML\Graphics\Font.cpp
Qui n'existe pas. Comme je l'ai dit précédemment, D:, c'est mon lecteur CD.

[Laurent]

Ne te préoccupe pas du chemin des fichiers sources dans les symboles de debugging, c'est le chemin qui a été pris lorsque les binaires ont été compilés, donc sur ma propre machine.

Bon, maintenant tu as un code qui fonctionne, et un code qui ne fonctionne pas. Tu as fait le plus dur, il suffit désormais d'ajouter petit à petit au code qui fonctionne, jusqu'à ce que ça ne fonctionne à nouveau plus. Il n'y a pas de magie, c'est comme ça que tout le monde fait. Faut pas hésiter à bidouiller le code dans tous les sens pour trouver l'origine de tels bugs.

[Glân de Brylan]

Trouvé ! J'ai suivi ta méthode maintenant je sais que le problème vient de glan::ButtonsList.
Je vais continuer à chercher, mais ça devrait être plus facile maintenant que je sais où chercher.

Cependant, j'ai remarqué une autre chose qui m'intrigue : quand je quitte le programme durant le debugging, le message suivant s'affiche dans la fenêtre du debugger de l'IDE (pas dans la console) :

At C:\Users\Jules\Desktop\Documents\C++\Projets SFML\SFML GUI\ButtonsList.cpp:16
Program received signal SIGTRAP, Trace/breakpoint trap.
In ?? () ()

Je n'ai mis aucun breakpoint ligne 16, c'est l'accolade de fin de fonction du destructeur, je suis assez perplexe. Ensuite il y a :

350     D:\developpement\sfml\sfml\src\SFML\Graphics\Font.cpp: No such file or directory.
#11 0x68ec25dc in sf::Font::cleanup (this=0x28f854) at D:\developpement\sfml\sfml\src\SFML\Graphics\Font.cpp:350
Cannot find bounds of current function

Là s'affichent dans la console les "An internal OpenGL...". Et quand je fais "next line", "Cannot find bounds of current function" se répète apparemment à l'infini. Évidemment, il n'y a pas de fonction à la ligne 350 de Font.cpp.

Bon.

[Laurent]

Te prends pas trop la tête pour ça. Concentre toi sur ton problème.