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

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

GTK+ avec C & C++ Discussion :

GTK et OpenGL


Sujet :

GTK+ avec C & C++

  1. #1
    Membre actif Avatar de straasha
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    juillet 2004
    Messages
    145
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : Conseil

    Informations forums :
    Inscription : juillet 2004
    Messages : 145
    Points : 267
    Points
    267
    Par défaut GTK et OpenGL
    Bonjour,

    Je voudrai faire une application fenêtre avec barre d'outils et autre contenant notamment une ou plusieurs zone pour dessiner des scènes OpenGL.
    J'ai installé le pack bundle depuis http://www.gtk.org/download/win32.php.
    J'ai créé un projet sous Code::Block dont le code par défaut m'a permis d'afficher une fenetre avec 2 boutons (1 pour quitter et 1 pour afficher une fenêtre de dialogue "Hello World").
    Le pack GTK est donc bien installé.
    Par contre lorsque je reprend l'exemple trouvé sur http://forum.ubuntu-fr.org/viewtopic.php?id=725661 (le 2e qui est en C vu que le 1er est en python) j'ai le message d'erreur suivant :
    erreur fatale : gdk/gdkgl.h : No such file or directory
    et effectivement dans mon répertoire GTK il n'y a aucun fichier de ce nom.

    du coup je me demande d'où il sort ? est ce que ca vient d'une vielle version de GTK ? et dans ce cas là comment fait-on aujourd'hui ? ou est-ce un truc spécifique à Ubuntu (le code vient du forum Ubuntu-fr mais je développe sous winXP) ?

    merci d'éclairer ma lanterne moi qui découvre GTK.
    il parait que la plume est plus forte que l'épée, heureusement j'ai une hache

  2. #2
    Membre confirmé
    Avatar de Le Farfadet Spatial
    Homme Profil pro
    En cours de précision…
    Inscrit en
    avril 2008
    Messages
    179
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : En cours de précision…

    Informations forums :
    Inscription : avril 2008
    Messages : 179
    Points : 600
    Points
    600
    Par défaut
    Salut à tous !

    Tiens, ça fait longtemps que je ne suis pas passé sur le forum Ubuntu-fr.

    Contrairement à ce qu’y dit Hibou57, il existe bien une version C++ de GtkGlExt, à savoir GtkGlExtmm. Justement, je suis en train de réaliser la conversion des tutoriels NeHe en Gtkmm et je compte les mettre très prochainement à disposition de n’importe qui pour aider à utiliser GtkGlExtmm. Et faire quelques articles pour aider.

    Joins à ce message, le septième tutoriel NeHe, version Gtkmm. Il est géré avec CMake, il n’y a normalement rien de particulier à faire pour le compiler sous Windows. Je t’invite à le télécharger et à me confirmer que tu as pu ouvrir l’archive et compiler le code. Cela te fera un exemple.

    Je ne sais pas trop où Hibou57 a trouvé « #include <gdk/gdkgl.h> » et « #include <gtk/gtkgl.h> ». En C, il faut « #include <gtkgl.h> », en C++ « #include <gtkglmm.h> ». Sauf erreur de ma part, l’installateur officiel de Gtk+ sos Microsoft Windows permet l’installation de GtkGlExtmm.

    Est-ce que cela t’aide ?

    À bientôt.

    Le Farfadet Spatial

    Édition : une fois le programme lancé, si tu appuies sur la touche « F », tu appliqueras des filtres successifs sur les textures, si tu appuies sur « L » tu allumes ou éteints la l’éclairage. Tu peux faire bouger le cube en utilisant les flèches, ainsi que « Pg.Préc » et « Pg.Suiv ».
    Fichiers attachés Fichiers attachés

  3. #3
    Membre actif Avatar de straasha
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    juillet 2004
    Messages
    145
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : Conseil

    Informations forums :
    Inscription : juillet 2004
    Messages : 145
    Points : 267
    Points
    267
    Par défaut
    merci pour ta réponse, je vais regarder ça maintenant et je reviendrai dire ce qu'il en est
    il parait que la plume est plus forte que l'épée, heureusement j'ai une hache

  4. #4
    Membre actif Avatar de straasha
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    juillet 2004
    Messages
    145
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : Conseil

    Informations forums :
    Inscription : juillet 2004
    Messages : 145
    Points : 267
    Points
    267
    Par défaut
    bon après une interruption réunion et la découverte de CMake (avant je pensais que c'était un compilateur comme gcc ou autre ), il apparait que :
    sh.exe was found in your PATH, here:
    C:/WINDOWS/system32/bin/sh.exe

    For MinGW make to work correctly sh.exe must NOT be in your path.
    et comme je n'ai pas les droits admin sur ma machine, je peux pas virer c:/WINDOWS/system32/bin du PATH même temporairement
    du coup il faut que je trouve une autre solution sans passer par CMake
    il parait que la plume est plus forte que l'épée, heureusement j'ai une hache

  5. #5
    Membre confirmé
    Avatar de Le Farfadet Spatial
    Homme Profil pro
    En cours de précision…
    Inscrit en
    avril 2008
    Messages
    179
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : En cours de précision…

    Informations forums :
    Inscription : avril 2008
    Messages : 179
    Points : 600
    Points
    600
    Par défaut
    Salut à tous !

    Visiblement, tu utilises MinGW. C’est parfaitement supporté par Gtk+, voir l’environnement supporté par défaut par Gtk+ sur Windows.

    Gtk+ a plutôt tendance à utiliser Autotools que CMake, je préfère CMake car plus portable, mais tu pourras parfaitement utiliser Gtk+ sans y avoir recours.

    Pour l’instant, oubli le code que je t’ai donné. Nous allons procéder par étapes peut-être un peu plus longues, mais il n’y a pas de raison de ne pas s’en sortir. Premièrement, avec l’installateur de Gtk+, vérifie que tu as bien installé GtkGlExt.

    Par ailleurs, pour l’instant GtkGlExt n’a pas été porté sur Gtk+ 3 et il n’y a pas encore de distribution officielle de Gtk+ 3 pour Microsoft Windows, donc je voudrais m’assurer que tu as bien installé Gtk+ 2.

    GtkGlExt permet de donner des capacités OpenGL a n’importe quel composant, mais le plus courant est de le faire dans une zone de dessin. Donc, je t’invite à prendre le premier exemple Cairo du tutoriel Gtkmm et à le compiler. Le tutoriel donne également les bases pour pouvoir compiler un projet Gtkmm avec les Autotools, au besoin tu peux utiliser cet autre tutoriel sur le sujet. Une fois cela fait, revient ici et nous verrons comment ajouter les capacités OpenGL au composant.

    Au fait, je t’ai donné le tutoriel version C++, mais peut-être es-tu plus intéressé par le C ?

    À bientôt.

    Le Farfadet Spatial

  6. #6
    Membre actif Avatar de straasha
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    juillet 2004
    Messages
    145
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : Conseil

    Informations forums :
    Inscription : juillet 2004
    Messages : 145
    Points : 267
    Points
    267
    Par défaut
    bon alors j'ai réussi à paramétrer code::block pour le 1er exemple Cairo
    j'ai donc la fenêtre avec les 3 droites, ce qui est pas mal vu d’où je pars.
    maintenant il reste plus qu'a lier ça avec OpenGL.

    Pour ce qui est du C ou C++, je suis développeur embarqué ce qui fait que je suis plus à l'aise avec le C mais je connais aussi le C++ et ça pourrait etre aussi un bon exercice pour moi de m'y remettre, tout comme l'OpenGL, ça fait presque 10 ans que j'en ai pas fait par contre j'avais jamais utilisé GTK.
    il parait que la plume est plus forte que l'épée, heureusement j'ai une hache

  7. #7
    Membre confirmé
    Avatar de Le Farfadet Spatial
    Homme Profil pro
    En cours de précision…
    Inscrit en
    avril 2008
    Messages
    179
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : En cours de précision…

    Informations forums :
    Inscription : avril 2008
    Messages : 179
    Points : 600
    Points
    600
    Par défaut
    Salut à tous !

    Bon, donc, tu avances. Poste ici le code que tu as produit, j’essayerais de te proposer des modifications pour faire un tracé OpenGL.

    À bientôt.

    Le Farfadet Spatial

  8. #8
    Membre actif Avatar de straasha
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    juillet 2004
    Messages
    145
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : Conseil

    Informations forums :
    Inscription : juillet 2004
    Messages : 145
    Points : 267
    Points
    267
    Par défaut
    ce que j'ai c'est le tutorial Cairo :
    Code myarea.h : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H
     
    #include <gtkmm/drawingarea.h>
     
    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();
     
    protected:
      //Override default signal handler:
      virtual bool on_expose_event(GdkEventExpose* event);
    };
     
    #endif // GTKMM_EXAMPLE_MYAREA_H
    Code myarea.cc : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    #include "myarea.h"
    #include <cairomm/context.h>
     
    MyArea::MyArea()
    {
    }
     
    MyArea::~MyArea()
    {
    }
     
    bool MyArea::on_expose_event(GdkEventExpose* event)
    {
      // This is where we draw on the window
      Glib::RefPtr<Gdk::Window> window = get_window();
      if(window)
      {
        Gtk::Allocation allocation = get_allocation();
        const int width = allocation.get_width();
        const int height = allocation.get_height();
     
        // coordinates for the center of the window
        int xc, yc;
        xc = width / 2;
        yc = height / 2;
     
        Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
        cr->set_line_width(10.0);
     
        // clip to the area indicated by the expose event so that we only redraw
        // the portion of the window that needs to be redrawn
        cr->rectangle(event->area.x, event->area.y,
                event->area.width, event->area.height);
        cr->clip();
     
        // draw red lines out from the center of the window
        cr->set_source_rgb(0.8, 0.0, 0.0);
        cr->move_to(0, 0);
        cr->line_to(xc, yc);
        cr->line_to(0, height);
        cr->move_to(xc, yc);
        cr->line_to(width, yc);
        cr->stroke();
      }
     
      return true;
    }
    Code main.cc : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #include "myarea.h"
    #include <gtkmm/main.h>
    #include <gtkmm/window.h>
     
    int main(int argc, char** argv)
    {
       Gtk::Main kit(argc, argv);
     
       Gtk::Window win;
       win.set_title("DrawingArea");
     
       MyArea area;
       win.add(area);
       area.show();
     
       Gtk::Main::run(win);
     
       return 0;
    }
    il parait que la plume est plus forte que l'épée, heureusement j'ai une hache

  9. #9
    Membre confirmé
    Avatar de Le Farfadet Spatial
    Homme Profil pro
    En cours de précision…
    Inscrit en
    avril 2008
    Messages
    179
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : En cours de précision…

    Informations forums :
    Inscription : avril 2008
    Messages : 179
    Points : 600
    Points
    600
    Par défaut
    Salut à tous !

    Reprendre le tutoriel est une bonne approche. Tu as utilisé le tutoriel C++, que je trouve plus accessible que ce que l’on trouve en C. Voici les modifications que je te propose pour obtenir un zone de rendu OpenGL. J’ai essayé de suivre les conventions que tu as appliquées dans ton code. J’ai mis les commentaires et les messages en français, j’ai pensé que tu préférerais.

    Dans tes fichiers de gestion du projet – que ce soit Make, Autotools, CMake, Scons ou autre –, il faut ajouter « gtkglextmm ». Pkg-config gère de manière standard GtkGlExt, donc il suffit d’ajouter quelque chose d’approchant ceci :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    pkg-config gtkglextmm-1.2 --cflags --libs
    À adapter pour coller au gestionnaire de projets utilisé.

    Malheureusement, pour l’instant GtkGlExt n’est pas totalement compatible avec OpenGL 3, ni OpenGL 4, il faut s’en tenir à un OpenGL plus archaïque.

    J’ai ajouté des classes pour la gestion d’exceptions. Il n’est pas obligatoire de gérer les erreurs par exceptions, mais je trouve cela plus propre. Du coup, j’ai ajouté le fichier « erreurs.h » suivant :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    #ifndef ERREURS_H
    #define ERREURS_H
     
    /*
     * Exceptions pour la gestions des erreurs.
     */
     
    #include <exception>
     
    /* Espace de nommage pour la gestion des erreurs. */
    namespace Erreurs {
      /* Erreurs provoquées par l’interface graphique. */
      class ErreurInterface: public std::exception {
        public:
          /* Constructeur par défaut. */
          ErreurInterface () throw () {}
     
          /* Destructeur. */
          virtual ~ErreurInterface () throw () {}
     
          /* Génére le message d’erreur. */
          virtual const char* what () const throw () {
            return "une erreur s’est produite dans l’interface graphique";
          }
      };
     
      /* Erreur lors de la configuration d’OpenGL. */
      class ErreurConfigurationGL: public ErreurInterface {
        public:
          /* Constructeur par défaut. */
          ErreurConfigurationGL () throw () {}
     
          /* Destructeur. */
          virtual ~ErreurConfigurationGL () throw () {}
     
          /* Génère le message d’erreur. */
          virtual const char* what () const throw () {
            return "erreur lors de la configuration d’OpenGL";
          }
      };
     
      /* Erreur lors de la création du contexte OpenGL. */
      class ErreurCreationContexte: public ErreurInterface {
        public:
          /* Constructeur par défaut. */
          ErreurCreationContexte () throw () {}
     
          /* Destructeur. */
          virtual ~ErreurCreationContexte () throw () {}
     
          /* Génère le message d’erreur. */
          virtual const char* what () const throw () {
            return "impossible de créer un contexte OpenGL";
          }
      };
     
      /* Erreur à l’obtention du contexte OpenGL. */
      class ErreurObtentionContexte: public ErreurInterface {
        public:
          /* Constructeur par défaut. */
          ErreurObtentionContexte () throw () {}
     
          /* Destructeur. */
          virtual ~ErreurObtentionContexte () throw () {}
     
          /* Génère le message d’erreur. */
          virtual const char* what () const throw () {
            return "impossible d’obtenir le contexte OpenGL";
          }
      };
    }
     
    #endif  /* #ifndef ERREURS_H */
    On remarque que j’ai également ajouté un espace de nommage pour les erreurs. Je conseille fortement l’usage d’espaces de nommages, cela permet de régler beaucoup de problèmes.

    Première chose pour utiliser GtkGlExtmm, il faut ajouter les en-têtes. « #include <gtkglmm.h> » inclus tous les en-têtes de l’extension, c’est-à-dire ce qui permet d’initialiser le contexte et les primitives d’OpenGL, soit ce que l’on utilise à chaque fois. Inutile, en conséquence, de cherche à inclure plus finement les en-têtes, la seule chose que l’on ferait c’est reprendre exactement ce qui est fait dans l’en-tête « gtkglmm.h ».

    Il faut donc ajouter les capacités OpenGL au composant. Cela créera un contexte OpenGL dans le composant. Ce contexte est un contexte OpenGL classique, il faut donc le lier au contexte Gtk+. En conséquence, il faut nécessairement surcharger les méthodes « on_realize » (qui correspond à l’initialisation de la fenêtre) et « on_configure_event » – correspondant à l’évènement de changement de la configuration, notamment lorsque la fenêtre est redimensionnée.

    Ce qui implique de modifier le fichier « myarea.h » de la façon suivante :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H
     
    #include <gtkmm/drawingarea.h>
    #include <gtkglmm.h>
     
    class MyArea : public Gtk::DrawingArea, public Gtk::GL::Widget<MyArea> {
      public:
        MyArea ();
        virtual ~MyArea ();
     
      protected:
        //Override default signal handler:
        virtual bool on_expose_event (GdkEventExpose* event);
     
        /* À l’initialisation de la fenêtre. */
        virtual void on_realize ();
     
        /* Au changement de taille de la fenêtre. */
        virtual bool on_configure_event (GdkEventConfigure* event);
    };
     
    #endif // GTKMM_EXAMPLE_MYAREA_H
    Il faut faire attention à ce que l’initialisation d’OpenGL et la création du contexte soit fait avant tout rendu, sinon cela provoquera une erreur. Pour cela, il faut faire attention à ce qui est appelé en fonction de quel évènement.

    Tout d’abord, je conseille de faire l’initialisation d’OpenGL dans le constructeur de la classe du composant. Je fais la création du contexte OpenGL (qui se base sur l’initialisation précédente) dans la méthode « on_realize ». OpenGL étant une machine à état avec conservation du contexte, il n’est pas nécessaire, contrairement à ce qui se passe avec Cairo, de créer un contexte à chaque rendu, on peut utiliser le même à chaque fois.

    Le rendu se fait toujours dans la méthode « on_expose_event ». Entre « gl_begin(get_gl_context()) » et « gl_end() », nous sommes dans un contexte OpenGL classique, il suffit de faire des appels aux fonctions OpenGL comme on le ferait dans n’importe quel cas.

    Enfin, on prend en compte le redimensionnement dans « on_configure_event ». Attention : si Gtk+ réalise bien le changement de taille, il n’en notifie pas OpenGL. Il faut donc le faire soit-même en appelant « glViewport ».

    Ce qui donne les modifications suivantes dans le fichier « myarea.cc » :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    #include <cairomm/context.h>
    #include <glibmm/error.h>
    #include <sstream>
    #include <GL/glu.h>
     
    #include "myarea.h"
    #include "erreurs.h"
     
    MyArea::MyArea () {
      #ifndef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
        /* Connecte les contrôleurs de signaux s’il ne s’agit pas déjà de
           méthodes virtuelles surchargées : */
        signal_realize().connect(sigc::mem_fun(*this,
                                               &GlDrawingArea::on_realize),
                                 false);
        signal_expose_event().connect(sigc::mem_fun(*this,
                                                &GlDrawingArea::on_expose_event),
                                      false);
        signal_configure_event().connect(sigc::mem_fun(*this,
                                             &GlDrawingArea::on_configure_event),
                                         false);
      #endif  /* #ifndef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED */
     
      /* Configuration d’OpenGL */
      Glib::RefPtr<Gdk::GL::Config> configuration;
     
      /* Tente d’ouvrir une espace à double tampon. */
      configuration = Gdk::GL::Config::create(Gdk::GL::MODE_RGBA   |
                                              Gdk::GL::MODE_DEPTH  |
                                              Gdk::GL::MODE_DOUBLE);
      if (!configuration) {
        /* Message d’avertissement. */
        std::stringstream message;
        message << "Impossible de configurer OpenGL en mode double tampon, "
                << "tente le mode simple tampon.\n";
        g_warning(message.str().c_str());
        /* Tente de configurer un tampon simple. */
        configuration = Gdk::GL::Config::create(Gdk::GL::MODE_RGBA  |
                                                Gdk::GL::MODE_DEPTH);
        if (!configuration) throw Erreurs::ErreurConfigurationGL ();
      }
     
      /* Donne accès à OpenGL au composant. */
      set_gl_capability(configuration);
    }
     
    MyArea::~MyArea () {
    }
     
    /* Initialisation du contexte OpenGL. */
    void MyArea::on_realize () {
      /* D’abord l’initialisation standard. */
      Gtk::Widget::on_realize();
     
      if (!create_gl_context()) throw Erreurs::ErreurCreationContexte ();
      /* Fenêtre OpenGL. */
      Glib::RefPtr<Gdk::GL::Window> fenetreGl = get_gl_window();
      if (!fenetreGl) throw Erreurs::ErreurObtentionContexte ();
     
      fenetreGl->gl_begin(get_gl_context());
     
        /* Permet un joli ombrage. */
        glShadeModel(GL_SMOOTH);
     
        /* Fond noir. */
        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     
        /* Mis en place du tampon de profondeur. */
        glClearDepth(1.0f);
        /* Mis en place du test de profondeur. */
        glEnable(GL_DEPTH_TEST);
        /* Le type de test de profondeur . */
        glDepthFunc(GL_LEQUAL);
     
        /* Calcul de perspective le plus réaliste. */
        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
     
      fenetreGl->gl_end();
    }
     
    bool MyArea::on_expose_event (GdkEventExpose* event) {
        /* Fenêtre OpenGL. */
      Glib::RefPtr<Gdk::GL::Window> fenetreGl = get_gl_window();
      if (!fenetreGl)  throw Erreurs::ErreurObtentionContexte ();
     
      fenetreGl->gl_begin(get_gl_context());
     
        /* Vide l'écran et le Z-Buffer (Depth Buffer : contient les informations
           de profondeur de chaque pixel). */
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        /* Repositionne la caméra. */
        glLoadIdentity();
     
        /* Bouge de 1.5 unités vers la gauche et de 6.0 unités vers l'intérieur
           de l'écran. */
        glTranslatef(-1.5f,0.0f,-6.0f);
     
        /* Dessiner un Triangle. */
        glBegin(GL_TRIANGLES);
          /* Point du haut. */
          glVertex3f( 0.0f, 1.0f, 0.0f);
          /* Point en bas à gauche. */
          glVertex3f(-1.0f,-1.0f, 0.0f);
          /* Point en bas à droite */
          glVertex3f( 1.0f,-1.0f, 0.0f);
        /* Le dessin du Triangle est fini */
        glEnd();
     
        /* Bouge de 3.0f unités vers la droite. */
        glTranslatef(3.0f,0.0f,0.0f);
     
        /* Dessin d'un quadrilatère. */
        glBegin(GL_QUADS);
          /* Haut Gauche. */
          glVertex3f(-1.0f, 1.0f, 0.0f);
          /* Haut Droite. */
          glVertex3f( 1.0f, 1.0f, 0.0f);
          /* Bas Droite. */
          glVertex3f( 1.0f,-1.0f, 0.0f);
          /* Bas Gauche. */
          glVertex3f(-1.0f,-1.0f, 0.0f);
        glEnd();
     
      fenetreGl->gl_end();
      fenetreGl->swap_buffers();
     
      /* Partie standard de la la procédure d’affichage. */
      return Gtk::Widget::on_expose_event(event);
    }
     
    /* Lorsque la fenêtre est redimensionnée. */
    bool MyArea::on_configure_event (GdkEventConfigure* event) {
      /* Fenêtre OpenGL. */
      Glib::RefPtr<Gdk::GL::Window> fenetreGl = get_gl_window();
      if (!fenetreGl)  throw Erreurs::ErreurObtentionContexte ();
     
      /* Largeur de la zone de rendu. */
      const GLsizei largeur = static_cast<GLsizei>(get_width());
      /* Hauteur de la zone de rendu. */
      const GLsizei hauteur = static_cast<GLsizei>(get_height());
     
      fenetreGl->gl_begin(get_gl_context());
     
        /* Fixer la taille de la zone de rendue. */
        glViewport(0, 0, largeur, hauteur);
        /* Choisir la matrice de projection. */
        glMatrixMode(GL_PROJECTION);
        /* Remettre a zéro de la matrice de projection. */
        glLoadIdentity();
     
        /* Calculer le ratio pour la perspective de la fenêtre. */
        gluPerspective(45.0f, static_cast<GLfloat>(largeur)
                                / static_cast<GLfloat>(hauteur), 0.1f,100.0f);
        glMatrixMode(GL_MODELVIEW);
        /* Remetre à zéro la matrice de modélisation. */
        glLoadIdentity();
     
      fenetreGl->gl_end();
     
      /* Partie standard du redimensionnement. */
      return Gtk::Widget::on_configure_event(event);
    }
    Comme exemple, j’ai pris le tracé d’un triangle et d’un carré, blancs tous les deux.

    Enfin, il faut penser à faire l’initialisation générale d’OpenGL avant de faire le moindre appel à OpenGL. Cela ce fait avec « Gtk::GL::init ». Comme cette fonction prend les arguments de la ligne de commande, je fais cet appel dans la fonction principale. J’y ai aussi ajouté la gestion des exceptions. Ce qui donne les modifications suivantes du fichier « main.cc » :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    #include <gtkmm/main.h>
    #include <gtkmm/window.h>
    #include <gtkglmm.h>
    #include <exception>
    #include <glibmm/error.h>
    #include <sstream>
    #include <iostream>
     
    #include "myarea.h"
    #include "erreurs.h"
     
    int main(int argc, char** argv) {
      try {
        Gtk::Main kit(argc, argv);
        Gtk::GL::init(argc, argv);
     
        Gtk::Window win;
        win.set_title("DrawingArea");
     
        MyArea area;
        win.add(area);
        area.show();
     
        Gtk::Main::run(win);
     
        return 0;
      }
      catch(const Glib::Error &ex) {
        /* Message d’erreur. */
        std::ostringstream message;
        message << "Erreur venant de GLib : " <<  ex.what() << '\n';
        g_critical(message.str().c_str());
        return -1;
      }
      catch (const Erreurs::ErreurInterface &e) {
        /* Message d’erreur. */
        std::ostringstream message;
        message << "Erreur de contexte OpenGL : " << e.what() << ".\n";
        g_critical(message.str().c_str());
        return -2;
      }
      catch (const std::exception &e) {
        /* Message d’erreur. */
        std::ostringstream message;
        message << "Erreur venant de la bibliothèque standard : " << e.what()
                << '\n';
        g_critical(message.str().c_str());
        return -3;
      }
      catch (...) {
        g_critical("Exception non-standard.\n");
        return -4;
      }
    }
    Test, voies si tu t’en sors et confirme-le ici. Par ailleurs, je te signale que je dépose la conversion des tutoriels NeHe en GtkGlExtmm dès ce soir sur la plate-forme de téléchargement de Développez.com. Je prépare quelques tutoriels pour donner les éléments qui peuvent piéger.

    À bientôt.

    Le Farfadet Spatial

  10. #10
    Membre actif Avatar de straasha
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    juillet 2004
    Messages
    145
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : Conseil

    Informations forums :
    Inscription : juillet 2004
    Messages : 145
    Points : 267
    Points
    267
    Par défaut
    Désolé pour le silence, j'ai eu pas mal d’imprévu la semaine dernière, mais je vais pouvoir m'y remettre cette semaine.

    Dans tes fichiers de gestion du projet – que ce soit Make, Autotools, CMake, Scons ou autre –, il faut ajouter « gtkglextmm ». Pkg-config gère de manière standard GtkGlExt, donc il suffit d’ajouter quelque chose d’approchant ceci :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    pkg-config gtkglextmm-1.2 --cflags --libs
    C'est justement cette partie que je ne maitrise pas du tout, est ce que tu pourrai la détailler ?
    J'ai fait mon projet sous Code::Block mais je pense qu'il faut compiler d'abord ces librairies séparément donc j'ai essayé de suivre le README.win32 trouvé dans le répertoire gtkglextmm-1.2.0 : il indique qu'il faut en pré-requis avoir compilé gtkglext-1.2.0. J'ai donc suivi le README.win32 trouvé dans gtkglext-1.2.0 et en exécutant les instructions sous cygwin, je suis tombé sur le message suivant :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    checking for BASE_DEPENDENCIES... configure: error: Package requirements (gtk+-2.0 >= 2.0.0 gdk-2.0 >= 2.0.0 pango >= 1.0.0 pangox >= 1.0.0 gmodule-2.0 >= 2.0.0 ) were not met:
     
    No package 'pangox' found
    C'est quoi ce pangox ? J'ai l’impression qu'il devrai plutôt chercher pangowin32 vu que je suis sous win et pas sous x11. Si c'est ça, je devrai juste avoir une option à fixer quelque part, mais où ?

    Si il y a une méthode pour compiler tout ça tout en restant sous Code::Block, je suis preneur
    il parait que la plume est plus forte que l'épée, heureusement j'ai une hache

  11. #11
    Membre confirmé
    Avatar de Le Farfadet Spatial
    Homme Profil pro
    En cours de précision…
    Inscrit en
    avril 2008
    Messages
    179
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : En cours de précision…

    Informations forums :
    Inscription : avril 2008
    Messages : 179
    Points : 600
    Points
    600
    Par défaut
    Salut à tous !

    Citation Envoyé par straasha Voir le message
    C'est justement cette partie que je ne maitrise pas du tout, est ce que tu pourrai la détailler ?
    Spécialement pour configurer un projet selon la méthode non standard qu’utilise de base Code::Blocks ? Non : je n’utilise pas Code::Blocks et pour tout dire, je ne comprends pas l’engouement pour cet environnement. Maintenant, pour découvrir, utiliser la gestion de projet non standard de Code::Blocks peut être envisagé. Cela dit, les environnements, ça passe et il vaut mieux utiliser des méthodes standards et portables : ça permet de ne pas se bloquer dans un environnement de développement particulier.

    Cela dit, tu as réussi à configurer Code::Blocks pour utiliser Gtkmm, c’est la même façon de procéder avec GtkGlExtmm.

    Si je me réfère à ce que l’on trouve sur Internet, il faut que tu te rendes dans Project → Build options → Compiler settings → Other options et que tu y ajoutes – ajouter, pas remplacer – ceci :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    `pkg-config --cflags gtkglextmm-1.2`
    Puis, il faut aller dans Project → Build options → Linker settings → Other linker et ajouter – encore une fois, ne pas remplacer – ceci :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    `pkg-config --libs gtkglextmm-1.2`
    J'ai fait mon projet sous Code::Block mais je pense qu'il faut compiler d'abord ces librairies séparément
    Pourquoi ? Si tu as utilisé l’installateur Windows de Gtk, les bibliothèques sont déjà compilées. As-tu utilisé l’installateur Windows ? D’ailleurs, as-tu compilé Gtkmm – je ne pense pas, sinon tu ne poserais sans doute pas ces questions ?

    Vu que tu as été capable de compiler un code Gtkmm, il ne devrait rien avoir de particulier.

    C'est quoi ce pangox ?
    Sauf erreur de ma part, la version pour XWindows de Pango, la bibliothèque de rendu des polices de caractères qu’utilise Gtk+.

    À bientôt.

    Le Farfadet Spatial

Discussions similaires

  1. (ANN] Demo de Gtk et OpenGL
    Par poincare dans le forum GTK+ avec C & C++
    Réponses: 0
    Dernier message: 16/04/2013, 23h54
  2. GTK+ et Opengl
    Par chanCH dans le forum Bibliothèques, systèmes et outils
    Réponses: 4
    Dernier message: 30/04/2011, 15h11
  3. Gtk avec OpenGl
    Par acryline dans le forum GTK+ avec C & C++
    Réponses: 6
    Dernier message: 29/08/2010, 10h48
  4. GTK et OPENGL avec gtkglarea
    Par Vincent|Dev dans le forum OpenGL
    Réponses: 1
    Dernier message: 09/02/2005, 14h33

Partager

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