gtkglext et gtk_drawing_area qui n'affiche rien ?!

Bonjour,

J'essaie de compiler un programme (fait initialement sous linux) sous windows avec code blocks et mingw. J'utilise les bibliothèques openGL, GTK+ et GtkGlExt. J'ai résolu les problèmes d'installation des librairies grace à l'installateur suivant :
ici

je dois faire face maintenant à des problèmes de portabilité, en effet le code est beaucoup plus chaffouin sous windows...

J'ai des gros problèmes d'affichage : en réduisant le code à :

main.c

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
/**************
* main module *
**************/
 
//librairies
 
#include <stdlib.h>
#include <stdio.h>
#include <gtk/gtk.h>
#include <gdk/gdkgl.h>
#include <gtk/gtkgl.h>
 
//headers
#include "carte.h"
#include "main.h"
 
//variables
GtkWidget * fenetre;					// le widget qui va servir de fenetre
GtkWidget * gl;
 
int main (int argc, char *argv[])//principal
{
    printf("********** start here ****************************\n\n");
    //initialisation GTK+ et openGL
    gtk_init(&argc,&argv);
    //gtk_gl_init_check(&argc,&argv);
    //glutInit(&argc,argv);
    //GUI
    buildGui();
    gtk_widget_show_all(GTK_WIDGET (fenetre));
    gtk_widget_queue_draw(GTK_WIDGET(gl));
    //main loop
    gtk_main ();
    return 0;
}
 
//fonctions principales
void buildGui(void) //construction de l'interface graphique
{
    GdkGLConfig * config;
    //fenetre principale *************************
    fenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(fenetre), "cartographie astronomique");
    gtk_window_set_default_size(GTK_WINDOW(fenetre), 1000, 800);
    gtk_window_set_position (GTK_WINDOW (fenetre), GTK_WIN_POS_NONE);
    //connections
    g_signal_connect(GTK_OBJECT(fenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);//quitter
    g_signal_connect(GTK_OBJECT(fenetre), "delete_event",	G_CALLBACK(gtk_main_quit), NULL);
    //carte du ciel
    gl = gtk_drawing_area_new();
    //OpenGL via Gtkglext
    config = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE);
    gtk_widget_set_gl_capability(GTK_WIDGET(gl), config, NULL, TRUE, GDK_GL_RGBA_TYPE);
    //signaux
    gtk_signal_connect (GTK_OBJECT (gl), "realize", G_CALLBACK(Carte_realize), NULL);
    gtk_signal_connect (GTK_OBJECT (gl), "expose_event", G_CALLBACK(Carte_expose_event), NULL);
    gtk_signal_connect (GTK_OBJECT (gl), "configure_event", G_CALLBACK(Carte_configure_event), NULL);
    gtk_signal_connect (GTK_OBJECT (gl), "motion_notify_event", G_CALLBACK(Carte_motion_notify_event), NULL);
    gtk_signal_connect (GTK_OBJECT (gl), "button_press_event", G_CALLBACK(Carte_button_press_event), NULL);
    gtk_signal_connect (GTK_OBJECT (gl), "button_release_event", G_CALLBACK(Carte_button_release_event), NULL);
    gtk_signal_connect (GTK_OBJECT (gl), "key_press_event", G_CALLBACK(Carte_key_press_event), NULL);
    gtk_signal_connect (GTK_OBJECT (gl), "key_release_event", G_CALLBACK(Carte_key_release_event), NULL);
    gtk_widget_set_events (gl, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
        | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
    //GTK_WIDGET_SET_FLAGS (gui->da_Carte, GTK_CAN_FOCUS);//permettre le signal key press et key release
    gtk_container_add(GTK_CONTAINER(fenetre), GTK_WIDGET(gl));
}

carte.c

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
/******************************************************
* fonctions connectées aux signaux de la drawing_area *
******************************************************/
 
// librairies//
#ifdef WIN32
#include <windows.h>
#endif
 
#include <GL/gl.h>
#include <GL/glu.h>
#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include <gdk/gdkgl.h>
#include <gtk/gtkgl.h>
 
//headers autres/
#include "gl.h"
#include "carte.h"
 
static int KeyPressed = 0;//les touches du clavier
static int ButPressed = 0;//bouton de la souris
static int processing = 0;
static int Souris[2]; //position actuelle de la souris
 
gint Carte_realize (GtkWidget *widget, gpointer data) //premiere apparition du widget
{
    printf("realize\n");
    //récupération du contexte
    GdkGLContext *contexte = gtk_widget_get_gl_context(GTK_WIDGET(widget));
    GdkGLDrawable *surface = gtk_widget_get_gl_drawable(GTK_WIDGET(widget));
    //activation du contexte
    if(gdk_gl_drawable_gl_begin(surface,contexte))
    {
        init();//init openGL
        gdk_gl_drawable_gl_end(surface);// désactivation du contexte
    }
 
    return TRUE;
}
 
gint Carte_configure_event (GtkWidget *widget, GdkEventConfigure *event, gpointer data) //en cas de redimensionnement
{
    printf("configure\n");
    //récupération du contexte
    GdkGLContext *contexte = gtk_widget_get_gl_context(GTK_WIDGET(widget));
    GdkGLDrawable *surface = gtk_widget_get_gl_drawable(GTK_WIDGET(widget));
    //activation du contexte
    if(gdk_gl_drawable_gl_begin(surface,contexte))
    {
        reshape(event->height, event->width);//redimensionnement
        gdk_gl_drawable_gl_end(surface);// désactivation du contexte
    }
    return TRUE;
}
 
gint Carte_expose_event (GtkWidget *widget, gpointer data)//Redessine la zone de dessin en fonction du tracé
{
    printf("expose\n");
    printf("%p pt\n",widget);
    GdkGLContext *contexte1 = gtk_widget_get_gl_context(GTK_WIDGET(widget));
    GdkGLDrawable *surface1 = gtk_widget_get_gl_drawable(GTK_WIDGET(widget));
    //activation du contexte
    if(gdk_gl_drawable_gl_begin(surface1,contexte1))
    {
        draw();//dessin openGL
        gdk_gl_drawable_swap_buffers(surface1);//permutation des tampons
        gdk_gl_drawable_gl_end(surface1);// désactivation du contexte
    }
    return TRUE;
}
 
gint Carte_button_press_event (GtkWidget *widget, GdkEventButton *event)//si on appuis sur le bouton de la souris
{
    ButPressed = 1;
    gtk_grab_add(widget);
    return TRUE;
}
 
gint Carte_button_release_event (GtkWidget *widget, GdkEventButton *event)//si on relache le bouton
{
    ButPressed = 0;
    processing = 0;
    gtk_grab_remove(widget);
    return TRUE;
}
 
gint Carte_motion_notify_event (GtkWidget *widget, GdkEventMotion *event)//si on déplace la souris
{
    gtk_widget_get_pointer(widget, &Souris[0], &Souris[1]);//position de la souris
    if(ButPressed)gtk_widget_queue_draw(GTK_WIDGET(widget));
    return TRUE;
}
 
gint Carte_key_press_event (GtkWidget *widget, GdkEventKey *event)//gestion du clavier
{
    processing = 1;
    return TRUE;
}
 
gint Carte_key_release_event (GtkWidget *widget, GdkEventKey *event)
{
    processing = 0;
    KeyPressed = 0;
    return TRUE;
}

et gl.c

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
/****************************
* fonctions openGL dessin...*
****************************/
 
 
// librairies//
#ifdef WIN32
#include <windows.h>
#endif
 
#include <stdlib.h>
#include <stdio.h>
#include <GL/gl.h>
#include <GL/glu.h>
//#include <GL/glut.h>
 
//headers autres/
#include "gl.h"
 
void init() //initialisation openGL
{
	glClearColor(0.0,0.0,0.0,0.0);
	glShadeModel(GL_SMOOTH);
	glEnable(GL_DEPTH_TEST);
 
 }
 
void reshape(int height, int width)
{
	glViewport(0,0,width,height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(60.0,(GLfloat)width/(GLfloat)height,1.0,1000000.0);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}
 
void draw()
{
	printf("draw !\n");
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
	gluLookAt(0.0,0.0,30.0,0.0,0.0,-1.0,0.0,1.0,0.0);
	glBegin(GL_QUADS);
 
		glColor3f(1.0,0.0,0.0);
		glVertex3f(-10.0,-10.0,0.0);
		glColor3f(0.0,1.0,0.0);
		glVertex3f(-10.0,10.0,0.0);
		glColor3f(0.0,0.0,1.0);
		glVertex3f(10.0,10.0,0.0);
		glColor3f(1.0,1.0,0.0);
		glVertex3f(10.0,-10.0,0.0);
 
	glEnd();
}

J'obtiens une drawingarea transparente qui réagit à la souris mais qui n'affiche rien du tout :calim2:

J'arrive pas à trouver mon erreur...
:cry: surtout que tout bien marche sur linux :arf: et que j'ai un exemple quasi identique qui marche correctement sous windows :arf:

en fait, pour afficher quelques chose d'openGL, je suis obliger de garder dans mon main :

Code:

gtk_idle_add(idling,(gpointer)gl);

et
Code:

1 2 3 4 5 gboolean idling(gpointer data) { gtk_widget_queue_draw(GTK_WIDGET(data)); return TRUE; }
Il n'y a pas moyen de se passer de cette fonction ???
en plus, ça rame sec... :cfou:

Ah oui si tu utilises des threads avec gtk+ et que tu ajoutes en plus de l'opengl, il faut faire très attention à ce que tu fais :)

oui, j'ai l'habitude de travailler sous linux et cette fonction n'est pas nécessaire... du coup, j'ai pris l'habitude de m'en passer.

Je pense que je peut mettre résolu du coup.

La migration vers windows est un peu hard ! J'ai plein de problèmes que j'avais pas avant.
même avec des fread :aie:

Je donne plus de précision sur ce problèmes pour ceux qui le rencontrerait.
L'ajout du rafraichissement avec une fonction idle() ne faisait que "cacher la misère" ! Le problème vient de Vista :mouarf: :mouarf: :mouarf:

Il faut désactiver aero qui bouffe quasi toutes les performances 3D.
clique-droit sur le bureau->personaliser->Couleur et apparence des fenetre->Modèle de couleurs : mettre Windows Vista Basic.

Et la ça tourne.... :ccool: sans idle