Partage
  • Partager sur Facebook
  • Partager sur Twitter

FAQs bibliothèques tierces

SDL / OpenGL / GTK+

    1 février 2009 à 0:05:06

    [SDL][8] Comment utiliser et programmer avec la SDL sur GNU/Linux (en particulier sur Debian/Ubuntu) ?

    Tout d'abord, il vous faudra installer les paquets contenant la SDL. Sous Ubuntu/Debian, ils sont nommés libsdl1.2debian-all (pour utiliser la SDL) et libsdl1.2-dev (pour développer avec la SDL). Pour installer la SDL Image, il faut utiliser libsdl-image1.2 et libsdl-image1.2-dev (sur le même principe que précédemment). De même pour TTF qui s'installe via les paquets libsdl-ttf2.0-0 et libsdl-ttf2.0-dev.

    Pour compiler un projet SDL, il vous faudra ajouter `sdl-config --cflags --libs` à la commande gcc, ce qui donnera par exemple :
    gcc `sdl-config --cflags --libs` main.c affichage.c -o programme


    Pour utiliser la SDL Image et TTF, il faut ajouter respectivement les options -lSDL_image et -lSDL_ttf, ce qui donne dans le cas où on utilise les 2 bibliothèques :
    gcc `sdl-config --cflags --libs` -lSDL_image -lSDL_ttf main.c affichage.c -o programme
    • Partager sur Facebook
    • Partager sur Twitter
      23 février 2009 à 0:53:20

      C'est la question 9.
      Peut-être faudrait-il préciser que --libs c'est pour le "linkage" et --cflags pour la compilation... non ?
      Si tu veux bien éditer en enlevant ta signature stp, ça sera plus lisible comme ça.
      • Partager sur Facebook
      • Partager sur Twitter
        8 juillet 2009 à 16:18:30

        Salut, j'ai une idée de question mais pas de réponse malheureusement !

        [SDL] comment redimensionner une image ?

        => par exemple lorsque que la fenêtre du jeu avec zozor (celui du tuto de mateo) perd le focus, je veux prendre l'image de zozor et l'aggrandir à toute la surface de l'écran, et ce tant que la fenêtre n'a pas récupéré le focus. comment créer une nouvelle image, qui n'est qu'une image existante mais aggrandie ?

        j'ai entendu parler de rotozoom, ça a l'air fichtrement intéressant et ça pourrait faire l'objet d'une autre question
        [SDL] utiliser Rotozoom: mais expliqué à la manière du tuto de mateo, en douceur avec des dessins etc, ce serait un pur bonheur. je suis tombé sur une doc mais j'ai pas trop eu le tps de m'y plonger. doc sur rotozoom, si ça peut vous aider à vous remémorer le truc.

        tchao les biloutes :)
        • Partager sur Facebook
        • Partager sur Twitter
          11 octobre 2009 à 6:42:33

          [SDL][10]Comment changer le driver vidéo sous windows ?

          Sous windows, la SDL à 2 drivers vidéos disponibles :
          • Windib
          • DirectX

          Par défaut, sur les versions récentes de la SDL, le driver vidéo par défaut est windib. C'est apparement parce que l'alpha blending sous DirectX(ddraw en fait) est très lent, que ce choix a été fait.
          Cependant, cela pose un problème : il est impossible d'avoir des surfaces en mémoire vidéo sous windib.
          Par exemple

          screen = SDL_Surface(640, 480 32, SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF);
          

          Si on teste de la sorte
          if (screen->flag & SDL_HWSURFACE)...
          

          On se rend compte que la surface n'est pas en mémoire vidéo...
          C'est génant, car on ne peux plus profiter de blits rapide, ni du page flipping...
          La solution

          Avant l'initialisation de la SDL, il faut sélectionner direct X comme driver vidéo... Pour ce faire on se sert d'une fonction de l'api windows : SetEnvironmentVariable
          Exemple

          #include <stdlib.h>
          #include <windows.h>
          #include <sdl.h>
          
          #define SCR_W   640
          #define SCR_H   480
          #define SCR_BPP 32
          
          int main (int argc, char* argv[])
          {
              SDL_Surface *screen;
          
              SetEnvironmentVariable("SDL_VIDEODRIVER", "directx");
          
              if (SDL_Init(SDL_INIT_VIDEO < 0))
              {
                  printf("Unable to initialize SDL : %s", SDL_GetError());
                  exit(EXIT_FAILURE);
              }
          
              screen = SDL_SetVideoMode(SCR_W, SCR_H, SCR_BPP, SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF | SDL_HWPALETTE);
              if (!screen)
              {
                  printf("Unable to set video mode : %s", SDL_GetError());
                  exit(EXIT_FAILURE);
              }
          
              if (screen->flags & SDL_HWSURFACE)
              {
                  printf("La surface est en mémoire vidéo.\n");
              }
              else
              {
                  printf("La surface n'est pas en mémoire vidéo.\n");
              }
          
              SDL_Quit();
          
              return EXIT_SUCCESS;
          }
          

          Dernière précision, pour que la surface soit en mémoire vidéo, il faut impérativement être en fullscreen. Le flag SDL_DOUBLEBUF est alors quasiment obligatoire pour éviter les clignotements.

          • Partager sur Facebook
          • Partager sur Twitter
          Zeste de Savoir, le site qui en a dans le citron !
            16 octobre 2009 à 21:30:07

            [SDL][11] Pourquoi mon clavier est en QWERTY ?

            Sur certains PC il arrive que la SDL considère votre clavier comme un clavier QWERTY, et du coup il faut appuyer sur Q pour appuyer sur A ...
            Pas très pratique !

            Il existe donc un moyen de pouvoir utiliser son clavier en AZERTY. Il suffit tout simplement d'utiliser l'unicode qui prendra comme valeur la valeur du caractère et non pas la valeur de la touche.
            Voici comment procéder :

            SDL_EnableUNICODE(1);
             
            /* Du code */
            
            /* Boucle d'évènement */
            switch (event.key.keysym.unicode) {
            	case SDLK_a:
            		/* Du code */
            		break;
            	/* D'autre 'case' */
            	default:
            		break;
            }
            
            • Partager sur Facebook
            • Partager sur Twitter
              4 décembre 2009 à 13:00:53

              [GTK+][3] Comment installer GTK+ pour developper avec codeblocks sous windows?

              Telechargez le bundle Gtk+ (bin&dev, environ 20Mo) ici: (lien), puis décompressez l'archive.

              Créez le fichier Gtk+\etc\gtkrc suivant:
              gtk-theme-name = "MS-Windows"


              Rajoutez le répertoire Gtk+\bin à la variable d'environnement PATH de windows. (cf. google si ça ne vous dit rien)

              Ouvrez codeblocks->nouveau projet Gtk+. Dans repertoire de Gtk+, mettez le répertoire Gtk+ qui contient les répertoires bin\ etc\ include\... et cliquez sur ok. (Une autre fenetre s'ouvre vous demandant le répertoire de Gtk+, mais cliquez sur annuler)
              Allez dans project->build options->linker settings et rajouter tous les fichiers *.lib du répertoire Gtk+\lib\ (pas en chemin relatif, mais absolu) puis cliquez sur Ok.

              Vous pouvez maintenant utiliser codeblocks pour créer vos programmes Gtk+. Je vous conseil cependant avant tout d'aller dans fichier->save project as user template pour ne pas avoir à spécifier les options du linker à chaque fois.
              • Partager sur Facebook
              • Partager sur Twitter
              - Il y a un chemin vers chaque sommet, même le plus haut -
                10 mars 2010 à 18:22:03

                [SDL][12]Comment accélerer les blits et conserver les infos de transparence ?

                Si le format des pixels de la surface source et de la surface de destination sont différents, la surface source est d'abord copiée dans une nouvelle surface au même format que la surface de destination à chaque blit. C'est une opération couteuse qui ralentit énormément les blits.

                Au chargement de l'image, il faut utiliser la fonction:
                SDL_Surface *SDL_DisplayFormat(SDL_Surface *surface);
                qui effectue la copie dans une surface au format de l'écran.

                Avantage, cette copie n'a lieu qu'une fois au chargement de l'image.
                Surface *loadSurface ( char const *filename )
                {
                    SDL_Surface *srfTmp = NULL;
                    SDL_Surface *srfDst = NULL;
                
                    /* On charge l'image dans une surface temporaire */
                    srfTmp = SDL_LoadBMP ( filename );
                    if ( srfTmp != NULL )
                    {
                        /* On convertit la surface au format de l'écran et on l'affecte à notre
                         * nouvelle surface
                         */
                        srfDst = SDL_DisplayFormat ( srfTmp );
                    }
                    /* On libère la surface temporaire */
                    SDL_FreeSurface ( srfTmp );
                    
                
                    return srfDst;
                }
                

                Un problème subsiste:
                Certains formats d'image contiennent des infos de transparence, qui sont perdues lors de l'appel à SDL_DisplayFormat.
                Il faut alors utiliser la fonction:
                SDL_Surface *SDL_DisplayFormatAlpha(SDL_Surface *surface); .

                On peut alors imaginer une fonction qui charge correctement une image de n'importe quel format supporté par bibliothèque SDL_Image.
                SDL_Surface *loadSurface ( char const *filename )
                {
                    SDL_Surface *srfTmp = NULL;
                    SDL_Surface *srfDst = NULL;
                
                    srfTmp = IMG_Load ( filename );
                    if ( srfTmp != NULL )
                    {
                        if ( ( srfTmp->flags & SDL_SRCALPHA ) == SDL_SRCALPHA )
                            srfDst = SDL_DisplayFormatAlpha ( srfTmp );
                        else
                            srfDst = SDL_DisplayFormat ( srfTmp );
                
                        SDL_FreeSurface ( srfTmp );
                    }
                
                    return srfDst;
                }
                

                Si il y a un canal alpha, il sera conservé.

                Une dernière chose à laquelle il faut faire attention:
                Les fonctions SDL_SetColorKey et SDL_SetAlpha doivent être appelées AVANT SDL_DisplayFormat ou SDL_DisplayFormatAlpha .
                • Partager sur Facebook
                • Partager sur Twitter
                Zeste de Savoir, le site qui en a dans le citron !
                  27 mars 2010 à 15:39:03

                  [SDL][13] Comment mettre des accents dans le titre d'un fenêtre SDL ?

                  Cette astuce n'est affective que sous un environnement Windows, en tout cas, elle n'a pas étée testée sous un autre environnement.
                  Si vous tentez de compiler un fenêtre codée avec l'aide du tutoriel officiel sur le langage C, il se peut que l'accent comprit dans la titre de la fenêtre ne s'affiche pas correctement. Pour remédier à ce problème, il faut modifier les paramètres de compilation du compilateur.
                  Voici comment faire pour CodeBlocks, IDE utilisé majoritairement par les zéros que nous sommes puisque c'est lui qui est utilisé et conseillé dans le tutoriel officiel sur le langage C :

                  Setting > Editor > Default encoding when opening files > UTF-8

                  La compilation en UTF-8 permet l'affichage de caractères spéciaux comme les accents dans les titres de fenêtre.
                  C'est le chemin d'accès aux paramètres du compilateur par défaut de CodeBlocks.
                  • Partager sur Facebook
                  • Partager sur Twitter
                    27 mars 2010 à 23:25:49

                    Arnolddu51: tu pars d'un problème général et le rapporte à une solution très particulière, qui s'avère finalement n'avoir plus beaucoup de rapport avec le problème initial.

                    Pourquoi ne pas proposer une solution générale au problème des accents dans les codes dans la FAQ C, et y poster simplement un lien ici, en précisant la nature du problème dans le titre de la question ?
                    • Partager sur Facebook
                    • Partager sur Twitter
                      1 mai 2010 à 21:26:50

                      [SDL][13] Comment centrer la fenêtre ?

                      Il suffit d'utiliser cette commande après l'initialisation :

                      putenv("SDL_VIDEO_WINDOW_POS=center"); /* Pour centrer la fenêtre */
                      
                      • Partager sur Facebook
                      • Partager sur Twitter
                        16 août 2010 à 16:37:12

                        [SDL][14] Comment mettre le clavier en AZERTY sans activer l'unicode ?

                        Il faut modifier et remplacer le header SDL_keysym.h par celui-ci: SDL_keysym.h AZERTY
                        • Partager sur Facebook
                        • Partager sur Twitter
                          4 octobre 2010 à 23:06:40

                          [SDL][15] Comment faire pour identifier un double-click avec sdl ?


                          Il n'y a pas de moyen direct pour ce faire, il faudra donc innover.

                          Une des méthodes possible (trouvée sur Internet) est d'effectuer une vérification après la capture d'un event souris SDL_BUTTON_LEFT pour vérifier si le même event a déjà été envoyé depuis n millisecondes.

                          Cette méthode ne peut néanmoins pas être utilisée si l'on doit effectuer un traitement différent pour le simple clic.


                          #define DOUBLE_CLICK_MAX_DELAY  200
                          int DoubleClickDetected (void)
                          {
                              static Uint32 LastClickTicks = 0;
                              Uint32 CurrentClickTicks;
                              /* The first time this function is called, LastClickTicks has not been initialised yet. */
                              if (! LastClickTicks)
                              {
                                  LastClickTicks = SDL_GetTicks ();
                                  return 0;
                              }
                              else
                              {
                                  CurrentClickTicks = SDL_GetTicks ();
                                  /* If the period between the two clicks is smaller or equal to a pre-defined number, we report a DoubleClick event. */
                                  if (CurrentClickTicks - LastClickTicks <= DOUBLE_CLICK_MAX_DELAY)
                                  {
                                      /* Update LastClickTicks and signal a DoubleClick. */
                                      LastClickTicks = CurrentClickTicks;
                                      return 1;
                                  }
                                  else
                                  {
                                      /* Update LastClickTicks and signal a SingleClick. */
                                      LastClickTicks = CurrentClickTicks;
                                      return 0;
                                  }
                              }
                          }
                          
                          • Partager sur Facebook
                          • Partager sur Twitter
                            28 juillet 2011 à 19:11:11

                            [SDL][16] Mon programme n'affiche rien et se ferme sans rien faire dès que je l'exécute, que faire ?

                            A priori, une des opérations qu'effectue votre programme a échoué.

                            Pour découvrir quel est le problème, veillez à tester les valeurs de retour des fonctions telles que SDL_Init, SDL_LoadBMP, IMG_Load.

                            Mauvais exemple :
                            #include <SDL.h>
                            #include <stdio.h>
                            
                            void pause(void);
                            
                            int main(void)
                            {
                                SDL_Surface *ecran, *image;
                                SDL_Rect position = {0, 0, 0, 0};
                                
                                SDL_Init(SDL_INIT_VIDEO);
                                
                                ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
                                image = SDL_LoadBMP("fond.bmp");
                                SDL_BlitSurface(ecran, NULL, image, &position);
                                
                                pause();
                                
                                SDL_FreeSurface(image);
                                SDL_QuitSubsystem(SDL_INIT_VIDEO);
                                SDL_Quit();
                                
                                return 0;
                            }
                            
                            void pause(void)
                            {
                                /* ... */
                            }
                            

                            Bon exemple :
                            #include <SDL.h>
                            #include <stdio.h>
                            
                            void pause(void);
                            
                            int main(void)
                            {
                                SDL_Surface *ecran, *image;
                                SDL_Rect position = {0, 0, 0, 0};
                                
                                if(SDL_Init(SDL_INIT_VIDEO) != 0)
                                {
                                    printf("Impossible d'initialiser la SDL : %s\n", SDL_GetError());
                                    return 1;
                                }
                                
                                ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
                                if(ecran == NULL)
                                {
                                    printf("Impossible de choisir le mode video : %s\n", SDL_GetError());
                                    return 2;
                                }
                            
                                image = SDL_LoadBMP("fond.bmp");
                                if(image == NULL)
                                {
                                    printf("Impossible de charger l'image : %s\n", SDL_GetError());
                                    return 3;
                                }
                                
                                SDL_BlitSurface(ecran, NULL, image, &position);
                                SDL_Flip(ecran);
                                
                                pause();
                                
                                SDL_FreeSurface(image);
                                SDL_QuitSubsystem(SDL_INIT_VIDEO);
                                SDL_Quit();
                                
                                return 0;
                            }
                            
                            void pause(void)
                            {
                                /* ... */
                            }
                            


                            Comme vous le voyez, cet exemple est bien plus volumineux, mais un bon découpage des fonctions devrait éviter les problèmes.

                            Pourquoi ce code est-il meilleur ? Chaque fois qu'une opération qui peut échouer (du style, j'essaie de charger une image alors que le fichier n'existe pas), il teste si l'opération en question a réussi. En cas d'erreur, il affiche un message expliquant quel est le problème. La fonction SDL_GetError (voir la doc) renvoie une chaîne de caractères contenant un message d'erreur explicite de la SDL.

                            Ainsi, il suffira de lire dans la console (ou de lire le fichier stdout.txt, selon les cas) pour connaître la nature du souci. Vous pourrez alors probablement le résoudre vous-mêmes. :)
                            • Partager sur Facebook
                            • Partager sur Twitter
                            J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.
                              11 août 2011 à 19:40:29

                              [SDL][17] Au secours, mon SDL_FreeSurface() fait planter mon programme !

                              SDL_FreeSurface peut générer un overflow si la surface passée en paramètre n'est pas allouée

                              Cela peut-être causé par plusieurs problèmes :
                              • une erreur lors de l'allocation de la surface (se référer au [16])
                              • la surface à déjà été libérée (par exemple, avec un autre pointeur qui la pointait) (voir dessous)

                              Mauvais exemple :
                              #include <SDL.h>
                              #include <stdio.h>
                              
                              int main(void)
                              {
                                  SDL_Surface *ecran;
                                  SDL_Surface *imageA, *imageB, *imageEnCours;
                                  SDL_Event event;    
                                  char continuer;
                                  
                                  // On initialise la SDL
                                  if(SDL_Init(SDL_INIT_VIDEO) != 0)
                                  {
                                      printf("Impossible d'initialiser la SDL : %s\n", SDL_GetError());
                                      return 1;
                                  }
                                  
                                  // On ouvre la fenêtre
                                  ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
                                  if(ecran == NULL)
                                  {
                                      printf("Impossible de choisir le mode video : %s\n", SDL_GetError());
                                      return 2;
                                  }
                              
                                  // On charge (alloue de la place pour) l'image A.bmp et on stocke l'adresse mémoire dans imageA
                                  imageA = SDL_LoadBMP("A.bmp");
                                  if(imageA == NULL)
                                  {
                                      printf("Impossible de charger l'image : %s\n", SDL_GetError());
                                      return 3;
                                  }
                              
                                  // On charge (alloue de la place pour) l'image B.bmp et on stocke l'adresse mémoire dans imageB
                                  imageB = SDL_LoadBMP("B.bmp");
                                  if(imageB == NULL)
                                  {
                                      printf("Impossible de charger l'image : %s\n", SDL_GetError());
                                      return 3;
                                  }
                              
                                  // on fait pointer imageEnCours sur l'image "A.bmp" en premier
                                  imageEnCours = imageA; 
                              
                                  // on initialise continuer à 1
                                  continuer = 1;
                              
                                  while(continuer)
                                  {
                                      // On met à jour event
                                      SDL_WaitEvent(&event);
                                      switch(event.type)
                                      {
                                          // bouton fermer..
                                          case SDL_QUIT:
                                              continuer = 0; // on quitte
                                          break;
                              
                                          // touche enfoncee..
                                          case SDL_KEYDOWN:
                                              switch(event.key.keysym.sym)
                                              {
                                                  // touche Entree..
                                                  case SDLK_RETURN:
                                                 
                                                      // On fais pointer imageEnCours sur l'autre image
                                                      if(imageEnCours == imageA)
                                                          imageEnCours = imageB;
                                                      else
                                                          imageEnCours = imageA;
                                                  break;
                              
                                                  // touche Echap..
                                                  case SDLK_ESCAPE:
                                                      continuer = 0; // on quitte
                                                  break;
                                                  default:
                                                  break;
                                             }
                                          break;
                                          default:
                                          break;
                                      }
                              
                                      // On (re)met l'ecran en blanc
                                      SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
                              
                                      // On met l'image pointee par imageEnCours sur l'ecran
                                      SDL_BlitSurface(ecran, NULL, imageEnCours, NULL);
                              
                                      // on met à jour l'ecran
                                      SDL_Flip(ecran); 
                                  }      
                                  
                                  // On libere nos trois SDL_Surface...
                                  SDL_FreeSurface(imageEnCours);
                                  SDL_FreeSurface(imageA);
                                  SDL_FreeSurface(imageB);
                              
                                  // On libere la SDL
                                  SDL_QuitSubsystem(SDL_INIT_VIDEO);
                                  SDL_Quit();
                                  
                                  return 0;
                              }
                              


                              Explications :
                              SDL_FreeSurface(imageEnCours);
                              SDL_FreeSurface(imageA);
                              SDL_FreeSurface(imageB);
                              


                              Tout d'abord, on libere la surface pointée par imageEnCours.
                              imaginons que c'est l'image B.bmp..

                              Ensuite, on libere la surface pointée par imageA,
                              ici pas de problème

                              Mais ensuite, on libère celle pointée par imageB :
                              étant donné que la surface était pointée par imageEnCours tout à l'heure, imageB contient une surface déjà libérée !!
                              vouloir re-libérer cette partie de mémoire alors qu'elle peut être utilisée autre part provoque un overflow.

                              Il faut donc retirer la ligne SDL_FreeSurface(imageEnCours);

                              Bon exemple :

                              #include <SDL.h>
                              #include <stdio.h>
                              
                              int main(void)
                              {
                                  SDL_Surface *ecran;
                                  SDL_Surface *imageA, *imageB, *imageEnCours;
                                  SDL_Event event;    
                                  char continuer;
                                  
                                  // On initialise la SDL
                                  if(SDL_Init(SDL_INIT_VIDEO) != 0)
                                  {
                                      printf("Impossible d'initialiser la SDL : %s\n", SDL_GetError());
                                      return 1;
                                  }
                                  
                                  // On ouvre la fenetre
                                  ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
                                  if(ecran == NULL)
                                  {
                                      printf("Impossible de choisir le mode video : %s\n", SDL_GetError());
                                      return 2;
                                  }
                              
                                  // On charge (alloue de la place pour) l'image A.bmp et on stocke l'adresse mémoire dans imageA
                                  imageA = SDL_LoadBMP("A.bmp");
                                  if(imageA == NULL)
                                  {
                                      printf("Impossible de charger l'image : %s\n", SDL_GetError());
                                      return 3;
                                  }
                              
                                  // On charge (alloue de la place pour) l'image B.bmp et on stocke l'adresse mémoire dans imageB
                                  imageB = SDL_LoadBMP("B.bmp");
                                  if(imageB == NULL)
                                  {
                                      printf("Impossible de charger l'image : %s\n", SDL_GetError());
                                      return 3;
                                  }
                              
                                  // on fait pointer imageEnCours sur l'image "A.bmp" en premier
                                  imageEnCours = imageA; 
                              
                                  // on initialise continuer à 1
                                  continuer = 1;
                              
                                  while(continuer)
                                  {
                                      // On met à jour event
                                      SDL_WaitEvent(&event);
                                      switch(event.type)
                                      {
                                          // bouton fermer..
                                          case SDL_QUIT:
                                              continuer = 0; // on quitte
                                          break;
                              
                                          // touche enfoncee..
                                          case SDL_KEYDOWN:
                                              switch(event.key.keysym.sym)
                                              {
                                                  // touche Entree..
                                                  case SDLK_RETURN:
                                                 
                                                      // On fais pointer imageEnCours sur l'autre image
                                                      if(imageEnCours == imageA)
                                                          imageEnCours = imageB;
                                                      else
                                                          imageEnCours = imageA;
                                                  break;
                              
                                                  // touche Echap..
                                                  case SDLK_ESCAPE:
                                                      continuer = 0; // on quitte
                                                  break;
                                                  default:
                                                  break;
                                             }
                                          break;
                                          default:
                                          break;
                                      }
                              
                                      // On (re)met l'ecran en blanc
                                      SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
                              
                                      // On met l'image pointee par imageEnCours sur l'ecran
                                      SDL_BlitSurface(ecran, NULL, imageEnCours, NULL);
                              
                                      // on met à jour l'ecran
                                      SDL_Flip(ecran); 
                                  }      
                                  
                                  // On libere nos deux surfaces...    
                                  SDL_FreeSurface(imageA);
                                  SDL_FreeSurface(imageB);
                              
                                  /*
                                      Et pas : SDL_FreeSurface(imageEnCours);
                                      qui générera un overflow !
                                  */
                              
                                  // On libere la SDL
                                  SDL_QuitSubsystem(SDL_INIT_VIDEO);
                                  SDL_Quit();
                                  
                                  return 0;
                              }
                              


                              En règle générale :

                              Citation

                              à chaque load, il faut son free :
                              il n'en faut ni plus, ni moins


                              Citation

                              à chaque variable allouée, il faut garder le pointeur inchangé jusqu'à sa libération :
                              pour éviter de perdre l'adresse (fuite de mémoire)



                              Edit : A noter que ce genre d'erreur n'est pas propre à la SDL,
                              on peut la retrouver avec tout ce qui touche à l'allocation dynamique
                              (par exemple : la gestion des fichiers avec FILE*)
                              • Partager sur Facebook
                              • Partager sur Twitter
                              perror(const char * str); will save your life !
                                16 octobre 2011 à 15:18:59

                                [GTK+][7] Comment connaître le type d'une variable?

                                Cela peut-être utile lors de la manipulation de box ou de table.
                                Il existe une macro très pratique pour connaître le type d'une variable GTK:
                                #define GTK_IS_(type) (variable)
                                

                                type est le type de variable (GTK_WINDOW,GTK_ENTRY,GTK_CONTAINER,...) et variable la variable dont on souhaite savoir si elle est de type type.

                                Exemple:

                                #include <stdlib.h>
                                #include <gtk/gtk.h>
                                
                                int main(int argc, char **argv)
                                {
                                    int type=0;
                                    GtkWidget *MainWindow = NULL;
                                    GtkWidget *BoiteDialogue;
                                
                                    gtk_init(&argc, &argv);
                                
                                    MainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
                                
                                    g_signal_connect(G_OBJECT(MainWindow), "delete-event", G_CALLBACK(gtk_main_quit), NULL);
                                
                                    gtk_widget_show(MainWindow);
                                
                                    type=GTK_IS_WINDOW(MainWindow);/*On récupère le résultat de la macro*/
                                
                                    if(type)/*Si c'est vrai (booléen) on affiche une boite de dialog le signalant*/
                                    {
                                        BoiteDialogue = gtk_message_dialog_new (NULL,
                                                                         GTK_DIALOG_MODAL,
                                                                         GTK_MESSAGE_INFO,
                                                                         GTK_BUTTONS_OK,
                                                                         "MainWindow est de type Window");
                                
                                        gtk_dialog_run(GTK_DIALOG(BoiteDialogue));
                                        gtk_widget_destroy(BoiteDialogue);
                                    }
                                
                                    type=GTK_IS_ABOUT_DIALOG(MainWindow);
                                
                                    if(!type)/*Ici MainWindow n'est pas de type AboutDialog donc type=0*/
                                    {
                                        BoiteDialogue = gtk_message_dialog_new (NULL,
                                                                         GTK_DIALOG_MODAL,
                                                                         GTK_MESSAGE_INFO,
                                                                         GTK_BUTTONS_OK,
                                                                         "MainWindow n'est pas de type AboutDialog");
                                
                                        gtk_dialog_run(GTK_DIALOG(BoiteDialogue));
                                        gtk_widget_destroy(BoiteDialogue);
                                    }
                                
                                    gtk_main();
                                
                                    return EXIT_SUCCESS;
                                }
                                
                                • Partager sur Facebook
                                • Partager sur Twitter
                                Utilitaire de chiffrement (EncrypBox)
                                  10 décembre 2011 à 17:29:57

                                  @itch'nak: ce n'est pas réellement ça.
                                  En fait SDL_DisplayFormat t'as permis de créer une surface au format de l'écran mais sans canal alpha.
                                  Le comportement lors du blit d'une surface avec un canal alpha est décrit dans la doc.

                                  RGBA->RGB with SDL_SRCALPHA
                                  The source is alpha-blended with the destination, using the alpha channel. SDL_SRCCOLORKEY and the per-surface alpha are ignored.

                                  pour tous les cas de figures.
                                  Donc pour pouvoir utiliser SDL_SetColorKey ET la transparence globale(per-surface alpha), on crée une surface sans canal alpha.
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                  Zeste de Savoir, le site qui en a dans le citron !
                                    10 juillet 2012 à 15:51:02

                                    De plus il faut tester le retour de IMG_Load.
                                    Ton exemple pourrait inciter les débutants à écrire des trucs comme ça :
                                    SDL_Surface *image = SDL_DisplayFormat(IMG_Load("image.PNG"));
                                    

                                    Qui, en plus, est une fuite de mémoire. ^^'

                                    Citation : SDL_DisplayFormat

                                    Remember to use a different variable for the returned surface, otherwise you have a memory leak, since the original surface isn't freed.

                                    surface = SDL_DisplayFormat(surface);  // memory leak!!
                                    
                                    // correct version
                                    NewSurface = SDL_DisplayFormat(surface);
                                    SDL_FreeSurface(surface);
                                    


                                    NB: Désolé pour le déterrage ^^'
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    perror(const char * str); will save your life !
                                    Anonyme
                                      17 juillet 2012 à 21:28:36

                                      [SDL][18] Comment installer la SDL sous Mac OS X Lion ?
                                       
                                      Pour ce faire, voici la procédure à suivre :

                                      - Vous devez lire et appliquer à la lettre ce tuto partie Mac OS X

                                      - Puis vous avez simplement à vous rendre dans Build Settings, changer dans Compiler for C/C++/Objective-C pour avoir LLVM GCC 4.2

                                      Une fois ceci fais vous pouvez profiter de la SDL sous Mac OS X Lion ! :)
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        27 avril 2013 à 22:18:59

                                        [SDL][19] Comment installer la SDL avec CodeBlocks sous Windows ?

                                        Tout d'abord, il faut que vous ayez Code::Blocks d'installé (peu importe la version).

                                        Rendez-vous sur la page de téléchargement de la SDL que voici: http://www.libsdl.org/index.php

                                        Allez dans la section "Download" puis dans "SDL 1.2". Vous aurez alors deux archives à télécharger:

                                        La premiere se trouve dans "Runtime Libraries" et se nomme "SDL-1.2.15-win32.zip". A l'intérieur se trouve le fichier "SDL.dll" que vous devez placer dans le dossier de votre projet (à côté de votre fichier .cbp). Cette DLL sera également à fournir si vous souhaitez partager votre programme.

                                        La seconde archive se trouve dans "Development Libraries" et se nomme "SDL-devel-1.2.15-mingw.tar.gz". Décompressez-la et copier le dossier "SDL-1.2.15" dans le dossier de CodeBlocks, à côté du dossier MinGW.

                                        Enfin, pour créer une application SDL, ouvrez CodeBlocks, demandez à créer un nouveau projet SDL (SDL Project), donnez un nom à votre programme puis lorsque CodeBlocks vous demande ou se trouve le dossier SDL ("Please select SDL's location), choisissez le dossier "SDL-1.2.15" que vous avez placé à côté du dossier MinGW (si par la suite une nouvelle fenêtre s'ouvre et vous demande de configurer les différents emplacement de vos headers et de vos lib, ne modifiez que la section "Base" en indiquant à nouveau le chemin du dossier "SDL-1.2.15".

                                        Notez que dans votre dossier "SDL-1.2.15", vous pouvez supprimer les fichiers commençants par un point, vous n'en aurez pas besoin.

                                        De plus, comme CodeBlocks fournit un template pour créer un projet SDL, une fois cette dernière installée, vous n'aurez pas besoin de linker les lib, CodeBlocks le fera tout seul.

                                        Par contre, si vous rajoutez des extensions comme SDL_image ou SDL_ttf par exemple, il vous faudra placer les headers de ces bibliothèques dans le dossier "include/SDL" de votre dossier "SDL-1.2.15", et de même pour les fichiers ".lib" (à placer dans "SDL-1.2.15/lib"). N'oubliez-pas à ce moment là de linker ces nouvelles lib rajoutées.

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          19 mai 2013 à 16:31:14

                                          Bonjour a tous et veuillez tout d'abords m'excusez si je ne suis pas au bon endroit pour formuler  ma requête!

                                          Je voudrais savoir ce que vous pouvez me conseiller comme cours a apprendre pour gerer mon tk enfin la programation de mon tk !

                                          Et ceci car j'ai un programmeur qui s'en  occupe ,mais j'aimerais bien y arriver par moi même ,je suis novice en ce domaine et je ne demande qu'a apprendre!

                                          Cordialement Bernard

                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            19 mai 2013 à 20:59:18

                                            Salut Anonymus2,

                                            Tu ne postes pas dans le bon topic. Ici c'est la FAQ Bibliothèques tierces et concerne uniquement les sujets se rapportant à celle-ci...

                                            Crée un nouveau sujet sur le forum et on te répondra...

                                            Cordialement.

                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              25 juin 2013 à 0:36:55 - Message modéré pour le motif suivant : Merci de poster cela dans un nouveau sujet


                                                29 juin 2013 à 15:17:28 - Message modéré pour le motif suivant : Merci de poster cela dans un nouveau sujet


                                                  16 août 2013 à 1:13:08 - Message modéré pour le motif suivant : Merci de poster cela dans un nouveau sujet


                                                  @mic5tera HTML5 CSS3 JS PHP - Web Dev
                                                    16 août 2013 à 15:44:22 - Message modéré pour le motif suivant : Merci de poster cela dans un nouveau sujet


                                                      16 août 2013 à 16:36:53

                                                      Bonjour,

                                                      Ce sujet n'a pas pour vocation de recevoir des demandes d'aide. D'une part, cela limite la visibilité des messages appartenant à la FAQ, et d'autre part, il y a peu de chance que quelqu'un vous réponde ici. Pour ces raisons, il est préférable de poser sa question dans un nouveau sujet. N'hésitez pas à parcourir ces informations pour ce faire.

                                                      Bonne journée ! :)

                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                      Staff désormais retraité.
                                                      Anonyme
                                                        9 septembre 2013 à 14:10:43 - Message modéré pour le motif suivant : Merci de poster cela dans un nouveau sujet


                                                          11 février 2014 à 1:00:45 - Message modéré pour le motif suivant : Merci de poster cela dans un nouveau sujet


                                                            6 mars 2014 à 11:55:23

                                                            [SDL][20] Comment installer la SDL2 avec CodeBlocks sous Windows ?


                                                            Bonjour à tous,

                                                            Suite à de nombreux problèmes que rencontrent certains forumeurs pour installer la bibliothèque SDL2 sous Code::Blocks, j'ai décidé de créer ce sujet afin de les aider dans leur démarche.

                                                            Tout d'abord, il faut que vous ayez Code::Blocks d'installé (peu importe la version).

                                                            Rendez-vous sur la page de téléchargement de la SDL que voici: http://www.libsdl.org/index.php

                                                            Allez dans la section "Download" puis dans "SDL 2.0". Vous aurez alors deux archives à télécharger:

                                                            La premiere se trouve dans "Runtime Libraries" et se nomme "SDL2-2.0.1-win32-x86.zip" (notez que ce fichier correspond à la version 32 bits contrairement à l'archive "SDL2-2.0.1-win32-x64.zip" qui correspond à la version 64 bits). Pour des raisons de comptabilité, je vous recommande de télécharger la version 32 bits. A l'intérieur se trouve le fichier "SDL2.dll" que vous devez placer dans le dossier de votre projet (à côté de votre fichier .cbp). Cette DLL sera également à fournir si vous souhaitez partager votre programme.
                                                            La seconde archive se trouve dans "Development Libraries" et se nomme "SDL2-devel-2.0.1-mingw.tar.gz". Décompressez-la et copier le dossier "SDL2-2.0.1" dans le dossier de CodeBlocks, à côté du dossier MinGW.

                                                            Enfin, pour créer une application SDL2, ouvrez CodeBlocks, demandez à créer un "Empty project" puis donnez un nom à votre programme ("SDL2" par exemple). Ne choisissez surtout pas "SDL project" pour ne pas créer un projet "SDL 1.2".

                                                            Maintenant que vous avez créé un projet "SDL2", il va falloir le configurer.

                                                            Allez dans "Project" puis "Build options". Dans l'onglet "Linker settings", cliquez sur le bouton "Add" et ajouter les fichiers suivants:

                                                            CodeBlocks/MinGW/lib/libmingw32.a
                                                            Si on vous demande "Keep this as a relative path ?", cliquez sur NON.

                                                            Dans le répertoire "SDL2-2.0.1" (a côté du dossier MinGW si vous avez suivi la procédure mentionnée plus haut), ajoutez les fichiers suivants:
                                                            i686-w64-mingw32/lib/libSDL2main.a
                                                            i686-w64-mingw32/lib/libSDL2.dll.a

                                                            Il faut mettre impérativement ces 2 dernières libs dans l'ordre (vous remarquerez que j'ai choisi la version 32 bits à des fins de compatibilité mais vous pouvez choisir la version 64 bits si vous le souhaitez mais à ce moment là, vous devez choisir de télécharger la version 64 bits de la DLL "SDL2.dll").

                                                            Allez ensuite dans l'onglet "Search directories" (juste à côté).
                                                            Dans le premier onglet "Compiler", cliquez sur "Add" et ajoutez le répertoire "include" de la "SDL2-2.0.1" (là où vous l'avez déposé, dans CodeBlocks si vous avez suivi mes instructions):
                                                            "i686-w64-mingw32\include"

                                                            Dans le deuxième onglet "Linker" (juste à côté), ajoutez le répertoire contenant les libs:
                                                            "i686-w64-mingw32\lib"

                                                            Le projet SDL2 est maintenant crée.
                                                            Copiez la DLL dans le répertoire de votre projet, à côté de votre .cbp ("SDL2.dll").

                                                            Créez un nouveau fichier "main.c" ou "main.cpp" et sauvegardez ce fichier (afin qu'il fasse parti de votre projet).

                                                            Vous voilà prêts à coder à l'intérieur de ce fichier.

                                                            Voici un exemple de code que vous pouvez tester afin de vérifier que votre projet SDL2 fonctionne.

                                                            main.cpp:

                                                            #ifdef __cplusplus
                                                                #include <cstdlib>
                                                                #include <cstdio>
                                                            #else
                                                                #include <stdlib.h>
                                                                #include <stdio.h>
                                                            #endif
                                                            
                                                            #include <SDL2/SDL.h>
                                                            
                                                            int main(int argc, char** argv)
                                                            {
                                                                /* Initialisation simple */
                                                                if (SDL_Init(SDL_INIT_VIDEO) != 0 )
                                                                {
                                                                    fprintf(stdout,"Échec de l'initialisation de la SDL (%s)\n",SDL_GetError());
                                                                    return -1;
                                                                }
                                                            
                                                                {
                                                                    /* Création de la fenêtre */
                                                                    SDL_Window* pWindow = NULL;
                                                                    pWindow = SDL_CreateWindow("Ma premiere application SDL2",SDL_WINDOWPOS_UNDEFINED,
                                                                                                                              SDL_WINDOWPOS_UNDEFINED,
                                                                                                                              640,
                                                                                                                              480,
                                                                                                                              SDL_WINDOW_SHOWN);
                                                            
                                                                    if( pWindow )
                                                                    {
                                                                        SDL_Delay(3000); /* Attendre trois secondes, que l'utilisateur voit la fenêtre */
                                                            
                                                                        SDL_DestroyWindow(pWindow);
                                                                    }
                                                                    else
                                                                    {
                                                                        fprintf(stderr,"Erreur de création de la fenêtre: %s\n",SDL_GetError());
                                                                    }
                                                                }
                                                            
                                                                SDL_Quit();
                                                            
                                                                return 0;
                                                            }
                                                            
                                                            

                                                            Pour finir, afin d'éviter de refaire toute la configuration lorsque vous créerai un nouveau projet SDL2, vous pouvez créer un template:
                                                            Allez dans "File", puis "Save project as template" et donnez un nom à votre template.

                                                            Pour se servir de ce template plus tard, allez dans "File" puis "New", puis "Project" et choisissez "User templates" dans la colonne de gauche.

                                                            Vous voilà donc prêts à programmer en utilisant la SDL2.

                                                            -
                                                            Edité par Gaetano-GX 6 mars 2014 à 11:58:03

                                                            • Partager sur Facebook
                                                            • Partager sur Twitter

                                                            FAQs bibliothèques tierces

                                                            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                            × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                            • Editeur
                                                            • Markdown