Partage
  • Partager sur Facebook
  • Partager sur Twitter

FAQs bibliothèques tierces

SDL / OpenGL / GTK+

    7 juin 2007 à 13:43:49

    Bonjour à toutes et à tous,

    Suite à la création de la FAQ C et de son rapide enrichissement en questions/réponses sur les bibliothèques tierces, nous avons décidé de créer une <acronym title="Foire Aux Questions">FAQ</acronym> spécialement dédiée à celles-ci.

    Dans ce sujet seront regroupées les questions concernant les bibliothèques suivantes :



    Avant de créer un sujet pour poser une question sur l'une des bibliothèques énumérées ci-dessus, merci de bien vouloir vérifier qu'elle n'a pas déjà été traitée dans cette FAQ, cela permettra de faire gagner du temps à tout le monde.


    FAQs



    OpenGL

    1. Qu'est-ce qu'OpenGL ?
    2. Comment installer OpenGL ?
    3. Où trouver de la documentation de référence sur OpenGL ?
    4. Où trouver des tutoriels sur OpenGL ?
    5. Qu'est-ce que les extensions d'OpenGL ?
    6. Comment mettre à jour ma version d'OpenGL ?
    7. Comment utiliser OpenGL dans mes programmes ?
    8. Mes polygones se rentrent dedans en scintillant, que se passe-t-il ?
    9. Ma texture est toute blanche lorsque je l'affiche, que faire ?
    10. Comment changer la couleur de fond ?
    11. Comment afficher des images 2D par dessus un rendu 3D ?
    12. Peut-on placer une vidéo dans une texture ?


    SDL

    1. Comment faire pour gérer plusieurs événements claviers en même temps ?
    2. Mes appels à SDL_GL_SetAttribute() sont ignorés, pourquoi ?
    3. Comment lire l'animation d'un GIF animé avec la SDL ?
    4. Pourquoi le 2e paramètre de SDL_BlitSurface() est-il toujours NULL ? À quoi sert-il ?
    5. Comment faire fonctionner la SDL avec GTK+ ? (Windows et Linux)
    6. Comment avoir son propre curseur personnalisé ?
    7. Pourquoi SDL_FillRect porte ce nom ? Pourquoi son deuxième paramètre est-il toujours NULL ?
    8. Pourquoi utiliser la forme while(SDL_PollEvent()) ? ou pourquoi mes événements sont récupérés en retard ?
    9. Comment utiliser et programmer avec la SDL sur GNU/Linux (en particulier sur Debian/Ubuntu) ?
    10. Comment changer le driver vidéo sous windows ?
    11. Pourquoi mon clavier est en QWERTY ?
    12. Comment accélerer les blits et conserver les infos de transparence ?
    13. Comment centrer la fenêtre ?
    14. Comment mettre le clavier en AZERTY sans activer l'unicode ?
    15. Comment faire pour identifier un double-click avec sdl ?
    16. Mon programme n'affiche rien et se ferme sans rien faire dès que je l'exécute, que faire ?
    17. Au secours, mon SDL_FreeSurface() fait planter mon programme !
    18. Comment installer la SDL sous Mac OS X Lion ?
    19. Comment installer la SDL sous Code::Blocks (Windows) ?
    20. Comment installer la SDL2 avec Code::Blocks (Windows) ?


    GTK+

    1. Qu'est-ce que GTK+ ?
    2. Pourquoi un + derrière GTK ?
    3. Comment installer GTK+ pour développer ?
    4. Où trouver la documentation de référence pour GTK+ ?
    5. À quoi sert le quatrième paramètre de g_signal_connect() et comment l'utiliser ?
    6. Existe-t-il un logiciel de conception d'interface GTK+ ?


    Pour aller plus loin, vous pouvez consulter la FAQ sur GTK+ de developpez.com.

    Pour participer



    Ajout de question/réponse


    Vous avez une idée de question/réponse ? Vous pouvez bien entendu participer à l'évolution de cette FAQ en postant une nouvelle réponse.
    Pour cela, je vous demanderai de bien vouloir respécter le format suivant :
    <gras>[bibliothèque][numéro question] question ?</gras>
     
    réponse

    Exemple :

    Citation : Exemple de question/réponse

    [SDL][1] Comment initialiser la SDL ?

    Il faut utiliser la fonction SDL_Init().



    Veuillez également désactiver votre signature svp, cela augmenterait la lisibilité de cette FAQ.

    Si votre question/réponse est un minimum correct, elle sera bien sûr ajoutée à la liste ci-dessus, avec nos remerciements :)

    -
    Edité par L1ne 6 mars 2014 à 21:47:12

    • Partager sur Facebook
    • Partager sur Twitter
      7 juin 2007 à 13:48:32

      [OpenGL][1] Qu'est-ce qu'OpenGL ?

      OpenGL est une API graphique programmée en langage C permettant de développer aussi bien des applications 2D que 3D.
      Créé par la société Silicon Graphics, OpenGL est la version "open-specifications" de l'avant dernière version de <acronym title="Graphics Library">GL</acronym> (par exemple si GL est en version 2.2, alors OpenGL est en version 2.1).

      OpenGL ne doit pas être confondu avec ce que l'on appelle un moteur 3D (ou moteur graphique), ce n'est pas la même chose, OpenGL est une API bas niveau.

      OpenGL présente le grand avantage d'être une API portable et simple à manipuler, ce qui fait qu'elle est très utilisée chez les programmeurs souhaitant s'initier à la programmation 3D. Ce qui ne l'empèche pas d'être également très utilisée dans le monde professionnel, notamment dans les logiciels d'imagerie médicale mais aussi dans des logiciels de modélisation 3D, comme Blender ou encore Maya.

      Dans quels autres projets a-t-il été utilisé ?

      Dans plusieurs jeux multiplate-forme. Des jeux libres comme Nexuiz ou Quake3, mais aussi commerciaux comme les très connus Doom3 et Quake4.

      Liens relatifs :


      • Partager sur Facebook
      • Partager sur Twitter
        7 juin 2007 à 13:50:01

        [OpenGL][2] Comment installer OpenGL ?

        OpenGL n'est qu'un standard, il existe différentes implémentations de celui-ci. Les plus communes et les plus évoluées sont celles fournies par les drivers de votre carte graphique. Avec Visual Studio, vous aurez besoin d'installer le Platform SDK. Sous Linux, vous pouvez utiliser l'implémentation libre MESA si vous le désirez, mais les drivers catalyst (pour ATI) et forceware (pour nVidia) se chargent de vous fournir la bibliothèque dynamique .so, donc rien à faire de particulier si vous les utilisez.
        • Partager sur Facebook
        • Partager sur Twitter
          7 juin 2007 à 13:52:31

          [OpenGL][3] Où trouver de la documentation de référence sur OpenGL ?

          Sur le site d'OpenGL :
          http://www.opengl.org/sdk/docs/man/xhtml/
          • Partager sur Facebook
          • Partager sur Twitter
            7 juin 2007 à 13:54:29

            [OpenGL][4] Où trouver des tutoriels sur OpenGL ?

            Image utilisateur


            • CodeSampler.com : nombreux exemples de code, mais ce ne sont pas des tutos..
            • NeHe Productions : excellents tutoriels très réputés, présentant des exemples de code dans une foule de langages différents (Python, Delphi, et j'en passe).

            Image utilisateur



            Vous pouvez également aller consulter ce post-it de la section du forum 'Autres langages' qui répertorie quelques liens sur OpenGL.

            Avec l'aimable participation de :
            - scriptoff
            • Partager sur Facebook
            • Partager sur Twitter
              7 juin 2007 à 13:57:27

              [OpenGL][5] Qu'est-ce que les extensions d'OpenGL ?

              Votre implémentation d'OpenGL ne pouvant être mise à jour, il a fallu trouver une astuce pour que vous puissez bénéficier des mises à jour de l'API, cette astuce s'appelle les extensions.
              Il y a de fortes chances pour que votre implémentation soit en version 1.1, mais aujourd'hui OpenGL étant en version 2.1, vous allez devoir passer par les extensions pour pouvoir bénéficier des ajouts apportés à l'API depuis sa version 1.1.

              Les extensions représentant le seul moyen d'évolution d'OpenGL, il est important de les normer. La normalisation des extensions d'OpenGL était assurée jusqu'à présent par l'ARB, mais c'est maintenant Khronos Group qui s'en occupe.

              Liens relatifs :
              • Partager sur Facebook
              • Partager sur Twitter
                7 juin 2007 à 13:58:21

                [OpenGL][6] Comment mettre à jour ma version d'OpenGL ?

                Mettez simplement à jour vos drivers graphique.

                Voir « qu'est-ce que les extensions d'OpenGL ? » et « comment installer OpenGL ? »
                • Partager sur Facebook
                • Partager sur Twitter
                  7 juin 2007 à 14:08:00

                  [OpenGL][7] Comment utiliser OpenGL dans mes programmes ?

                  Afin de fonctionner, OpenGL doit avoir un contexte, il vous faut donc avant toute chose créer celui-ci.
                  En règle général, il vous est impossible de créer un contexte OpenGL de façon portable, en effet, vous devrez utiliser le gestionnaire de fenêtres de votre système d'exploitation, WGL sous Windows, et GLX pour le gestionnaire de fenêtres X Window (Linux & MacOS).
                  Toutefois, il existe des bibliothèques portables vous permettant de vous simplifier la vie, qui se chargeront pour vous de la création d'un contexte OpenGL. Il en existe plusieurs très connues :
                  • SDL
                  • GTK+
                  • QT
                  • GLUT

                  La pratique utilisant la SDL est présentée dans le tutoriel de Kayl du Site du Zér0. La bibliothèque GLUT n'est plus maintenue à jour, son utilisation est donc déconseillée.

                  Liens relatifs :




                  Avec l'aimable participation de :
                  - scriptoff
                  • Partager sur Facebook
                  • Partager sur Twitter
                    7 juin 2007 à 14:08:52

                    [OpenGL][8] Mes polygones se rentrent dedans en scintillant, que se passe-t-il ?

                    Si vous avez un problème comparable à ce qui se passe en bas de cette image :
                    Image utilisateur

                    alors vous avez certainement un problème lié à la profondeur.

                    Un problème de profondeur est causé par un depth-buffer (ou Z-buffer) mal réglé.
                    Deux possibilités :

                    • Vous avez réglé votre depth-buffer sur une résolution trop élevée (rapport far-near trop grand). Dans ce cas, reconfigurez votre matrice de projection avec un ratio far-near moins grand, par exemple : gluProjection(..., 0.1, 10000.0)
                    • Votre depth-buffer est réglé sur une précision flottante trop faible. Par exemple 16 bits sont parfois insuffisants. Avec la SDL, pour régler la précision du depth buffer, invoquez SDL_GL_SetAttribute de cette manière :
                      SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, depth_size);
                      depth_size est une variable entière représentant le nombre de bits de précision de votre z-buffer. (32 est une bonne valeur)

                    • Partager sur Facebook
                    • Partager sur Twitter
                      7 juin 2007 à 14:14:25

                      [OpenGL][9] Ma texture est toute blanche lorsque je l'affiche, que faire ?

                      Votre texture n'est pas blanche en réalité, c'est simplement que son chargement a échoué, et donc la couleur de votre polygone texturé est celle par défaut : le blanc.

                      Le chargement d'une texture peut échouer pour plusieurs raisons :

                      • Vous avez chargé votre texture avant la création d'un contexte OpenGL. Dans ce cas là, le chargement côté API a obligatoirement échoué. Avec la SDL, la création du contexte OpenGL a lieu avec l'appel à la fonction SDL_SetVideoMode() avec le flag SDL_OPENGL. Vos chargement de textures doivent donc être effectués après cet appel.

                      • Vous avez oublié d'activer le texturage. C'est une erreur fréquente, pour activer le texturage appelez glEnable() avec comme paramètre GL_TEXTURE_2D (pour les textures 2D).

                      • Vous n'avez pas activé la bonne unité de texturage. Si vous texturez l'unité de texture 1 alors que vous avez "bindé" votre texture sur une autre unité, ça ne fonctionnera pas. Assurez-vous donc d'avoir activé la bonne unité de texturage avec glActiveTexture().

                      • Vous utilisez une image aux dimensions non puissance de 2. Toutes les cartes graphiques récentes supportent les textures non-puissance de 2, mais si votre modèle de carte est inférieur à une GeForce 6, vous ne supportez probablement pas les textures non puissance de 2. Afin de savoir si vous supportez des dimensions non puissance de 2, cherchez l'extension nommée GL_ARB_texture_non_power_of_two.

                      • Vous utilisez du mipmapping avec gluBuild2DMipmaps(). La fonction GLU gluBuild2DMipmaps() ne supporte pas les formats d'image compressés (DXT, 3DC, ..). Quand cette fonction échoue, elle renvoie un code d'erreur qui peut être analysé avec gluErrorString(). La valeur 0 est retournée en cas de succès.

                      • Vous avez oublié de "binder" votre texture avec glBindTexture(). Eh oui, pour dire à OpenGL d'utiliser telle ou telle texture, n'oubliez pas qu'il vous faut la spécifier explicitement avant le rendu de vos polygone, en appelant la fonction glBindTexture() comme ceci :

                        1. glBindTexture(GL_TEXTURE_2D, identifiant_texture);

                      • Partager sur Facebook
                      • Partager sur Twitter
                        7 juin 2007 à 14:16:07

                        [OpenGL][10] Comment changer la couleur de fond ?

                        La "couleur de fond" par défaut est le noir.
                        En fait, cette couleur est la couleur de vidange par défaut de votre tampon de couleur, et il vous est bien sûr possible de la modifier. Pour cela, utilisez glClearColor(), cette fonction attend quatre valeurs flottantes situées entre 0 et 1 inclus :
                        glClearColor(R, G, B, A);


                        Ainsi, les prochains appels à glClear() vidangeront votre tampon de couleur avec la couleur que vous aurez spécifiée à glClearColor().

                        Notez que l'alpha n'influera pas sur la transparence de votre fenêtre.
                        • Partager sur Facebook
                        • Partager sur Twitter
                          7 juin 2007 à 14:21:35

                          [SDL][1] Comment faire pour gérer plusieurs événements claviers en même temps ?

                          Plus généralement, pour gérer le clavier, il existe 2 possibilités. La première c'est celle qu'enseigne m@teo21 dans son cours :
                          switch(evt.type)
                          {
                              switch(evt.key.keysym.sym)
                              {
                              case SDLK_q:
                                  /* ... */
                                  break;
                              /* ... */
                              }
                          }
                          Cette méthode consiste en 1° récupérer un événement 2° Voir s'il ne s'agit pas d'un appui de touche 3° Réagir selon la touche appuyée.

                          La deuxième méthode, c'est d'utiliser un tableau de booléens. En gros, on a un tableau d'int, dont chaque int correspond à une touche. Donc si l'int de, mettons, la touche 'q' est égal à 1, la touche est enfoncée. Ainsi, on peut gérer, par exemple, les touches maintenues enfoncées sans EnableKeyRepeat, ou encore gérer 2 touches maintenues enfoncées en même temps.
                          OK C'est cool et ton tableau je l'obtiens comment ?
                          Comme ceci :
                          /* Je vous passe le début de main */
                          while(continuer)
                          {
                              /* Uint8 est environ égal à unsigned int, c'est un type défini par la SDL. Le paramètre de cette fonction se laisse généralement à NULL, et elle retourne notre fameux tableau. */
                              Uint8 *touches = SDL_GetKeyState(NULL);

                              /* On n'a plus qu'a tester si telle où telle touche est enfoncée : */
                              if(touches[SDLK_q])
                                  continuer = 0;

                              if(touches[SDLK_UP])
                                  positionPerso.y--; //imaginaire...
                          }
                          Après, à vous de gérer. Mais, de cette manière, si l'utilisateur enfonce 'o' et 'h' pendant longtemps, vous pourrez gérer sans aucun problème les deux.
                          • Partager sur Facebook
                          • Partager sur Twitter
                          J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.
                            7 juin 2007 à 14:26:04

                            [SDL][3] Comment lire l'animation d'un GIF animé avec la SDL ?

                            Directement, c'est impossible. Il faut séparer les différentes images de l'animation, puis toutes les charger, et les blitter les unes après les autres pour donner une illusion d'animation. Petit exemple :


                            //Pour une animation de 4 images :

                            SDL_Surface *animation[4];
                            gif[0] = IMG_Load("image1.png");
                            gif[1] = IMG_Load("image2.png");
                            /* [...] */

                            /* Je vous passe les tests pour voir si l'image à été chargée et tout le reste du programme, vous êtes grands :) .*/

                            while(continuer) //On arrive à la boucle évènementielle
                            {
                                /* [...] */

                                /*Nombre de secondes écoulées depuis le lancement du programme*/
                                Uint32 temps = SDL_GetTicks() / 1000;
                                /*Blittage d'une image du tableau en fonction du temps écoulé. */
                                SDL_BlitSurface(gif[temps%4], NULL, ecran, &position);
                            }


                            Ici, on s'est basé sur le temps pour savoir laquelle des quatre images blitter. On a utilisés un modulo pour obtenir une valeur qui rentre dans le tableau, et on a blitté l'image correspondante. Il existe bien sûr d'autres façons de faire, mais c'est pour vous donner une idée :)

                            edit pour yno : c'est vrai, merci.
                            • Partager sur Facebook
                            • Partager sur Twitter
                            J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.
                              7 juin 2007 à 14:26:18

                              [SDL][2] Mes appels à SDL_GL_SetAttribute() sont ignorés, pourquoi ?

                              Les appels à SDL_GL_SetAttribute() doivent être faits avant la création du contexte OpenGL, soit avant SDL_SetVideoMode(..., SDL_OPENGL).

                              Pourquoi ?

                              Car SDL_GL_SetAttribute() permet en général d'initialiser des états qui ne peuvent être changés une fois le contexte créé. (taille des tampons, multi-sampling, ...)
                              • Partager sur Facebook
                              • Partager sur Twitter
                                7 juin 2007 à 14:29:03

                                [SDL][4] Pourquoi le 2e paramètre de SDL_BlitSurface est-il toujours NULL ? A quoi sert-il ?

                                Il n'est pas toujours NULL. Ce 2e paramètre est, comme le 4e, un SDL_Rect.
                                Vous vous souvenez du 4e paramètre ? Il sert à dire sur quelle partie de l'écran on blitte la surface.
                                Ben, le 2e, c'est le contraire : il sert à dire quelle partie de la surface on blitte sur l'écran.

                                Par exemple, si vous voulez, mettons, prendre une surface, et ne blitter que la moitié droite de celle-ci, vous allez créer un SDL_Rect qui englobe la moitié droite de la surface, et faire un SDL_BlitSurface en passant comme 2e paramètre l'adresse de ce SDL_Rect.

                                Notez que vous pouvez utiliser le 2e et le 4e paramètre en même temps : c'est très utile pour programmer le défilement d'une map par exemple (pour les maps plus grandes que l'écran).
                                En faisant des tests et jouant un peu avec le 2e et le 4e paramètre de BlitSurface, vous devriez trouver comment on code ça :) .
                                • Partager sur Facebook
                                • Partager sur Twitter
                                J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.
                                  7 juin 2007 à 14:40:58

                                  [SDL][5] Comment faire fonctionner la SDL et GTK+ ? (Windows et Linux)

                                  voici un lien vers la réponse ;) : http://gtk.developpez.com/faq/?page=gtksdl

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    7 juin 2007 à 20:27:12

                                    [SDL][6] Comment avoir son propre curseur personnalisé ?

                                    Il existe plusieurs façons pour effectuer cette opération.
                                    La solution la plus portable et celle qui donnera le meilleur résultat est de définir une surface "mouse" qui contiendra l'image de la souris. Voici les fragments de code substantielles pour avoir son propre curseur :

                                    On commence par désactiver le curseur par défaut :

                                    /* On désactive la souris */
                                    SDL_ShowCursor(0);
                                    


                                    Puis, on charge une surface qui sera notre souris :

                                    /* On charge la surface */
                                    SDL_Surface *mouse = SDL_LoadBMP("cursor.bmp");
                                    


                                    Et pour finir, on récupère la position de la surface et on fait un rendu :

                                    int x,y;
                                    // On recupere la position de la souris
                                    SDL_GetMouseState(&x,&y);
                                    
                                    //On met a jour la structure rect
                                    rect.x = x;
                                    rect.y = y;
                                    
                                    //On met notre image de souris
                                    SDL_BlitSurface(mouse,NULL,ecran,&rect);
                                    


                                    Voici le lien d'un exemple complet.


                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      7 juin 2007 à 20:59:23

                                      [GTK+][1] Qu'est-ce que GTK + ?

                                      GTK+ (The GIMP Tool Kit) est un ensemble de bibliothèques logicielles, c'est-à-dire un ensemble de fonctions informatiques, développé originellement pour les besoins du logiciel de traitement d'images The GIMP.
                                      GTK+ est également utilisé pour le développement des environnements de bureau GNOME, Xfce et ROX.

                                      GTK+ est libre (licence GNU LGPL) et multi-plateforme.


                                      Lien relatifs :

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        7 juin 2007 à 21:32:53

                                        [GTK+][2] Pourquoi un + derrière GTK ?

                                        Le + derrière GTK sert à faire la distinction entre la version original de GTK et la nouvelle version.
                                        On peut considérer ceci comme une mise en valeur de la version originale de GTK à
                                        laquelle ont été ajoutées des caractéristiques orientées objets.
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          7 juin 2007 à 22:17:52

                                          [GTK+][3] Comment installer GTK+ pour developper ?

                                          Par "bibliothèque GTK+", on désigne en fait tout un framework, formé des bibliothèques suivantes :
                                          • GTK+
                                          • GDK
                                          • GLib
                                          • Pango
                                          • ATK
                                          • Gdk-Pixbuf

                                          Chacune de ces bibliothèque a une fonction bien particulière dans l'ensemble, consultez la documentation pour plus d'informations.

                                          Les paquets de développement sont disponibles pour la plupart des distributions GNU/Linux, MacOSX via le projet Fink, et Windows. Sinon, vous pouvez aussi compiler les sources vous-même (elles sont disponibles sur le site officiel).

                                          Il existe de nombreux tutos sur le net, pour vous aider dans l'installation, qui peut paraitre complexe à certain. Il y en a un ici même sur le Site du Zér0.
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            10 juin 2007 à 0:34:56

                                            [GTK+][4] Où trouver la documentation de référence pour GTK+ ?

                                            La documentation de référence pour GTK+, et ses bibliothèques connexes, est disponible sur le site du projet GNOME, section développeurs.

                                            Voiçi en gros à quoi correspond chaque bibliothèque :
                                            • GTK+ : Ici sont décrits les différents widgets de la bibliothèque, et toutes les fonctions qui permettent de les manipuler. Cette page vous sera particulièrement utile pour trouver rapidement la documentation d'un widget particulier, ou pour tous les découvrir.
                                            • GDK : GDK est la sous-couche de GTK+, c'est lui qui s'occupe du fenêtrage, et du dialogue avec le serveur X. Elle permet également une gestion plus avancée des évènements utilisateurs, du fait de son plus bas niveau par rapport à GTK+.
                                            • GLib : La GLib est quelque chose de vraiment génial. On peut la considérer comme une bibliothèque standard avancée, plus développée, permettant une programmation plus simple.
                                              Elle met (par exemple) à disposition une sorte de classe string (mais en C), des fonctions de stockage et conversion de données, des threads portables, des listes chainées, un parseur XML, des timers, etc… La liste est longue, et vous y trouverez surement votre bonheur ! ;) (notamment pour les chaines de caractères)
                                            • Pango : C'est la bibliothèque qui s'occupe du rendu des textes pour GTK+. Tout texte affiché par GTK+ passe par là, et c'est une bibliothèque très pratique, dont vous aurez surement besoin dès que vous ferez des choses un peu avancées.

                                            Les documentations sont à visiter impérativement avant de poser une question. Je vous conseille aussi de prendre un peu de temps, pour vous balader dedans, vous apprendrez plein de choses, et vous pourrez même découvrir des fonctionnalités dont vous ignoriez l'existence. Image utilisateur
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              10 juin 2007 à 9:29:09

                                              [Gtk+][5]Le tuto de Guimers n'est pas assez complet .

                                              Le tutoriel gtk.org(en) ici est la référence.
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                13 juin 2007 à 1:01:34

                                                [OpenGL][11] Comment afficher des images 2D par dessus un rendu 3D ?

                                                Il est bien sûr possible de dessiner sur l'écran en "mode 2D" comme avec la SDL, après un rendu 3D, pour afficher des informations comme le nombre de vies restantes, etc...

                                                Pour cela, il vous faut reconfigurer votre matrice de projection en perspective cavalière, ou mode "ortho", puis dessiner les objets (généralement munis de textures pour obtenir un plus joli rendu) qui devront être rendus "à plat" sur l'écran.

                                                La théorie de la technique est la suivante :

                                                1. initialisez vos matrices comme bon vous semble pour la projection de vos objets 3D dans la scène ;
                                                2. dessinez vos objets 3D, sans oublier d'emballer le tout dans de jolis glPush/PopMatrix() ;
                                                3. configurez la matrice de projection en mode "ortho" ;
                                                4. dessinez vos informations 2D, en utilisant par exemple de simples GL_QUADS (carrés) texturés.

                                                Et en pratique, ça donne ça :

                                                /* etape 1 */
                                                glMatrixMode(GL_PROJECTION);
                                                gluPerspective(70.0, (float)W / H, 0.1, 1000.0);
                                                glMatrixMode(GL_MODELVIEW);
                                                glLoadIdentity();
                                                 
                                                /* etape 2 */
                                                glPushMatrix();
                                                dessinerScene();
                                                glPopMatrix();
                                                 
                                                /* etape 3 */
                                                glMatrixMode(GL_PROJECTION);
                                                glLoadIdentity();
                                                gluOrtho2D(0, W, 0, H);
                                                glMatrixMode(GL_MODELVIEW);
                                                 
                                                /* etape 4 */
                                                glPushMatrix();
                                                dessinerInfos();
                                                glPopMatrix();
                                                

                                                On suppose ici que W et H sont, respectivement, la largeur et la hauteur de votre fenêtre de rendu.
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  13 juin 2007 à 22:05:03

                                                  [OpenGL][12] Peut-on placer une vidéo dans une texture ?

                                                  Placer une vidéo dans une texture est une tâche possible mais difficile.
                                                  De plus, elle est dépendante du système d'exploitation.
                                                  De ce fait, OpenGL ne fournit aucune fonctionnalité pour effectuer cette tâche.

                                                  Voici un lien vers un tutorial expliquant comment faire sous Windows :
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    15 juin 2007 à 17:53:41

                                                    [SDL][7] Pourquoi SDL_FillRect porte ce nom ? Pourquoi son deuxième paramètre est-il toujours NULL ?

                                                    Comme pour SDL_BlitSurface, le deuxième paramètre de cette fonction n'est pas toujours NULL. S'il l'est, alors elle colorie toute la surface que vous lui avez passé avec une couleur donnée.
                                                    Mais on peut aussi lui passer un pointeur d'SDL_Rect. Un SDL_Rect contient les coordonnées d'un rectangle (x,y pour les coordonées du point supérieur gauche, et w,h pour les dimensions de la figure). Si vous passez un pointeur sur un rectangle à SDL_FillRect, alors seule la partie contenue dans ce rectangle va être coloriée.
                                                    Cette astuce peut éviter d'utiliser plein de SDL_Surface pour rien : vous pouvez directement colorier certaines parties de l'écran à coups de SDL_Rect maintenant.

                                                    Vous comprenez aussi pourquoi elle s'appelle FillRect : Fill, en Anglais, veut dire «remplir». Du coup, son nom serait, en français : SDL_Remplir_Rectangle. Nom qui peut paraître étrange quand on s'en sert uniquement sur des surface entières (comme dans le cours), mais pas quand on comprend entièrement comment on s'en sert (comme vous maintenant :) ).

                                                    T'as pas un exemple ?

                                                    Bien sûr. Imaginons ceci :


                                                    /* Je vous passe les initialisations */

                                                    /* Ici, on crée un rectangle situé en position (0, 50),
                                                    qui fait 100px de large pour 150 de haut. Nous allons
                                                    afficher ce rectangle en vert sur fond jaune. */

                                                    SDL_Rect rct;
                                                    rct.x = 0;
                                                    rct.y = 50;
                                                    rct.w = 100;
                                                    rct.h = 150;

                                                    /* ... */

                                                    while(continuer)
                                                    {
                                                        switch(event.type)
                                                        {
                                                            /* ... */
                                                        }

                                                        /* On remplit tout l'écran de jaune : 2e paramètre à NULL */
                                                        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 0));

                                                        /* Après, on remplit toute la partie située dans notre rectangle en vert */.
                                                        SDL_FillRect(ecran, &rct, SDL_MapRGB(ecran->format, 0, 255, 0));

                                                        /* Et un petit SDL_Flip */
                                                        SDL_Flip(ecran);
                                                    }

                                                    /* ... */


                                                    Concrètement on aura ça : (J'ai ajouté là légende en rouge pour que vous voyez à quoi correspond chaque chiffre)


                                                    Schema SDL_FillRect


                                                    Faites des expériences pour bien comprendre le principe !

                                                    Merci à Yno pour ses suggestions.
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.
                                                      15 juin 2007 à 20:02:12

                                                      [SDL][8] Pourquoi utiliser la forme while(SDL_PollEvent()) ? ou pourquoi mes événements sont récupérés en retard ?

                                                      Si vous envoyez une suite d'événements rapidement à votre application, et que celle-ci réagi en retard, alors c'est que la file d'événements n'est pas vidée à chaque tour de votre boucle principale.
                                                      Ce qui signifie ?
                                                      A chaque fois que vous envoyez un événement à votre application SDL, celle-ci l'empile dans une file d'événements en attente d'être récupérés. Il vous est possible de lire dans cette file avec la fonction SDL_PollEvent(). Si un événement se trouvait dans la file, cette fonction renvoie un entier qui vaut 1 (true), 0 (false) sinon. Si vous ne videz pas cette file à chaque tour de boucle en n'interprêtant à chaque fois qu'un seul événement, elle se remplira et les derniers événements ne seront lu que bien après.
                                                      Pourquoi c'est lent ?
                                                      Car avant de pouvoir récupérer le 50ème événement par exemple, il faudra attendre que vote boucle principale s'exécute 50 fois. En supposant qu'un tour s'exécute en 20ms, il faudra attendre 20*50 = 1000ms, soit une seconde avant de pouvoir récupérer le 50ème événement. En une seconde, il peut se passer bien des choses, comme par exemple 100 nouveaux événements dans la file...
                                                      Que faire ?
                                                      Il faut se servir de la valeur de retour de SDL_PollEvent(), et récupérer tous les événements de la file à chaque tour de boucle. Pour cela, nous faisons simplement comme ceci :
                                                      while(mainloop)
                                                      {
                                                          /* tant qu'il y a un evenement dans la file... */
                                                          while(SDL_PollEvent(&ev))
                                                          {
                                                              /* on le lit et l'analyse... */
                                                              /* ici, on ne s'occupera QUE des evenements */
                                                          }
                                                          
                                                          /* et ici vous pourrez dessiner
                                                             et faire tout ce que vous voudrez */
                                                      
                                                      }
                                                      
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        3 juillet 2008 à 15:36:09

                                                        [GTK+][5] À quoi sert le quatrième paramètre de g_signal_connect() et comment l'utiliser ?

                                                        Le quatrième paramètre de g_signal_connect() sert à passer des données personnelles au callback passé en troisième argument.
                                                        Ce paramètre est un pointeur qui va être transmit comme dernier argument au callback.

                                                        Attention, le pointeur en question est passé en dernier argument, cela ne veux pas forcément dire deuxième. Certains callbacks ont trois, voir plus d'arguments. Référez-vous à la documentation du signal que vous connectez pour en connaître le prototype.

                                                        Passer plusieurs données au callback


                                                        g_signal_connect() permet de spécifier un seul pointeur, donc comment passer plusieurs données au callback ?
                                                        Pour cela, la meilleur solution consiste en général à utiliser une structure contenant les différentes données à passer à la fonction callback.
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                        Anonyme
                                                          9 août 2008 à 14:13:41

                                                          [GTK+] [6] Où trouver la documentation de référence pour GTK+ ?

                                                          Pour l'installation de GTK+, et la gestion des signaux, je conseille le tutoriel du site du zéro.

                                                          Et pour les widgets, un très bon tuto sur developpez.com.
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            9 août 2008 à 14:42:49

                                                            Citation : Zomb0

                                                            [GTK+] [6] Où trouver la documentation de référence pour GTK+ ?
                                                            […]



                                                            Il serait bon avec un titre comme ça de fournir les lien vers la documentation de référence justement :

                                                            Et même peut-être l'ensemble des documentation présente sur library.gnome.org, qui contient entre autres GTK+, GDK, GDK-Pixbuf, GLib, GObject cités ci-dessus, mais aussi ATK, GIO, Pango, GConf… : http://library.gnome.org/devel/references
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              19 septembre 2008 à 21:24:29

                                                              [GTK+][7] Existe-t-il un logiciel de conception d'interface GTK+ ?

                                                              Oui. Ce logiciel se nomme Glade. (Interface de Glade)
                                                              Il prend en charge toute la partie de gestion/génération de l'interface. Les anciennes versions de Glade (2.x) permettaient de générer directement le code en C.
                                                              Cependant, depuis la version 3, cette fonctionnalité a été supprimée pour différentes raisons.

                                                              Glade enregistre les interfaces graphiques en générant des fichiers XML. La bibliothèque libglade permet de lire ces fichiers dynamiquement.
                                                              Grâce à libglade, ces fichiers XML peuvent être utilisés par de nombreux langages de programmation tels que C, C++, Java, Perl, Python, C#, PHP (extension PHP-GTK), Pike, Ruby, Haskell, Objective Caml et Scheme.

                                                              Quelques liens utiles :

                                                              • 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é.
                                                              • Editeur
                                                              • Markdown