X-Git-Url: http://pileus.org/git/?p=grits;a=blobdiff_plain;f=src%2Fobjects%2Fgrits-tile.c;h=6ea70f88cbf052e38073b8087e3ea300c7f19c79;hp=14e699d270a00531f6ba79e3250922f559d1732e;hb=8594927c0cd07daea95e8b99dc36ffef4f12da8a;hpb=4bef8517366b0195e321add06250e7d659434661 diff --git a/src/objects/grits-tile.c b/src/objects/grits-tile.c index 14e699d..6ea70f8 100644 --- a/src/objects/grits-tile.c +++ b/src/objects/grits-tile.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009-2010 Andy Spencer + * Copyright (C) 2009-2010, 2012 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 @@ -16,33 +16,38 @@ */ /** - * SECTION:gis-tile + * SECTION:grits-tile * @short_description: Latitude/longitude overlays * - * Each #GisTile corresponds to a latitude/longitude box on the surface of the - * earth. When drawn, the #GisTile renders an images associated with it to the - * surface of the earth. This is primarily used to draw ground overlays. + * Each #GritsTile corresponds to a latitude/longitude box on the surface of + * the earth. When drawn, the #GritsTile renders an images associated with it + * to the surface of the earth. This is primarily used to draw ground overlays. * - * Each GisTile can be split into subtiles in order to draw higher resolution + * Each GritsTile can be split into subtiles in order to draw higher resolution * overlays. Pointers to subtitles are stored in the parent tile and a parent * pointer is stored in each child. * - * Each #GisTile has a data filed which must be set by the user in order for - * the tile to be drawn. When used with GisOpenGL the data must be an integer + * Each #GritsTile has a data filed which must be set by the user in order for + * the tile to be drawn. When used with GritsOpenGL the data must be an integer * representing the OpenGL texture to use when drawing the tile. */ +#define GL_GLEXT_PROTOTYPES #include -#include -#include "gis-tile.h" +#include +#include +#include "gtkgl.h" +#include "grits-tile.h" -gchar *gis_tile_path_table[2][2] = { +static guint grits_tile_mask = 0; + +gchar *grits_tile_path_table[2][2] = { {"00.", "01."}, {"10.", "11."}, }; /** - * gis_tile_new: + * grits_tile_new: * @parent: the parent for the tile, or NULL * @n: the northern border of the tile * @s: the southern border of the tile @@ -51,21 +56,23 @@ gchar *gis_tile_path_table[2][2] = { * * Create a tile associated with a particular latitude/longitude box. * - * Returns: the new #GisTile + * Returns: the new #GritsTile */ -GisTile *gis_tile_new(GisTile *parent, +GritsTile *grits_tile_new(GritsTile *parent, gdouble n, gdouble s, gdouble e, gdouble w) { - GisTile *tile = g_object_new(GIS_TYPE_TILE, NULL); + GritsTile *tile = g_object_new(GRITS_TYPE_TILE, NULL); tile->parent = parent; tile->atime = time(NULL); - gis_bounds_set_bounds(&tile->coords, 0, 1, 1, 0); - gis_bounds_set_bounds(&tile->edge, n, s, e, w); + grits_bounds_set_bounds(&tile->coords, 0, 1, 1, 0); + grits_bounds_set_bounds(&tile->edge, n, s, e, w); + if (parent) + tile->proj = parent->proj; return tile; } /** - * gis_tile_get_path: + * grits_tile_get_path: * @child: the tile to generate a path for * * Generate a string representation of a tiles location in a group of nested @@ -75,15 +82,15 @@ GisTile *gis_tile_new(GisTile *parent, * * Returns: the path representing the tiles's location */ -gchar *gis_tile_get_path(GisTile *child) +gchar *grits_tile_get_path(GritsTile *child) { /* This could be easily cached if necessary */ int x, y; GList *parts = NULL; - for (GisTile *parent = child->parent; parent; child = parent, parent = child->parent) - gis_tile_foreach_index(child, x, y) + for (GritsTile *parent = child->parent; parent; child = parent, parent = child->parent) + grits_tile_foreach_index(child, x, y) if (parent->children[x][y] == child) - parts = g_list_prepend(parts, gis_tile_path_table[x][y]); + parts = g_list_prepend(parts, grits_tile_path_table[x][y]); GString *path = g_string_new(""); for (GList *cur = parts; cur; cur = cur->next) g_string_append(path, cur->data); @@ -91,9 +98,9 @@ gchar *gis_tile_get_path(GisTile *child) return g_string_free(path, FALSE); } -static gdouble _gis_tile_get_min_dist(GisPoint *eye, GisBounds *bounds) +static gdouble _grits_tile_get_min_dist(GritsPoint *eye, GritsBounds *bounds) { - GisPoint pos = {}; + GritsPoint pos = {}; pos.lat = eye->lat > bounds->n ? bounds->n : eye->lat < bounds->s ? bounds->s : eye->lat; pos.lon = eye->lon > bounds->e ? bounds->e : @@ -106,10 +113,10 @@ static gdouble _gis_tile_get_min_dist(GisPoint *eye, GisBounds *bounds) return distd(a, b); } -static gboolean _gis_tile_precise(GisPoint *eye, GisBounds *bounds, +static gboolean _grits_tile_precise(GritsPoint *eye, GritsBounds *bounds, gdouble max_res, gint width, gint height) { - gdouble min_dist = _gis_tile_get_min_dist(eye, bounds); + gdouble min_dist = _grits_tile_get_min_dist(eye, bounds); gdouble view_res = MPPX(min_dist); gdouble lat_point = bounds->n < 0 ? bounds->n : @@ -117,24 +124,69 @@ static gboolean _gis_tile_precise(GisPoint *eye, GisBounds *bounds, gdouble lon_dist = bounds->e - bounds->w; gdouble tile_res = ll2m(lon_dist, lat_point)/width; - /* This isn't really right, but it helps with memory since we don't (yet?) test if the tile - * would be drawn */ + /* This isn't really right, but it helps with memory since we don't + * (yet?) test if the tile would be drawn */ gdouble scale = eye->elev / min_dist; view_res /= scale; + view_res *= 1.8; //view_res /= 1.4; /* make it a little nicer, not sure why this is needed */ //g_message("tile=(%7.2f %7.2f %7.2f %7.2f) " // "eye=(%9.1f %9.1f %9.1f) " // "elev=%9.1f / dist=%9.1f = %f", - // tile->edge.n, tile->edge.s, tile->edge.e, tile->edge.w, - // lat, lon, elev, - // elev, min_dist, scale); + // bounds->n, bounds->s, bounds->e, bounds->w, + // eye->lat, eye->lon, eye->elev, + // eye->elev, min_dist, scale); return tile_res < max_res || tile_res < view_res; } +static void _grits_tile_split_latlon(GritsTile *tile) +{ + //g_debug("GritsTile: split - %p", tile); + const gdouble rows = G_N_ELEMENTS(tile->children); + const gdouble cols = G_N_ELEMENTS(tile->children[0]); + const gdouble lat_dist = tile->edge.n - tile->edge.s; + const gdouble lon_dist = tile->edge.e - tile->edge.w; + const gdouble lat_step = lat_dist / rows; + const gdouble lon_step = lon_dist / cols; + + int row, col; + grits_tile_foreach_index(tile, row, col) { + if (!tile->children[row][col]) + tile->children[row][col] = + grits_tile_new(tile, 0, 0, 0, 0); + /* Set edges aferwards so that north and south + * get reset for mercator projections */ + GritsTile *child = tile->children[row][col]; + child->edge.n = tile->edge.n - lat_step*(row+0); + child->edge.s = tile->edge.n - lat_step*(row+1); + child->edge.e = tile->edge.w + lon_step*(col+1); + child->edge.w = tile->edge.w + lon_step*(col+0); + } +} + +static void _grits_tile_split_mercator(GritsTile *tile) +{ + GritsTile *child = NULL; + GritsBounds tmp = tile->edge; + + /* Project */ + tile->edge.n = asinh(tan(deg2rad(tile->edge.n))); + tile->edge.s = asinh(tan(deg2rad(tile->edge.s))); + + _grits_tile_split_latlon(tile); + + /* Convert back to lat-lon */ + tile->edge = tmp; + grits_tile_foreach(tile, child) { + child->edge.n = rad2deg(atan(sinh(child->edge.n))); + child->edge.s = rad2deg(atan(sinh(child->edge.s))); + } +} + /** - * gis_tile_update: + * grits_tile_update: * @root: the root tile to split * @eye: the point the tile is viewed from, for calculating distances * @res: a maximum resolution in meters per pixel to split tiles to @@ -149,43 +201,53 @@ static gboolean _gis_tile_precise(GisPoint *eye, GisBounds *bounds, * the tile is recursively subdivided until a sufficient resolution is * achieved. */ -void gis_tile_update(GisTile *root, GisPoint *eye, +void grits_tile_update(GritsTile *tile, GritsPoint *eye, gdouble res, gint width, gint height, - GisTileLoadFunc load_func, gpointer user_data) + GritsTileLoadFunc load_func, gpointer user_data) { - root->atime = time(NULL); - //g_debug("GisTile: update - %p->atime = %u", - // root, (guint)root->atime); - const gdouble rows = G_N_ELEMENTS(root->children); - const gdouble cols = G_N_ELEMENTS(root->children[0]); - const gdouble lat_dist = root->edge.n - root->edge.s; - const gdouble lon_dist = root->edge.e - root->edge.w; - const gdouble lat_step = lat_dist / rows; - const gdouble lon_step = lon_dist / cols; - int row, col; - gis_tile_foreach_index(root, row, col) { - GisTile **child = &root->children[row][col]; - GisBounds edge; - edge.n = root->edge.n-(lat_step*(row+0)); - edge.s = root->edge.n-(lat_step*(row+1)); - edge.e = root->edge.w+(lon_step*(col+1)); - edge.w = root->edge.w+(lon_step*(col+0)); - if (!_gis_tile_precise(eye, &edge, res, - width/cols, height/rows)) { - if (!*child) { - *child = gis_tile_new(root, edge.n, edge.s, - edge.e, edge.w); - load_func(*child, user_data); + GritsTile *child; + + if (tile == NULL) + return; + + //g_debug("GritsTile: update - %p->atime = %u", + // tile, (guint)tile->atime); + + /* Is the parent tile's texture high enough + * resolution for this part? */ + gint xs = G_N_ELEMENTS(tile->children); + gint ys = G_N_ELEMENTS(tile->children[0]); + if (tile->parent && _grits_tile_precise(eye, &tile->edge, + res, width/xs, height/ys)) { + GRITS_OBJECT(tile)->hidden = TRUE; + return; + } + + /* Load the tile */ + if (!tile->load && !tile->data) + load_func(tile, user_data); + tile->atime = time(NULL); + tile->load = TRUE; + GRITS_OBJECT(tile)->hidden = FALSE; + + /* Split tile if needed */ + grits_tile_foreach(tile, child) { + if (child == NULL) { + switch (tile->proj) { + case GRITS_PROJ_LATLON: _grits_tile_split_latlon(tile); break; + case GRITS_PROJ_MERCATOR: _grits_tile_split_mercator(tile); break; } - gis_tile_update(*child, eye, - res, width, height, - load_func, user_data); } } + + /* Update recursively */ + grits_tile_foreach(tile, child) + grits_tile_update(child, eye, res, width, height, + load_func, user_data); } /** - * gis_tile_find: + * grits_tile_find: * @root: the root tile to search from * @lat: target latitude * @lon: target longitude @@ -195,7 +257,7 @@ void gis_tile_update(GisTile *root, GisPoint *eye, * * Returns: the child tile */ -GisTile *gis_tile_find(GisTile *root, gdouble lat, gdouble lon) +GritsTile *grits_tile_find(GritsTile *root, gdouble lat, gdouble lon) { gint rows = G_N_ELEMENTS(root->children); gint cols = G_N_ELEMENTS(root->children[0]); @@ -219,13 +281,13 @@ GisTile *gis_tile_find(GisTile *root, gdouble lat, gdouble lon) if (row < 0 || row >= rows || col < 0 || col >= cols) return NULL; else if (root->children[row][col] && root->children[row][col]->data) - return gis_tile_find(root->children[row][col], lat, lon); + return grits_tile_find(root->children[row][col], lat, lon); else return root; } /** - * gis_tile_gc: + * grits_tile_gc: * @root: the root tile to start garbage collection at * @atime: most recent time at which tiles will be kept * @free_func: function used to free the image when a new tile is collected @@ -236,24 +298,27 @@ GisTile *gis_tile_find(GisTile *root, gdouble lat, gdouble lon) * * Returns: a pointer to the original tile, or NULL if it was garbage collected */ -GisTile *gis_tile_gc(GisTile *root, time_t atime, - GisTileFreeFunc free_func, gpointer user_data) +GritsTile *grits_tile_gc(GritsTile *root, time_t atime, + GritsTileFreeFunc free_func, gpointer user_data) { if (!root) return NULL; gboolean has_children = FALSE; int x, y; - gis_tile_foreach_index(root, x, y) { - root->children[x][y] = gis_tile_gc( + grits_tile_foreach_index(root, x, y) { + root->children[x][y] = grits_tile_gc( root->children[x][y], atime, free_func, user_data); if (root->children[x][y]) has_children = TRUE; } - //g_debug("GisTile: gc - %p->atime=%u < atime=%u", - // root, (guint)root->atime, (guint)atime); - if (!has_children && root->atime < atime && root->data) { - free_func(root, user_data); + //g_debug("GritsTile: gc - %p kids=%d time=%d data=%d load=%d", + // root, !!has_children, root->atime < atime, !!root->data, !!root->load); + if (root->parent && !has_children && root->atime < atime && + (root->data || !root->load)) { + //g_debug("GritsTile: gc/free - %p", root); + if (root->data) + free_func(root, user_data); g_object_unref(root); return NULL; } @@ -262,35 +327,60 @@ GisTile *gis_tile_gc(GisTile *root, time_t atime, /* Use GObject for this */ /** - * gis_tile_free: + * grits_tile_free: * @root: the root tile to free * @free_func: function used to free the image when a new tile is collected * @user_data: user data to past to the free function * * Recursively free a tile and all it's children. */ -void gis_tile_free(GisTile *root, GisTileFreeFunc free_func, gpointer user_data) +void grits_tile_free(GritsTile *root, GritsTileFreeFunc free_func, gpointer user_data) { if (!root) return; - GisTile *child; - gis_tile_foreach(root, child) - gis_tile_free(child, free_func, user_data); + GritsTile *child; + grits_tile_foreach(root, child) + grits_tile_free(child, free_func, user_data); if (free_func) free_func(root, user_data); g_object_unref(root); } +/* Load texture mask so we can draw a texture to just a part of a triangle */ +static guint _grits_tile_load_mask(void) +{ + guint tex; + const int width = 256, height = 256; + guint8 *bytes = g_malloc(width*height); + memset(bytes, 0xff, width*height); + glGenTextures(1, &tex); + glBindTexture(GL_TEXTURE_2D, tex); + + glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, + GL_ALPHA, GL_UNSIGNED_BYTE, bytes); + + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); + g_free(bytes); + return tex; +} + /* Draw a single tile */ -static void gis_tile_draw_one(GisTile *tile, GisOpenGL *opengl, GList *triangles) +static void grits_tile_draw_one(GritsTile *tile, GritsOpenGL *opengl, GList *triangles) { if (!tile || !tile->data) return; if (!triangles) - g_warning("GisOpenGL: _draw_tiles - No triangles to draw: edges=%f,%f,%f,%f", + g_warning("GritsOpenGL: _draw_tiles - No triangles to draw: edges=%f,%f,%f,%f", tile->edge.n, tile->edge.s, tile->edge.e, tile->edge.w); + //g_message("drawing %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); + tile->atime = time(NULL); + gdouble n = tile->edge.n; gdouble s = tile->edge.s; gdouble e = tile->edge.e; @@ -302,6 +392,8 @@ static void gis_tile_draw_one(GisTile *tile, GisOpenGL *opengl, GList *triangles gdouble xscale = tile->coords.e - tile->coords.w; gdouble yscale = tile->coords.s - tile->coords.n; + glPolygonOffset(0, -tile->zindex); + for (GList *cur = triangles; cur; cur = cur->next) { RoamTriangle *tri = cur->data; @@ -344,78 +436,93 @@ static void gis_tile_draw_one(GisTile *tile, GisOpenGL *opengl, GList *triangles xy[i][1] = tile->coords.n + xy[i][1]*yscale; } - glEnable(GL_TEXTURE_2D); - glEnable(GL_POLYGON_OFFSET_FILL); + /* Draw triangle */ glBindTexture(GL_TEXTURE_2D, *(guint*)tile->data); - glPolygonOffset(0, -tile->zindex); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 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); + glNormal3dv(tri->p.r->norm); glMultiTexCoord2dv(GL_TEXTURE0, xy[0]); glMultiTexCoord2dv(GL_TEXTURE1, xy[0]); glVertex3dv((double*)tri->p.r); + glNormal3dv(tri->p.m->norm); glMultiTexCoord2dv(GL_TEXTURE0, xy[1]); glMultiTexCoord2dv(GL_TEXTURE1, xy[1]); glVertex3dv((double*)tri->p.m); + glNormal3dv(tri->p.l->norm); glMultiTexCoord2dv(GL_TEXTURE0, xy[2]); glMultiTexCoord2dv(GL_TEXTURE1, xy[2]); glVertex3dv((double*)tri->p.l); glEnd(); } } /* Draw the tile */ -static void gis_tile_draw_rec(GisTile *tile, GisOpenGL *opengl) +static gboolean grits_tile_draw_rec(GritsTile *tile, GritsOpenGL *opengl) { - /* Only draw children if possible */ - gboolean has_children = FALSE; - GisTile *child; - gis_tile_foreach(tile, child) - if (child && child->data) - has_children = TRUE; + //g_debug("GritsTile: draw_rec - tile=%p, data=%d, load=%d, hide=%d", tile, + // tile ? !!tile->data : 0, + // tile ? !!tile->load : 0, + // tile ? !!GRITS_OBJECT(tile)->hidden : 0); - GList *triangles = NULL; - if (has_children) { - /* TODO: simplify this */ - const gdouble rows = G_N_ELEMENTS(tile->children); - const gdouble cols = G_N_ELEMENTS(tile->children[0]); - const gdouble lat_dist = tile->edge.n - tile->edge.s; - const gdouble lon_dist = tile->edge.e - tile->edge.w; - const gdouble lat_step = lat_dist / rows; - const gdouble lon_step = lon_dist / cols; - int row, col; - gis_tile_foreach_index(tile, row, col) { - GisTile *child = tile->children[row][col]; - if (child && child->data) { - gis_tile_draw_rec(child, opengl); - } else { - const gdouble n = tile->edge.n-(lat_step*(row+0)); - const gdouble s = tile->edge.n-(lat_step*(row+1)); - const gdouble e = tile->edge.w+(lon_step*(col+1)); - const gdouble w = tile->edge.w+(lon_step*(col+0)); - GList *these = roam_sphere_get_intersect(opengl->sphere, - FALSE, n, s, e, w); - triangles = g_list_concat(triangles, these); - } - } - } else { - triangles = roam_sphere_get_intersect(opengl->sphere, FALSE, + if (!tile || !tile->data || GRITS_OBJECT(tile)->hidden) + return FALSE; + + GritsTile *child = NULL; + + /* Draw child tiles */ + gboolean draw_parent = FALSE; + grits_tile_foreach(tile, child) + if (!grits_tile_draw_rec(child, opengl)) + draw_parent = TRUE; + + /* Draw parent tile underneath using depth test */ + if (draw_parent) { + GList *triangles = roam_sphere_get_intersect(opengl->sphere, FALSE, tile->edge.n, tile->edge.s, tile->edge.e, tile->edge.w); + grits_tile_draw_one(tile, opengl, triangles); + g_list_free(triangles); } - if (triangles) - gis_tile_draw_one(tile, opengl, triangles); - g_list_free(triangles); + + return TRUE; } -static void gis_tile_draw(GisObject *tile, GisOpenGL *opengl) +static void grits_tile_draw(GritsObject *tile, GritsOpenGL *opengl) { glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); - gis_tile_draw_rec(GIS_TILE(tile), opengl); + glEnable(GL_ALPHA_TEST); + glAlphaFunc(GL_GREATER, 0.1); + glEnable(GL_POLYGON_OFFSET_FILL); + glEnable(GL_BLEND); + + /* Setup texture mask */ + if (!grits_tile_mask) + grits_tile_mask = _grits_tile_load_mask(); + glActiveTexture(GL_TEXTURE1); + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, grits_tile_mask); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + /* Setup texture */ + glActiveTexture(GL_TEXTURE0); + glEnable(GL_TEXTURE_2D); + + /* Hack to show maps tiles with better color */ + if (GRITS_TILE(tile)->proj == GRITS_PROJ_MERCATOR) { + float material_emission[] = {0.5, 0.5, 0.5, 1.0}; + glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, material_emission); + } + + /* Draw all tiles */ + grits_tile_draw_rec(GRITS_TILE(tile), opengl); + + /* Disable texture mask */ + glActiveTexture(GL_TEXTURE1); + glDisable(GL_TEXTURE_2D); + glActiveTexture(GL_TEXTURE0); } /* GObject code */ -G_DEFINE_TYPE(GisTile, gis_tile, GIS_TYPE_OBJECT); -static void gis_tile_init(GisTile *tile) +G_DEFINE_TYPE(GritsTile, grits_tile, GRITS_TYPE_OBJECT); +static void grits_tile_init(GritsTile *tile) { } -static void gis_tile_class_init(GisTileClass *klass) +static void grits_tile_class_init(GritsTileClass *klass) { - g_debug("GisTile: class_init"); - GisObjectClass *object_class = GIS_OBJECT_CLASS(klass); - object_class->draw = gis_tile_draw; + g_debug("GritsTile: class_init"); + GritsObjectClass *object_class = GRITS_OBJECT_CLASS(klass); + object_class->draw = grits_tile_draw; }