Sujets

1

Général / SFML et OpenGL, fenêtre qui se ferme aussitôt

« le: Mai 14, 2018, 12:24:12 am »

Bonjour/Bonsoir,

J'essais de faire fonctionner OpenGL avec la SFML, mais j'ai un petit soucis au lancement de l'application.
Plutôt que de m'afficher mon joli petit triangle, la fenêtre se ferme tout simplement dès le lancement de l'application sans aucune erreur.

J'ai tester sf::Event::Closed pour voir et effectivement, l'événement est appelé dès le début de l'application...
La SFML Aurait un système qui fait que si rien est affiché la fenêtre se ferme automatiquement?
J'ai essayer d'afficher un shape et la fenêtre reste bien ouverte avec seulement le shape d'affiché...

Fait très étrange, si je place ce code avant ma boucle mais sans draw le shape:

sf::CircleShape shape(50);
shape.setFillColor(sf::Color(100, 250, 50));

L'application se lance et m'affiche bien le triangle... Il n'y a pas moyen de garder la fenêtre ouverte autrement?

#include <iostream>

#include <glm/glm.hpp>
#include <GL/glew.h>
#include <SFML/OpenGL.hpp>

#include "SFML/Graphics.hpp"
#include "include/Engine/Engine.hpp"
#include "include/Engine/SystemEngine.hpp"
#include "include/RessourceManager/RessourceManager.hpp"

int main()
{
    sf::ContextSettings settings;
    settings.depthBits = 24;
    settings.stencilBits = 8;
    settings.antialiasingLevel = 4;
    settings.majorVersion = 3;
    settings.minorVersion = 0;

    sf::RenderWindow window(sf::VideoMode(200, 200), "Pymous Project", sf::Style::Default, settings);
    window.setVerticalSyncEnabled(true);

    Engine::getInstance();
    SystemEngine::getInstance().setWindow(&window);

    GLenum initialisationGLEW( glewInit() );
    if(initialisationGLEW != GLEW_OK)
    {
        AbstractLogger::log().setLogger(new FileLogger("Logs/GlewReports.log"));
        AbstractLogger::log() << "Une erreur est survenu lors de l'initialisation de glew.";
        return -1;
    }

    float vertices[] = {-0.5, -0.5, 0.0, 0.5, 0.5, -0.5};

    bool running = true;
    while(running)
    {
        SystemEngine::getInstance().updateEvents();

        if(SystemEngine::getInstance().getWindowEvents().windowClosed)
        {
            std::cout << "On demande la fermeture de l'application" << std::endl;
            running = false; // On ferme la fenêtre
        }
        if(SystemEngine::getInstance().getWindowEvents().windowResized)
            glViewport(0, 0, SystemEngine::getInstance().getWindowEvents().windowSize.x, SystemEngine::getInstance().getWindowEvents().windowSize.y);

        window.setActive(true);

        glClear(GL_COLOR_BUFFER_BIT);

        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertices);
        glEnableVertexAttribArray(0);
        glDrawArrays(GL_TRIANGLES, 0, 3);

        glDisableVertexAttribArray(0);

        window.display();

        window.setActive(false);

        SystemEngine::getInstance().resetAllEvents();
    }

    RessourceManager::destroy();
    Engine::destroy();

    return 0;
}
 

Merci et bonne soirée!

2

Général / Delete qui fait planter le programme

« le: Mai 10, 2018, 10:39:13 pm »

Bonjour!

Petit soucis aujourd'hui...
J'ai créer un logger pour écrire des messages dans une console ou un fichier.
Mais j'ai un petit problème! Lorsque je veux affecter un nouveau logger(pour switcher entre différents fichiers ou la console) mon programme plante.
Après quelques recherches, je me suis aperçu que c'est mon delete qui fait planter mon programme!

Le truc étrange, c'est qu'on rentre deux fois d'affiler dans la fonction destroy()... et à chaque fois, le delete ne fonctionne pas.

Quelqu'un aurait une idée d'où ça pourrais venir?

Voici mon retour dans la console:

On change le logger
Destruction de l'objet...
Objet détruit
Objet re-définit
Teste
On change le logger
Destruction de l'objet...
Destruction de l'objet...

Voici le code dans mon main:

AbstractLogger::setLogger(new ConsoleLogger());
AbstractLogger::log() << "Teste \n";

AbstractLogger.hpp:

#ifndef DEF_ABSTRACT_LOGGER
#define DEF_ABSTRACT_LOGGER

#include <iostream>

class AbstractLogger
{
    public:
        AbstractLogger();
        virtual ~AbstractLogger();

        static void setLogger(AbstractLogger* logger); // Permet de modifier le logger à utiliser
        static AbstractLogger& log(); // Renvoie une référence sur le logger actuel

        AbstractLogger& operator <<(const std::string& message); // Permet de logger ce qu'on veut en utilisant la syntaxe du C++(grace à la surcharge de l'opérateur <<)

    private:
        static void destroy(); // Détruit l'instance du logger, private pour éviter de l'appeler n'importe où

        virtual void write(const std::string& message) = 0; // Fonction purement virtuelle pour éviter d'instancier cette classe directement, elle nous servira à lancer l'écriture

        static AbstractLogger* m_instance; // Pointeur sur le logger actuel (singleton)
};

#endif // DEF_ABSTRACT_LOGGER

AbstractLogger.cpp

#include <iostream>
#include "../../include/Logger/AbstractLogger.hpp"
#include "../../include/Logger/ConsoleLogger.hpp"

AbstractLogger* AbstractLogger::m_instance = nullptr; // Bien sur, on initialise notre instance à nullptr

AbstractLogger::AbstractLogger()
{

}
AbstractLogger::~AbstractLogger()
{
    destroy();
}

void AbstractLogger::setLogger(AbstractLogger* logger)
{
    std::cout << "On change le logger" << std::endl;
    destroy();
    m_instance = logger;
    std::cout << "Objet re-définit"<< std::endl;
}
void AbstractLogger::destroy()
{
    std::cout << "Destruction de l'objet..."<< std::endl;
    delete m_instance;
    std::cout << "Objet détruit"<< std::endl;
    m_instance = nullptr;
}

AbstractLogger& AbstractLogger::log()
{
    return *m_instance;
}

AbstractLogger& AbstractLogger::operator <<(const std::string& message)
{
    write(message);
    // On renvoie notre instance pour pouvoir chaîner les appels à << pour garder le même fonctionnement que std::cout <<
    return log();
}
 

ConsoleLogger.hpp

#ifndef DEF_CONSOLE_LOGGER
#define DEF_CONSOLE_LOGGER

#include <iostream>
#include "AbstractLogger.hpp"

class ConsoleLogger : public AbstractLogger
{
    public:
        ConsoleLogger();
    protected:
        virtual void write(const std::string& message);
};

#endif // DEF_CONSOLE_LOGGER
 

ConsoleLogger.cpp

#include <iostream>
#include "../../include/Logger/ConsoleLogger.hpp"

ConsoleLogger::ConsoleLogger()
{

}

void ConsoleLogger::write(const std::string& message)
{
    std::cout << message;
}

 

Pour tester le bon fonctionnement de mon logger, j'ai rajouter ce code dans le destructeur d'une de mes classes(pour tester l'écriture dans un fichier suite à une erreur, mais pour mes testes, je suis passer à l'écriture dans la console)

AbstractLogger::setLogger(new ConsoleLogger());
AbstractLogger::log() << "ALL GREEN";

C'est pour cela que nous avons 2 changements de logger.

J'ai essayer d'enlever le delete et l'application fonctionne niquel...

Merci à tous ceux qui pourront m'aider!

3

Graphique / SFML/OpenGL - Glew

« le: Avril 27, 2017, 07:37:27 pm »

Bonjour,

J'ai décider de me mettre à OpenGL aujourd'hui et de l'utiliser avec la SFML.
J'ai inclus comme votre tuto le disait <SFML/OpenGL>, mais j'ai u quelques soucis avec les fonctions du genre "glEnableVertexAttribArray".
Apparemment, il faudrait ajouter <GL/glew.h>... Et c'est là qu'est le drame.
Impossible d'installer correctement glew et de l'utiliser.
J'ai été sur ce site là entre autre: http://glew.sourceforge.net/install.html
Mais pas moyen de compiler, j'ai toujours une erreur me disant que codeblocks ne trouve pas -lglew32, alors que j'ai bien mis le .a dans les librairies...

J'aimerais donc savoir si quelqu'un pourrait m'aider à installer glew, vous me sauverez la vie!

Merci à vous!