/***
*** 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);
guint count;
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;
/* Reallocate the brush stroke list. */
for (count=0; count<g_list_length(brushStrokeList); count++)
{
g_free(g_list_nth_data(brushStrokeList, count));
}
g_list_free(brushStrokeList);
brushStrokeList = NULL;
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, w, 0.0, h, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gdk_gl_drawable_gl_end (gldrawable);
/*** OpenGL END ***/
return TRUE;
}
/*
expose function.real drawing takes place here,
params:gtk opgn gl canvas , GdkEventExpose object and custom data
return value:true or false, fails (false) if cannot init gl
*/
gboolean expose_event(GtkWidget * widget, GdkEventExpose * event,
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 | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glexpose_main(view); //draw all stuff
/* 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;
}
/***
*** The "realize" signal handler. All the OpenGL initialization
*** should be performed here, such as default background colour,
*** certain states etc.
***/
static void
realize (GtkWidget *widget,
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;
/*** Fill in the details here. ***/
glClearColor(1.0,1.0,1.0,1.0);
glClearDepth(1.0);
gdk_gl_drawable_gl_end (gldrawable);
/*** OpenGL END ***/
return;
}
static gboolean
configure_event (GtkWidget *widget,
GdkEventConfigure *event,
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;
glViewport (0, 0,
widget->allocation.width, widget->allocation.height);
gdk_gl_drawable_gl_end (gldrawable);
/*** OpenGL END ***/
return TRUE;
}
static gboolean resize(GtkWidget *drawing_area, GdkEventConfigure *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);
}
if (resize_func)
resize_func(drawing_area->allocation.width, drawing_area->allocation.height);
gdk_gl_drawable_gl_end(gl_dbl);
return TRUE;
}
static gboolean
expose_event (GtkWidget *widget,
GdkEventExpose *event,
gpointer data)
{
GtkAllocation allocation;
GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
gtk_widget_get_allocation (widget, &allocation);
/*** OpenGL BEGIN ***/
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
return FALSE;
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* Sync. */
gdk_gl_drawable_wait_gl (gldrawable);
/* GDK rendering. */
gdk_draw_rectangle (GDK_DRAWABLE (gldrawable),
gtk_widget_get_style (widget)->black_gc,
TRUE,
allocation.width/10,
allocation.height/10,
allocation.width*8/10,
allocation.height*8/10);
/* Sync. */
gdk_gl_drawable_wait_gdk (gldrawable);
glCallList (1);
glFlush ();
gdk_gl_drawable_gl_end (gldrawable);
/*** OpenGL END ***/
return TRUE;
}
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);
GLsizei w;
GLsizei 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, w, h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective (2.0 * FOVY_2,
(GLfloat) w / (GLfloat) h,
Z_NEAR,
2.0 * Z_NEAR);
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
gluLookAt (0.0, 0.0, Z_NEAR,
0.0, 0.0, 0.0,
0.0, 1.0, 0.0);
glTranslatef (0.0, 0.0, -Z_NEAR);
gdk_gl_drawable_gl_end (gldrawable);
/*** OpenGL END ***/
return TRUE;
}
/***
*** The "expose_event" signal handler. All the OpenGL re-drawing should
*** be done here. This is repeatedly called as the painting routine
*** every time the 'expose'/'draw' event is signalled.
***/
static gboolean
expose_event (GtkWidget *widget,
GdkEventExpose *event,
gpointer data)
{
GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
guint count;
Point* coord;
/*** OpenGL BEGIN ***/
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
return FALSE;
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* Set the foreground colour. */
glColor3f(0.0,0.0,0.0);
/* Draw the list of brush strokes. */
for (count=0; count<g_list_length(brushStrokeList); count++)
{
coord = g_list_nth_data(brushStrokeList, count);
glRecti(coord->x + thickness,
coord->y - thickness,
coord->x - thickness,
coord->y + thickness);
}
/* 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 on_configure_listing (GtkWidget* pWidget, GdkEventConfigure* pEvent, CDListing *pListing)
{
gint iNewWidth, iNewHeight;
if (pListing->container.bIsHorizontal)
{
pListing->container.iWindowPositionX = pEvent->x;
pListing->container.iWindowPositionY = pEvent->y;
iNewWidth = pEvent->width;
iNewHeight = pEvent->height;
}
else
{
pListing->container.iWindowPositionX = pEvent->y;
pListing->container.iWindowPositionY = pEvent->x;
iNewWidth = pEvent->height;
iNewHeight = pEvent->width;
}
if (pListing->container.iWidth != iNewWidth || pListing->container.iHeight != iNewHeight)
{
pListing->container.iWidth = iNewWidth;
pListing->container.iHeight = iNewHeight;
if (g_bUseOpenGL && pListing->container.glContext)
{
GdkGLContext* pGlContext = gtk_widget_get_gl_context (pWidget);
GdkGLDrawable* pGlDrawable = gtk_widget_get_gl_drawable (pWidget);
GLsizei w = pEvent->width;
GLsizei h = pEvent->height;
if (!gdk_gl_drawable_gl_begin (pGlDrawable, pGlContext))
return FALSE;
glViewport(0, 0, w, h);
cairo_dock_set_ortho_view (w, h);
gdk_gl_drawable_gl_end (pGlDrawable);
}
}
return FALSE;
}
static void
realize(GtkWidget * widget, const GraphData * UNUSED(gd))
{
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget);
if (!gdk_gl_drawable_gl_begin(gldrawable, gtk_widget_get_gl_context(widget)))
return;
/* Deep blue background colour */
glClearColor(.2f, .2f, .4f, 1.f);
if (!CreateNumberFont(&numberFont, FONT_VERA, FONT_PITCH, FONT_SIZE, FONT_HEIGHT_RATIO))
g_print("Error creating font\n");
if (!CreateFontText(&totalText, _("Totals"), FONT_VERA, FONT_PITCH, FONT_SIZE, FONT_HEIGHT_RATIO))
g_print("Error creating font\n");
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
gdk_gl_drawable_gl_end(gldrawable);
/*** OpenGL END ***/
}
/// Returns a "global" (to the document) gdkgl context that can be used to share display lists
GdkGLContext* gdkgl_share_list()
{
if(!m_gdkgl_share_list)
{
GdkGLConfig* const config = gdk_gl_config_new_by_mode(
static_cast<GdkGLConfigMode>(GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE | GDK_GL_MODE_DEPTH));
return_val_if_fail(config, 0);
Gtk::Window* const window = new Gtk::Window();
gtk_widget_set_gl_capability(GTK_WIDGET(window->gobj()), config, 0, true, GDK_GL_RGBA_TYPE);
window->show();
window->hide();
GdkGLContext* const context = gtk_widget_get_gl_context(GTK_WIDGET(window->gobj()));
return_val_if_fail(context, 0);
m_gdkgl_share_list = context;
}
return m_gdkgl_share_list;
}
gint glarea_reshape (GtkWidget* widget, GdkEventConfigure* event, gpointer data) {
GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
gint w = widget->allocation.width;
gint h = widget->allocation.height;
gfloat aspect_ratio, actual_aspect_ratio = ((gfloat) w)/ (gfloat) h;
static gfloat epsilon = 0.01;
gl_preview_struct *glp = (gl_preview_struct *) data;
aspect_ratio = glp->cameras[glp->current_camera_id]->aspect_ratio;
// printf("*************RESHAPE\n");
// Keep the right ratio for the display area
/*** OpenGL BEGIN ***/
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
return FALSE;
if (ABS(aspect_ratio - actual_aspect_ratio) < epsilon) // Ratios are equal
glViewport (0,0, w, h);
else
if (actual_aspect_ratio > aspect_ratio) {
// Area widget too wide, we translate the viewport on the X axis
glViewport ( (gint) ((w-(gint) (aspect_ratio*(gfloat) h)) / 2.0), 0,
(gint) (aspect_ratio*(gfloat) h),h);
}
else { // Area widget too narrow, we translate the viewport on the Y axis
glViewport ( 0,(gint) ((h-(gint)( ((gfloat) w)/aspect_ratio) ) / 2.0),
w,(gint) ( ((gfloat) w)/aspect_ratio) );
}
gdk_gl_drawable_gl_end (gldrawable);
/*** OpenGL END ***/
return (TRUE);
}
gboolean GLWidget::onHierarchyChanged(GtkWidget* widget,
GtkWidget* previous_toplevel, GLWidget* self) {
if (previous_toplevel == NULL && !gtk_widget_is_gl_capable(widget)) {
// Create a new GL config structure
GdkGLConfig* glconfig = (self->_zBuffer) ? createGLConfigWithDepth()
: createGLConfig();
ASSERT_MESSAGE(glconfig != NULL, "failed to create OpenGL config");
gtk_widget_set_gl_capability(widget, glconfig,
g_shared != NULL ? gtk_widget_get_gl_context(g_shared) : NULL,
TRUE, GDK_GL_RGBA_TYPE);
gtk_widget_realize(widget);
// Shared not set yet?
if (g_shared == 0) {
g_shared = widget;
}
}
return FALSE;
}
static gboolean
configure_event (GtkWidget *widget,
GdkEventConfigure *event,
gpointer 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;
/*** OpenGL BEGIN ***/
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);
/*** 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();
glViewport (0, 0, da->allocation.width, da->allocation.height);
glOrtho (-10,10,-10,10,-20050,10000);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glScalef (10., 10., 10.);
gdk_gl_drawable_gl_end (gldrawable);
return TRUE;
}
static gboolean
darxen_splash_darea_configure(GtkWidget *widget, GdkEventConfigure *event)
{
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;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, event->width, event->height, 0, 1, -1);
glViewport(0, 0, event->width, event->height);
glMatrixMode(GL_MODELVIEW);
gdk_gl_drawable_gl_end(gldrawable);
return FALSE;
}
static void
realize (GtkWidget *widget,
gpointer data)
{
GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
GLUquadricObj *qobj;
static GLfloat light_diffuse[] = {1.0, 0.0, 0.0, 1.0};
static GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0};
/*** OpenGL BEGIN ***/
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
return;
qobj = gluNewQuadric ();
gluQuadricDrawStyle (qobj, GLU_FILL);
glNewList (1, GL_COMPILE);
gluSphere (qobj, 1.0, 20, 20);
glEndList ();
glLightfv (GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv (GL_LIGHT0, GL_POSITION, light_position);
glEnable (GL_LIGHTING);
glEnable (GL_LIGHT0);
glEnable (GL_DEPTH_TEST);
glClearColor (0.0, 0.0, 0.0, 0.0);
glClearDepth (1.0);
gdk_gl_drawable_gl_end (gldrawable);
/*** OpenGL END ***/
/* Get PangoFT2 context. */
ft2_context = pango_ft2_get_context (72, 72);
}
static gboolean on_expose_event (GtkWidget *widget, GdkEventExpose *event, 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 | GL_DEPTH_BUFFER_BIT);
// FIXME: draw stuff here.
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 TRUE;
}
void on_drawingArea_realize (GtkWidget *widget, GtkGui *gui)
{
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;
gdk_gl_drawable_gl_end (gldrawable);
}
extern "C" G_MODULE_EXPORT
gboolean on_drawingArea_expose_event (GtkWidget *widget,
GdkEventExpose *event __attribute__((unused)),
GtkGui *gui)
{
GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
{
printf ("error in gdk_gl_drawable_gl_begin\n");
return FALSE;
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
global_gui->draw_gl_components();
if (gdk_gl_drawable_is_double_buffered (gldrawable))
gdk_gl_drawable_swap_buffers (gldrawable);
else
glFlush ();
gboolean browser_expose_event(GtkWidget *w, GdkEventExpose *event, gpointer data)
{
int width = w->allocation.width / browser_columns;
rows = (tex_names.size() / browser_columns) + 1;
int top = gtk_range_get_value(GTK_RANGE(browse_vscroll));
// Set sizes for row and page steps (for the scrollbar)
int rows_page = w->allocation.height / width;
gtk_range_set_increments(GTK_RANGE(browse_vscroll), width, rows_page * width);
GdkGLContext *context = gtk_widget_get_gl_context(w);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(w);
if (!gdk_gl_drawable_gl_begin(gldrawable, context))
return false;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
int sel_index = -1;
int a = 0;
for (int row = 0; row < rows; row++)
{
for (int col = 0; col < browser_columns; col++)
{
if (a >= tex_names.size())
continue;
rect_t rect(col * width, (row * width) - top, width, width, 0);
glLineWidth(2.0f);
if (selected_tex == tex_names[a])
{
draw_rect(rect, rgba_t(0, 180, 255, 150, 0), true);
draw_rect(rect, rgba_t(100, 220, 255, 255, 0), false);
sel_index = a;
}
glLineWidth(1.0f);
rect.resize(-8, -8);
if (((row + 1) * width) > top && (row * width) < (top + w->allocation.height))
{
if (!browse_sprites)
{
if (tex_names[a] != "-")
draw_texture_scale(rect, tex_names[a], 0);
draw_text(rect.x1() + (width/2) - 8, rect.y2() - 4, rgba_t(255, 255, 255, 255, 0), 1, tex_names[a].c_str());
}
else
draw_texture_scale(rect, browsesprites[a], 3);
}
a++;
}
}
if (browse_sprites && sel_index != -1)
draw_text(0, 0, rgba_t(255, 255, 255, 255, 0), 0, tex_names[sel_index].c_str());
if (gdk_gl_drawable_is_double_buffered(gldrawable))
gdk_gl_drawable_swap_buffers(gldrawable);
else
glFlush();
gdk_gl_drawable_gl_end(gldrawable);
return false;
}
bool OpenGLExampleX11::onWindowAttached(FB::AttachedEvent *evt, FB::PluginWindowX11 *win)
{
FBLOG_WARN("", "AttachedEvent start");
// Initialize GTK/GDK on this thread
//boost::scoped_array<char> argv(new char[1][20]);
int argc = 0;
//strcpy(argv[0], "--sync");
//gboolean initSucceeded = gtk_init_check(&argc, argv.get());
gdk_threads_enter();
FBLOG_WARN("", "Starting Render Thread");
//gboolean initSucceeded = gdk_gl_init_check(&argc, NULL);
//FBLOG_WARN("", "gdk_gl_init_check returned " << initSucceeded);
drawing_area = gtk_drawing_area_new();
gtk_widget_set_size_request(drawing_area, 500, 500);
GdkGLConfigMode glconf = static_cast<GdkGLConfigMode>(
GDK_GL_MODE_RGB |
GDK_GL_MODE_DOUBLE |
GDK_GL_MODE_DEPTH
);
//FBLOG_WARN("", "Trying to config");
//glConfig = gdk_gl_config_new_by_mode(glconf);
//FBLOG_WARN("", "Created config: " << glConfig);
//if (!glConfig) {
//FBLOG_WARN("", "Double-buffer didn't work. Trying single.");
glconf = static_cast<GdkGLConfigMode>(
GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH
);
glConfig = gdk_gl_config_new_by_mode(glconf);
FBLOG_WARN("", "Created config: " << glConfig);
if (!glConfig) {
FBLOG_WARN("", "Couldn't initialize opengl. No idea why, sorry!");
return false;
} else {
FBLOG_INFO("", "Single-buffer opengl");
}
//} else {
//FBLOG_INFO("", "Double-buffer opengl");
//}
FBLOG_WARN("", "Setting GL capability on Widget: " << drawing_area);
gtk_widget_set_gl_capability (drawing_area,
glConfig,
NULL,
TRUE,
GDK_GL_RGBA_TYPE);
gtk_container_add(win->getGtkContainer(), drawing_area);
gtk_widget_show(drawing_area);
FBLOG_WARN("", "Getting GL Context");
GdkGLContext *glcontext = gtk_widget_get_gl_context (drawing_area);
FBLOG_WARN("", "Got GL Context: " << glcontext << " Now getting Drawable:");
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (drawing_area);
FBLOG_WARN("", "Got GL Drawable: " << gldrawable);
// Attach our OpenGL context to the widget
gdk_threads_leave();
rThread = boost::thread(&OpenGLExampleX11::renderThread, this);
FBLOG_WARN("", "AttachedEvent end");
}
static gboolean
draw (GtkWidget *widget,
GdkEventExpose *event,
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 | GL_DEPTH_BUFFER_BIT);
glPushMatrix ();
glRotatef (view_rotx, 1.0, 0.0, 0.0);
glRotatef (view_roty, 0.0, 1.0, 0.0);
glRotatef (view_rotz, 0.0, 0.0, 1.0);
glPushMatrix ();
glTranslatef (-3.0, -2.0, 0.0);
glRotatef (angle, 0.0, 0.0, 1.0);
glCallList (gear1);
glPopMatrix ();
glPushMatrix ();
glTranslatef (3.1, -2.0, 0.0);
glRotatef (-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
glCallList (gear2);
glPopMatrix ();
glPushMatrix ();
glTranslatef (-3.1, 4.2, 0.0);
glRotatef (-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
glCallList (gear3);
glPopMatrix ();
glPopMatrix ();
if (gdk_gl_drawable_is_double_buffered (gldrawable))
gdk_gl_drawable_swap_buffers (gldrawable);
else
glFlush ();
gdk_gl_drawable_gl_end (gldrawable);
/*** OpenGL END ***/
frames++;
{
gdouble seconds = g_timer_elapsed (timer, NULL);
if (seconds >= 5.0) {
gdouble fps = frames / seconds;
g_print ("%d frames in %6.3f seconds = %6.3f FPS\n", frames, seconds, fps);
g_timer_reset (timer);
frames = 0;
}
}
return TRUE;
}
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);
// g_print (" :: expose\n");
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
{
g_assert_not_reached ();
}
/* draw in here */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
//glRotatef (ang, 1, 0, 0);
glRotatef (ang, 0, 1, 0);
// glRotatef (ang, 0, 0, 1);
glShadeModel(GL_FLAT);
#if 0
glBegin (GL_QUADS);
glColor4f(0.0, 0.0, 1.0, ALPHA);
glVertex3fv(boxv[0]);
glVertex3fv(boxv[1]);
glVertex3fv(boxv[2]);
glVertex3fv(boxv[3]);
glColor4f(1.0, 1.0, 0.0, ALPHA);
glVertex3fv(boxv[0]);
glVertex3fv(boxv[4]);
glVertex3fv(boxv[5]);
glVertex3fv(boxv[1]);
glColor4f(0.0, 1.0, 1.0, ALPHA);
glVertex3fv(boxv[2]);
glVertex3fv(boxv[6]);
glVertex3fv(boxv[7]);
glVertex3fv(boxv[3]);
glColor4f(1.0, 0.0, 0.0, ALPHA);
glVertex3fv(boxv[4]);
glVertex3fv(boxv[5]);
glVertex3fv(boxv[6]);
glVertex3fv(boxv[7]);
glColor4f(1.0, 0.0, 1.0, ALPHA);
glVertex3fv(boxv[0]);
glVertex3fv(boxv[3]);
glVertex3fv(boxv[7]);
glVertex3fv(boxv[4]);
glColor4f(0.0, 1.0, 0.0, ALPHA);
glVertex3fv(boxv[1]);
glVertex3fv(boxv[5]);
glVertex3fv(boxv[6]);
glVertex3fv(boxv[2]);
glEnd ();
#endif
/*glBegin (GL_LINES);
glColor3f (1., 0., 0.);
glVertex3f (0., 0., 0.);
glVertex3f (1., 0., 0.);
glEnd ();
glBegin (GL_LINES);
glColor3f (0., 1., 0.);
glVertex3f (0., 0., 0.);
glVertex3f (0., 1., 0.);
glEnd ();
glBegin (GL_LINES);
glColor3f (0., 0., 1.);
glVertex3f (0., 0., 0.);
glVertex3f (0., 0., 1.);
glEnd ();*/
//circle(0.3, 0.2, 0.8, 36);
glColor4f(0.0, 1.0, 0.0, ALPHA);
disc( 0.3 , 0.2 , 0.8 , 36, 0.5);
/*glBegin(GL_LINES);
glColor3f (1., 1., 1.);
glVertex3fv(boxv[0]);
glVertex3fv(boxv[1]);
glVertex3fv(boxv[1]);
glVertex3fv(boxv[2]);
glVertex3fv(boxv[2]);
glVertex3fv(boxv[3]);
glVertex3fv(boxv[3]);
glVertex3fv(boxv[0]);
glVertex3fv(boxv[4]);
glVertex3fv(boxv[5]);
glVertex3fv(boxv[5]);
glVertex3fv(boxv[6]);
glVertex3fv(boxv[6]);
glVertex3fv(boxv[7]);
glVertex3fv(boxv[7]);
glVertex3fv(boxv[4]);
glVertex3fv(boxv[0]);
glVertex3fv(boxv[4]);
glVertex3fv(boxv[1]);
glVertex3fv(boxv[5]);
glVertex3fv(boxv[2]);
glVertex3fv(boxv[6]);
glVertex3fv(boxv[3]);
glVertex3fv(boxv[7]);
glEnd();*/
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;
}
gboolean
on_drawing3D_expose_event (GtkWidget *widget,
GdkEventExpose *event,
gpointer user_data)
{
//Gets the 3D drawing context
GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
//If we can not draw, return
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
return FALSE;
if(flag_minMax==0)
glClearColor(1.0,1.0,1.0,1.0);
else
glClearColor(0.0,0.0,0.0,0.0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(flag_draw_3D)
{
setUpVolumeMatrices();
if(drawCube_flag){
/* cube->draw(rot3DX,rot3DY,200,3*flag_minMax,0); */
for(int i = 0; i < toDraw.size(); i++){
toDraw[i]->draw();
setUpVolumeMatrices();
}
}
setUpVolumeMatrices();
if(flag_cube_transparency)
glDisable(GL_DEPTH_TEST);
else
glEnable(GL_DEPTH_TEST);
if(flag_draw_neuron && neuronita)
neuronita->draw();
//glCallList(1);
draw_last_point();
draw_contours();
draw_graphcuts();
}
//Draws the XY view
if(flag_draw_XY)
{
glEnable(GL_DEPTH_TEST);
setUpMatricesXY(layerSpanViewZ);
glColor3f(1.0,1.0,1.0);
if(drawCube_flag)
cube->draw_layer_tile_XY(layerToDrawXY);
if(flag_cube_transparency)
glDisable(GL_DEPTH_TEST);
else
glEnable(GL_DEPTH_TEST);
if(flag_draw_neuron && neuronita)
neuronita->draw();
//glCallList(1);
/* for(int i = 0; i < toDraw.size(); i++) */
/* toDraw[i]->draw(); */
draw_last_point();
draw_contours();
draw_graphcuts();
glDisable(GL_DEPTH_TEST);
}
if(flag_draw_XZ)
{
glEnable(GL_DEPTH_TEST);
setUpMatricesXZ(layerSpanViewZ);
if(drawCube_flag)
cube->draw_layer_tile_XZ(layerToDrawXZ);
if(flag_cube_transparency)
glDisable(GL_DEPTH_TEST);
else
glEnable(GL_DEPTH_TEST);
if(flag_draw_neuron && neuronita)
neuronita->draw();
//glCallList(1);
draw_last_point();
draw_contours();
draw_graphcuts();
glDisable(GL_DEPTH_TEST);
}
if(flag_draw_YZ)
{
glEnable(GL_DEPTH_TEST);
setUpMatricesYZ(layerSpanViewZ);
if(drawCube_flag)
cube->draw_layer_tile_YZ(layerToDrawYZ);
if(flag_cube_transparency)
glDisable(GL_DEPTH_TEST);
else
glEnable(GL_DEPTH_TEST);
if(flag_draw_neuron && neuronita)
neuronita->draw();
//glCallList(1);
draw_last_point();
draw_contours();
draw_graphcuts();
glDisable(GL_DEPTH_TEST);
}
if(flag_draw_combo){
setUpVolumeMatrices();
glViewport ((GLsizei)0,(GLsizei)0,
(GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
if(drawCube_flag){
for(int i = 0; i < toDraw.size(); i++){
setUpVolumeMatrices();
glViewport ((GLsizei)0,(GLsizei)0,
(GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
toDraw[i]->draw();
}
/* cube->draw(rot3DX,rot3DY,200,flag_minMax,0); */
setUpVolumeMatrices();
glViewport ((GLsizei)0,(GLsizei)0,
(GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
glEnable(GL_BLEND);
setUpVolumeMatrices();
cube->draw_layer_tile_XY(layerToDrawXY,1);
cube->draw_layer_tile_XZ(layerToDrawXZ,1);
cube->draw_layer_tile_YZ(layerToDrawYZ,1);
glPushMatrix();
glTranslatef(wx,wy,wz);
glColor3f(0.0,1.0,1.0);
glutSolidSphere(3, 10,10);
glPopMatrix();
glDisable(GL_BLEND);
}
if(flag_cube_transparency)
glDisable(GL_DEPTH_TEST);
else
glEnable(GL_DEPTH_TEST);
if(flag_draw_neuron && neuronita)
neuronita->draw();
//glCallList(1);
draw_last_point();
glEnable(GL_DEPTH_TEST);
setUpMatricesXZ(100000);
glViewport ((GLsizei)0,(GLsizei)widgetHeight/2,
(GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
if(drawCube_flag){
cube->draw_layer_tile_XY(layerToDrawXY,1);
cube->draw_layer_tile_XZ(layerToDrawXZ,0);
cube->draw_layer_tile_YZ(layerToDrawYZ,1);
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glPushMatrix();
glTranslatef(wx,wy,wz);
glColor3f(0.0,1.0,1.0);
glutSolidSphere(1, 10,10);
glPopMatrix();
glDisable(GL_BLEND);
}
if(flag_cube_transparency)
glDisable(GL_DEPTH_TEST);
else
glEnable(GL_DEPTH_TEST);
if(flag_draw_neuron){
setUpMatricesXZ(layerSpanViewZ);
glViewport ((GLsizei)0,(GLsizei)widgetHeight/2,
(GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
if(flag_draw_neuron && neuronita)
neuronita->draw();
//glCallList(1);
draw_last_point();
}
glEnable(GL_DEPTH_TEST);
setUpMatricesYZ(1000000);
glViewport ((GLsizei)widgetWidth/2, (GLsizei)0,
(GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
if(drawCube_flag){
cube->draw_layer_tile_XY(layerToDrawXY,1);
cube->draw_layer_tile_XZ(layerToDrawXZ,1);
cube->draw_layer_tile_YZ(layerToDrawYZ,0);
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glPushMatrix();
glTranslatef(wx,wy,wz);
glColor3f(0.0,1.0,1.0);
glutSolidSphere(1, 10,10);
glPopMatrix();
glDisable(GL_BLEND);
}
if(flag_cube_transparency)
glDisable(GL_DEPTH_TEST);
else
glEnable(GL_DEPTH_TEST);
if(flag_draw_neuron){
setUpMatricesYZ(layerSpanViewZ);
glViewport ((GLsizei)widgetWidth/2, (GLsizei)0,
(GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
if(flag_draw_neuron && neuronita)
neuronita->draw();
//glCallList(1);
draw_last_point();
}
glEnable(GL_DEPTH_TEST);
setUpMatricesXY(1000000);
glViewport ((GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2,
(GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
if(drawCube_flag){
cube->draw_layer_tile_XY(layerToDrawXY,0);
cube->draw_layer_tile_XZ(layerToDrawXZ,1);
cube->draw_layer_tile_YZ(layerToDrawYZ,1);
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glPushMatrix();
glTranslatef(wx,wy,wz);
glColor3f(0.0,1.0,1.0);
glutSolidSphere(1, 10,10);
glPopMatrix();
glDisable(GL_BLEND);
}
if(flag_cube_transparency)
glDisable(GL_DEPTH_TEST);
else
glEnable(GL_DEPTH_TEST);
if(flag_draw_neuron){
setUpMatricesXY(layerSpanViewZ);
glViewport ((GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2,
(GLsizei)widgetWidth/2, (GLsizei)widgetHeight/2);
if(flag_draw_neuron && neuronita)
neuronita->draw();
//glCallList(1);
draw_last_point();
}
glDisable(GL_DEPTH_TEST);
}
if(majorMode == MOD_ASCEDITOR){
exposeAsc(widget, event, user_data);
}
//Show what has been drawn
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 gint redraw(GtkWidget *widget, gpointer data)
{
GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
GLdouble m[4][4];
if(!GTK_IS_WIDGET(widget)) return TRUE;
if(!GTK_WIDGET_REALIZED(widget)) return TRUE;
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext)) return FALSE;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
addFog();
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
set_background_color();
mYPerspective(45,(GLdouble)widget->allocation.width/(GLdouble)widget->allocation.height,1,100);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if(optcol==-1) drawChecker();
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();
if(perspective)
glTranslatef(Trans[0],Trans[1],Trans[2]);
else
{
glTranslatef(Trans[0]/10,Trans[1]/10,0);
glScalef(1/Zoom*2,1/Zoom*2,1/Zoom*2);
}
SetLight();
build_rotmatrix(m,Quat);
glMultMatrixd(&m[0][0]);
redrawGeometry();
redrawSurfaces();
redrawCell();
redrawContours();
redrawPlanesMapped();
if(get_show_symbols() || get_show_numbers() || get_show_charges()) showLabelSymbolsNumbersCharges();
if(get_show_dipole()) showLabelDipole();
if(get_show_distances()) showLabelDistances();
if(get_show_axes()) showLabelAxes();
if(get_show_axes()) showLabelPrincipalAxes();
showLabelTitle(GLArea->allocation.width,GLArea->allocation.height);
/*
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDepthRange(0.0f,1.0f);
*/
if (gdk_gl_drawable_is_double_buffered (gldrawable))
gdk_gl_drawable_swap_buffers (gldrawable);
else glFlush ();
gdk_gl_drawable_gl_end (gldrawable);
while( gtk_events_pending() ) gtk_main_iteration();
createImagesFiles();
/* gtk_widget_queue_draw(PrincipalWindow);*/
return TRUE;
}
gboolean glwidget_make_current (GtkWidget *widget)
{
GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);
return gdk_gl_drawable_gl_begin (gldrawable, glcontext);
}
GdkGLDrawable *gtk_widget_gl_begin(GtkWidget *gwnd) {
GdkGLDrawable *pGLD = gtk_widget_get_gl_drawable(gwnd);
if (!gdk_gl_drawable_gl_begin(pGLD, gtk_widget_get_gl_context(gwnd)))
pGLD = 0;
return pGLD;
}
bool GLWidget::makeCurrent(GtkWidget* widget) {
GdkGLContext* glcontext = gtk_widget_get_gl_context(widget);
GdkGLDrawable* gldrawable = gtk_widget_get_gl_drawable(widget);
return static_cast<bool>(gdk_gl_drawable_gl_begin(gldrawable, glcontext));
}
gint glarea_draw (GtkWidget* widget, GdkEventExpose* event, gpointer data) {
// Rotates, translate, etc. the scene but does not refresh the mesh
gint i;
camera_struct *camera;
gl_preview_struct *gl_hf = (gl_preview_struct *) data;
camera = gl_hf->cameras[gl_hf->current_camera_id];
/* Draw only on the last expose event. */
// printf("************* GL DRAWING 1 *************\n");
if (event->count > 0) {
return(TRUE);
}
// printf("************* GL DRAWING 2 **************\n");
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;
/* Clear the drawing color buffer and depth buffers */
/* before drawing. */
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Drawing instructions
glLoadIdentity();
gluLookAt(0.0,0.0,camera->distance + BASE_DISTANCE,0.0,0.0,0.0,0.0,1.0,0.0);
glLightfv(GL_LIGHT0,GL_POSITION,l0pos);
glLightfv(GL_LIGHT1,GL_POSITION,l1pos);
// glCallList(lights_list);
glTranslatef(camera->translate_x, camera->translate_y+BASE_TRANSLATE_Y,0.0);
glRotatef(camera->rot_x+ROT_X_BASE,1.0,0.0,0.0);
glRotatef(camera->rot_y+ROT_Y_BASE,0.0,0.0,1.0);
glCallList(gl_hf->hf_list);
// A very simple water plane
if (gl_hf->use_water && *gl_hf->use_water) {
glColor4fv(water_colour);
glBegin(GL_POLYGON);
glVertex3f(1.5,-1.5,*gl_hf->water_level*HEIGHT_SCALE);
glVertex3f(1.5,1.5,*gl_hf->water_level*HEIGHT_SCALE);
glVertex3f(-1.5,1.5,*gl_hf->water_level*HEIGHT_SCALE);
glVertex3f(-1.5,-1.5,*gl_hf->water_level*HEIGHT_SCALE);
glEnd();
}
// glCallList(normals_list);
// Back up the cameras
if (FLAG_CAMERA_CHANGE) {
for(i=0; i<NBCAMERAS; i++) {
copy_camera(&cameras[i],gl_hf->cameras[i]);
}
FLAG_CAMERA_CHANGE = FALSE;
}
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);
}
void cb_glext2d_realize(GtkWidget *widget, gpointer user_data)
{
PangoFont *font;
PangoFontMetrics *font_metrics;
PangoFontDescription *font_desc;
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;
}
glShadeModel(GL_FLAT);
glDisable(GL_DITHER);
// generate display list for our square base
glNewList(GREY_2D_SQUARE_CALL_LIST, GL_COMPILE);
glBegin(GL_QUAD_STRIP);
glColor3ub(100, 100, 100);
glVertex2f(-1, -1);
glVertex2f(-1, 1);
glVertex2f(1, -1);
glVertex2f(1, 1);
glEnd();
glEndList();
glNewList(WHITE_2D_SQUARE_CALL_LIST, GL_COMPILE);
glBegin(GL_QUAD_STRIP);
glColor3ub(255, 255, 255);
glVertex2f(-1, -1);
glVertex2f(-1, 1);
glVertex2f(1, -1);
glVertex2f(1, 1);
glEnd();
glEndList();
// generate display lists for our font
const char *font_string = gtk_entry_get_text(GTK_ENTRY(viz->prefs_label_font));
viz->font_list_2d = glGenLists(128);
font_desc = pango_font_description_from_string(font_string);
font = gdk_gl_font_use_pango_font(font_desc, 0, 128, viz->font_list_2d);
if (font == NULL) {
g_warning("cannot load font '%s', falling back to '%s'", font_string, DEFAULT_LABEL_FONT);
font_desc = pango_font_description_from_string(DEFAULT_LABEL_FONT);
font = gdk_gl_font_use_pango_font(font_desc, 0, 128, viz->font_list_3d);
}
// use pango to determine dimensions of font
font_metrics = pango_font_get_metrics(font, NULL);
viz->font_height_2d = pango_font_metrics_get_ascent(font_metrics) + pango_font_metrics_get_descent(font_metrics);
viz->font_height_2d = PANGO_PIXELS(viz->font_height_2d);
pango_font_description_free(font_desc);
pango_font_metrics_unref(font_metrics);
// define display lists for our as labels
glNewList(LABELS_2D_AS_CALL_LIST, GL_COMPILE);
// output our labels
glColor3f(1.0, 1.0, 1.0);
// 0 label
glRasterPos2f(-1.0, -1.0);
glListBase(viz->font_list_2d);
glCallLists(strlen(" 0"), GL_UNSIGNED_BYTE, " 0");
// 65535 label
glRasterPos2f(1.0, 1.0);
glListBase(viz->font_list_2d);
glCallLists(strlen(" 65535"), GL_UNSIGNED_BYTE, " 65535");
glEndList();
// enable the use of glDrawArrays with vertices and normals
glEnableClientState(GL_VERTEX_ARRAY);
gdk_gl_drawable_gl_end(gldrawable);
}
