X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=src%2Fobjects%2Fgrits-tile.c;h=f269e5e9752995e1dcfa5458afd4c61472325b52;hb=6ec0202fba35eb878af793ed6086ff928f13ce5b;hp=c71be5071bc4b953313b3bd13cf99f82daa912e2;hpb=d8948985b467a5cfd0447ae413ed1c5d01afb024;p=grits diff --git a/src/objects/grits-tile.c b/src/objects/grits-tile.c index c71be50..f269e5e 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,36 @@ */ /** - * 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. */ #include -#include +#include +#include "gtkgl.h" #include "grits-tile.h" -gchar *gis_tile_path_table[2][2] = { +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 +54,25 @@ 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; + tile->zindex = parent->zindex+1; + } 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,68 @@ 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) +{ + 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 +200,52 @@ 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 (_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 +255,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 +279,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 +296,26 @@ 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", + //g_debug("GritsTile: 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); + if (!has_children && root->atime < atime && + (root->data || !root->load)) { + if (root->data) + free_func(root, user_data); g_object_unref(root); return NULL; } @@ -262,35 +324,59 @@ 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; + guint8 byte = 0xff; + glGenTextures(1, &tex); + glBindTexture(GL_TEXTURE_2D, tex); + + glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 1, 1, 0, + GL_ALPHA, GL_UNSIGNED_BYTE, &byte); + + 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); + 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); + if (!grits_tile_mask) + grits_tile_mask = _grits_tile_load_mask(); + //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; @@ -344,78 +430,102 @@ 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); + /* Polygon offset */ glEnable(GL_POLYGON_OFFSET_FILL); - glBindTexture(GL_TEXTURE_2D, *(guint*)tile->data); glPolygonOffset(0, -tile->zindex); + + /* Setup texture */ + glActiveTexture(GL_TEXTURE0); + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, *(guint*)tile->data); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + /* Enable texture mask */ + if (tile->proj == GRITS_PROJ_MERCATOR) { + glActiveTexture(GL_TEXTURE1); + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, grits_tile_mask); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + /* Hack to show maps tiles with better color */ + float material_emission[] = {0.5, 0.5, 0.5, 1.0}; + glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, material_emission); + + glEnable(GL_BLEND); + } + + /* Draw triangle */ 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(); + + /* Disable texture mask */ + glDisable(GL_TEXTURE_2D); + glActiveTexture(GL_TEXTURE0); } } /* 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; - - 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); - } + //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); + + if (!tile || !tile->data || GRITS_OBJECT(tile)->hidden) + return FALSE; + + GritsTile *child = NULL; + gboolean done = FALSE; + while (!done) { + /* Only draw children if possible */ + gboolean draw_parent = FALSE; + grits_tile_foreach(tile, child) + if (!child || !child->data || GRITS_OBJECT(child)->hidden) + draw_parent = TRUE; + + /* Draw parent tile underneath */ + 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); } - } else { - triangles = roam_sphere_get_intersect(opengl->sphere, FALSE, - tile->edge.n, tile->edge.s, tile->edge.e, tile->edge.w); + + /* Draw child tiles */ + gboolean drew_all_children = TRUE; + grits_tile_foreach(tile, child) + if (!grits_tile_draw_rec(child, opengl)) + drew_all_children = FALSE; + + /* Check if tiles were hidden by a thread while drawing */ + done = draw_parent || drew_all_children; } - 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); + grits_tile_draw_rec(GRITS_TILE(tile), opengl); } /* 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; }