Discussion :

[Hybrix]

Bonjour/Bonsoir à tous,

Je travail actuellement sur un jeu du type Smash Bros sur Pc.
Actuellement je travail avec les bibliothèques suivantes :
- FMOD.
- SDL.
- OpenGl.
- DeVil.
- Freetype.

Je code en C++ sous codeBlock.

Etant assez maniaque sur l'utilisation mémoire, j'aimerais savoir si il était possible de faire une fonction pour charger les images ne laissant pas de mémoire de côté.

Explications:
Actuellement je travail comme ça :
Je charge puis traite les images à l'aide de DeVil, ensuite, je les "converti" en texture OpenGL.

Les problèmes :
- Un tout petit peu lent lorsqu'il y a 10 surfaces à convertir
- La RAM n'est pas entièrement libéré lors de la conversion.

Avant le changement de fond :
19964 Ko utilisé.
Apres le changement de fond :
21072 Ko (juste en reconvertissant la surface en texture, pas de déclaration)

On peut voir que la convertion utilise 1108Ko de plus (~1 Mo), ce qui n'est pas négligeable lorsque par la suite j'en ferrais plus de 20 (20 Mo en plus ).

Actuellement la fonction pour convertir est :

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
 
 
// prototypes
GLuint chargerTexture(const char * filename, bool useMipMap = false);
 
int main(int argc, char *argv[])
{
     GLuint IMG_fond     = chargerTexture("../media/images/menus/connexion.jpg");
}
 
/**************************
*         Charger
*      les textures
**************************/
GLuint chargerTexture(const char * filename, bool useMipMap)
{
    ILuint  ilimage;
    GLuint id;
 
    ilGenImages(1,&ilimage);
    ilBindImage(ilimage);
    ilLoad(IL_TYPE_UNKNOWN ,(ILstring)filename);
    ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
    iluFlipImage();
 
    glGenTextures(1,&id);
    glBindTexture(GL_TEXTURE_2D,id);
 
    if (useMipMap)
    {
 
        gluBuild2DMipmaps(GL_TEXTURE_2D, 4, ilGetInteger(IL_IMAGE_WIDTH),
                          ilGetInteger(IL_IMAGE_HEIGHT), GL_RGBA,GL_UNSIGNED_BYTE,
                          ilGetData());
 
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,
                        GL_LINEAR_MIPMAP_LINEAR);
 
    }
    else
    {
        glTexImage2D(GL_TEXTURE_2D, 0, 4, ilGetInteger(IL_IMAGE_WIDTH),
                     ilGetInteger(IL_IMAGE_HEIGHT), 0, GL_RGBA,GL_UNSIGNED_BYTE,
                     ilGetData());
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    }
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
 
    ilDeleteImages(1, &ilimage);
    return id;
}

En gros, j'aimerais savoir si il était possible de faire une fonction liberant entierement la mémoire.

Merci à vous.
Hybrix.

[bafman]

et tu les sort d'ou tes chiffres d'utilisation memoire ? si c'est du gestionnaire de taches windows, pas la peine de trop t'inquieter, il est juste completement imprecis

[Hybrix]

Effectivement ça vient du gestionnaire Windows.

il est juste completement imprecis

C'est pas très rassurant , y a t-il un logiciel qui s'occupe de ça ? (en plus précis )

Merci d'avoir répondu.

[Tosh]

Imprecis certe, mais il saura quand meme te detecter 20 mega de leak
Pour etre sur, charges tes 20 textures (ou alors un tres grosss) et regarde le resultat, meme si il ne sera pas fiable a l'octet pres, ca te confirmera tes doutes.

[Sixissor]

Test Corona: http://corona.sourceforge.net/, c'est plus haut niveau que DevIl.

[Hybrix]

Merci beaucoup de vos réponses,
J'ai testé et je perd effectivement de la mémoire au changement de fond, enfin c'est mieux qu'avant donc ce n'est pas trop dramatique (le jeu utilise 25Mo de Ram seulement (comparé au 60 Mo d'avant, qui montait a 130Mo lors du chargement).

Je suis confronté à un nouveau problème, évitant de faire plusieurs sujets, je me permet d'exposé mon problème ici .

Je fait actuellement un Mmorpg, .... je plaisantais, il y a suffisant de personnes souhaitant en faire .
Pour en revenir au sujet, je fait un jeu en 2D du type super smash bros (ejecter le joueur hors de la zone de combat).
Le jeu étant en 2D, a chaque tour de boucle je ré-affiche tous les éléments à l'écran, enfin seulement ce qui se trouve sur l'écran, avant je collais tous les éléments sur une image que je déplaçais, mais c'était beaucoup plus lent (50 FPS contre 104 FPS actuellement).

Je suis rendus aux chargement des monstres, ne connaissant pas le nombre de monstres avant le chargement de la map, il m'est difficile de savoir combien il vas y en avoir.

Chaque monstre contient différentes variables, que j'ai stocké dans une structure :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
// Les monstres
typedef struct Monstres Monstres;
struct Monstres
{
    long        type;  // 1- goomba 2- Koopa 3- Bob-omb 4- ...
    long        etat;  // 1- en vie 2- second etat (ex : koopa qui roule) 3- mort, 4 - bloquer :(, 5- saute.
    long      action;  // parle, se repose, ....
    long   animation; // animer le monstre.
    long   direction; // animer le monstre dans la bonne direction.
    long      divers; // pour diverses actions.
    int x;
    int y;
};

J'aimerais faire une allocation dynamique de cette structure, sur le forum du site , un membre m'a proposé d'utilisé les vectors.

J'ai donc essayé à l'aide du tuto présent dans la FAQ, mais le programme plante à se fermeture.

Voici le code actuel :
aventure.cpp :

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
 
void aventure()
{
    /**************************
    *         Variables
    **************************/
    bool continuer = true;
    // Nombre de monstres qui seront présent.
    int nombreMonstres = 0;
    // Allocation dynamique des monstres
    std::vector<Monstres> monstre;
 
    // ... //
 
     // Charge le niveau : 1.1 = niveau a charger.
    decors.chargerCarte(1.1, monstre, &nombreMonstres);
}

Et Decors.cpp la fonction chargerCarte :

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
 
/**************************
*    Charger la carte
*
**************************/
void Decors::chargerCarte(double niveauDemandee, std::vector<Monstres> monstre, int *nombreMonstres)
{
    FILE *fichier = NULL;
    int futurFond = 0;
    int hasard = 0;
 
    if(niveauDemandee == 1.1)
        fichier = fopen("../media/levels/zone1-1.lvl", "r");
    else if(niveauDemandee == 1.2)
        fichier = fopen("../media/levels/zone1-2.lvl", "r");
    else if(niveauDemandee == 1.4)
        fichier = fopen("../media/levels/zone1-4.lvl", "r");
    else
        fichier = fopen("../media/levels/zone1-1.lvl", "r");
 
 
    for (int i = 0 ; i < NB_BLOCS_LARGEUR; i++)
    {
        for (int j = 0 ; j < NB_BLOCS_HAUTEUR; j++)
        {
            fscanf(fichier, "%ld ", &carte[i][j]);
            // Si lors du chargement l'on croise un monstre on l'enregistre
            if(carte[i][j] == 800) // Goomba
            {
                hasard = (rand() % 2) + 1;
                monstre[*nombreMonstres].type     = 1;
                monstre[*nombreMonstres].etat     = 1;
                monstre[*nombreMonstres].x        = i * TAILLE_BLOC;
                monstre[*nombreMonstres].y        = j * TAILLE_BLOC;
                monstre[*nombreMonstres].direction= hasard;
                // un monstre en plus donc 1 struture en plus.
                (*nombreMonstres)++;
                monstre.resize(*nombreMonstres);
            }
        }
    }
 
    fscanf(fichier, "\n%ld ", &futurFond);
 
    if(futurFond != m_fondNiveau)
    {
        m_fondNiveau = futurFond;
        changerFond(0);
    }
    m_positionCarteX = 0;
    fclose(fichier);
}

Je vous remercie de m'avoir lus, et de vos futurs réponses.
Hybrix.