[Résolu] [SFML 2.0] Synchronisation verticale et fluidité

[Opulus]

Bonjour,

Alors voila je poste car je rencontre des problèmes vis a vis de la synchronisation verticale.
Je m'explique.

Chez moi cette option provoque un mouvement des sprites très saccadé. Les déplacements ne se font pas
de manière fluide, mais plutôt très discontinu.
Même pour un code très simple qui déplace juste un sprite sur l'écran, le phénomène apparait.

J'ai pensé tout d'abord qu'il s'agissait de la variation de la longueur de la frame. Mais étant donné que
la variation est de l'ordre de la milliseconde, je doute que cela soit réellement perceptible.
Cependant voila, je suis perdu, je ne comprend pas d'ou peut venir ce problème.

De plus en cherchant un peu, sur le forum j'ai trouvé ce message :

J'active juste la synchronisation verticale.
J'ai testé sur un PC de bureau bas/moyen de gamme : saccades
Sur un PC portable bas de gamme : aucune saccades
Sur mon PC portable plus puissant que les deux autres PC : saccades
J'ai deux amis qui ont testé le programme et eux ne voient pas les saccades (l'un d'eux à un PC haut de gamme).

PS : les saccades apparaissent toutes les deux-trois secondes et sont très brèves, mais assez gênantes.

Cette personne semble effectivement avoir le même problème que moi et, apparemment, cela dépend
du PC utilisé. (Pour ma part, le mien est tout neuf et plutôt puissant)

Pouvez vous m'aider ?
Impossible pour le moment de finaliser un programme avec ce genre de soucis d'affichage. Il faut que
je remédie a cela, sachant que la fonction sleep ne fonctionne pas bien sur mon pc, m'empechant d'utiliser
la fonction setFramerateLimit.

Merci beaucoup.

[Laurent]

C'est chiant de demander à chaque fois

- code complet minimal qui reproduit le problème
- version de SFML ?
- OS ?
- carte graphique ?
- drivers graphiques à jour ?

[Opulus]

Ok, alors deja le code : (Déplacement d'un cube avec le temps en référence)

main.cpp

#include <SFML/Graphics.hpp>
#include <iostream>
#include "Cube.h"

using namespace sf;

int main()
{
        RenderWindow Window(VideoMode(800, 600, 32), "SFML Sample Application");
        Window.setVerticalSyncEnabled(true);
        Window.setFramerateLimit(0);

        Cube *cube(0);
        cube=new Cube("bloc.png");

        Clock horloge;
        horloge.restart();

        while (Window.isOpen())
        {
                Event Event;
                while (Window.pollEvent(Event))
                {
                        switch (Event.type)
                        {
                        case Event::Closed:
                                Window.close();
                                break;
                        default:
                                break;
                        }
                }

                Window.clear(Color(0, 0, 0));

                if (Keyboard::isKeyPressed(Keyboard::D))
                {
                    cube->horizontal(300, horloge.getElapsedTime());
                }
                if (Keyboard::isKeyPressed(Keyboard::Q))
                {
                    cube->horizontal(-300, horloge.getElapsedTime());
                }
                if (Keyboard::isKeyPressed(Keyboard::S))
                {
                    cube->vertical(300, horloge.getElapsedTime());
                }
                if (Keyboard::isKeyPressed(Keyboard::Z))
                {
                    cube->vertical(-300, horloge.getElapsedTime());
                }

                horloge.restart();

                Window.draw(cube->sprite());
                Window.display();
        }

        return 0;
}

Cube.h

#ifndef CUBE_H
#define CUBE_H
#include <SFML/Graphics.hpp>
#include <SFML/System.hpp>

sf::Color const fond(255,255,255,255);

class Cube
{
    public:
        Cube(std::string);
        virtual ~Cube();
        float x() const;
        float y() const;
        sf::Sprite sprite() const;
        void horizontal(float vitesse,sf::Time t);
        void vertical(float vitesse, sf::Time t);
    protected:
    private:
        sf::Image *m_image;
        sf::Texture *m_texture;
        sf::Sprite *m_sprite;
};

#endif // CUBE_H
 

Cube.cpp

#include "Cube.h"

using namespace sf;

// ------------------ Constructeurs, Destructeurs ------------------ //

Cube::Cube(std::string adresse) : m_image(0), m_texture(0), m_sprite(0)
{
    m_image=new Image;
    m_image->loadFromFile(adresse);
    m_image->createMaskFromColor(fond,0);
    m_texture=new Texture;
    m_texture->loadFromImage(*m_image);
    m_sprite=new Sprite;
    m_sprite->setTexture(*m_texture);
}

Cube::~Cube()
{
    delete m_image;
    delete m_texture;
    delete m_sprite;
}

// --------------------------- Accesseurs -------------------------- //

float Cube::x() const
{
    return m_sprite->getPosition().x;
}

float Cube::y() const
{
    return m_sprite->getPosition().y;
}

Sprite Cube::sprite() const
{
    return *m_sprite;
}

// ---------------------------- Methodes --------------------------- //

void Cube::horizontal(float vitesse, Time t)
{
    m_sprite->setPosition(x()+vitesse*t.asSeconds(), y());
}

void Cube::vertical(float vitesse, Time t)
{
    m_sprite->setPosition(x(), y()+vitesse*t.asSeconds());
}

// --------------------------- Operateurs -------------------------- //
 

Carte Graphique : Radeon HD 7950 Vapor-X - OC With Boost - 3 Go.
Drivers : A jour, puis je n'ai de soucis dans aucun jeu ni programme.
Version SFML : 2.0 (affiché dans le titre).
OS : Windows seven.

[Laurent]

Ce serait plus pratique avec un vieux sf::RectangleShape plutôt qu'une classe qui charge plein de trucs

Version SFML : 2.0 (affiché dans le titre).

Soit. Mais un SFML 2.0 qui date de quand ?

[Opulus]

Le but est quand même de pouvoir animer un sprite sans bug.
La SFML date du 06/04/13.

[Laurent]

Non, le but est de fournir un code le plus minimal possible afin de pouvoir se concentrer sur le problème sans fioritures. Si c'est bien un problème de v-sync alors peu importe que le carré que tu déplaces aient des pixels en point d'interrogation ou bien soient tout blancs. C'est pareil. Et si ce n'est pas pareil, alors on aura un indice extrêmement intéressant.

[Opulus]

Voici le code :

#include <SFML/Graphics.hpp>

using namespace sf;

int main()
{
        RenderWindow Window(VideoMode(800, 600, 32), "Test");
        Window.setVerticalSyncEnabled(true);
        Window.setFramerateLimit(0);

        CircleShape circle(25);
        circle.setPosition(20,300);
        float x(0);

        while (Window.isOpen())
        {
                Event Event;
                while (Window.pollEvent(Event))
                {
                        switch (Event.type)
                        {
                        case Event::Closed:
                                Window.close();
                                break;
                        default:
                                break;
                        }
                }

                x+=3;
                circle.setPosition(x,300);

                Window.clear(Color(0, 0, 0));

                Window.draw(circle);
                Window.display();
        }

        return 0;
}

Les saccades sont bel et bien présentes.

[Opulus]

Désolé, petit +1 

[Laurent]

Désolé, je suis un peu overbooké en ce moment

Alors j'ai testé ton code, et chez moi c'est ultra-fluide. Plus fluide que ça tu meurs. Du coup tu devrais essayer de faire tourner autre chose qui utilise OpenGL et la synchro verticale (genre un petit programme similaire avec SDL 2), histoire de voir si c'est ton environnement qui a un souci.

[Opulus]

Bah j'ai joué à beaucoup de jeux qui utilisent la synchronisation verticale (coché dans les options) et je n'ai
jamais remarqué de problèmes particuliers .

Connaitrais tu un moyen de tester rapidement son efficacité ? (Je n'ai pas la SDL 2 et ne connais pas
encore openGl)

[Laurent]

Tu devrais mesurer le framerate (avec FRAPS par exemple) pour vérifier qu'elle est bien active.

[Opulus]

J'ai fais le test, Fraps affiche 60 ips tout pile.

[Laurent]

Essaye de faire une vidéo de l'application.

[Opulus]

Alors la je suis scotché...

Je prend une vidéo avec Fraps (saccades apparentes), puis je cherche la vidéo créée et la...
Quand je joue la vidéo, le mouvement est parfaitement fluide. 

[Laurent]

Je m'attendais un peu à un truc dans ce genre

Ce qui signifie que ce n'est pas l'application qui saccade, mais plutôt le rendu au niveau du moniteur ou autre. Essaye en mode plein écran pour voir, ou sur un autre moniteur.