/***
*** 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 ***/
}
