IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

SDL Discussion :

Vitesse d'execution d'une boucle ou traitement d'une image trop lourd ?


Sujet :

SDL

  1. #1
    Membre du Club Avatar de Jordinateur
    Profil pro
    Inscrit en
    Février 2007
    Messages
    119
    Détails du profil
    Informations personnelles :
    Âge : 32
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 119
    Points : 51
    Points
    51
    Par défaut Vitesse d'execution d'une boucle ou traitement d'une image trop lourd ?
    Bonjour à tous !

    Je viens de finir un petit programme qui fais de la pluie
    Simplement, dans ma boucle qui anime les gouttes de pluie j'ai deux facteur de "vitesse" : Les millisecondes d'écart entre chaques déplacements de toutes les gouttes de pluie, et le nombre de pixels que l'ont rajoute a Y.

    Mon programme marche comme je veux mais lorsque je rajoute une image de fond pour voir ce que sa donne un peu plus avec un cas "concret", l'animation des gouttes est beaucoup plus lente alors que je n'ai rien touché, mis à part le fait d'avoir rajouté une image de fond au format jpg.

    Alors j'aimerais savoir si c'est un bug, si c'est normal ou je ne sais pas ...

    J'ai pensé que peut-être la boucle peut s'executer plus lentement en raison du blitage de l'image...

    Si vous voulez le code source demandez-moi mais je ne juge pas vraiment nécessaire de le mettre !

    Merci à ceux qui essairont de m'aider

  2. #2
    Membre éclairé
    Avatar de N_I_C_S
    Profil pro
    Inscrit en
    Septembre 2006
    Messages
    450
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2006
    Messages : 450
    Points : 681
    Points
    681
    Par défaut
    Salut,
    pour être sûr de l'utilisation des variables : tu récupère bien dans "millisecondes" le temps écoulé entre 2 affichages (ou un facteur proportionnel) et tu multiplie "déplacement Y" par ce facteur ?

  3. #3
    Expert éminent sénior

    Avatar de fearyourself
    Homme Profil pro
    Ingénieur Informaticien Senior
    Inscrit en
    Décembre 2005
    Messages
    5 121
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur Informaticien Senior
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2005
    Messages : 5 121
    Points : 11 877
    Points
    11 877
    Par défaut
    Citation Envoyé par Jordinateur Voir le message
    Si vous voulez le code source demandez-moi mais je ne juge pas vraiment nécessaire de le mettre !
    Ben si, il faudrait voir le code en espérant qu'il est relativement court et facile à comprendre,

    Jc

  4. #4
    Membre du Club Avatar de Jordinateur
    Profil pro
    Inscrit en
    Février 2007
    Messages
    119
    Détails du profil
    Informations personnelles :
    Âge : 32
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 119
    Points : 51
    Points
    51
    Par défaut
    Salut,
    pour être sûr de l'utilisation des variables : tu récupère bien dans "millisecondes" le temps écoulé entre 2 affichages (ou un facteur proportionnel) et tu multiplie "déplacement Y" par ce facteur ?
    En fait, quand alpha millisecondes se sont écoulées, je déplace les gouttes de bêta pixels ; alpha est le facteur 1 de vitesse et bêta est le facteur 2 de vitesse si on peut dire sa comme ça.


    enfin voici le code source :
    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
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    ///=============================================================================
    /*
    generation_goute.c
     
    -génération aléatoire d'une certaine quantité de gouttes
    -génération aléatoire des coordonnées de toutes ces gouttes
    -affichage des gouttes + simulation de pluie
    -retournement à main.c des coordonnées de toutes les goutes dans un tableau de structure de coordonnées
    */
     
    #include "generation_goute.h"
    ///=============================================================================
     
     
     
     
     
     
     
     
     
    ///=============================================================================
    ///DEBUT PLUIE
     
    //Effet de pluie
    void pluie (SDL_Surface *fenetre, const long hauteur_fenetre, const long intensite_min, const long intensite_max, unsigned char couleur_goutte1, unsigned char couleur_goutte2, unsigned char couleur_goutte3, long longueur_min_goutte, long longueur_max_goutte, long largeur_goutte, long fvitesse1, long fvitesse2)
    {
        //Coordonnées aléatoires des goutes de pluie en X
        int i, j;
        srand(time(NULL)); //Initialisation du générateur
     
        unsigned long nbr_goutte = 0; //Nombre de goutes à l'écran
        nbr_goutte =  nbr_aleatoire(intensite_min, intensite_max); /*Génération d'un nombre aléatoire entre 1 et intensite
                                        et qui va représenter le nombre de goutes de pluie à l'écran*/
     
        unsigned long Coord_Goutte_X[nbr_goutte];//Tableau des coordonnées de toutes les goutes pour l'axe des abcisses
        unsigned long Coord_Goutte_Y[nbr_goutte];//Tableau des coordonnées de toutes les goutes pour l'axe des ordonnés
        for (i=1; i<nbr_goutte; i++)
        {
            Coord_Goutte_X[i] = nbr_aleatoire(1, 800);
            Coord_Goutte_Y[i] = nbr_aleatoire(1, 600);
        }
     
        //--------------------------------------------------------------------------
     
     
        //--------------------------------------------------------------------------
        //Création des tableaux + allocation de la mémoire
        SDL_Surface ** goutte = NULL;//Pointeur de surface qui va servir de tableau de surfaces
     
        goutte = malloc(nbr_goutte * sizeof(* goutte));//Allocation de la mémoire pour le tableau du nombre de gouttes aléatoire
        if (goutte == NULL)
            exit(0);
     
        for(i = 1; i<nbr_goutte; i++)
            goutte[i] = SDL_CreateRGBSurface(SDL_HWSURFACE, largeur_goutte, nbr_aleatoire(longueur_min_goutte, longueur_max_goutte), 32, 0, 0, 0, 0);
        //--------------------------------------------------------------------------
     
     
        //--------------------------------------------------------------------------
        //Boucle principale
     
        unsigned char Continuer = 1;
        SDL_Event event;
     
        SDL_Rect coord_goutte; //Coordonnées de la goutte qui va être dessinée
        int temps_actuel = 0, temps_precedent = 0;
     
        SDL_Rect coord_image_de_fond;
        coord_image_de_fond.x = 0;
        coord_image_de_fond.y = 0;
        SDL_Surface *image_de_fond = IMG_Load("IMAGES/sunlake.jpg");
     
        //Répétition des touches activées
        SDL_EnableKeyRepeat(120,120);
     
        while (Continuer)
        {
     
    	//Gestion des événements
    	SDL_PollEvent(&event);
    	switch(event.type)
    	{
                case SDL_QUIT : Continuer = 0; break;
                case SDL_KEYDOWN :
                    switch(event.key.keysym.sym)
                    {
                        case SDLK_ESCAPE : Continuer = 0; break;
                        case SDLK_KP_ENTER :
                        if (fenetre == SDL_SetVideoMode (800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF))
                        {
                            fenetre = SDL_SetVideoMode (800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN); break;
                        }
                        else if (fenetre == SDL_SetVideoMode (800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN))
                        {
                            fenetre = SDL_SetVideoMode (800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF); break;
                        }
                    }
                break;
    	}
     
        temps_actuel = SDL_GetTicks();
        if (temps_actuel - temps_precedent > fvitesse1)
        {
            for (i=0; i<nbr_goutte; i++)
            {
                Coord_Goutte_Y[i] += fvitesse2;
                if (Coord_Goutte_Y[i] > hauteur_fenetre)
                {
                    Coord_Goutte_Y[i] = 0;
                    Coord_Goutte_X[i] = nbr_aleatoire(1, 800);
                }
            }
            temps_precedent = temps_actuel;
        }
     
        SDL_FillRect (fenetre, NULL, SDL_MapRGB(fenetre->format, 0, 0, 0));
        SDL_BlitSurface (image_de_fond, NULL, fenetre, &coord_image_de_fond);
     
        for(i = 1; i<nbr_goutte; i++)
        {
            coord_goutte.x = Coord_Goutte_X[i];//assignement d'une valeur aléatoire aux coordoonnées en X de la goutte qui va être dessinée
            coord_goutte.y = Coord_Goutte_Y[i];//Coordonnées de départ en Y de la goutte qui va être dessinée
            SDL_FillRect (goutte[i], NULL, SDL_MapRGB(fenetre->format, couleur_goutte1, couleur_goutte2, couleur_goutte3));
            SDL_SetAlpha (goutte[i], SDL_SRCALPHA, 128);
            SDL_BlitSurface (goutte[i], NULL, fenetre, &coord_goutte);
        }
     
    	SDL_Flip(fenetre);
        }
        //--------------------------------------------------------------------------
     
     
        //--------------------------------------------------------------------------
        //Libération de la mémoire pour le tableau de surface
        for (i=0; i<nbr_goutte; i++)
            SDL_FreeSurface(goutte[i]);
        //--------------------------------------------------------------------------
     
    }
     
    ///FIN PLUIE
    ///=============================================================================


    Et quand j'enlève la ligne

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    SDL_BlitSurface (image_de_fond, NULL, fenetre, &coord_image_de_fond);
    la vitesse de déplacements des gouttes est relativement plus élevée.


    Je penses que c'est parce que j'ai mal codé...Si vous pouviez m'aiclairer

  5. #5
    Expert éminent sénior

    Avatar de fearyourself
    Homme Profil pro
    Ingénieur Informaticien Senior
    Inscrit en
    Décembre 2005
    Messages
    5 121
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur Informaticien Senior
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2005
    Messages : 5 121
    Points : 11 877
    Points
    11 877
    Par défaut
    Déjà tu pourrais faire un appel à SDL_DisplayFormat pour avoir le bon format et enlever le SDL_FillRect qui devient superflu.

    Jc

  6. #6
    Membre du Club Avatar de Jordinateur
    Profil pro
    Inscrit en
    Février 2007
    Messages
    119
    Détails du profil
    Informations personnelles :
    Âge : 32
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 119
    Points : 51
    Points
    51
    Par défaut
    Eu désolé mais ça sert a quoi SDL_DisplayFormat ?

  7. #7
    Membre éclairé
    Avatar de N_I_C_S
    Profil pro
    Inscrit en
    Septembre 2006
    Messages
    450
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2006
    Messages : 450
    Points : 681
    Points
    681
    Par défaut
    Je crois que c'est bien ce que je disais :
    tu testes si (temps_actuel-temps_précédent) (on va dire deltaT) est supérieur à ton frame-rate minimum, mais tu n'actualise pas ton fvitesse2 en fonction.
    donc si tu as un deltaT 2 fois plus grand avec l'image (ce qui est possible...), tes gouttes tombent 2 fois plus lentement.
    Il faut que tu fasse une règle de 3 pour déterminer ton fvitesse2 selon deltaT à chaque frame.

  8. #8
    Membre du Club Avatar de Jordinateur
    Profil pro
    Inscrit en
    Février 2007
    Messages
    119
    Détails du profil
    Informations personnelles :
    Âge : 32
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 119
    Points : 51
    Points
    51
    Par défaut
    donc si tu as un deltaT 2 fois plus grand avec l'image (ce qui est possible...)
    Comment ça c'est possible ?...

  9. #9
    Membre du Club Avatar de Jordinateur
    Profil pro
    Inscrit en
    Février 2007
    Messages
    119
    Détails du profil
    Informations personnelles :
    Âge : 32
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 119
    Points : 51
    Points
    51
    Par défaut
    donc si tu as un deltaT 2 fois plus grand avec l'image (ce qui est possible...)
    Comment ça c'est possible ?...

    DeltaT comme tu l'appelles est défini lors de l'appel de la fonction !

  10. #10
    Membre actif
    Profil pro
    Inscrit en
    Octobre 2005
    Messages
    267
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2005
    Messages : 267
    Points : 275
    Points
    275
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    if (temps_actuel - temps_precedent > fvitesse1)
        {
            for (i=0; i<nbr_goutte; i++)
            {
                Coord_Goutte_Y[i] += fvitesse2;
    (...)
    C'est exactement ce que te dis N_I_C_S...
    Exemple:

    _ dans ta premiere application, tu as un temps deltaT = 5 ms à chaque boucle.
    _ Toutes les 5 ms, tu vas ajouter fvitesse2

    _ dans ta premiere application, tu as deltaT = 20 ms.
    _ Toutes les 20 ms, tu vas ajouter fvitesse2 (c'est donc plus lent)

    Il faut que tu ajoute K*deltaT (avec K une constante). Ainsi la vitesse des gouttes sera indépendantes du temps.

    DeltaT comme tu l'appelles est défini lors de l'appel de la fonction !
    ???

  11. #11
    Nouveau membre du Club
    Profil pro
    Inscrit en
    Août 2007
    Messages
    37
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2007
    Messages : 37
    Points : 34
    Points
    34
    Par défaut
    Le problème dans ton code, c'est que si deltaT est supérieur à fvitesse2, ce temps supplémentaire est perdu après ton update. Il faudrait au minimum avoir...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    temps_precedent -= fvitesse1;
    ...au lieu de simplement "temps_precedent = temps_actuel". Mais si fvitesse1 est trop petit, ça ne marchera pas non plus, et de toute façon le rendu sera saccadé.

    Généralement pour la partie graphique on préfère un framerate variable, comme dit dans les réponses précédentes. Dans ton code, enlève le "if (temps_actuel - temps_precedent > fvitesse1)", et remplace ton calcul de position des gouttes par:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Coord_Goutte_Y[i] += (temps_actuel - temps_precedent) * (fvitesse2 / fvitesse1);
    et tu devrais obtenir une vitesse constante, quelque soit le framerate.

  12. #12
    Membre du Club Avatar de Jordinateur
    Profil pro
    Inscrit en
    Février 2007
    Messages
    119
    Détails du profil
    Informations personnelles :
    Âge : 32
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 119
    Points : 51
    Points
    51
    Par défaut
    DeltaT comme tu l'appelles est défini lors de l'appel de la fonction !
    ???
    Excuse-moi je me suis mal exprimé. J'apelle la fonction pluie à partir d'une fonction main et lorsque je l'apelle, je donne 30 à l'argument "fvitesse1".
    Donc ce la valeur de ce facteur ne peux pas changer !


    Sinon lorannt j'ai fais ce que tu m'as dis j'ai donc suprimé la condition et remplacé

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Coord_Goutte_Y[i] += fvitesse2;
    par
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Coord_Goutte_Y[i] += (temps_actuel - temps_precedent) * (fvitesse2 / fvitesse1);
    Mais lorsque je fais le deuxième changement la fenêtre s'ouvre et se ferme automatiquement...Pourtant ton calcul m'avais l'air juste !

  13. #13
    Nouveau membre du Club
    Profil pro
    Inscrit en
    Août 2007
    Messages
    37
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2007
    Messages : 37
    Points : 34
    Points
    34
    Par défaut
    Citation Envoyé par Jordinateur Voir le message
    Sinon lorannt j'ai fais ce que tu m'as dis j'ai donc suprimé la condition
    En fait en y réfléchissant, tu peux aussi garder la condition, ça peut permettre d'éviter que le framerate ne s'envole et bouffe tout le cpu...

    Mais lorsque je fais le deuxième changement la fenêtre s'ouvre et se ferme automatiquement...Pourtant ton calcul m'avais l'air juste !
    J'avais pas vu que fvitesse1 et fvitesse2 étaient des entiers: il vaut mieux les passer en float ou en double (à cause de la division), ou encore mieux les remplacer par une seule variable de vitesse.

    Mais ça ne devrait pas faire planter l'appli... Si tu ne changes que cette ligne, la fenêtre se ferme toute seule, sans autre message d'erreur?

  14. #14
    Membre du Club Avatar de Jordinateur
    Profil pro
    Inscrit en
    Février 2007
    Messages
    119
    Détails du profil
    Informations personnelles :
    Âge : 32
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 119
    Points : 51
    Points
    51
    Par défaut
    Bien en fait le problème est à moitié résolu !
    Quand je change le type des deux variables "fvitesse1" et "fvitesse2" en float, la fenêtre ne se referme pas automatiquement...Mais je ne vois pas vraiment pourquoi !

    Mais les gouttes ne bougent plus en reste affichées aux mêmes coordonnées aparemment...

    Je vais voir ça d'un peu plus près dès que j'ai le temps !
    En attendant si toi tu trouves un peu de temps et voir ce qui se passe aussi sa serait sympa !

  15. #15
    Expert éminent sénior
    Avatar de Mat.M
    Profil pro
    Développeur informatique
    Inscrit en
    Novembre 2006
    Messages
    8 360
    Détails du profil
    Informations personnelles :
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Novembre 2006
    Messages : 8 360
    Points : 20 378
    Points
    20 378
    Par défaut
    for(i = 1; i<nbr_goutte; i++) goutte[i] = SDL_CreateRGBSurface
    SDL_Surface *image_de_fond = IMG_Load("IMAGES/sunlake.jpg");
    C'est ce que tu fais à chaque instant ?
    Déjà le fait de créer des SDL_Surface à chaque instant t risque de fragmenter la mémoire RAM et VRAM je conseille de le faire au début du programme une bonne fois pour toute
    2ièmement il faut pas perdre de vue que les jpeg il faut les décompresser ce qui peut prendre du temps de traitement CPU.
    Soit tu charges une BMP ou PNG soit tu charges les jpeg au début du programme

  16. #16
    Membre du Club Avatar de Jordinateur
    Profil pro
    Inscrit en
    Février 2007
    Messages
    119
    Détails du profil
    Informations personnelles :
    Âge : 32
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 119
    Points : 51
    Points
    51
    Par défaut
    Ba je ne savais pas pour le jpeg je me disais bien que c'était lourd le traitement mais en tout cas je ne vois pas de solution alternative ! Il faut bien que je réaffiche l'image nan ?!

    A moins que j'affiche l'image au début et que je crée une autre surface destinée a contenir toutes les gouttes, comme ça au moins je pourrais n'actualiser que la surface crée et ne pas réafficher l'image à chaque fois !

    Qu'en penses-tu ?

  17. #17
    Nouveau membre du Club
    Profil pro
    Inscrit en
    Août 2007
    Messages
    37
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2007
    Messages : 37
    Points : 34
    Points
    34
    Par défaut
    Je ne pense pas que ça soit la solution, mais au début de ton code, tu as:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    int temps_actuel = 0, temps_precedent = 0;
    Ce qui veux dire qu'au premier tour tu risque d'avoir un deltaT énorme. Il vaut mieux faire:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    int temps_precedent = SDL_GetTicks();
    Après, je vois pas pourquoi tes gouttes restent immobiles... Essaient de mettre quelques printf (ou utilise un débogueur) pour voir comment évoluent les différentes valeurs (deltaT, la vitesse calculée, les coordonnées des gouttes).

    Essaie aussi de remplacer (fvitesse2 / fvitesse1) par une seule valeur entière.

    En ce qui concerne le chargement de l'image, je ne pense pas qu'il y ai de problème puisque tu le fait en dehors de la boucle principale. Par contre tu peux éviter de faire le FillRect et le SetAlpha sur les gouttes à chaque update: fait le une fois pour toute au début.

  18. #18
    Nouveau membre du Club
    Profil pro
    Inscrit en
    Août 2007
    Messages
    37
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2007
    Messages : 37
    Points : 34
    Points
    34
    Par défaut
    Bon, je viens de faire un essai rapide, et chez moi, avec fvitesse1 et 2 en float et la formule postée plus haut, ça marche sans probleme...

    Par contre il y a un autre bug dans ton code: parfois tu indexes ton tableau de gouttes à partir de 0, parfois à partir de 1... Commence à 0 partout.

  19. #19
    Membre du Club Avatar de Jordinateur
    Profil pro
    Inscrit en
    Février 2007
    Messages
    119
    Détails du profil
    Informations personnelles :
    Âge : 32
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 119
    Points : 51
    Points
    51
    Par défaut
    Eu je vais essayer de tester les valeurs !
    Je crois que c'est parce que j'ai modifié un peu le code :


    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
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    ///=============================================================================
    /*
    generation_goute.c
     
    -génération aléatoire d'une certaine quantité de gouttes
    -génération aléatoire des coordonnées de toutes ces gouttes
    -affichage des gouttes + simulation de pluie
    -retournement à main.c des coordonnées de toutes les goutes dans un tableau de structure de coordonnées
    */
     
    #include "generation_goute.h"
    ///=============================================================================
     
     
     
     
     
     
     
     
     
    ///=============================================================================
    ///DEBUT PLUIE
     
    //Effet de pluie
    void pluie (SDL_Surface *fenetre, const long hauteur_fenetre, const long intensite_min, const long intensite_max, unsigned char couleur_goutte1, unsigned char couleur_goutte2, unsigned char couleur_goutte3, long longueur_min_goutte, long longueur_max_goutte, long largeur_goutte, float fvitesse1, float fvitesse2)
    {
        //Coordonnées aléatoires des goutes de pluie en X
        int i, j;
        srand(time(NULL)); //Initialisation du générateur
     
        unsigned long nbr_goutte = 0; //Nombre de goutes à l'écran
        nbr_goutte =  nbr_aleatoire(intensite_min, intensite_max); /*Génération d'un nombre aléatoire entre 1 et intensite
                                        et qui va représenter le nombre de goutes de pluie à l'écran*/
     
        unsigned long Coord_Goutte_X[nbr_goutte];//Tableau des coordonnées de toutes les goutes pour l'axe des abcisses
        unsigned long Coord_Goutte_Y[nbr_goutte];//Tableau des coordonnées de toutes les goutes pour l'axe des ordonnés
        for (i=1; i<nbr_goutte; i++)
        {
            Coord_Goutte_X[i] = nbr_aleatoire(1, 800);
            Coord_Goutte_Y[i] = nbr_aleatoire(1, 600);
        }
     
        //--------------------------------------------------------------------------
     
     
        //--------------------------------------------------------------------------
        //Création des tableaux + allocation de la mémoire
        SDL_Surface ** goutte = NULL;//Pointeur de surface qui va servir de tableau de surfaces
     
        goutte = malloc(nbr_goutte * sizeof(* goutte));//Allocation de la mémoire pour le tableau du nombre de gouttes aléatoire
        if (goutte == NULL)
            exit(0);
     
        for(i = 1; i<nbr_goutte; i++)
            goutte[i] = SDL_CreateRGBSurface(SDL_HWSURFACE, largeur_goutte, nbr_aleatoire(longueur_min_goutte, longueur_max_goutte), 32, 0, 0, 0, 0);
        //--------------------------------------------------------------------------
     
     
        //--------------------------------------------------------------------------
        //Boucle principale
     
        unsigned char Continuer = 1;
        SDL_Event event;
     
        SDL_Rect coord_goutte; //Coordonnées de la goutte qui va être dessinée
        int temps_actuel = 0, temps_precedent = 0;
     
        SDL_Rect coord_image_de_fond;
        coord_image_de_fond.x = 0;
        coord_image_de_fond.y = 0;
        SDL_Surface *image_de_fond = IMG_Load("IMAGES/sunlake.jpg");
     
        //Répétition des touches activées
        SDL_EnableKeyRepeat(120,120);
     
        while (Continuer)
        {
     
    	//Gestion des événements
    	SDL_PollEvent(&event);
    	switch(event.type)
    	{
                case SDL_QUIT : Continuer = 0; break;
                case SDL_KEYDOWN :
                    switch(event.key.keysym.sym)
                    {
                        case SDLK_ESCAPE : Continuer = 0; break;
                        case SDLK_KP_ENTER : fenetre = SDL_SetVideoMode (800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN); break;
                    }
                break;
    	}
     
        temps_actuel = SDL_GetTicks();
        if (temps_actuel - temps_precedent > fvitesse1)
        {
            for (i=0; i<nbr_goutte; i++)
            {
                Coord_Goutte_Y[i] += fvitesse2;
                //Coord_Goutte_Y[i] += (temps_actuel - temps_precedent) * (fvitesse2 / fvitesse1);
                if (Coord_Goutte_Y[i] > hauteur_fenetre)
                {
                    Coord_Goutte_Y[i] = 0;
                    Coord_Goutte_X[i] = nbr_aleatoire(1, 800);
                }
            }
            temps_precedent -= fvitesse1;
        }
     
        SDL_FillRect (fenetre, NULL, SDL_MapRGB(fenetre->format, 0, 0, 0));
        //SDL_DisplayFormat(image_de_fond);
        //SDL_BlitSurface (image_de_fond, NULL, fenetre, &coord_image_de_fond);
     
        for(i = 1; i<nbr_goutte; i++)
        {
            coord_goutte.x = Coord_Goutte_X[i];//assignement d'une valeur aléatoire aux coordoonnées en X de la goutte qui va être dessinée
            coord_goutte.y = Coord_Goutte_Y[i];//Coordonnées de départ en Y de la goutte qui va être dessinée
            SDL_FillRect (goutte[i], NULL, SDL_MapRGB(fenetre->format, couleur_goutte1, couleur_goutte2, couleur_goutte3));
            SDL_SetAlpha (goutte[i], SDL_SRCALPHA, 60);
            SDL_BlitSurface (goutte[i], NULL, fenetre, &coord_goutte);
        }
     
        //--------------------------------------------------------------------------
        //Test de la valeur de certaines variables.
        TTF_Font *police = NULL;
        SDL_Surface *texte = NULL;
        SDL_Rect coord_texte;
        SDL_Color couleur = {255, 255, 255};
        police = TTF_OpenFont("arial.ttf", 25);
        char txt[200] = "";
        sprintf (txt, "Nombre de gouttes : %ld", nbr_goutte);
        texte = TTF_RenderText_Solid (police, txt, couleur);
        coord_texte.x = 400;
        coord_texte.y = 300;
        SDL_BlitSurface (texte, NULL, fenetre, &coord_texte);
        //--------------------------------------------------------------------------
     
     
    	SDL_Flip(fenetre);
        }
        //--------------------------------------------------------------------------
     
     
        //--------------------------------------------------------------------------
        //Libération de la mémoire pour le tableau de surface
        for (i=0; i<nbr_goutte; i++)
            SDL_FreeSurface(goutte[i]);
        //--------------------------------------------------------------------------
     
    }
     
    ///FIN PLUIE
    ///=============================================================================


    Je crois que j'ai mal fais ce que tu m'as dis avant !

  20. #20
    Expert éminent sénior
    Avatar de Mat.M
    Profil pro
    Développeur informatique
    Inscrit en
    Novembre 2006
    Messages
    8 360
    Détails du profil
    Informations personnelles :
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Novembre 2006
    Messages : 8 360
    Points : 20 378
    Points
    20 378
    Par défaut
    je ne comprends pas : d'abord que contient la ou les images jpg ?
    Si tu as dessiné des gouttes , eh bien au init() de ton programme tu stockes les fichiers jpg par exemple dans un std::vector qui va contenir des SDL_Surface plutot qu'à l'exécution recharger les bitmaps et créer des surfaces
    Puis au rendu tu balaies le std::vector et avec un tirage de paramêtres aléatoire tu dessines avec des SDL_Rect pour découper dans des modèles de dessin

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. optimiser une boucle while imbriquer dans une boucle for
    Par bakaratoun dans le forum MATLAB
    Réponses: 0
    Dernier message: 28/01/2010, 15h35
  2. Accélération d'un traitement dans une boucle
    Par mobi_bil dans le forum Langage
    Réponses: 4
    Dernier message: 15/06/2009, 12h57
  3. Réponses: 5
    Dernier message: 27/11/2008, 17h34
  4. [loop] ralentir le traitement d'une boucle
    Par jontleman dans le forum Windows Forms
    Réponses: 7
    Dernier message: 30/11/2007, 14h34
  5. [DEBUTANT]Procédure stockée Traitement sur une boucle de requete
    Par tripper.dim dans le forum MS SQL Server
    Réponses: 1
    Dernier message: 21/06/2007, 16h24

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo