X-Git-Url: http://pileus.org/git/?p=grits;a=blobdiff_plain;f=src%2Fobjects%2Fgrits-tile.c;h=6ea70f88cbf052e38073b8087e3ea300c7f19c79;hp=c8326daeb5ec998d17694c96e288d115e7abce7e;hb=8594927c0cd07daea95e8b99dc36ffef4f12da8a;hpb=ce0016070b1fe7db3bd208d6148a776efd3f7d6e

diff --git a/src/objects/grits-tile.c b/src/objects/grits-tile.c
index c8326da..6ea70f8 100644
--- a/src/objects/grits-tile.c
+++ b/src/objects/grits-tile.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2010 Andy Spencer <andy753421@gmail.com>
+ * Copyright (C) 2009-2010, 2012 Andy Spencer <andy753421@gmail.com>
  *
  * 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
@@ -32,10 +32,15 @@
  * representing the OpenGL texture to use when drawing the tile.
  */
 
+#define GL_GLEXT_PROTOTYPES
 #include <config.h>
+#include <math.h>
+#include <string.h>
 #include "gtkgl.h"
 #include "grits-tile.h"
 
+static guint  grits_tile_mask = 0;
+
 gchar *grits_tile_path_table[2][2] = {
 	{"00.", "01."},
 	{"10.", "11."},
@@ -61,6 +66,8 @@ GritsTile *grits_tile_new(GritsTile *parent,
 	tile->atime  = time(NULL);
 	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;
 }
 
@@ -117,22 +124,67 @@ static gboolean _grits_tile_precise(GritsPoint *eye, GritsBounds *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)));
+	}
+}
+
 /**
  * grits_tile_update:
  * @root:      the root tile to split
@@ -149,43 +201,49 @@ static gboolean _grits_tile_precise(GritsPoint *eye, GritsBounds *bounds,
  * the tile is recursively subdivided until a sufficient resolution is
  * achieved.
  */
-void grits_tile_update(GritsTile *root, GritsPoint *eye,
+void grits_tile_update(GritsTile *tile, GritsPoint *eye,
 		gdouble res, gint width, gint height,
 		GritsTileLoadFunc load_func, gpointer user_data)
 {
-	root->atime = time(NULL);
+	GritsTile *child;
+
+	if (tile == NULL)
+		return;
+
 	//g_debug("GritsTile: 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;
-	grits_tile_foreach_index(root, row, col) {
-		GritsBounds 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));
-
-		GritsTile **child = &root->children[row][col];
-		if (!_grits_tile_precise(eye, &edge, res,
-				width/cols, height/rows)) {
-			if (!*child) {
-				*child = grits_tile_new(root, edge.n, edge.s,
-						edge.e, edge.w);
-				load_func(*child, user_data);
+	//		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;
 			}
-			grits_tile_update(*child, eye,
-					res, width, height,
-					load_func, user_data);
-			GRITS_OBJECT(*child)->hidden = FALSE;
-		} else if (*child) {
-			GRITS_OBJECT(*child)->hidden = TRUE;
 		}
 	}
+
+	/* Update recursively */
+	grits_tile_foreach(tile, child)
+		grits_tile_update(child, eye, res, width, height,
+				load_func, user_data);
 }
 
 /**
@@ -254,10 +312,13 @@ GritsTile *grits_tile_gc(GritsTile *root, time_t atime,
 		if (root->children[x][y])
 			has_children = TRUE;
 	}
-	//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);
+	//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;
 	}
@@ -285,6 +346,28 @@ void grits_tile_free(GritsTile *root, GritsTileFreeFunc free_func, gpointer user
 	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 grits_tile_draw_one(GritsTile *tile, GritsOpenGL *opengl, GList *triangles)
 {
@@ -293,6 +376,7 @@ static void grits_tile_draw_one(GritsTile *tile, GritsOpenGL *opengl, GList *tri
 	if (!triangles)
 		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);
@@ -308,6 +392,8 @@ static void grits_tile_draw_one(GritsTile *tile, GritsOpenGL *opengl, GList *tri
 	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;
 
@@ -350,66 +436,81 @@ static void grits_tile_draw_one(GritsTile *tile, GritsOpenGL *opengl, GList *tri
 			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 grits_tile_draw_rec(GritsTile *tile, GritsOpenGL *opengl)
+static gboolean grits_tile_draw_rec(GritsTile *tile, GritsOpenGL *opengl)
 {
-	/* Only draw children if possible */
-	gboolean has_children = FALSE;
-	GritsTile *child;
+	//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;
+
+	/* Draw child tiles */
+	gboolean draw_parent = FALSE;
 	grits_tile_foreach(tile, child)
-		if (child && child->data)
-			has_children = TRUE;
+		if (!grits_tile_draw_rec(child, opengl))
+			draw_parent = TRUE;
 
-	GList *triangles = NULL;
-	if (has_children && !GRITS_OBJECT(tile)->hidden) {
-		/* 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;
-		grits_tile_foreach_index(tile, row, col) {
-			GritsTile *child = tile->children[row][col];
-			if (child && child->data) {
-				grits_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,
+	/* 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);
-	}
-	if (triangles)
 		grits_tile_draw_one(tile, opengl, triangles);
-	g_list_free(triangles);
+		g_list_free(triangles);
+	}
+
+	return TRUE;
 }
 
 static void grits_tile_draw(GritsObject *tile, GritsOpenGL *opengl)
 {
 	glEnable(GL_DEPTH_TEST);
 	glDepthFunc(GL_LESS);
+	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);
 }