Créer une animation fluide

**stc074** · 30/01/2012, 02h06

Je poste car j'ai rien vu sur le net, j'ai codé un starfield et je n'arrive pas a faire en sorte que l'animation soit fluide ni avec les timer ni avec SDL_Ticks (avec un simple test dans une boucle).
J'aimerais savoir si vous avez des "trucs" pour arriver a une animation fluide a tout les coups.
Faut il faire en sorte que le code soit le seul programme tournant sur la machine (et d'ailleurs est-ce possible ?) afin que ça ne gène pas trop l'animation?
Merci pour vos hints !

**Kannagi** · 30/01/2012, 14h10

Moi j'arrive a avoir une animation fluide a tous les coups.
Il faut respecté 2 choses , un FPS constants , et une 'cadence' de image , je veux dire faut programmé que image soit affiché un certain nombre de fois ,par exemple j'ai une cadence de 2 j'affiche 2 fois l'image avant de passer a la suivante , c'est surtout utile pour les FPS élevé.
Pour avoir le 'max' de fluidité un fps de 60 est conseillé.

Enfin chez moi ça donne de bon resultats demo
(il tourne sur 30 fps).

**stc074** · 30/01/2012, 22h12

par exemple j'ai une cadence de 2 j'affiche 2 fois l'image avant de passer a la suivante , c'est surtout utile pour les FPS élevé.

Je comprend pas pourquoi tu affiches 2 fois l'image ? avant de la rafraîchir ?

**Kannagi** · 30/01/2012, 23h15

Apres si on veut , je parlait dans le sens ou une animation c'est que un défilement image donc bon , mais faire une défilement image est pas suffisant pour que visuellement cela soit correct.

Pour te répondre :
Ben imaginons que l'animation de la marche est sur 4 images , sur 40 fps , l'animation est affiché 10 fois par seconde ce qui est beaucoup, sur une cadence de 5(on affiche 5 fois la même image avant de passer a la suivante) la marche est affiché 2fois par seconde ce qui est plus jolie visuellement.

M'enfin c'est quelque chose qu'il faut régler ça dépend du nombre de animation , du FPS mis ,et de animation en elle meme (si animation représente un mouvement long ou rapide).

Je pose la question du compte gérer animation par callback ?(vu par rapport a ton ancien post) si c'est le cas c'est pas une bonne idée ,il doit y avoir des moyen pour utilisé mais pas pour ce genre de utilisation.

**stc074** · 30/01/2012, 23h28

Je pose la question du compte gérer animation par callback ?(vu par rapport a ton ancien post) si c'est le cas c'est pas une bonne idée ,il doit y avoir des moyen pour utilisé mais pas pour ce genre de utilisation.

Non j'ai modifié mon code j'utilise désormais un SDL_GetTicks(), je le compare a chaque boucle, si il y a une différence de plus de 17 ms je ré-affiche mon starfield, par contre en affichant avec un printf le delay j'ai vu que des fois il dépassait largement les 17 ms (une fois j'ai eu 43ms) donc c normal que ça saccade, je pensais que le C serait plus rapide.
Peut être est-ce a cause des programme qui tourne en tache de fond? (je dis ça car mon cpu tourne autour des 25%)
Pour te faire une idée voici ma boucle principale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
void anim() {
    int continuer=1;
    Uint32 tempsActuel=0, tempsPrecedent=0;
    SDL_Event event;
    while(continuer) {
        tempsActuel=SDL_GetTicks();
        if(tempsActuel-tempsPrecedent>=17)
        {
            printf("Delay : %d\n", tempsActuel-tempsPrecedent);
            SDL_Flip(ecran);
            tempsPrecedent=tempsActuel;
    SDL_PollEvent(&event);
    switch(event.type) {
        case SDL_QUIT:
            continuer=0;
            break;
        case SDL_KEYDOWN:
            continuer=0;
            break;
    }
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
    int i=0, x=0, y=0;
    for(i=0; i<NB_STARS; i++) {
    x=stars1[i][0];
    y=stars1[i][1];
    x+=STEP1;
    if(x>=WIDTH) {
        x=0;
        //y=(int)((double)rand()/(double)RAND_MAX*(HEIGHT-1));
    }
    //if(x>=0&&y>=0&&x<WIDTH&&y<HEIGHT) {
    stars1[i][0]=x;
    //stars1[i][1]=y;
    //}
    *((Uint32*)(ecran->pixels)+x+(y*ecran->w))=SDL_MapRGB(ecran->format, RGB1, RGB1, RGB1);
    }
    for(i=0; i<NB_STARS; i++) {
        x=stars2[i][0];
        y=stars2[i][1];
        x+=STEP2;
        if(x>=WIDTH) {
            x=0;
            //y=(int)((double)rand()/(double)RAND_MAX*(HEIGHT-1));
        }
        //if(x>=0&&y>=0&&x<WIDTH&&y<HEIGHT) {
        stars2[i][0]=x;
        //stars2[i][1]=y;
        //}
        *((Uint32*)(ecran->pixels)+x+(y*ecran->w))=SDL_MapRGB(ecran->format, RGB2, RGB2, RGB2);
    }
    for(i=0; i<NB_STARS; i++) {
        x=stars3[i][0];
        y=stars3[i][1];
        x+=STEP3;
        if(x>=WIDTH) {
            x=0;
            //y=(int)((double)rand()/(double)RAND_MAX*(HEIGHT-1));
        }
        //if(x>=0&&y>=0&&x<WIDTH&&y<HEIGHT) {
        stars3[i][0]=x;
        //stars3[i][1]=y;
        //}
        *((Uint32*)(ecran->pixels)+x+(y*ecran->w))=SDL_MapRGB(ecran->format, RGB3, RGB3, RGB3);
    }
        }
    }
}

**Kannagi** · 31/01/2012, 00h13

Alors avant je préfère signalé qql erreur a pas faire.
Le code est assez mal indenté.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int i=0, x=0, y=0;

Ceci doit ce trouver au début de la fonction , pas au milieu d'une boucle.

La fonction est mal nommé anim la fonction gère trop de chose pour pouvoir s’appellé anim.

et tu réécris quasiment 3 fois la même chose.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
for(i=0; i<NB_STARS; i++)
            {
                x=stars3[i][0];
                y=stars3[i][1];
                x+=STEP3;
                if(x>=WIDTH)
                {
                    x=0;
                    //y=(int)((double)rand()/(double)RAND_MAX*(HEIGHT-1));
                }
                //if(x>=0&&y>=0&&x<WIDTH&&y<HEIGHT) {
                stars3[i][0]=x;
                //stars3[i][1]=y;
                //}
                *((Uint32*)(ecran->pixels)+x+(y*ecran->w))=SDL_MapRGB(ecran->format, RGB3, RGB3, RGB3);
            }

Que tu peut mettre en fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void affiche(SDL_Surface *ecran,int step,int *stars[],int width,int rgb,int n)
{
    int i,x,y;
    for(i=0; i<n; i++)
    {
        x=stars[i][0];
        y=stars[i][1];
        x+=step;
        if(x>=width)
        {
            x=0;
            //y=(int)((double)rand()/(double)RAND_MAX*(HEIGHT-1));
        }
        //if(x>=0&&y>=0&&x<WIDTH&&y<HEIGHT) {
        stars[i][0]=x;
        //stars3[i][1]=y;
        //}
        *((Uint32*)(ecran->pixels)+x+(y*ecran->w))=SDL_MapRGB(ecran->format, rgb, rgb, rgb);
    }
}

Et je viens de capter un truk stars1,2 et 3 sont des variable globale non ?
Alors les variable global sont a bannir , et utilisation des pointeurs est conseillé.
Si tu débute assure toi de bien maîtrisé pointeur,Structure et fonction avant de continuer.
D'ailleurs l'utilisation des define est exagéré ici( qui sont d’ailleurs inutile quand on les mets sous fonction).

Pour revenir a ton problème , tu n'utilise pas de Delay (sleep ou SDL_Delay peu importe) , donc ton programme tourne en boucle (et donc CPU doit bien être utilisé aux max ),il y a effectivement ta méthode pour gérer le FPS mais ce n'est pas ma préférer vu qu'elle est pas super précise.
Il y a une autre avec un SDL_Delay(temps); avec temps qui est variable.

**stc074** · 31/01/2012, 00h36

Oui en effet je débute et c'est vrai que j'ai du mal avec les pointeurs je me suis alors laissé tenté par les variables globales.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Il y a une autre avec un SDL_Delay(temps); avec temps qui est variable.

Je connais cette fonction ils en parlent dans le tuto du SDZ et ils disent qu'elles n'est pas précises (a cause d'autres programmes pouvant tourner en tache de fond).
Il y a aussi un autre truc si j'utilise SDL_Delay ça met mon programme en attente mais je dois aussi prendre en compte le temps que prend l'affichage, tu crois que je dois jongler avec les 2 ? (SDL_Ticks et SDL_Delay) ?
Merci pour ton aide, elle est précieuse !

**LittleWhite** · 31/01/2012, 09h46

Bonjour,

Afin d'obtenir une animation correcte, on peut faire en sorte de séparer l'affichage de la mise à jour de l'animation.
Pour cela, il n'est pas obligé de faire deux boucles.
Voici un algorithme qui permet d'expliquer mon architecture :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
{
     while ( 1 )
     {
          affiche(); // On affiche généralement autant de fois que l'on peut. Si vraiment on veut limiter les FPS, alors on peut rajouter un code utilisant SDL_GetTicks().
 
          // Gestion de l'update
          if ( SDL_GetTicks() - temps_de_la_derniere_update > 20 ) // 20ms, donc 50 update par seconde
          {
               update();
               temps_de_la_derniere_update = SDL_GetTicks();
          }
     }
}

Ainsi, l'animation est fluide. On peut aussi imaginer un système encore plus avancé, utilisant un delta (le temps entre deux update), qui permettra de faire bouger l'animation selon ce delta (car si cela rame, actuellement, le programme va faire la mise à jour (un pas), dès que le programme reprend le contrôle, mais avec un delta, selon le temps de ralentissement, il va faire plusieurs pas).

**math_lab** · 31/01/2012, 11h25

Moi j'aurai fait le contraire: on update autant que possible, et on affiche quand on peut. Il faut juste que l'update prenne en compte la différence de temps depuis la dernière update.

**LittleWhite** · 31/01/2012, 11h28

Ah ...

Mais alors, votre update ne fait pas les calculs de l'IA ? (bon, ok, je sors un peu du contexte de la discussion).
Je n'arrive pas à voir quels sont les avantages de faire l'update tout le temps ...

**Mat.M** · 31/01/2012, 11h53

Salut ah l'animation ! C'est une des choses les plus délicates à mettre en oeuvre
Un bon lien classique
http://www.koonsolo.com/news/dewitters-gameloop/

sinon le plus simple c'est de prendre la solution de LittleWhite

**math_lab** · 31/01/2012, 11h55

Bah l'IA peut être dedans tout comme elle ne peut ne pas l’être. Mais par exemple, pour gérer les mouvements des persos IA ou de la physique, c'est quand même mieux de le faire autant que possible (tant qu'on crame pas son proc, évidemment) pour être sur d'avoir une bonne précision (imagine une intégration d’Euler, si ton pas est plus petit, ça colle plus a la réalité).

**Mat.M** · 31/01/2012, 11h58

Envoyé par math_lab

Bah l'IA peut être dedans tout comme elle ne peut ne pas l’être. Mais par exemple, pour gérer les mouvements des persos IA ou de la physique, c'est quand même mieux de le faire autant que possible (tant qu'on crame pas son proc, évidemment) pour être sur d'avoir une bonne précision (imagine une intégration d’Euler, si ton pas est plus petit, ça colle plus a la réalité).

à ce moment-là il faut détacher le traitement de l'IA dans un thread à part en parallèle,mais ça complexifie l'architecture du jeu

**Kannagi** · 31/01/2012, 12h47

Envoyé par stc074

Je connais cette fonction ils en parlent dans le tuto du SDZ et ils disent qu'elles n'est pas précises (a cause d'autres programmes pouvant tourner en tache de fond).
Il y a aussi un autre truc si j'utilise SDL_Delay ça met mon programme en attente mais je dois aussi prendre en compte le temps que prend l'affichage, tu crois que je dois jongler avec les 2 ? (SDL_Ticks et SDL_Delay) ?
Merci pour ton aide, elle est précieuse !

SDL_Delay n'est pas super précise mais suffisamment pour faire un FPS constant.
Oui tu peux jongler avec les deux je te le conseille en tous cas.

Envoyé par LittleWhite

Bonjour,

Afin d'obtenir une animation correcte, on peut faire en sorte de séparer l'affichage de la mise à jour de l'animation.
Pour cela, il n'est pas obligé de faire deux boucles.
Voici un algorithme qui permet d'expliquer mon architecture :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
{
     while ( 1 )
     {
          affiche(); // On affiche généralement autant de fois que l'on peut. Si vraiment on veut limiter les FPS, alors on peut rajouter un code utilisant SDL_GetTicks().
 
          // Gestion de l'update
          if ( SDL_GetTicks() - temps_de_la_derniere_update > 20 ) // 20ms, donc 50 update par seconde
          {
               update();
               temps_de_la_derniere_update = SDL_GetTicks();
          }
     }
}

Ainsi, l'animation est fluide. On peut aussi imaginer un système encore plus avancé, utilisant un delta (le temps entre deux update), qui permettra de faire bouger l'animation selon ce delta (car si cela rame, actuellement, le programme va faire la mise à jour (un pas), dès que le programme reprend le contrôle, mais avec un delta, selon le temps de ralentissement, il va faire plusieurs pas).

Je me pose la question justement cette technique est pas optimal en terme de processus utilisé ?
Il y a pas de Delay dans ton programme donc tu utilisera le processus des que possible , je trouve pas top surtout pour faire quasiment aucun calcul.
Apres faire un gros 'if' est pas trop dans mes règle de codage ,sauf si on met une fonction update(); comme tu le met mais faudra mettre pas mal d'arguments ou les mettre dans une Structure et la structure serait assez générique donc bon (sauf si tu utilise des variable global est c'est le mal x) ).

Moi je montre mon architecture marche très bien jusqu’à présent :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
Evenment();
Collision();
Deplacement();
Affichage();
Fps();

**LittleWhite** · 31/01/2012, 13h08

Bah, un jeu, ça prend 100% du CPU, car on s'inquiète pas trop du reste (l'utilisateur, lorsqu'il lance le jeu, ne fait que jouer).
Sinon, on peut voir avec la limite 60FPS, pour faire en sorte de libérer un peu le CPU.

screetch · 31/01/2012, 13h27

ce n'est pas une excuse pour faire du code cradoc qui brûle du petrôle ou de l'uranium pour juste attendre la prochaine frame!!!
Il n'y a pas besoin d'une précision élevée pour avoir un FPS stable, il y a deux bonnes méthodes:
- bloquer le rafraichissement a 60FPS: ton programme sera bloqué automatiquement et ne prendra pas de CPU jusqu'a la prochaine frme
- aller aussi vite que possible et fficher toutes les frame, mais avoir des update de temps variables. La plupart des jeux peuvent aussi faire ainsi. Comme la physique ne passe pas bien en variable, on effectue la physique seulement si la derniere physique calculée a été, mettons, il y a 16 millisecondes. Les autres frame, si on va plus vite on fait un peu d'interpolation et si on va trop lentement on effectue l pysique plusieurs fois.

**Kannagi** · 31/01/2012, 14h05

Tous a fait d'accord avec screetch pas une raison que un jeu (en 2D en plus) utilise 100% du CPU D= , si tu peux faire moins tu le fais x)
Mes jeux en 2D utilise 10% de cpu , je vois pas pk il devrait en prendre plus ,a part a cause d'une mauvaise architecture.
Je pense que mettre un FPS est conseillé/obligatoire.
Comme le dis screeth , il y a Deux méthode je conseille la premiere pour un code plus facile a voir/maintenir.

**LittleWhite** · 31/01/2012, 14h12

J'ai du mal à comprendre screetch, car au final il répète ce que j'ai dit (ou alors je m'exprime très mal). Enfin bref, il a dit ce qui est à dire

Il ne faut pas croire qu'il y a qu'une seule technique ou deux -> http://www.koonsolo.com/news/dewitters-gameloop/

Moi, je vois des jeux, du style UT2004, par exemple, qui n'ont pas de blocage FPS mais qui possède un blocage des update, du coup, ça prend 100% du CPU.

Là, où il y a vraiment un besoin de limiter les FPS, c'est pour les jeux sur smartphone et autre périphérique portable, sinon on crame la batterie et le consommateur ne sera pas content.
Un jeu XBox / PS3 ne s'inquiète pas trop de cela.

Après, je ne vois pas où j'ai parlé de code crado. Il suffit de quelques lignes pour faire une limitation des FPS (avec le Sleep).

screetch · 31/01/2012, 14h52

j'ai mal lu ton code; j'ai lu que tu bouclais tant que le GetTickCount() n'avait pas atteint 20ms

mea culpa.

**Kannagi** · 31/01/2012, 14h56

Oui ben une limitation du cpu est conseillé.
Apres qu'un autre jeu utilise 100% du cpu alors qu'il pouvait en prendre moins ,surtout si c'est rajouté une ligne comme tu dis me laisse perplexe.
Je peux faire le reproche pour la mémoire aussi , moins t'en utilise mieux c'est , en gros penser au petite config c'est un plus.

C'est vrai que de nos jours il n'y a pas de programme qui tourne en fond(sans parler d’antivirus et pour le système exploitation),ça m'arrive de jouer et de parler via skype , et ça devient plus courant avec mumble msn ou autre,perso si on peut faire que nos programme utilise peu de cpu est facilement pk s'en privé ? =P

Créer une animation fluide

SDL

Discussions similaires

Partager

Partager