Messages

1

Graphique / Re : [SFML 2.0] Synchronisation verticale et fluidité

« le: Avril 28, 2013, 07:58:33 pm »

Merci beaucoup en fait !
Le problème est résolu !

(pour ceux qui auraient le même problème)

Cause : Le moniteur.
Solution : Mode plein écran.

2

Graphique / Re : [SFML 2.0] Synchronisation verticale et fluidité

« le: Avril 25, 2013, 07:57:46 pm »

Ah ! Génial on s'approche de la solution 

Utilisant deux moniteurs, j'ai glissé la fenêtre sur l'autre écran et... C'est en effet beaucoup plus fluide.
Ensuite j'ai mis en plein écran sur l'écran principal (celui que j'utilise tout le temps) et cette fois,
un mouvement beaucoup plus fluide !

Comment est ce possible ?

3

Graphique / Re : [SFML 2.0] Synchronisation verticale et fluidité

« le: Avril 25, 2013, 04:25:39 pm »

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. 

4

Graphique / Re : [SFML 2.0] Synchronisation verticale et fluidité

« le: Avril 25, 2013, 03:57:25 pm »

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

5

Graphique / Re : [SFML 2.0] Synchronisation verticale et fluidité

« le: Avril 25, 2013, 03:33:09 pm »

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)

6

Graphique / Re : [SFML 2.0] Synchronisation verticale et fluidité

« le: Avril 25, 2013, 01:17:49 pm »

Désolé, petit +1 

7

Graphique / Re : [SFML 2.0] Synchronisation verticale et fluidité

« le: Avril 23, 2013, 10:31:27 pm »

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.

8

Graphique / Re : [SFML 2.0] Synchronisation verticale et fluidité

« le: Avril 23, 2013, 10:06:29 pm »

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

9

Graphique / Re : [SFML 2.0] Synchronisation verticale et fluidité

« le: Avril 23, 2013, 08:58:31 pm »

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.

10

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

« le: Avril 23, 2013, 02:38:30 pm »

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.

11

Système / Re : [SFML 2.0] La fonction sf::sleep ne fonctionne pas comme il faut.

« le: Avril 21, 2013, 10:55:00 pm »

Ok, en tout cas merci pour toutes les réponses !
Jsuis a présent fixé sur pas mal de choses.

Je vais opter pour changer la structure de mes programme alors, en prenant en compte le
temps en référence.

Je reposterais pour mon autre problème proprement !

12

Système / Re : [SFML 2.0] La fonction sf::sleep ne fonctionne pas comme il faut.

« le: Avril 21, 2013, 10:32:06 pm »

Aaah ok, d'ou l'effet similaire que provoque le setFrameRateLimit...
Donc en bref, il n'y a aucune autre solution que la synchronisation verticale ?

Parce que l'affichage n'est vraiment pas propre.
J'ai fais un test en affichant l'horloge a chaque affichage de la fenetre et ca donne ca :

Temps de l'affichage : 15844
Temps de l'affichage : 15818
Temps de l'affichage : 15848
Temps de l'affichage : 15717
Temps de l'affichage : 15811
Temps de l'affichage : 15587
Temps de l'affichage : 15855
Temps de l'affichage : 15728
Temps de l'affichage : 15665
Temps de l'affichage : 12492
Temps de l'affichage : 16161
Temps de l'affichage : 15492
Temps de l'affichage : 16409
Temps de l'affichage : 16240
Temps de l'affichage : 15909
Temps de l'affichage : 15991

Ca varie beaucoup.

Du moins concrètement, le simple déplacement de sprite est saccadé. (jonché d'accoups, comme ci toutes
les quelques frames, la boucle s'effectue plusieurs fois avant d'afficher le sprite).

13

Système / Re : La fonction sf::sleep ne fonctionne pas comme il faut.

« le: Avril 21, 2013, 08:12:16 pm »

J'ai simplifié le code.
Le probleme est toujours le meme et la console affiche la meme chose.

Code :

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

using namespace sf;

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

        Clock horloge;
        Time t1, t2;
        Time tempsAffichage;
        tempsAffichage=seconds(0.0166667f);

        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));

                t1=tempsAffichage-horloge.getElapsedTime();
                t2=horloge.getElapsedTime();
                sleep(t1);

                std::cout<<"HORLOGE : "<<horloge.getElapsedTime().asMicroseconds()<<std::endl;
                Window.display();
                std::cout<<"Temps de l'affichage : "<<horloge.getElapsedTime().asMicroseconds()<<"        "<<t1.asMicroseconds()<<"         "<<t2.asMicroseconds()<<std::endl;
                horloge.restart();
        }

        return 0;
}
 

EDIT : Info supplémentaire - J'ai regardé quelques vidéos et j'ai réessayer le programme, et le
temps affiché à "HORLOGE : " est passé a une autre valeur. Toujours trop lente mais différente.
Je comprend de moins en moins, du coup cela doit dépendre d'autre chose que le code
lui même. De quoi se sert la fonction sf::sleep ?

14

Système / [Résolu] [SFML 2.0] La fonction sf::sleep ne fonctionne pas comme il faut.

« le: Avril 21, 2013, 07:38:12 pm »

Bonjours,

Je poste aujourd'hui car j'ai repéré un gros soucis avec la fonction sleep.

Deja je tiens a dire que les fonctions setFrameRateLimit et setVerticalSyncEnabled ne me conviennent
pas du tout étant donné qu'elles provoquent une discontinuité de l'affichage pour la 1ère (avec des temps
de boucles a chaque fois différents) et une trainée derrières les sprites lors des déplacements rapides
pour la 2ème.

J'ai donc voulu fixer les intervalles d'affichage a l'aide de la fonction sf::sleep.

Et la j'ai fais mon enquête car rien ne fonctionnait comme prévu.

Le test donne donc le résultat suivant :

Code : (juste la partie concercée)

                /*Fonctions déplaçant un cube témoin pour analyser la fluidité.
                Très simple, et non buguée, elle ajoute simplement 3, ou retire 3 a la
                coordonnée x du sprite */
               
                Window.clear(Color(0, 0, 0));
                Window.draw(sprite);

                t1=tempsAffichage-horloge.getElapsedTime();                    
                t2=horloge.getElapsedTime();
                sleep(t1);

                std::cout<<"HORLOGE : "<<horloge.getElapsedTime().asMicroseconds()<<std::endl;
                Window.display();
                std::cout<<"Temps de l'affichage : "<<horloge.getElapsedTime().asMicroseconds()<<"        "<<t1.asMicroseconds()<<"         "<<t2.asMicroseconds()<<std::endl;
                horloge.restart();

Dans ce code j'execute une fonction sleep pour attendre le temps d'affichage moins le temps
correspondant aux étapes depuis le précédent affichage.

La console affiche ensuite les valeurs suivantes :

...
HORLOGE : 29253
Temps de l'affichage : 30357        16579         88
HORLOGE : 29586
Temps de l'affichage : 30693        16514         153
HORLOGE : 29364
Temps de l'affichage : 30660        16615         52
HORLOGE : 29415
Temps de l'affichage : 30725        16636         31
HORLOGE : 29296
Temps de l'affichage : 30913        16624         43
HORLOGE : 29018
Temps de l'affichage : 30087        16631         36
HORLOGE : 29197
Temps de l'affichage : 29860        16629         46
HORLOGE : 29176
Temps de l'affichage : 30515        16626         41
HORLOGE : 28946
Temps de l'affichage : 29978        16625         42
...

Donc en gros, le temps à l'entrée de la fonction sleep tourne autour de 40 millisecondes.
Le temps t1 affiche bien la valeur manquante pour arriver a un temps correspondant
au temps d'affichage (qui est de 0.0166667f secondes - pour un ips voulu d'environ 60).
Jusqu'ici aucun problème, sauf qu'à la sortie de la fonction sleep, l'horloge affiche
environ 29000 millisecondes. Soit une attente presque deux fois plus longue que celle demandée.

La fonction sleep ne fait donc ici pas son travail correctement, comme dit sur la doc :
"Make the current thread sleep for a given duration."

Pouvez vous m'aider, merci !