X-Git-Url: http://pileus.org/git/?p=grits;a=blobdiff_plain;f=src%2Fgis-opengl.c;h=9a88896eccb5d67e3b2c9da580cf7c684157d5b1;hp=78491b81164f4cefa5668392b5f1580e48d45c2a;hb=c2e39b9d64035038a19d753129cc2124b4ed1382;hpb=14cdbb4a9c369576a5485315260fad5285935e80 diff --git a/src/gis-opengl.c b/src/gis-opengl.c index 78491b8..9a88896 100644 --- a/src/gis-opengl.c +++ b/src/gis-opengl.c @@ -1,16 +1,16 @@ /* - * Copyright (C) 2009 Andy Spencer - * + * Copyright (C) 2009-2010 Andy Spencer + * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. - * + * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * + * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ @@ -21,6 +21,7 @@ #include #include +#include #include #include #include @@ -28,226 +29,49 @@ #include #include "gis-opengl.h" +#include "gis-util.h" +#include "gis-object.h" #include "roam.h" -#include "wms.h" #define FOV_DIST 2000.0 #define MPPX(dist) (4*dist/FOV_DIST) // #define ROAM_DEBUG -/************* - * ROAM Code * - *************/ -void roam_queue_draw(WmsCacheNode *node, gpointer _self) -{ - gtk_widget_queue_draw(GTK_WIDGET(_self)); -} - -void roam_height_func(RoamPoint *point, gpointer _self) +/*********** + * Helpers * + ***********/ +static void _gis_opengl_begin(GisOpenGL *self) { - GisOpenGL *self = _self; - - gdouble lat, lon, elev; - xyz2lle(point->x, point->y, point->z, &lat, &lon, &elev); - -#ifdef ROAM_DEBUG - lle2xyz(lat, lon, 0, &point->x, &point->y, &point->z); - return; -#endif + g_assert(GIS_IS_OPENGL(self)); - gdouble cam_lle[3], cam_xyz[3]; - gis_view_get_location(self->view, &cam_lle[0], &cam_lle[1], &cam_lle[2]); - lle2xyz(cam_lle[0], cam_lle[1], cam_lle[2], &cam_xyz[0], &cam_xyz[1], &cam_xyz[2]); - - gdouble res = MPPX(distd(cam_xyz, (double*)point)); - //g_message("lat=%f, lon=%f, res=%f", lat, lon, res); - - point->node = wms_info_fetch_cache(self->srtm, point->node, - res, lat, lon, NULL, roam_queue_draw, self); - - if (point->node) { - WmsBil *bil = point->node->data; - - gint w = bil->width; - gint h = bil->height; - - gdouble xmin = point->node->latlon[0]; - gdouble ymin = point->node->latlon[1]; - gdouble xmax = point->node->latlon[2]; - gdouble ymax = point->node->latlon[3]; - - gdouble xdist = xmax - xmin; - gdouble ydist = ymax - ymin; - - gdouble x = (lon-xmin)/xdist * w; - gdouble y = (1-(lat-ymin)/ydist) * h; - - gdouble x_rem = x - (int)x; - gdouble y_rem = y - (int)y; - guint x_flr = (int)x; - guint y_flr = (int)y; - - /* TODO: Fix interpolation at edges: - * - Pad these at the edges instead of wrapping/truncating - * - Figure out which pixels to index (is 0,0 edge, center, etc) */ - gint16 px00 = bil->data[MIN((y_flr ),h-1)*w + MIN((x_flr ),w-1)]; - gint16 px10 = bil->data[MIN((y_flr ),h-1)*w + MIN((x_flr+1),w-1)]; - gint16 px01 = bil->data[MIN((y_flr+1),h-1)*w + MIN((x_flr ),w-1)]; - gint16 px11 = bil->data[MIN((y_flr+1),h-1)*w + MIN((x_flr+1),w-1)]; - - elev = px00 * (1-x_rem) * (1-y_rem) + - px10 * ( x_rem) * (1-y_rem) + - px01 * (1-x_rem) * ( y_rem) + - px11 * ( x_rem) * ( y_rem); - //g_message("elev=%f -- %hd %hd %hd %hd", - // elev, px00, px10, px01, px11); - } else { - elev = 0; - } + GdkGLContext *glcontext = gtk_widget_get_gl_context(GTK_WIDGET(self)); + GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(self)); - lle2xyz(lat, lon, elev, &point->x, &point->y, &point->z); + if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext)) + g_assert_not_reached(); } -void roam_tri_func(RoamTriangle *tri, gpointer _self) +static void _gis_opengl_end(GisOpenGL *self) { -#ifdef ROAM_DEBUG - glBegin(GL_TRIANGLES); - glNormal3dv(tri->p.r->norm); glVertex3dv((double*)tri->p.r); - glNormal3dv(tri->p.m->norm); glVertex3dv((double*)tri->p.m); - glNormal3dv(tri->p.l->norm); glVertex3dv((double*)tri->p.l); - glEnd(); - return; -#endif - - GisOpenGL *self = _self; - if (tri->error < 0) return; - - /* Get lat-lon min and maxes for the triangle */ - gdouble lat[3], lon[3], elev[3]; - xyz2lle(tri->p.r->x, tri->p.r->y, tri->p.r->z, &lat[0], &lon[0], &elev[0]); - xyz2lle(tri->p.m->x, tri->p.m->y, tri->p.m->z, &lat[1], &lon[1], &elev[1]); - xyz2lle(tri->p.l->x, tri->p.l->y, tri->p.l->z, &lat[2], &lon[2], &elev[2]); - gdouble lat_max = MAX(MAX(lat[0], lat[1]), lat[2]); - gdouble lat_min = MIN(MIN(lat[0], lat[1]), lat[2]); - gdouble lat_avg = (lat_min+lat_max)/2; - gdouble lon_max = MAX(MAX(lon[0], lon[1]), lon[2]); - gdouble lon_min = MIN(MIN(lon[0], lon[1]), lon[2]); - gdouble lon_avg = (lon_min+lon_max)/2; - - /* Get target resolution */ - gdouble cam_lle[3], cam_xyz[3]; - gis_view_get_location(self->view, &cam_lle[0], &cam_lle[1], &cam_lle[2]); - lle2xyz(cam_lle[0], cam_lle[1], cam_lle[2], &cam_xyz[0], &cam_xyz[1], &cam_xyz[2]); - gdouble distr = distd(cam_xyz, (double*)tri->p.r); - gdouble distm = distd(cam_xyz, (double*)tri->p.m); - gdouble distl = distd(cam_xyz, (double*)tri->p.l); - double res = MPPX(MIN(MIN(distr, distm), distl)); - - /* TODO: - * - Fetch needed textures, not all corners - * - Also fetch center textures that aren't touched by a corner - * - Idea: send {lat,lon}{min,max} to fetch_cache and handle it in the recursion */ - /* Fetch textures */ - tri->nodes[0] = wms_info_fetch_cache(self->bmng, tri->nodes[0], res, lat_min, lon_min, NULL, roam_queue_draw, self); - tri->nodes[1] = wms_info_fetch_cache(self->bmng, tri->nodes[1], res, lat_max, lon_min, NULL, roam_queue_draw, self); - tri->nodes[2] = wms_info_fetch_cache(self->bmng, tri->nodes[2], res, lat_min, lon_max, NULL, roam_queue_draw, self); - tri->nodes[3] = wms_info_fetch_cache(self->bmng, tri->nodes[3], res, lat_max, lon_max, NULL, roam_queue_draw, self); - tri->nodes[4] = wms_info_fetch_cache(self->bmng, tri->nodes[4], res, lat_avg, lon_avg, NULL, roam_queue_draw, self); - /* Hopefully get all textures at the same resolution to prevent overlaps */ - //gdouble maxres = 0; - //for (int i = 0; i < 5; i++) - // if (tri->nodes[i] && tri->nodes[i]->res > maxres) - // maxres = tri->nodes[i]->res; - //if (maxres != 0) { - // tri->nodes[0] = wms_info_fetch_cache(self->bmng, tri->nodes[0], maxres, lat_min, lon_min, NULL, roam_queue_draw, self); - // tri->nodes[1] = wms_info_fetch_cache(self->bmng, tri->nodes[1], maxres, lat_max, lon_min, NULL, roam_queue_draw, self); - // tri->nodes[2] = wms_info_fetch_cache(self->bmng, tri->nodes[2], maxres, lat_min, lon_max, NULL, roam_queue_draw, self); - // tri->nodes[3] = wms_info_fetch_cache(self->bmng, tri->nodes[3], maxres, lat_max, lon_max, NULL, roam_queue_draw, self); - // tri->nodes[4] = wms_info_fetch_cache(self->bmng, tri->nodes[4], maxres, lat_avg, lon_avg, NULL, roam_queue_draw, self); - //} - - /* Vertex color for hieght map viewing, 8848m == Everest */ - gfloat colors[] = { - (elev[0]-EARTH_R)/8848, - (elev[1]-EARTH_R)/8848, - (elev[2]-EARTH_R)/8848, - }; - - /* Draw each texture */ - /* TODO: Prevent double exposure when of hi-res textures on top of - * low-res textures when some high-res textures are not yet loaded. */ - glBlendFunc(GL_ONE, GL_ZERO); - for (int i = 0; i < 5; i++) { - /* Skip missing textures */ - if (tri->nodes[i] == NULL) - continue; - /* Skip already drawn textures */ - switch (i) { - case 4: if (tri->nodes[i] == tri->nodes[3]) continue; - case 3: if (tri->nodes[i] == tri->nodes[2]) continue; - case 2: if (tri->nodes[i] == tri->nodes[1]) continue; - case 1: if (tri->nodes[i] == tri->nodes[0]) continue; - } - - WmsCacheNode *node = tri->nodes[i]; - - if (node->latlon[0] == -180) { - if (lon[0] < -90 || lon[1] < -90 || lon[2] < -90) { - if (lon[0] > 90) lon[0] -= 360; - if (lon[1] > 90) lon[1] -= 360; - if (lon[2] > 90) lon[2] -= 360; - } - } else if (node->latlon[2] == 180.0) { - if (lon[0] < -90) lon[0] += 360; - if (lon[1] < -90) lon[1] += 360; - if (lon[2] < -90) lon[2] += 360; - } - - gdouble xmin = node->latlon[0]; - gdouble ymin = node->latlon[1]; - gdouble xmax = node->latlon[2]; - gdouble ymax = node->latlon[3]; - - gdouble xdist = xmax - xmin; - gdouble ydist = ymax - ymin; - - gdouble xy[][3] = { - {(lon[0]-xmin)/xdist, 1-(lat[0]-ymin)/ydist}, - {(lon[1]-xmin)/xdist, 1-(lat[1]-ymin)/ydist}, - {(lon[2]-xmin)/xdist, 1-(lat[2]-ymin)/ydist}, - }; - - glBindTexture(GL_TEXTURE_2D, *(guint*)node->data); - - glBegin(GL_TRIANGLES); - glColor3fv(colors); glNormal3dv(tri->p.r->norm); glTexCoord2dv(xy[0]); glVertex3dv((double*)tri->p.r); - glColor3fv(colors); glNormal3dv(tri->p.m->norm); glTexCoord2dv(xy[1]); glVertex3dv((double*)tri->p.m); - glColor3fv(colors); glNormal3dv(tri->p.l->norm); glTexCoord2dv(xy[2]); glVertex3dv((double*)tri->p.l); - glEnd(); - glBlendFunc(GL_ONE, GL_ONE); - } + g_assert(GIS_IS_OPENGL(self)); + GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(self)); + gdk_gl_drawable_gl_end(gldrawable); } -static void set_camera(GisOpenGL *self) +static void _set_visuals(GisOpenGL *self) { glMatrixMode(GL_MODELVIEW); glLoadIdentity(); + + /* Camera 1 */ double lat, lon, elev, rx, ry, rz; - gis_view_get_location(self->view, &lat, &lon, &elev); - gis_view_get_rotation(self->view, &rx, &ry, &rz); + gis_viewer_get_location(GIS_VIEWER(self), &lat, &lon, &elev); + gis_viewer_get_rotation(GIS_VIEWER(self), &rx, &ry, &rz); glRotatef(rx, 1, 0, 0); glRotatef(rz, 0, 0, 1); - glTranslatef(0, 0, -elev2rad(elev)); - glRotatef(lat, 1, 0, 0); - glRotatef(-lon, 0, 1, 0); -} -static void set_visuals(GisOpenGL *self) -{ /* Lighting */ - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); #ifdef ROAM_DEBUG float light_ambient[] = {0.7f, 0.7f, 0.7f, 1.0f}; float light_diffuse[] = {2.0f, 2.0f, 2.0f, 1.0f}; @@ -264,7 +88,7 @@ static void set_visuals(GisOpenGL *self) float material_ambient[] = {0.2, 0.2, 0.2, 1.0}; float material_diffuse[] = {0.8, 0.8, 0.8, 1.0}; - float material_specular[] = {0.0, 0.0, 0.0, 1.0}; + float material_specular[] = {0.1, 0.1, 0.1, 1.0}; float material_emission[] = {0.0, 0.0, 0.0, 1.0}; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material_ambient); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material_diffuse); @@ -273,15 +97,10 @@ static void set_visuals(GisOpenGL *self) glDisable(GL_TEXTURE_2D); glDisable(GL_COLOR_MATERIAL); - /* Camera */ - set_camera(self); - - /* Misc */ - gdouble lat, lon, elev; - gis_view_get_location(self->view, &lat, &lon, &elev); - gdouble rg = MAX(0, 1-(elev/20000)); - gdouble blue = MAX(0, 1-(elev/50000)); - glClearColor(MIN(0.65,rg), MIN(0.65,rg), MIN(1,blue), 1.0f); + /* Camera 2 */ + glTranslatef(0, 0, -elev2rad(elev)); + glRotatef(lat, 1, 0, 0); + glRotatef(-lon, 0, 1, 0); glDisable(GL_ALPHA_TEST); @@ -301,216 +120,514 @@ static void set_visuals(GisOpenGL *self) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); //glShadeModel(GL_FLAT); + + roam_sphere_update_view(self->sphere); +} + + +/******************** + * Object handleing * + ********************/ +static void _draw_marker(GisOpenGL *self, GisMarker *marker) +{ + GisPoint *point = gis_object_center(GIS_OBJECT(marker)); + gdouble px, py, pz; + gis_viewer_project(GIS_VIEWER(self), + point->lat, point->lon, point->elev, + &px, &py, &pz); + if (pz > 1) + return; + + //g_debug("GisOpenGL: draw_marker - %s pz=%f ", marker->label, pz); + + cairo_surface_t *surface = cairo_get_target(marker->cairo); + gdouble width = cairo_image_surface_get_width(surface); + gdouble height = cairo_image_surface_get_height(surface); + + glMatrixMode(GL_PROJECTION); glLoadIdentity(); + glMatrixMode(GL_MODELVIEW); glLoadIdentity(); + glOrtho(0, GTK_WIDGET(self)->allocation.width, + 0, GTK_WIDGET(self)->allocation.height, -1, 1); + glTranslated(px - marker->xoff, + py - marker->yoff, 0); + + glDisable(GL_LIGHTING); + glDisable(GL_COLOR_MATERIAL); + glDisable(GL_DEPTH_TEST); + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, marker->tex); + glBegin(GL_QUADS); + glTexCoord2f(1, 1); glVertex3f(width, 0 , 0); + glTexCoord2f(1, 0); glVertex3f(width, height, 0); + glTexCoord2f(0, 0); glVertex3f(0 , height, 0); + glTexCoord2f(0, 1); glVertex3f(0 , 0 , 0); + glEnd(); +} + +static void _draw_callback(GisOpenGL *self, GisCallback *callback) +{ + callback->callback(callback, callback->user_data); +} + +static void _draw_object(GisOpenGL *self, GisObject *object) +{ + //g_debug("GisOpenGL: draw_object"); + /* Skip out of range objects */ + if (object->lod > 0) { + gdouble eye[3], obj[3]; + gis_viewer_get_location(GIS_VIEWER(self), &eye[0], &eye[1], &eye[2]); + lle2xyz(eye[0], eye[1], eye[2], &eye[0], &eye[1], &eye[2]); + lle2xyz(object->center.lat, object->center.lon, object->center.elev, + &obj[0], &obj[1], &obj[2]); + gdouble dist = distd(obj, eye); + if (object->lod < dist) + return; + } + + /* Draw */ + glMatrixMode(GL_PROJECTION); glPushMatrix(); + glMatrixMode(GL_MODELVIEW); glPushMatrix(); + glPushAttrib(GL_ALL_ATTRIB_BITS); + switch (object->type) { + case GIS_TYPE_MARKER: + _draw_marker(self, GIS_MARKER(object)); + break; + case GIS_TYPE_CALLBACK: + _draw_callback(self, GIS_CALLBACK(object)); + break; + default: + break; + } + glPopAttrib(); + glMatrixMode(GL_PROJECTION); glPopMatrix(); + glMatrixMode(GL_MODELVIEW); glPopMatrix(); +} + +static void _load_object(GisOpenGL *self, GisObject *object) +{ + g_debug("GisOpenGL: load_object"); + switch (object->type) { + case GIS_TYPE_MARKER: { + GisMarker *marker = GIS_MARKER(object); + cairo_surface_t *surface = cairo_get_target(marker->cairo); + gdouble width = cairo_image_surface_get_width(surface); + gdouble height = cairo_image_surface_get_height(surface); + + _gis_opengl_begin(self); + glEnable(GL_TEXTURE_2D); + glGenTextures(1, &marker->tex); + glBindTexture(GL_TEXTURE_2D, marker->tex); + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glPixelStorei(GL_PACK_ALIGNMENT, 1); + glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, + cairo_image_surface_get_data(surface)); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + g_debug("load_texture: %d", marker->tex); + _gis_opengl_end(self); + break; + } + default: + break; + } +} + +static void _unload_object(GisOpenGL *self, GisObject *object) +{ + g_debug("GisOpenGL: unload_object"); + switch (object->type) { + case GIS_TYPE_MARKER: { + GisMarker *marker = GIS_MARKER(object); + g_debug("delete_texture: %d", marker->tex); + glDeleteTextures(1, &marker->tex); + break; + } + default: + break; + } } /************* * Callbacks * *************/ +/* The unsorted/sroted GLists are blank head nodes, + * This way us we can remove objects from the level just by fixing up links + * I.e. we don't need to do a lookup to remove an object if we have its GList */ +struct RenderLevel { + GList unsorted; + GList sorted; +}; + static void on_realize(GisOpenGL *self, gpointer _) { - set_visuals(self); + g_debug("GisOpenGL: on_realize"); + _set_visuals(self); + g_mutex_lock(self->sphere_lock); + roam_sphere_update_errors(self->sphere); + g_mutex_unlock(self->sphere_lock); } static gboolean on_configure(GisOpenGL *self, GdkEventConfigure *event, gpointer _) { - g_debug("GisOpenGL: on_confiure"); - gis_opengl_begin(self); + g_debug("GisOpenGL: on_configure"); + _gis_opengl_begin(self); double width = GTK_WIDGET(self)->allocation.width; double height = GTK_WIDGET(self)->allocation.height; - glViewport(0, 0, width, height); + /* Setup OpenGL Window */ + glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); double ang = atan(height/FOV_DIST); - gluPerspective(rad2deg(ang)*2, width/height, 1, 20*EARTH_R); + gluPerspective(rad2deg(ang)*2, width/height, 1, 10*EARTH_R); #ifndef ROAM_DEBUG - roam_sphere_update(self->sphere); + g_mutex_lock(self->sphere_lock); + roam_sphere_update_errors(self->sphere); + g_mutex_unlock(self->sphere_lock); #endif - gis_opengl_end(self); + _gis_opengl_end(self); return FALSE; } -static void on_expose_plugin(GisPlugin *plugin, gchar *name, GisOpenGL *self) +static gboolean _draw_level(gpointer key, gpointer value, gpointer user_data) { - set_visuals(self); - glMatrixMode(GL_PROJECTION); glPushMatrix(); - glMatrixMode(GL_MODELVIEW); glPushMatrix(); - gis_plugin_expose(plugin); - glMatrixMode(GL_PROJECTION); glPopMatrix(); - glMatrixMode(GL_MODELVIEW); glPopMatrix(); + g_debug("GisOpenGL: _draw_level - level=%-4d", (int)key); + GisOpenGL *self = user_data; + struct RenderLevel *level = value; + int nsorted = 0, nunsorted = 0; + GList *cur = NULL; + + /* Draw opaque objects without sorting */ + glDepthMask(TRUE); + glClear(GL_DEPTH_BUFFER_BIT); + for (cur = level->unsorted.next; cur; cur = cur->next, nunsorted++) + _draw_object(self, GIS_OBJECT(cur->data)); + + /* Freeze depth buffer and draw transparent objects sorted */ + /* TODO: sorting */ + //glDepthMask(FALSE); + glAlphaFunc(GL_GREATER, 0.1); + for (cur = level->sorted.next; cur; cur = cur->next, nsorted++) + _draw_object(self, GIS_OBJECT(cur->data)); + + /* TODO: Prune empty levels */ + + g_debug("GisOpenGL: _draw_level - drew %d,%d objects", + nunsorted, nsorted); + return FALSE; } + static gboolean on_expose(GisOpenGL *self, GdkEventExpose *event, gpointer _) { g_debug("GisOpenGL: on_expose - begin"); - gis_opengl_begin(self); - - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + _gis_opengl_begin(self); -#ifndef ROAM_DEBUG - set_visuals(self); - glEnable(GL_TEXTURE_2D); - roam_sphere_draw(self->sphere); -#endif + glClear(GL_COLOR_BUFFER_BIT); -#ifdef ROAM_DEBUG - set_visuals(self); + _set_visuals(self); +#ifdef ROAM_DEBUG glColor4f(0.0, 0.0, 9.0, 0.6); glDisable(GL_TEXTURE_2D); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); roam_sphere_draw(self->sphere); + //roam_sphere_draw_normals(self->sphere); +#else + g_tree_foreach(self->objects, _draw_level, self); + if (self->wireframe) { + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + roam_sphere_draw(self->sphere); + } #endif - //glDisable(GL_TEXTURE_2D); - //glEnable(GL_COLOR_MATERIAL); - //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); - //roam_sphere_draw(self->sphere); - - gis_plugins_foreach(self->plugins, G_CALLBACK(on_expose_plugin), self); + GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(self)); + gdk_gl_drawable_swap_buffers(gldrawable); - set_visuals(self); - gis_opengl_end(self); - gis_opengl_flush(self); + _gis_opengl_end(self); g_debug("GisOpenGL: on_expose - end\n"); return FALSE; } -static gboolean on_button_press(GisOpenGL *self, GdkEventButton *event, gpointer _) -{ - g_debug("GisOpenGL: on_button_press - Grabbing focus"); - gtk_widget_grab_focus(GTK_WIDGET(self)); - return TRUE; -} - static gboolean on_key_press(GisOpenGL *self, GdkEventKey *event, gpointer _) { g_debug("GisOpenGL: on_key_press - key=%x, state=%x, plus=%x", event->keyval, event->state, GDK_plus); - double lat, lon, elev, pan; - gis_view_get_location(self->view, &lat, &lon, &elev); - pan = MIN(elev/(EARTH_R/2), 30); guint kv = event->keyval; - if (kv == GDK_Left || kv == GDK_h) gis_view_pan(self->view, 0, -pan, 0); - else if (kv == GDK_Down || kv == GDK_j) gis_view_pan(self->view, -pan, 0, 0); - else if (kv == GDK_Up || kv == GDK_k) gis_view_pan(self->view, pan, 0, 0); - else if (kv == GDK_Right || kv == GDK_l) gis_view_pan(self->view, 0, pan, 0); - else if (kv == GDK_minus || kv == GDK_o) gis_view_zoom(self->view, 10./9); - else if (kv == GDK_plus || kv == GDK_i) gis_view_zoom(self->view, 9./10); - else if (kv == GDK_H) gis_view_rotate(self->view, 0, 0, -10); - else if (kv == GDK_J) gis_view_rotate(self->view, 10, 0, 0); - else if (kv == GDK_K) gis_view_rotate(self->view, -10, 0, 0); - else if (kv == GDK_L) gis_view_rotate(self->view, 0, 0, 10); - + gdk_threads_leave(); /* Testing */ + if (kv == GDK_w) { + self->wireframe = !self->wireframe; + gtk_widget_queue_draw(GTK_WIDGET(self)); + } #ifdef ROAM_DEBUG else if (kv == GDK_n) roam_sphere_split_one(self->sphere); else if (kv == GDK_p) roam_sphere_merge_one(self->sphere); else if (kv == GDK_r) roam_sphere_split_merge(self->sphere); - else if (kv == GDK_u) roam_sphere_update(self->sphere); + else if (kv == GDK_u) roam_sphere_update_errors(self->sphere); + gdk_threads_enter(); gtk_widget_queue_draw(GTK_WIDGET(self)); +#else + gdk_threads_enter(); #endif - - return TRUE; + return FALSE; } -static void on_view_changed(GisView *view, - gdouble _1, gdouble _2, gdouble _3, GisOpenGL *self) +static gboolean _update_errors_cb(gpointer sphere) { - gis_opengl_begin(self); - set_visuals(self); + roam_sphere_update_errors(sphere); + return FALSE; +} +static void on_view_changed(GisOpenGL *self, + gdouble _1, gdouble _2, gdouble _3) +{ + g_debug("GisOpenGL: on_view_changed"); + gdk_threads_enter(); + _gis_opengl_begin(self); + _set_visuals(self); #ifndef ROAM_DEBUG - roam_sphere_update(self->sphere); + g_idle_add_full(G_PRIORITY_HIGH_IDLE+30, _update_errors_cb, self->sphere, NULL); + //roam_sphere_update_errors(self->sphere); #endif - gis_opengl_redraw(self); - gis_opengl_end(self); + _gis_opengl_end(self); + gdk_threads_leave(); } static gboolean on_idle(GisOpenGL *self) { - gis_opengl_begin(self); + //g_debug("GisOpenGL: on_idle"); + gdk_threads_enter(); + _gis_opengl_begin(self); + g_mutex_lock(self->sphere_lock); if (roam_sphere_split_merge(self->sphere)) - gis_opengl_redraw(self); - gis_opengl_end(self); + gtk_widget_queue_draw(GTK_WIDGET(self)); + g_mutex_unlock(self->sphere_lock); + _gis_opengl_end(self); + gdk_threads_leave(); return TRUE; } -/*********** - * Methods * - ***********/ -GisOpenGL *gis_opengl_new(GisWorld *world, GisView *view, GisPlugins *plugins) +/********************* + * GisViewer methods * + *********************/ +GisViewer *gis_opengl_new(GisPlugins *plugins) { g_debug("GisOpenGL: new"); - GisOpenGL *self = g_object_new(GIS_TYPE_OPENGL, NULL); - self->world = world; - self->view = view; + GisViewer *self = g_object_new(GIS_TYPE_OPENGL, NULL); self->plugins = plugins; - g_object_ref(world); - g_object_ref(view); - - g_signal_connect(self->view, "location-changed", G_CALLBACK(on_view_changed), self); - g_signal_connect(self->view, "rotation-changed", G_CALLBACK(on_view_changed), self); - - /* TODO: update point eights sometime later so we have heigh-res heights for them */ - self->sphere = roam_sphere_new(roam_tri_func, roam_height_func, self); - - return g_object_ref(self); + return self; } -void gis_opengl_center_position(GisOpenGL *self, gdouble lat, gdouble lon, gdouble elev) +static void gis_opengl_center_position(GisViewer *_self, gdouble lat, gdouble lon, gdouble elev) { - set_camera(self); + GisOpenGL *self = GIS_OPENGL(_self); glRotatef(lon, 0, 1, 0); glRotatef(-lat, 1, 0, 0); glTranslatef(0, 0, elev2rad(elev)); } -void gis_opengl_redraw(GisOpenGL *self) +static void gis_opengl_project(GisViewer *_self, + gdouble lat, gdouble lon, gdouble elev, + gdouble *px, gdouble *py, gdouble *pz) { - g_debug("GisOpenGL: gl_redraw"); - gtk_widget_queue_draw(GTK_WIDGET(self)); + GisOpenGL *self = GIS_OPENGL(_self); + gdouble x, y, z; + lle2xyz(lat, lon, elev, &x, &y, &z); + gluProject(x, y, z, + self->sphere->view->model, + self->sphere->view->proj, + self->sphere->view->view, + px, py, pz); } -void gis_opengl_begin(GisOpenGL *self) + +static void gis_opengl_render_tile(GisViewer *_self, GisTile *tile) { - g_assert(GIS_IS_OPENGL(self)); + GisOpenGL *self = GIS_OPENGL(_self); + if (!tile || !tile->data) + return; + GList *triangles = roam_sphere_get_intersect(self->sphere, FALSE, + tile->edge.n, tile->edge.s, tile->edge.e, tile->edge.w); + if (!triangles) + g_warning("GisOpenGL: render_tiles - No triangles to draw: edges=%f,%f,%f,%f", + tile->edge.n, tile->edge.s, tile->edge.e, tile->edge.w); + //g_message("rendering %4d triangles for tile edges=%7.2f,%7.2f,%7.2f,%7.2f", + // g_list_length(triangles), tile->edge.n, tile->edge.s, tile->edge.e, tile->edge.w); + for (GList *cur = triangles; cur; cur = cur->next) { + RoamTriangle *tri = cur->data; + + gdouble lat[3] = {tri->p.r->lat, tri->p.m->lat, tri->p.l->lat}; + gdouble lon[3] = {tri->p.r->lon, tri->p.m->lon, tri->p.l->lon}; + + if (lon[0] < -90 || lon[1] < -90 || lon[2] < -90) { + if (lon[0] > 90) lon[0] -= 360; + if (lon[1] > 90) lon[1] -= 360; + if (lon[2] > 90) lon[2] -= 360; + } - GdkGLContext *glcontext = gtk_widget_get_gl_context(GTK_WIDGET(self)); - GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(self)); + gdouble n = tile->edge.n; + gdouble s = tile->edge.s; + gdouble e = tile->edge.e; + gdouble w = tile->edge.w; - if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext)) - g_assert_not_reached(); + gdouble londist = e - w; + gdouble latdist = n - s; + + gdouble xy[3][2] = { + {(lon[0]-w)/londist, 1-(lat[0]-s)/latdist}, + {(lon[1]-w)/londist, 1-(lat[1]-s)/latdist}, + {(lon[2]-w)/londist, 1-(lat[2]-s)/latdist}, + }; + + //if ((lat[0] == 90 && (xy[0][0] < 0 || xy[0][0] > 1)) || + // (lat[1] == 90 && (xy[1][0] < 0 || xy[1][0] > 1)) || + // (lat[2] == 90 && (xy[2][0] < 0 || xy[2][0] > 1))) + // g_message("w,e=%4.f,%4.f " + // "lat,lon,x,y=" + // "%4.1f,%4.0f,%4.2f,%4.2f " + // "%4.1f,%4.0f,%4.2f,%4.2f " + // "%4.1f,%4.0f,%4.2f,%4.2f ", + // w,e, + // lat[0], lon[0], xy[0][0], xy[0][1], + // lat[1], lon[1], xy[1][0], xy[1][1], + // lat[2], lon[2], xy[2][0], xy[2][1]); + + /* Fix poles */ + if (lat[0] == 90 || lat[0] == -90) xy[0][0] = 0.5; + if (lat[1] == 90 || lat[1] == -90) xy[1][0] = 0.5; + if (lat[2] == 90 || lat[2] == -90) xy[2][0] = 0.5; + + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, *(guint*)tile->data); + glBegin(GL_TRIANGLES); + glNormal3dv(tri->p.r->norm); glTexCoord2dv(xy[0]); glVertex3dv((double*)tri->p.r); + glNormal3dv(tri->p.m->norm); glTexCoord2dv(xy[1]); glVertex3dv((double*)tri->p.m); + glNormal3dv(tri->p.l->norm); glTexCoord2dv(xy[2]); glVertex3dv((double*)tri->p.l); + glEnd(); + } + g_list_free(triangles); } -void gis_opengl_end(GisOpenGL *self) + +static void gis_opengl_render_tiles(GisViewer *_self, GisTile *tile) { - g_assert(GIS_IS_OPENGL(self)); - GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(self)); - gdk_gl_drawable_gl_end(gldrawable); + GisOpenGL *self = GIS_OPENGL(_self); + /* Only render children if possible */ + gboolean has_children = TRUE; + GisTile *child; + gis_tile_foreach(tile, child) + if (!child || !child->data) + has_children = FALSE; + if (has_children) + /* Only render children */ + gis_tile_foreach(tile, child) + gis_opengl_render_tiles(_self, child); + else + /* No children, render this tile */ + gis_opengl_render_tile(_self, tile); } -void gis_opengl_flush(GisOpenGL *self) + +static void gis_opengl_set_height_func(GisViewer *_self, GisTile *tile, + RoamHeightFunc height_func, gpointer user_data, gboolean update) { - g_assert(GIS_IS_OPENGL(self)); - GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(GTK_WIDGET(self)); - if (gdk_gl_drawable_is_double_buffered(gldrawable)) - gdk_gl_drawable_swap_buffers(gldrawable); - else - glFlush(); - gdk_gl_drawable_gl_end(gldrawable); + GisOpenGL *self = GIS_OPENGL(_self); + if (!tile) + return; + /* TODO: get points? */ + g_mutex_lock(self->sphere_lock); + GList *triangles = roam_sphere_get_intersect(self->sphere, TRUE, + tile->edge.n, tile->edge.s, tile->edge.e, tile->edge.w); + for (GList *cur = triangles; cur; cur = cur->next) { + RoamTriangle *tri = cur->data; + RoamPoint *points[] = {tri->p.l, tri->p.m, tri->p.r, tri->split}; + for (int i = 0; i < G_N_ELEMENTS(points); i++) { + if (tile->edge.n >= points[i]->lat && points[i]->lat >= tile->edge.s && + tile->edge.e >= points[i]->lon && points[i]->lon >= tile->edge.w) { + points[i]->height_func = height_func; + points[i]->height_data = user_data; + roam_point_update_height(points[i]); + } + } + } + g_list_free(triangles); + g_mutex_unlock(self->sphere_lock); +} + +static void _gis_opengl_clear_height_func_rec(RoamTriangle *root) +{ + if (!root) + return; + RoamPoint *points[] = {root->p.l, root->p.m, root->p.r, root->split}; + for (int i = 0; i < G_N_ELEMENTS(points); i++) { + points[i]->height_func = NULL; + points[i]->height_data = NULL; + roam_point_update_height(points[i]); + } + _gis_opengl_clear_height_func_rec(root->kids[0]); + _gis_opengl_clear_height_func_rec(root->kids[1]); } +static void gis_opengl_clear_height_func(GisViewer *_self) +{ + GisOpenGL *self = GIS_OPENGL(_self); + for (int i = 0; i < G_N_ELEMENTS(self->sphere->roots); i++) + _gis_opengl_clear_height_func_rec(self->sphere->roots[i]); +} + +static void gis_opengl_begin(GisViewer *_self) +{ + g_assert(GIS_IS_OPENGL(_self)); + _gis_opengl_begin(GIS_OPENGL(_self)); +} + +static void gis_opengl_end(GisViewer *_self) +{ + g_assert(GIS_IS_OPENGL(_self)); + _gis_opengl_end(GIS_OPENGL(_self)); +} + +static gpointer gis_opengl_add(GisViewer *_self, GisObject *object, + gint key, gboolean sort) +{ + g_assert(GIS_IS_OPENGL(_self)); + GisOpenGL *self = GIS_OPENGL(_self); + _load_object(self, object); + struct RenderLevel *level = g_tree_lookup(self->objects, (gpointer)key); + if (!level) { + level = g_new0(struct RenderLevel, 1); + g_tree_insert(self->objects, (gpointer)key, level); + } + GList *list = sort ? &level->sorted : &level->unsorted; + list->next = g_list_prepend(list->next, object); + return list->next; +} + +static void gis_opengl_remove(GisViewer *_self, gpointer _link) +{ + g_assert(GIS_IS_OPENGL(_self)); + GList *link = _link; + GisOpenGL *self = GIS_OPENGL(_self); + _unload_object(self, link->data); + /* Just unlink and free it (blowup link to avoid warnings) */ + link = g_list_delete_link(NULL, link); +} /**************** * GObject code * ****************/ -G_DEFINE_TYPE(GisOpenGL, gis_opengl, GTK_TYPE_DRAWING_AREA); +static int _objects_cmp(gconstpointer _a, gconstpointer _b) +{ + gint a = (int)_a, b = (int)_b; + return a < b ? -1 : + a > b ? 1 : 0; +} + +G_DEFINE_TYPE(GisOpenGL, gis_opengl, GIS_TYPE_VIEWER); static void gis_opengl_init(GisOpenGL *self) { g_debug("GisOpenGL: init"); - self->bmng = wms_info_new_for_bmng(NULL, NULL); - self->srtm = wms_info_new_for_srtm(NULL, NULL); - /* OpenGL setup */ GdkGLConfig *glconfig = gdk_gl_config_new_by_mode( GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | @@ -529,60 +646,62 @@ static void gis_opengl_init(GisOpenGL *self) GDK_KEY_PRESS_MASK); g_object_set(self, "can-focus", TRUE, NULL); + self->objects = g_tree_new(_objects_cmp); + self->sphere = roam_sphere_new(self); + self->sphere_lock = g_mutex_new(); + #ifndef ROAM_DEBUG - self->sm_source = g_timeout_add(10, (GSourceFunc)on_idle, self); + self->sm_source[0] = g_timeout_add_full(G_PRIORITY_HIGH_IDLE+30, 33, (GSourceFunc)on_idle, self, NULL); + self->sm_source[1] = g_timeout_add_full(G_PRIORITY_HIGH_IDLE+10, 500, (GSourceFunc)on_idle, self, NULL); #endif - g_signal_connect(self, "realize", G_CALLBACK(on_realize), NULL); - g_signal_connect(self, "configure-event", G_CALLBACK(on_configure), NULL); - g_signal_connect(self, "expose-event", G_CALLBACK(on_expose), NULL); + g_signal_connect(self, "realize", G_CALLBACK(on_realize), NULL); + g_signal_connect(self, "configure-event", G_CALLBACK(on_configure), NULL); + g_signal_connect(self, "expose-event", G_CALLBACK(on_expose), NULL); - g_signal_connect(self, "button-press-event", G_CALLBACK(on_button_press), NULL); - g_signal_connect(self, "enter-notify-event", G_CALLBACK(on_button_press), NULL); - g_signal_connect(self, "key-press-event", G_CALLBACK(on_key_press), NULL); -} -static GObject *gis_opengl_constructor(GType gtype, guint n_properties, - GObjectConstructParam *properties) -{ - g_debug("GisOpengl: constructor"); - GObjectClass *parent_class = G_OBJECT_CLASS(gis_opengl_parent_class); - return parent_class->constructor(gtype, n_properties, properties); + g_signal_connect(self, "key-press-event", G_CALLBACK(on_key_press), NULL); + + g_signal_connect(self, "location-changed", G_CALLBACK(on_view_changed), NULL); + g_signal_connect(self, "rotation-changed", G_CALLBACK(on_view_changed), NULL); } static void gis_opengl_dispose(GObject *_self) { g_debug("GisOpenGL: dispose"); GisOpenGL *self = GIS_OPENGL(_self); - if (self->sm_source) { - g_source_remove(self->sm_source); - self->sm_source = 0; - } - if (self->sphere) { - roam_sphere_free(self->sphere); - self->sphere = NULL; - } - if (self->world) { - g_object_unref(self->world); - self->world = NULL; + if (self->sm_source[0]) { + g_source_remove(self->sm_source[0]); + self->sm_source[0] = 0; } - if (self->view) { - g_object_unref(self->view); - self->view = NULL; + if (self->sm_source[1]) { + g_source_remove(self->sm_source[1]); + self->sm_source[1] = 0; } + /* TODO: Cleanup/free objects tree */ G_OBJECT_CLASS(gis_opengl_parent_class)->dispose(_self); } static void gis_opengl_finalize(GObject *_self) { - g_debug("GisOpenGL: finalize"); + g_debug("GisViewer: finalize"); GisOpenGL *self = GIS_OPENGL(_self); - wms_info_free(self->bmng); - wms_info_free(self->srtm); + roam_sphere_free(self->sphere); + g_mutex_free(self->sphere_lock); G_OBJECT_CLASS(gis_opengl_parent_class)->finalize(_self); } static void gis_opengl_class_init(GisOpenGLClass *klass) { g_debug("GisOpenGL: class_init"); GObjectClass *gobject_class = G_OBJECT_CLASS(klass); - gobject_class->constructor = gis_opengl_constructor; - gobject_class->dispose = gis_opengl_dispose; - gobject_class->finalize = gis_opengl_finalize; + gobject_class->dispose = gis_opengl_dispose; + + GisViewerClass *viewer_class = GIS_VIEWER_CLASS(klass); + viewer_class->center_position = gis_opengl_center_position; + viewer_class->project = gis_opengl_project; + viewer_class->clear_height_func = gis_opengl_clear_height_func; + viewer_class->set_height_func = gis_opengl_set_height_func; + viewer_class->render_tile = gis_opengl_render_tile; + viewer_class->render_tiles = gis_opengl_render_tiles; + viewer_class->begin = gis_opengl_begin; + viewer_class->end = gis_opengl_end; + viewer_class->add = gis_opengl_add; + viewer_class->remove = gis_opengl_remove; }