GTK et OpenGL

Version imprimable

28/02/2013, 15h22
straasha

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 :

Citation:

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.
28/02/2013, 21h56
Le Farfadet Spatial

1 pièce(s) jointe(s)

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 ».
01/03/2013, 09h38
straasha

merci pour ta réponse, je vais regarder ça maintenant et je reviendrai dire ce qu'il en est
01/03/2013, 12h05
straasha

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 :aie:), il apparait que :

Citation:

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
01/03/2013, 17h50
Le Farfadet Spatial

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
04/03/2013, 14h04
straasha

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.
04/03/2013, 22h24
Le Farfadet Spatial

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

ce que j'ai c'est le tutorial Cairo :

Code:

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:

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:

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;
}

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:

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:

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:

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:

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:

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

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.

Citation:

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:

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:

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 ;)

13/03/2013, 03h44
Le Farfadet Spatial

Salut à tous !

Citation:

Envoyé par straasha

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:

`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:

`pkg-config --libs gtkglextmm-1.2`

Citation:

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.

Citation:

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