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 on_expose(GtkWidget *drawing, GdkEventExpose *event, gpointer _)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1,1, -1,1, 10,-10);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -5);
glEnable(GL_COLOR_MATERIAL);
glDisable(GL_TEXTURE_2D);
glColor3f(1.0, 1.0, 1.0);
/* Create vertexes */
double verts[20][3];
for (int i = 0; i < G_N_ELEMENTS(verts); i++) {
float ang = 2*G_PI * i / G_N_ELEMENTS(verts);
verts[i][0] = sin(ang) * (i%2+0.5) * 0.6;
verts[i][1] = cos(ang) * (i%2+0.5) * 0.6;
verts[i][2] = 0;
}
/* Draw raw polygon */
glColor4f(0.5, 0.0, 0.0, 1.0);
GLUtesselator *tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_BEGIN, glBegin);
gluTessCallback(tess, GLU_TESS_VERTEX, glVertex3dv);
gluTessCallback(tess, GLU_TESS_END, glEnd);
gluTessBeginPolygon(tess, NULL);
gluTessBeginContour(tess);
for (int i = 0; i < G_N_ELEMENTS(verts); i++)
gluTessVertex(tess, verts[i], verts[i]);
gluTessEndContour(tess);
gluTessEndPolygon(tess);
gluDeleteTess(tess);
/* Draw tesselated polygon */
//glColor4f(0.0, 0.0, 0.5, 1.0);
//glBegin(GL_POLYGON);
//for (int i = 0; i < G_N_ELEMENTS(verts); i++)
// glVertex3dv(verts[i]);
//glEnd();
/* Draw outline */
glColor4f(0.8, 0.8, 0.8, 1.0);
glBegin(GL_LINE_LOOP);
for (int i = 0; i < G_N_ELEMENTS(verts); i++)
glVertex3dv(verts[i]);
glEnd();
/* Flush */
GdkGLDrawable *gldrawable = gdk_gl_drawable_get_current();
if (gdk_gl_drawable_is_double_buffered(gldrawable))
gdk_gl_drawable_swap_buffers(gldrawable);
else
glFlush();
return FALSE;
}
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 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;
}
/***
*** 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;
}
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
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;
}
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
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;
}
//virtual
void
RenderArea::swapBuffers() {
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (GTK_WIDGET(gobj()));
if (gdk_gl_drawable_is_double_buffered (gldrawable)) {
gdk_gl_drawable_swap_buffers (gldrawable);
} else {
glFlush ();
}
}
void CGLDrawingArea::GTK_FlushBufferGL()
/***************************************/
{
GtkWidget* widget = reinterpret_cast<GtkWidget*>(gobj());
GdkGLDrawable* gldrawable = gtk_widget_get_gl_drawable (widget);
if (gdk_gl_drawable_is_double_buffered (gldrawable))
gdk_gl_drawable_swap_buffers (gldrawable);
else
glFlush();
}
void
GtkGlExtGlue::render()
{
// GNASH_REPORT_FUNCTION;
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (_drawing_area);
if (gdk_gl_drawable_is_double_buffered (gldrawable)) {
gdk_gl_drawable_swap_buffers (gldrawable);
} else {
glFlush();
}
}
gint glarea_init (GtkWidget* widget, gpointer data) {
// printf ("GLAREA_INIT - Realize Event\n");
gl_preview_struct *gl_hf = (gl_preview_struct *) 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)) {
my_msg(_("Not able to display the Open GL preview"),WARNING);
return FALSE;
}
glClearColor(0.0,0.0,0.0,1.0);
glEnable(GL_DEPTH_TEST);
glPolygonMode(GL_FRONT, GL_FILL);
// glDisable(GL_CULL_FACE);
set_perspective (gl_hf->cameras[gl_hf->current_camera_id]);
// Lights
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glLightfv(GL_LIGHT0, GL_DIFFUSE, l0dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, l0dif);
glLightfv(GL_LIGHT1, GL_DIFFUSE, l1dif);
glLightfv(GL_LIGHT1, GL_SPECULAR, l1dif);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) ;
// Materials
glMaterialfv(GL_FRONT, GL_SPECULAR, mspec);
glMaterialf(GL_FRONT, GL_SHININESS, mshiny);
glShadeModel (GL_SMOOTH);
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 GLBase::glSwapBuffers()
{
if (drw == NULL)
{
printf("Error, glSwapBuffers() called outside of glBegin()/glEnd() block!\n");
return;
}
if (gdk_gl_drawable_is_double_buffered(drw) == TRUE)
gdk_gl_drawable_swap_buffers(drw);
else
glFlush();
}
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);
GLfloat m[4][4];
mesh_info *info = (mesh_info*)g_object_get_data(G_OBJECT(widget), "mesh_info");
/*** OpenGL BEGIN ***/
if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
goto NO_GL;
/* basic initialization */
if (info->do_init == TRUE) {
initgl();
info->do_init = FALSE;
}
/* view */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(info->zoom, VIEW_ASPECT, 1,100);
glMatrixMode(GL_MODELVIEW);
/* draw object */
glClearColor(.3,.4,.6,1);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0,0,-30);
add_quats(info->dquat, info->quat, info->quat);
build_rotmatrix(m,info->quat);
glMultMatrixf(&m[0][0]);
lw_object_show(info->lwobject);
/* swap backbuffer to front */
if (gdk_gl_drawable_is_double_buffered(gldrawable))
gdk_gl_drawable_swap_buffers(gldrawable);
else
glFlush();
gdk_gl_drawable_gl_end(gldrawable);
/*** OpenGL END ***/
NO_GL:
return TRUE;
}
/*
* The "expose_event" signal handler for drawingarea1. All OpenGL re-drawing should be done here.
* This is called every time the expose/draw event is signalled.
*
*/
gboolean SludgeGLApplication::on_drawingarea1_expose_event(GtkWidget *theWidget, GdkEventExpose *theEvent)
{
GdkGLContext *glContext;
GdkGLDrawable *glDrawable;
// Don't continue if we get fed a dud window type.
if (theWidget->window == NULL)
{
return FALSE;
}
/*
* Lock rendering mutex if it's not busy - otherwise exit.
* This prevents the renderer being spammed by drawing requests if the rendering takes longer than the feed/timer process.
*/
if (!g_mutex_trylock(theRender_mutex))
return FALSE;
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))
{
g_mutex_unlock(theRender_mutex);
return FALSE;
}
drawRect();
/*
* Swap rendering buffers out (an auto glFlush is issued after) if we previously managed to initialise
* it as a double-buffered context, otherwise issue a standard glFlush call to signal we've finished
* OpenGL rendering.
*/
if (gdk_gl_drawable_is_double_buffered (glDrawable))
gdk_gl_drawable_swap_buffers (glDrawable);
else
glFlush ();
// Signal to gdk we're done with OpenGL operations.
gdk_gl_drawable_gl_end (glDrawable);
// Release the rendering mutex.
g_mutex_unlock(theRender_mutex);
return FALSE;
}
static gboolean on_expose_listing (GtkWidget *pWidget, GdkEventExpose *pExpose, CDListing *pListing)
{
if (g_bUseOpenGL && pListing->container.glContext)
{
GdkGLContext *pGlContext = gtk_widget_get_gl_context (pWidget);
GdkGLDrawable *pGlDrawable = gtk_widget_get_gl_drawable (pWidget);
if (!gdk_gl_drawable_gl_begin (pGlDrawable, pGlContext))
return FALSE;
if (pExpose->area.x + pExpose->area.y != 0)
{
glEnable (GL_SCISSOR_TEST);
glScissor ((int) pExpose->area.x,
(int) (pListing->container.bIsHorizontal ? pListing->container.iHeight : pListing->container.iWidth) -
pExpose->area.y - pExpose->area.height, // lower left corner of the scissor box.
(int) pExpose->area.width,
(int) pExpose->area.height);
}
cairo_dock_notify_on_container (CAIRO_CONTAINER (pListing), CAIRO_DOCK_RENDER_DEFAULT_CONTAINER, pListing, NULL);
glDisable (GL_SCISSOR_TEST);
if (gdk_gl_drawable_is_double_buffered (pGlDrawable))
gdk_gl_drawable_swap_buffers (pGlDrawable);
else
glFlush ();
gdk_gl_drawable_gl_end (pGlDrawable);
}
else
{
cairo_t *pCairoContext;
if (pExpose->area.x > 0 || pExpose->area.y > 0)
{
double fColor[4] = {0., 0., 0., 0.};
pCairoContext = cairo_dock_create_drawing_context_on_area (CAIRO_CONTAINER (pListing), &pExpose->area, fColor);
}
else
{
pCairoContext = cairo_dock_create_drawing_context (CAIRO_CONTAINER (pListing));
}
cairo_dock_notify_on_container (CAIRO_CONTAINER (pListing), CAIRO_DOCK_RENDER_DEFAULT_CONTAINER, pListing, pCairoContext);
cairo_destroy (pCairoContext);
}
return FALSE;
}
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);
/* brass */
static GLfloat ambient[4] = { 0.329412, 0.223529, 0.027451, 1.0 };
static GLfloat diffuse[4] = { 0.780392, 0.568627, 0.113725, 1.0 };
static GLfloat specular[4] = { 0.992157, 0.941176, 0.807843, 1.0 };
static GLfloat shininess = 0.21794872 * 128.0;
/*** OpenGL BEGIN ***/
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
return FALSE;
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity ();
glTranslatef (0.0, 0.0, -10.0);
glPushMatrix ();
glTranslatef (0.0, pos_y, 0.0);
glRotatef (angle, 0.0, 1.0, 0.0);
glMaterialfv (GL_FRONT, GL_AMBIENT, ambient);
glMaterialfv (GL_FRONT, GL_DIFFUSE, diffuse);
glMaterialfv (GL_FRONT, GL_SPECULAR, specular);
glMaterialf (GL_FRONT, GL_SHININESS, shininess);
gdk_gl_draw_torus (TRUE, 0.3, 0.6, 30, 30);
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 ***/
return TRUE;
}
// expose_event: Called when a part of the map_area needs to be redrawn
// ----------------------------------------------------------------- >>
gboolean expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
{
//render_map();
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget);
if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
return false;
draw_map();
if (gdk_gl_drawable_is_double_buffered(gldrawable))
gdk_gl_drawable_swap_buffers(gldrawable);
else
glFlush();
gdk_gl_drawable_gl_end(gldrawable);
return false;
}
/*
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 "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;
}
void render_map()
{
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(map_area);
if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
return;
draw_map();
if (gdk_gl_drawable_is_double_buffered(gldrawable))
gdk_gl_drawable_swap_buffers(gldrawable);
else
glFlush();
gdk_gl_drawable_gl_end(gldrawable);
/*
PangoLayout *pl = gtk_widget_create_pango_layout(map_area, "Testing!");
gdk_draw_layout(map_area->window, map_area->style->text_aa_gc[GTK_STATE_NORMAL],
10, 10, pl);
*/
}
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;
}
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);
}
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;
}
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;
}
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;
}
