/*** *** The "configure_event" signal handler. Any processing required when *** the OpenGL-capable drawing area is re-configured should be done here. *** Almost always it will be used to resize the OpenGL viewport when *** the window is resized. ***/ static gboolean configure_event (GtkWidget *widget, GdkEventConfigure *event, gpointer data) { GtkAllocation allocation; GdkGLContext *glcontext = gtk_widget_get_gl_context (widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget); GLfloat w; GLfloat h; gtk_widget_get_allocation (widget, &allocation); w = allocation.width; h = allocation.height; /*** OpenGL BEGIN ***/ if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext)) return FALSE; glViewport (0, 0, (GLsizei) w, (GLsizei) h); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glOrtho (-50.0, 50.0, -50.0, 50.0, -1.0, 1.0); glMatrixMode (GL_MODELVIEW); glLoadIdentity (); gdk_gl_drawable_gl_end (gldrawable); /*** OpenGL END ***/ return TRUE; }
/* When GLArea widget size changes, viewport size is set to match the new size */ static gint reshape(GtkWidget *widget, GdkEventConfigure *event) { GdkGLContext *glcontext = gtk_widget_get_gl_context (widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget); if(!GTK_IS_WIDGET(widget)) return TRUE; if(!GTK_WIDGET_REALIZED(widget)) return TRUE; if (gdk_gl_drawable_gl_begin (gldrawable, glcontext)) { /* pthread_mutex_lock (&theRender_mutex);*/ glViewport(0,0, widget->allocation.width, widget->allocation.height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); if(perspective) mYPerspective(Zoom,(GLdouble)widget->allocation.width/(GLdouble)widget->allocation.height,zNear,zFar); else { gdouble fw = (GLdouble)widget->allocation.width/(GLdouble)widget->allocation.height; gdouble fh = 1.0; glOrtho(-fw,fw,-fh,fh,-1,1); } glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gdk_gl_drawable_gl_end (gldrawable); /* pthread_mutex_unlock (&theRender_mutex);*/ gdk_window_invalidate_rect (gtk_widget_get_parent_window (widget), &widget->allocation, TRUE); gdk_window_process_updates (gtk_widget_get_parent_window (widget), TRUE); } return TRUE; }
static gboolean redraw(GtkWidget *drawing_area, GdkEventExpose *event, gpointer user_data) { GdkGLContext *gl_ctx = gtk_widget_get_gl_context(drawing_area); GdkGLDrawable *gl_dbl = gtk_widget_get_gl_drawable(drawing_area); UNUSED(event); UNUSED(user_data); if (!gdk_gl_drawable_gl_begin(gl_dbl, gl_ctx)) { printf("Can't start drawable :(\n"); exit(1); } /* Do drawing stuff */ if (redraw_func) redraw_func(); /* Finish up */ if (gdk_gl_drawable_is_double_buffered(gl_dbl)) gdk_gl_drawable_swap_buffers(gl_dbl); else glFlush(); gdk_gl_drawable_gl_end(gl_dbl); return TRUE; }
gboolean on_drawingarea1_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer user_data) { GdkGLContext *glcontext = gtk_widget_get_gl_context (widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget); /*** OpenGL BEGIN ***/ if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext)) return FALSE; glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glCallList (1); if (gdk_gl_drawable_is_double_buffered (gldrawable)) gdk_gl_drawable_swap_buffers (gldrawable); else glFlush (); gdk_gl_drawable_gl_end (gldrawable); /*** OpenGL END ***/ return FALSE; }
gboolean cb_glext2d_expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer user_data) { GdkGLContext *glcontext = gtk_widget_get_gl_context(widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget); if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext)) { return FALSE; } glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); // view transformation glLoadIdentity(); glTranslatef(trans_x, trans_y, -10.0); glScalef(view_scale, view_scale, view_scale); // render 2d scene viz->handler.render_2d_scene(); if (gdk_gl_drawable_is_double_buffered(gldrawable)) { gdk_gl_drawable_swap_buffers(gldrawable); } else { glFlush(); } gdk_gl_drawable_gl_end(gldrawable); return TRUE; }
static gboolean display (GtkWidget* widget, GdkEventExpose *event) { GdkGLContext* glcontext = gtk_widget_get_gl_context (widget); GdkGLDrawable* aldrawable = gtk_widget_get_gl_drawable (widget); gdk_gl_drawable_gl_begin (gldrawable, glcontext); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode (GL_MODELVIEW); glLoadIdentity (); gluLookAt (0.0, 30.0, 100.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); glPushMatrix (); glRotatef (angle, 0.0, 1.0, 0.0); glEnable (GL_COLOR_MATERIAL); glColor3f (0.9, 0.5, 0.2); gdk_gl_draw_teapot (TRUE, 25.0); glDisable (GL_COLOR_MATERIAL); glPopMatrix (); gdk_gl_drawable_swap_buffers (gldrawable); gdk_gl_drawable_gl_end (gldrawable); return TRUE; }
bool Render::on_expose_event(GdkEventExpose* event) { GdkGLContext *glcontext = gtk_widget_get_gl_context (get_widget()); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (get_widget()); if (!gldrawable || !gdk_gl_drawable_gl_begin (gldrawable, glcontext)) return false; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glLoadIdentity(); glTranslatef (0.0, 0.0, -2.0 * m_zoom); glMultMatrixf (m_transform.M); CenterView(); glPushMatrix(); glColor3f(0.75f,0.75f,1.0f); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1); Gtk::TreeModel::iterator iter = m_selection->get_selected(); m_view->Draw (iter); glPopMatrix(); if (gdk_gl_drawable_is_double_buffered(gldrawable)) gdk_gl_drawable_swap_buffers (gldrawable); else glFlush(); gdk_gl_drawable_gl_end (gldrawable); return true; }
static gboolean cb_draw_ext(GtkWidget *widget, GdkEventExpose *e, void *_object) { /* recuperation du contexte et de la surface de notre widget */ GdkGLContext *context; GdkGLDrawable *surface; //fprintf(stderr, "cb_draw_ext: %p\n", THIS); if (!gtk_widget_is_gl_capable(widget)) { fprintf(stderr, "not capable!\n"); return TRUE; } context = gtk_widget_get_gl_context(widget); surface = gtk_widget_get_gl_drawable(widget); /* activation du contexte */ if(gdk_gl_drawable_gl_begin(surface, context)) { //draw(); // dessin Opengl init_control(THIS); GB.Raise(THIS, EVENT_Draw, 0); gdk_gl_drawable_swap_buffers(surface); // permutation tampons gdk_gl_drawable_gl_end(surface); // désactivation du contexte } return TRUE; }
static void init_control(void *_object) { GdkGLContext *context; GdkGLDrawable *surface; GtkWidget *widget = THIS->widget; if (THIS->init) return; //fprintf(stderr, "init_control: %p\n", THIS); /* recuperation du contexte et de la surface de notre widget */ context = gtk_widget_get_gl_context(widget); surface = gtk_widget_get_gl_drawable(widget); /* activation du contexte */ if (gdk_gl_drawable_gl_begin(surface, context)) { GL.Init(); glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT); GB.Raise(THIS, EVENT_Open, 0); GB.Raise(THIS, EVENT_Resize, 0); gdk_gl_drawable_gl_end(surface); // désactivation du contexte } THIS->init = TRUE; return; }
static gboolean _chisel_native_openglview_configure_event( GtkWidget *widget, GdkEvent *event, gpointer native_data ) { if ( GTK_WIDGET_REALIZED(widget) ) { printf( "resize!\n" ); assert( gtk_widget_is_gl_capable( widget ) ); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable( widget ); GdkGLContext *glcontext = gtk_widget_get_gl_context( widget ); assert( gdk_gl_drawable_gl_begin( gldrawable, glcontext ) ); /*_chisel_native_openglview_reshape_callback( (native_handle)widget ); GtkAllocation allocation; gtk_widget_get_allocation( GTK_WIDGET(widget), &allocation );*/ glViewport (0, 0, widget->allocation.width, widget->allocation.height); gdk_gl_drawable_gl_end( gldrawable ); /*// now invalidate! Rect rect; rect.origin.x = 0;//allocation.x; rect.origin.y = 0;//allocation.y; rect.size.width = allocation.width; rect.size.height = allocation.height; _chisel_native_view_invalidate_rect( (native_handle)widget, rect );*/ } return TRUE; }
static gboolean expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer data) { /*** OpenGL BEGIN ***/ if (!gdk_gl_drawable_gl_begin (GDK_GL_DRAWABLE (glwindow), glcontext)) return FALSE; glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glCallList (1); if (gdk_gl_drawable_is_double_buffered (GDK_GL_DRAWABLE (glwindow))) gdk_gl_drawable_swap_buffers (GDK_GL_DRAWABLE (glwindow)); else glFlush (); gdk_gl_drawable_gl_end (GDK_GL_DRAWABLE (glwindow)); /*** OpenGL END ***/ return TRUE; }
static gboolean _chisel_native_openglview_expose_event( GtkWidget *widget, GdkEventExpose *event, gpointer native_data ) { if ( GTK_WIDGET_REALIZED(widget) ) { assert( gtk_widget_is_gl_capable( widget ) ); GdkGLContext *glcontext = gtk_widget_get_gl_context( widget ); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable( widget ); assert( gdk_gl_drawable_gl_begin( gldrawable, glcontext ) ); Rect rect; rect.origin.x = event->area.x; rect.origin.y = event->area.y; rect.size.width = event->area.width; rect.size.height = event->area.height; printf( "expose!\n" ); //_chisel_native_view_draw_rect_callback( (native_handle)widget, rect ); glViewport (0, 0, widget->allocation.width, widget->allocation.height); glClearColor( 0.0f, 0.0f, 1.0f, 1.0f ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); if (gdk_gl_drawable_is_double_buffered (gldrawable)) gdk_gl_drawable_swap_buffers (gldrawable); else glFlush (); gdk_gl_drawable_gl_end( gldrawable ); } return TRUE; }
void CGLDrawingArea::GTK_EndGL() /***************************************/ { GtkWidget* widget = reinterpret_cast<GtkWidget*>(gobj()); GdkGLDrawable* gldrawable = gtk_widget_get_gl_drawable (widget); gdk_gl_drawable_gl_end (gldrawable); }
/*** *** The "draw" signal handler. All the OpenGL re-drawing should *** be done here. This is repeatedly called as the painting routine *** every time the 'draw' event is signalled. ***/ static gboolean draw (GtkWidget *widget, cairo_t *cr, gpointer data) { GdkGLContext *glcontext = gtk_widget_get_gl_context (widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget); /*** OpenGL BEGIN ***/ if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext)) return FALSE; glClear (GL_COLOR_BUFFER_BIT); glPushMatrix (); glRotatef (spin, 0.0, 0.0, 1.0); glColor3f (1.0, 1.0, 1.0); glRectf (-25.0, -25.0, 25.0, 25.0); glPopMatrix (); /* Swap buffers */ if (gdk_gl_drawable_is_double_buffered (gldrawable)) gdk_gl_drawable_swap_buffers (gldrawable); else glFlush (); gdk_gl_drawable_gl_end (gldrawable); /*** OpenGL END ***/ return TRUE; }
static gboolean configure (GtkWidget *da, GdkEventConfigure *event, gpointer user_data) { GdkGLContext *glcontext = gtk_widget_get_gl_context (da); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (da); if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext)) { g_assert_not_reached (); } glLoadIdentity(); glMatrixMode(GL_PROJECTION); // Select The Projection Matrix glLoadIdentity(); glViewport (0, 0, da->allocation.width, da->allocation.height); glFrustum(-1,1,-1,1,100,100); glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix glLoadIdentity(); glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glScalef (.5,.5,.5); gdk_gl_drawable_gl_end (gldrawable); return TRUE; }
static gboolean cb_reshape_ext(GtkWidget *widget, GdkEventConfigure *ev, void *_object) { /* recuperation du contexte et de la surface de notre widget */ GdkGLContext *context; GdkGLDrawable *surface; if (!THIS->init) return TRUE; //fprintf(stderr, "cb_reshape_ext: %p\n", THIS); if (!gtk_widget_is_gl_capable(widget)) { fprintf(stderr, "not capable!\n"); return TRUE; } context = gtk_widget_get_gl_context(widget); surface = gtk_widget_get_gl_drawable(widget); /* activation du contexte */ if(gdk_gl_drawable_gl_begin(surface, context)) { //reshape(ev−>height,ev−>width); // redimensionnement Opengl GB.Raise(THIS, EVENT_Resize, 0); gdk_gl_drawable_gl_end(surface); // désactivation du contexte } return TRUE; }
static gboolean reshape (GtkWidget* widget, GdkEventConfigure* event) { GdkGLContext* glcontext = gtk_widget_get_gl_context (widget); GdkGLDrawable* gldrawable = gtk_widget_get_gl_drawable (widget); int w = event->width; int h = event->height; gdk_gl_drawable_gl_begin (gldrawable, glcontext); glClearColor (1.0, 1.0, 1.0, 0.0); glShadeModel (GL_SMOOTH); glCullFace (GL_FRONT); glEnable (GL_CULL_FACE); glEnable (GL_DEPTH_TEST); GLfloat light_position[] = {10000.0, 10000.0, 10000.0, 0.0}; GLfloat light_ambient[] = {0.2, 0.2, 0.2, 1.0}; GLfloat light_diffuse[] = {1.0, 1.0, 1.0, 1.0}; glLightfv (GL_LIGHT0, GL_POSITION, light_position); glLightfv (GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv (GL_LIGHT0, GL_DIFFUSE, light_diffuse); glEnable (GL_LIGHTING); glEnable (GL_LIGHTING); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glViewport (0, 0, w, h); gluPerspective (40.0, (w / (double)h), 1.0, 1000.0); gdk_gl_drawable_gl_end (gldrawable); return TRUE; }
static gboolean configure_event(GtkWidget * widget, GdkEventConfigure * UNUSED(eventDetails), const GraphData * gd) { int width, height; float maxY, maxX; GtkAllocation allocation; GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget); if (!gdk_gl_drawable_gl_begin(gldrawable, gtk_widget_get_gl_context(widget))) return FALSE; gtk_widget_get_allocation(widget, &allocation); width = allocation.width; height = allocation.height; maxX = (float) gd->numGames * RES_WIDTH + RES_WIDTH + TOTAL_GAP; modelWidth = maxX * (1 + NUM_WIDTH_PER); maxY = gd->maxY * 1.05f + 1; modelHeight = maxY * (1 + NUM_HEIGHT_PER); glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, (double) modelWidth, 0.0, (double) modelHeight, -1.0, 0.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gdk_gl_drawable_gl_end(gldrawable); return TRUE; }
static gboolean expose( GtkWidget* da, GdkEventConfigure* event, gpointer user_data ) { GdkGLContext *GLcontext = gtk_widget_get_gl_context( da ); GdkGLDrawable* GLdrawable = GDK_GL_DRAWABLE( gtk_widget_get_gl_window( da ) ); if( !gdk_gl_drawable_gl_begin( GLdrawable, GLcontext ) ) g_assert_not_reached(); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glPushMatrix(); glShadeModel( GL_FLAT ); glCallList( dl_index ); render(); glPopMatrix(); if( gdk_gl_drawable_is_double_buffered( GLdrawable) ) gdk_gl_drawable_swap_buffers( GLdrawable ); else glFlush(); gdk_gl_drawable_gl_end( GLdrawable ); return TRUE; }
static gboolean darxen_splash_darea_realize(GtkWidget *widget) { GdkGLContext *glcontext; GdkGLDrawable *gldrawable; g_return_val_if_fail(GTK_IS_DRAWING_AREA(widget), TRUE); glcontext = gtk_widget_get_gl_context(widget); gldrawable = gtk_widget_get_gl_drawable(widget); if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext)) return TRUE; glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glSettings->glShareList = glcontext; darxen_renderer_shared_init_text(); settings_set_gl(glSettings); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glClearColor(0.0, 0.0, 0.0, 0.0); gdk_gl_drawable_gl_end(gldrawable); return FALSE; }
void on_drawingarea1_realize (GtkWidget *widget, gpointer user_data) { GdkGLContext *glcontext = gtk_widget_get_gl_context (widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget); GLUquadricObj *qobj; static GLfloat red[] = {1.0, 0.0, 0.0, 1.0}; /*** OpenGL BEGIN ***/ if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext)) return; /* Create display list #1 */ qobj = gluNewQuadric (); gluQuadricDrawStyle (qobj, GLU_FILL); glNewList (1, GL_COMPILE); gluSphere (qobj, 1.0, 20, 20); glEndList (); /* Initialize rendering context */ init_gl (red); gdk_gl_drawable_gl_end (gldrawable); /*** OpenGL END ***/ }
static gboolean darxen_splash_darea_expose(GtkWidget *widget, GdkEventExpose *event) { GdkGLContext *glcontext; GdkGLDrawable *gldrawable; glcontext = gtk_widget_get_gl_context(widget); gldrawable = gtk_widget_get_gl_drawable(widget); if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext)) return TRUE; glClear(GL_COLOR_BUFFER_BIT); darxen_splash_darea_draw(); /* This code was fun, but no int i; for (i = 190; i > 4; i -= 10) { int x = g_random_int_range(0, 300 - i); int y = g_random_int_range(0, 200 - i); glColor4d(g_random_double_range(0.2, 1.0),g_random_double_range(0.2, 1.0),g_random_double_range(0.3, 1.0),g_random_double_range(0.5, 1.0)); glRecti(x, y, i, i); } */ gdk_gl_drawable_swap_buffers(gldrawable); gdk_gl_drawable_gl_end(gldrawable); return FALSE; }
gboolean cb_glext2d_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data) { GdkGLContext *glcontext = gtk_widget_get_gl_context(widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget); GLfloat w = widget->allocation.width; GLfloat h = widget->allocation.height; GLfloat aspect; if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext)) { return FALSE; } glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (w > h) { aspect = w / h; glFrustum(-aspect, aspect, 1.0, -1.0, 5.0, 60.0); } else { aspect = h / w; glFrustum(-1.0, 1.0, aspect, -aspect, 5.0, 60.0); } glMatrixMode(GL_MODELVIEW); gdk_gl_drawable_gl_end(gldrawable); return FALSE; }
static gboolean configure(GtkWidget *widget, GdkEventConfigure *event) { GtkAllocation allocation; GdkGLContext *glcontext; GdkGLDrawable *gldrawable; g_return_val_if_fail(widget && event, FALSE); glcontext = gtk_widget_get_gl_context(widget); gldrawable = gtk_widget_get_gl_drawable(widget); gtk_widget_get_allocation (widget, &allocation); /*** OpenGL BEGIN ***/ if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext)) goto NO_GL; glViewport (0, 0, allocation.width, allocation.height); gdk_gl_drawable_gl_end(gldrawable); /*** OpenGL END ***/ NO_GL: return TRUE; }
/* new window size or exposure */ static gboolean reshape (GtkWidget *widget, GdkEventConfigure *event, gpointer data) { GtkAllocation allocation; GdkGLContext *glcontext = gtk_widget_get_gl_context (widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget); GLfloat h; gtk_widget_get_allocation (widget, &allocation); h = (GLfloat) (allocation.height) / (GLfloat) (allocation.width); /*** OpenGL BEGIN ***/ if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext)) return FALSE; glViewport (0, 0, allocation.width, allocation.height); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glFrustum (-1.0, 1.0, -h, h, 5.0, 60.0); glMatrixMode (GL_MODELVIEW); glLoadIdentity (); glTranslatef (0.0, 0.0, -40.0); gdk_gl_drawable_gl_end (gldrawable); /*** OpenGL END ***/ return TRUE; }
/* set up GL for window size changes, run this when necesary (when window size or monitor resolution is changed) params:gtk opgn gl canvas , GdkEventConfigure object to retrieve window dimensions and custom data return value:true or false, fails (false) if cannot init gl */ static gboolean configure_event(GtkWidget * widget, GdkEventConfigure * event, gpointer data) { int vPort[4]; float aspect; GdkGLContext *glcontext = gtk_widget_get_gl_context(widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget); view->w = widget->allocation.width; view->h = widget->allocation.height; /*** OpenGL BEGIN ***/ if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext)) return FALSE; glViewport(0, 0, view->w, view->h); /* get current viewport */ glGetIntegerv(GL_VIEWPORT, vPort); /* setup various opengl things that we need */ glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (view->w > view->h) { aspect = (float) view->w / (float) view->h; glOrtho(-aspect * GL_VIEWPORT_FACTOR, aspect * GL_VIEWPORT_FACTOR, GL_VIEWPORT_FACTOR * -1, GL_VIEWPORT_FACTOR, -1500, 1500); } else { aspect = (float) view->h / (float) view->w; glOrtho(GL_VIEWPORT_FACTOR * -1, GL_VIEWPORT_FACTOR, -aspect * GL_VIEWPORT_FACTOR, aspect * GL_VIEWPORT_FACTOR, -1500, 1500); } glMatrixMode(GL_MODELVIEW); gdk_gl_drawable_gl_end(gldrawable); /*** OpenGL END ***/ return TRUE; }
int main(int argc, char **argv) { gtk_init(&argc, &argv); GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL); GtkWidget *drawing = gtk_drawing_area_new(); GdkGLConfig *glconfig = gdk_gl_config_new_by_mode((GdkGLConfigMode)( GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA)); g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(window, "key-press-event", G_CALLBACK(on_key_press), NULL); g_signal_connect(drawing, "expose-event", G_CALLBACK(on_expose), NULL); g_signal_connect(drawing, "configure-event", G_CALLBACK(on_configure), NULL); gtk_widget_set_gl_capability(drawing, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE); gtk_container_add(GTK_CONTAINER(window), drawing); gtk_widget_show_all(window); /* OpenGL setup */ GdkGLContext *glcontext = gtk_widget_get_gl_context(GTK_WIDGET(drawing)); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(drawing)); gdk_gl_drawable_gl_begin(gldrawable, glcontext); /* Go */ gtk_main(); gdk_gl_drawable_gl_end(gldrawable); }
static gboolean expose (GtkWidget *da, GdkEventExpose *event, gpointer user_data) { GdkGLContext *glcontext = gtk_widget_get_gl_context (da); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (da); if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext)) { g_assert_not_reached (); } /* draw in here */ openglrender(); /* end */ if (gdk_gl_drawable_is_double_buffered (gldrawable)) gdk_gl_drawable_swap_buffers (gldrawable); else glFlush (); gdk_gl_drawable_gl_end (gldrawable); return TRUE; }
void SludgeGLApplication::on_drawingarea1_realize(GtkWidget *theWidget) { GdkGLContext *glContext; GdkGLDrawable *glDrawable; if (theWidget->window == NULL) { return; } gtk_widget_add_events(theWidget, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK); glContext = gtk_widget_get_gl_context (theWidget); glDrawable = gtk_widget_get_gl_drawable (theWidget); // Signal to gdk the start OpenGL operations. if (!gdk_gl_drawable_gl_begin (glDrawable, glContext)) { return; } glViewport (0, 0, theWidget->allocation.width, theWidget->allocation.height); /* Your one-time OpenGL initialization code goes here */ x = y = 0; w = theWidget->allocation.width; h = theWidget->allocation.height; prepareOpenGL(); // Signal to gdk we're done with OpenGL operations. gdk_gl_drawable_gl_end (glDrawable); gdk_window_invalidate_rect (gtk_widget_get_parent_window (theWidget), &theWidget->allocation, TRUE); }
static void realize (GtkWidget *widget, gpointer data) { GdkGLContext *glcontext = gtk_widget_get_gl_context (widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget); static GLfloat ambient[] = { 0.0, 0.0, 0.0, 1.0 }; static GLfloat diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; static GLfloat position[] = { 1.0, 1.0, 1.0, 0.0 }; static GLfloat lmodel_ambient[] = {0.2, 0.2, 0.2, 1.0}; static GLfloat local_view[] = {0.0}; /*** OpenGL BEGIN ***/ if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext)) return; glLightfv (GL_LIGHT0, GL_AMBIENT, ambient); glLightfv (GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv (GL_LIGHT0, GL_POSITION, position); glLightModelfv (GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv (GL_LIGHT_MODEL_LOCAL_VIEWER, local_view); glEnable (GL_LIGHTING); glEnable (GL_LIGHT0); glEnable (GL_DEPTH_TEST); glClearColor (1.0, 1.0, 1.0, 1.0); glClearDepth (1.0); gdk_gl_drawable_gl_end (gldrawable); /*** OpenGL END ***/ }