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;
}
gboolean browser_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data)
{
GdkGLContext *context = gtk_widget_get_gl_context(widget);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget);
if (!gdk_gl_drawable_gl_begin(gldrawable, context))
return false;
glViewport(0, 0, widget->allocation.width, widget->allocation.height);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0f, widget->allocation.width, widget->allocation.height, 0.0f, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gdk_gl_drawable_gl_end(gldrawable);
rows = (tex_names.size() / browser_columns) + 1;
int width = widget->allocation.width / browser_columns;
int rows_page = widget->allocation.height / width;
gtk_range_set_range(GTK_RANGE(browse_vscroll), 0.0, (rows * width) - widget->allocation.height);
scroll_to_selected_texture(widget);
return true;
}
static gboolean expose(GtkWidget* widget, GdkEventExpose* e, gpointer data)
{
struct program *p = (struct program *)data;
GdkGLContext* context = gtk_widget_get_gl_context(widget);
GdkGLDrawable* drawable = gtk_widget_get_gl_drawable(widget);
(void)e;
p->draw.width = widget->allocation.width;
p->draw.height = widget->allocation.height;
if (!gdk_gl_drawable_gl_begin(drawable, context))
return FALSE;
if (p->viewed.type == TYPE_TEXTURE)
texture_draw(p);
else
draw_tri(p);
if (gdk_gl_drawable_is_double_buffered (drawable))
gdk_gl_drawable_swap_buffers(drawable);
else
glFlush();
gdk_gl_drawable_gl_end(drawable);
return TRUE;
}
void realizeOpenGL(struct OpenGL* ogl, long long gtkWindow_) {
GtkWidget* window = GTK_WIDGET((void*) gtkWindow_);
GdkGLConfig
* config = gdk_gl_config_new_by_mode_for_screen(
gdk_screen_get_default(), GDK_GL_MODE_RGB
| GDK_GL_MODE_SINGLE/*| GDK_GL_MODE_DOUBLE*/);
if (config == NULL)
return;
//printf("ogl=%p\n", ogl);
ogl->config = config;
gtk_widget_unrealize(window);
if (!gtk_widget_set_gl_capability(window, ogl->config, NULL, FALSE,
GDK_GL_RGBA_TYPE)) {
fprintf(stderr, "Cannot enable GDKGL on window");
return;
}
gtk_widget_realize(window);
GdkGLDrawable* drawable = gtk_widget_get_gl_drawable(GTK_WIDGET(window));
ogl->drawable = drawable;
ogl->widget = GTK_WIDGET(window);
ogl->context = gtk_widget_get_gl_context(ogl->widget);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, GL_SHORT, 0, ogl->vertices);
//gdk_gl_drawable_gl_begin(ogl->drawable, ogl->context);
}
CV_IMPL void cvSetOpenGlContext(const char* name)
{
CvWindow* window;
GdkGLContext* glcontext;
GdkGLDrawable* gldrawable;
CV_FUNCNAME( "cvSetOpenGlContext" );
__BEGIN__;
if(!name)
CV_ERROR( CV_StsNullPtr, "NULL name string" );
window = icvFindWindowByName( name );
if (!window)
CV_ERROR( CV_StsNullPtr, "NULL window" );
if (!window->useGl)
CV_ERROR( CV_OpenGlNotSupported, "Window doesn't support OpenGL" );
glcontext = gtk_widget_get_gl_context(window->widget);
gldrawable = gtk_widget_get_gl_drawable(window->widget);
if (!gdk_gl_drawable_make_current(gldrawable, glcontext))
CV_ERROR( CV_OpenGlApiCallError, "Can't Activate The GL Rendering Context" );
__END__;
}
/* 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;
}
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
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;
}
/*
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;
}
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;
}
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;
}
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 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 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;
}
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
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;
}
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
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;
}
/* 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 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 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;
}
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;
}
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);
}
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;
}
void OpenGLExampleX11::renderThread()
{
GdkGLContext *glcontext = gtk_widget_get_gl_context(drawing_area);
try {
while (!boost::this_thread::interruption_requested()) {
gdk_threads_enter();
GdkGLDrawable *gld = gtk_widget_get_gl_drawable (drawing_area);
gdk_gl_drawable_make_current(gld, glcontext);
gboolean tmp = gdk_gl_drawable_gl_begin(gld, glcontext);
FBLOG_WARN("", "Setting current context to widget. glbegin was " << tmp);
//render();
gdk_gl_drawable_gl_end(gld);
//FBLOG_INFO("", "Got drawable: " << gld);
//if (gdk_gl_drawable_is_double_buffered (gld)) {
//gdk_gl_drawable_swap_buffers (gld);
//} else {
//glFlush();
//}
gdk_flush();
gdk_threads_leave();
boost::this_thread::sleep(boost::posix_time::milliseconds(200));
}
} catch (const boost::thread_interrupted&) {
}
FBLOG_WARN("", "Thread stop signaled");
FBLOG_WARN("", "Thread stopping");
}
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 void on_realize(GritsTester *tester, gpointer _)
{
g_debug("GritsTester: on_realize");
/* Start OpenGL */
GdkGLContext *glcontext = gtk_widget_get_gl_context(GTK_WIDGET(tester));
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(tester));
if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
g_assert_not_reached();
/* Connect signals and idle functions now that opengl is fully initialized */
g_object_set(tester, "can-focus", TRUE, NULL);
gtk_widget_add_events(GTK_WIDGET(tester), GDK_KEY_PRESS_MASK);
g_signal_connect(tester, "configure-event", G_CALLBACK(on_configure), NULL);
g_signal_connect(tester, "expose-event", G_CALLBACK(on_expose), NULL);
g_signal_connect(tester, "key-press-event", G_CALLBACK(on_key_press), NULL);
/* Re-queue resize incase configure was triggered before realize */
gtk_widget_queue_resize(GTK_WIDGET(tester));
/* Setup model view matrix */
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslated(0, 0, -2);
}
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;
}
void draw_gl_end(struct program *p)
{
GtkWidget *widget = GTK_WIDGET(p->main.draw);
GdkGLDrawable* drawable = gtk_widget_get_gl_drawable(widget);
gdk_gl_drawable_gl_end(drawable);
}
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;
}
