Places map: city base map, cluster gallery, zoom + render polish

Base map / tiles:
- Switch the base map to the mapchart city-label world map; re-derive its
  Web-Mercator georeferencing (MAP_LON0/1, MAP_IMG_MY0/1) by least-squares
  against the pixel-identical graticule export.
- Add a 1.5x LANCZOS supersample LOD and bump tile quality 90->94 so city
  labels stay crisp when zoomed in (tools/png_to_tiles.py).
- Fill the map view background with the ocean colour instead of black.

Navigation / clustering:
- Snap the cluster grid to power-of-two zoom octaves so the bubbles stop
  jittering during a continuous zoom.
- Replace the loose zoom clamps with named MAP_SCALE_MIN/MAX (whole map fills
  the screen .. country/region level).
- Add a toggleable computed lat/lon graticule overlay (TRIANGLE).

Cluster gallery:
- Selecting a bubble now opens all its photos on the same justified grid as
  the timeline/search (a g_gallery_active filter). Members not already paged
  in are appended as hidden g_asset entries (kept out of the main timeline);
  a background metadata worker resolves each one's date/aspect so the grid
  reflows into month sections + true aspect ratios.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011uKJQMYDE9Nrq9ECsU3MxH

src/api.c

@@ -89,6 +89,7 @@ static int parse_assets(const char *js, size_t jslen, char *err, size_t errlen)
 			g_asset_ratio[cur] = 0.0f;
 			g_asset_rot[cur] = 0;
 			g_asset_is_video[cur] = 0;
+			g_asset_hidden[cur] = 0;
 			continue;
 		}
 		if (cur < 0 || tok[i].type != JSMN_STRING || tok[i].size != 1 ||
@@ -279,4 +280,102 @@ static int check_new_assets(void)
 	return fresh;
 }
 
+/* parse a single /api/assets/{id} object for the fields the grid needs to lay
+ * an item out: capture date, display aspect (from exif), orientation, video
+ * flag. returns 1 if the date was found. (parse_assets handles arrays; this is
+ * the one-object form used by the gallery's lazy metadata resolver.) */
+static int parse_one_asset(const char *js, size_t len, char *date, size_t datelen,
+			   float *ratio, unsigned char *rot, int *is_video)
+{
+	jsmn_parser p;
+	jsmn_init(&p);
+	int n = jsmn_parse(&p, js, len, NULL, 0);
+	if (n <= 0)
+		return 0;
+	jsmntok_t *t = malloc(sizeof(*t) * n);
+	if (!t)
+		return 0;
+	jsmn_init(&p);
+	n = jsmn_parse(&p, js, len, t, n);
+	if (n <= 0 || t[0].type != JSMN_OBJECT) {
+		free(t);
+		return 0;
+	}
+	date[0] = '\0';
+	*ratio = 0.0f;
+	*rot = 0;
+	*is_video = 0;
+	int exif_obj = -1, exw = 0, exh = 0, exori = 0, got = 0;
+	for (int i = 1; i + 1 < n; i++) {
+		if (t[i].type != JSMN_STRING || t[i].size != 1)
+			continue;
+		int kl = t[i].end - t[i].start;
+		const char *k = js + t[i].start;
+		jsmntok_t *v = &t[i + 1];
+		int vl = v->end - v->start;
+		if (t[i].parent == 0 && kl == 8 && !strncmp(k, "exifInfo", 8) &&
+		    v->type == JSMN_OBJECT) {
+			exif_obj = i + 1;
+			continue;
+		}
+		if (t[i].parent == exif_obj) {
+			if (kl == 14 && !strncmp(k, "exifImageWidth", 14))
+				exw = atoi(js + v->start);
+			else if (kl == 15 && !strncmp(k, "exifImageHeight", 15))
+				exh = atoi(js + v->start);
+			else if (kl == 11 && !strncmp(k, "orientation", 11))
+				exori = atoi(js + v->start);
+			continue;
+		}
+		if (t[i].parent != 0)
+			continue;
+		if (kl == 13 && !strncmp(k, "fileCreatedAt", 13) && vl >= 10) {
+			int cl = vl < (int)datelen - 1 ? vl : (int)datelen - 1;
+			memcpy(date, js + v->start, cl);
+			date[cl] = '\0';
+			got = 1;
+		} else if (kl == 4 && !strncmp(k, "type", 4)) {
+			*is_video = (vl >= 5 && !strncmp(js + v->start, "VIDEO", 5));
+		}
+	}
+	if (exw > 0 && exh > 0)
+		*ratio = (exori >= 5 && exori <= 8) ?
+			(float)exh / exw : (float)exw / exh;
+	*rot = (unsigned char)exori;
+	free(t);
+	return got;
+}
+
+/* background metadata resolver thread: fetches one asset's date/aspect at a
+ * time (the gallery's lazy fill). One-slot handoff like the thumb worker —
+ * main writes g_meta_id + flips to PENDING, we fetch+parse and flip to DONE. */
+static int meta_worker(SceSize args, void *argp)
+{
+	(void)args;
+	(void)argp;
+	for (;;) {
+		if (g_meta_state != META_PENDING) {
+			sceKernelDelayThread(4000);
+			continue;
+		}
+		char url[600];
+		snprintf(url, sizeof(url), "%s/api/assets/%s", g_server, g_meta_id);
+		membuf buf;
+		long code;
+		CURLcode r = http_request(url, NULL, &buf, &code, NULL, 0);
+		g_meta_date[0] = '\0';
+		g_meta_ratio = 0.0f;
+		g_meta_rot = 0;
+		g_meta_is_video = 0;
+		if (r == CURLE_OK && code >= 200 && code < 300 && buf.data)
+			parse_one_asset(buf.data, buf.size, g_meta_date,
+					sizeof(g_meta_date), &g_meta_ratio,
+					&g_meta_rot, &g_meta_is_video);
+		free(buf.data);
+		__sync_synchronize();
+		g_meta_state = META_DONE;
+	}
+	return 0;
+}
+
 

src/app.c

@@ -112,6 +112,8 @@ static void reset_for_account_change(void)
 	g_next_page = 1;
 	g_search_active = 0;
 	g_search_count = 0;
+	g_gallery_active = 0;
+	g_gallery_count = 0;
 	g_srv_state = 0;   /* re-fetch the cloud page's server info */
 	g_srv_fetching = 0;
 	g_map_state = 0;   /* re-fetch the new account's map markers */
@@ -272,6 +274,11 @@ int main(void)
 	if (syncw >= 0)
 		sceKernelStartThread(syncw, 0, NULL);
 
+	SceUID metaw = sceKernelCreateThread("meta_worker", meta_worker,
+					     0x10000100, 128 * 1024, 0, 0, NULL);
+	if (metaw >= 0)
+		sceKernelStartThread(metaw, 0, NULL);
+
 	load_autobackup();
 
 	int mode = MODE_GRID;
@@ -482,7 +489,8 @@ int main(void)
 				 * be fetched yet — pull pages until a new month
 				 * shows up (or the library ends). search results
 				 * aren't paginated, so skip the pull. */
-				if (dir > 0 && !g_search_active && can_pull) {
+				if (dir > 0 && !g_search_active &&
+				    !g_gallery_active && can_pull) {
 					int guard = 0;
 					while (g_next_page > 0 && guard++ < 10 &&
 					       !strncmp(disp_date(month_jump(sel, +1)),
@@ -540,7 +548,7 @@ int main(void)
 			 * screen: the grid stays up, the HUD's "+" already says
 			 * more is coming, and the fetch only blocks briefly */
 			if (!scrolling_fast && rl_idle >= 12 && !g_search_active &&
-			    g_next_page > 0 &&
+			    !g_gallery_active && g_next_page > 0 &&
 			    sel >= g_disp_count - COLS * 4) {
 				if (fetch_page(0) > 0)
 					rebuild_keep_view(&sel, &scroll,
@@ -553,6 +561,7 @@ int main(void)
 			 * across the relayout */
 			uint64_t pnow = sceKernelGetProcessTimeWide();
 			if (!scrolling_fast && !touch_active && !g_search_active &&
+			    !g_gallery_active &&
 			    pnow - last_poll > 30ULL * 1000 * 1000) {
 				last_poll = pnow;
 				if (check_new_assets() > 0)
@@ -664,6 +673,21 @@ int main(void)
 					}
 				}
 
+				/* in a cluster gallery, O returns to the map; any
+				 * bar action (search/cloud/map) drops the filter */
+				if (g_gallery_active && (pressed & SCE_CTRL_CIRCLE)) {
+					gallery_close();
+					mode = MODE_MAP;
+					sel = 0;
+					scroll = target = 0;
+					grid_last_sel = -1;
+					touch_active = touch_on_bar = 0;
+					continue;
+				}
+				if (g_gallery_active &&
+				    (do_open_cloud || do_open_map || do_search_open))
+					gallery_close();
+
 				if (do_open_cloud) {
 					mode = MODE_CLOUD;
 					continue;
@@ -825,6 +849,12 @@ int main(void)
 				last_vis = g_disp_count - 1;
 			}
 
+			/* cluster gallery: resolve members' date/aspect in the
+			 * background so the grid sorts into months + true aspects */
+			if (g_gallery_active)
+				gallery_meta_pump(first_vis, last_vis,
+						  &sel, &scroll, &target);
+
 			/* collect finished download, then hand the worker
 			 * the next most useful thumbnail */
 			if (g_req_state == REQ_DONE) {
@@ -1070,7 +1100,8 @@ int main(void)
 			}
 			if (pressed & SCE_CTRL_CIRCLE) {
 				/* back to wherever we came from (the map if the
-				 * photo was opened from a marker, else the grid) */
+				 * photo was opened from a marker, else the grid —
+				 * which may be showing a cluster gallery) */
 				mode = detail_from_map ? MODE_MAP : MODE_GRID;
 				detail_from_map = 0;
 				detail_idx = -1;
@@ -1831,6 +1862,7 @@ pf_skip:
 			if (pad.buttons & SCE_CTRL_DOWN)  g_map_cy += pstep;
 			if (pad.buttons & SCE_CTRL_RTRIGGER) g_map_scale *= 1.03;
 			if (pad.buttons & SCE_CTRL_LTRIGGER) g_map_scale /= 1.03;
+			if (pressed & SCE_CTRL_TRIANGLE) g_map_grid = !g_map_grid;
 			map_clamp_view();
 
 			/* touch: one finger drags the map, two fingers pinch-zoom,
@@ -1904,7 +1936,8 @@ pf_skip:
 			else if (tapped_cluster >= 0)
 				act = tapped_cluster;
 			if (act >= 0 && act < g_cl_count) {
-				if (map_should_open(act)) {
+				if (g_cl_n[act] <= 1) {
+					/* a lone marker: open the photo directly */
 					int s;
 					if (map_open_marker(g_cl_rep[act], &s)) {
 						sel = s;
@@ -1918,15 +1951,25 @@ pf_skip:
 						grid_last_sel = -1;
 						continue;
 					}
-					map_zoom_into(act); /* couldn't open: just zoom */
 				} else {
-					map_zoom_into(act);
+					/* a bubble: show all its photos on the grid */
+					g_search_active = 0;
+					gallery_open(act);
+					sel = 0;
+					scroll = target = 0.0f;
+					grid_last_sel = -1;
+					mode = MODE_GRID;
+					continue;
 				}
 			}
 
 			vita2d_start_drawing();
 			vita2d_clear_screen();
+			vita2d_draw_rectangle(0, 0, SCREEN_W, SCREEN_H,
+					      MAP_OCEAN_BG);   /* sea, not black */
 			map_draw_tiles();
+			if (g_map_grid)
+				map_draw_graticule();
 			map_draw_clusters(nc);
 			/* centre crosshair: shows what X will act on */
 			vita2d_draw_rectangle(SCREEN_W / 2.0f - 8, SCREEN_H / 2.0f,
@@ -1940,7 +1983,7 @@ pf_skip:
 				draw_text(12, 28, RGBA8(235, 235, 240, 255), 1.0f, mh);
 				draw_text(12, SCREEN_H - 16,
 					  RGBA8(150, 150, 158, 255), 0.85f,
-					  "d-pad pan   L/R zoom   X open/zoom   O back");
+					  "d-pad pan  L/R zoom  X open  /\\ grid  O back");
 			}
 			vita2d_end_drawing();
 			vita2d_swap_buffers();

src/display.c

@@ -176,6 +176,24 @@ static void layout_grid(void)
  * server asset is shown once, as the server asset (green badge). */
 static void rebuild_display(void)
 {
+	/* map cluster gallery: show exactly the selected bubble's members (server
+	 * assets), date-grouped like the timeline. Members whose metadata hasn't
+	 * resolved yet have an empty date and sort to the end until it arrives. */
+	if (g_gallery_active) {
+		if (!grow_disp(g_gallery_count > 0 ? g_gallery_count : 1))
+			return;
+		int n = 0;
+		for (int k = 0; k < g_gallery_count; k++) {
+			g_disp[n].src = SRC_SERVER;
+			g_disp[n].idx = g_gallery_idx[k];
+			n++;
+		}
+		g_disp_count = n;
+		qsort(g_disp, n, sizeof(g_disp[0]), disp_cmp);
+		layout_grid();
+		return;
+	}
+
 	/* search mode: the merged timeline is replaced by the result set
 	 * (server assets only, date-grouped); local media isn't folded in */
 	if (g_search_active) {
@@ -201,6 +219,8 @@ static void rebuild_display(void)
 
 	int n = 0;
 	for (int i = 0; i < g_asset_count; i++) {
+		if (g_asset_hidden[i])
+			continue;   /* gallery-only asset: not in the timeline */
 		g_disp[n].src = SRC_SERVER;
 		g_disp[n].idx = i;
 		n++;

src/main.c

@@ -128,6 +128,9 @@ static unsigned char *g_asset_is_video;
 /* set during display rebuild: a backed-up local file matches this server
  * asset, so its grid cell shows the green "backed up" badge */
 static unsigned char *g_asset_local_backed;
+/* 1 = appended only to back a map-cluster gallery (its id/thumb are needed but
+ * it isn't part of the paged library): shown in the gallery, hidden elsewhere */
+static unsigned char *g_asset_hidden;
 static int g_asset_count;
 static int g_asset_cap;
 static int g_next_page = 1; /* 0 = no more pages */

src/map.c

@@ -32,17 +32,33 @@ static volatile int g_map_fetching;  /* a worker thread is fetching now */
  * on-screen pixel size (256 << zoom). g_map_view_init is cleared so the
  * first time the page opens (and after an account switch) it fits to the
  * markers' bounding box instead of showing a stale view. */
+/* zoom limits — g_map_scale is the whole world's on-screen width in px.
+ * MIN stops zoom-out once the map covers the screen with no black bars; the map
+ * is taller-aspect than the screen, so the poles and a little longitude crop off
+ * (pan to reach them) rather than leaving margins. MAX is about country/region
+ * level — ~4x the deepest tile LOD (10496px), so the raster base map stays
+ * legible rather than blurring into mush as the old deep caps did. */
+#define MAP_SCALE_MIN 1200.0
+#define MAP_SCALE_MAX 4.0e4
+/* the base map's ocean colour — fills the view behind/around the tiles so the
+ * margins (and any gap while tiles stream in) read as sea, not black */
+#define MAP_OCEAN_BG RGBA8(217, 187, 149, 255)
 static double g_map_cx = 0.5, g_map_cy = 0.5;
-static double g_map_scale = 512.0;
+static double g_map_scale = MAP_SCALE_MIN;
 static int g_map_view_init;
+static int g_map_grid = 0;   /* overlay the computed graticule (toggle: TRIANGLE) */
 
 #define MAP_PI 3.14159265358979323846
 
-/* The source map (MapChart_Map (4)) is a clean conformal full-longitude Web
+/* The source map (a mapchart.net world map, city-label variant) is a
- * Mercator: lon -180..180 across its width, latitude band MAP_IMG_MY0..MY1.
+ * near-conformal full-longitude Web Mercator: lon spans the image width,
- * Verified by isolated-island centroids (span 360.0°, x/y scales match). */
+ * latitude band MAP_IMG_MY0..MY1. These bounds were fit by least-squares against
-#define MAP_LON0 (-180.0)    /* longitude at the image's left edge  */
+ * the pixel-identical graticule export of the same map (meridian residual
-#define MAP_LON1 (180.0)     /* longitude at the image's right edge */
+ * <0.5px, parallel <2.3px over 7000px) — that sibling shares this one's exact
+ * crop (verified: 0px phase-correlation shift), so the fit transfers directly.
+ * The image runs ~0.45° past ±180 each side. */
+#define MAP_LON0 (-180.40)   /* longitude at the image's left edge  */
+#define MAP_LON1 (180.50)    /* longitude at the image's right edge */
 
 /* lon/lat -> normalised image coords [0,1]. y is standard Web-Mercator (lat
  * clamped to the valid band); the image's merc-y bounds are MAP_IMG_MY0/MY1. */
@@ -168,8 +184,8 @@ static void fetch_map_markers(void)
 /* keep the centre on the map and the zoom within sane bounds */
 static void map_clamp_view(void)
 {
-	if (g_map_scale < 360.0)        g_map_scale = 360.0;       /* ~whole world */
+	if (g_map_scale < MAP_SCALE_MIN) g_map_scale = MAP_SCALE_MIN;  /* whole world */
-	if (g_map_scale > 2.0e8)        g_map_scale = 2.0e8;       /* street level */
+	if (g_map_scale > MAP_SCALE_MAX) g_map_scale = MAP_SCALE_MAX;  /* neighbourhood */
 	if (g_map_cx < 0.0) g_map_cx = 0.0;
 	if (g_map_cx > 1.0) g_map_cx = 1.0;
 	if (g_map_cy < 0.0) g_map_cy = 0.0;
@@ -183,7 +199,7 @@ static void map_fit_view(void)
 	if (g_map_count <= 0) {
 		g_map_cx = 0.5;
 		g_map_cy = 0.5;
-		g_map_scale = 512.0;
+		g_map_scale = MAP_SCALE_MIN;
 		map_clamp_view();
 		return;
 	}
@@ -202,9 +218,9 @@ static void map_fit_view(void)
 	if (h < 1e-9) h = 1e-9;
 	double sx = SCREEN_W * 0.82 / w, sy = SCREEN_H * 0.82 / h;
 	g_map_scale = sx < sy ? sx : sy;
-	/* a single point fits at "infinite" zoom — pull back to a city view */
+	/* a single point fits at "infinite" zoom — pull back to the max zoom */
-	if (g_map_scale > 4.0e6)
+	if (g_map_scale > MAP_SCALE_MAX)
-		g_map_scale = 4.0e6;
+		g_map_scale = MAP_SCALE_MAX;
 	map_clamp_view();
 }
 
@@ -226,13 +242,19 @@ static int g_cl_count;
 /* Group markers into bubbles. The grid cells are anchored in MAP (Web-Mercator)
  * space, not screen space, so panning leaves each marker in the same cell and
  * the bubbles simply translate with the map instead of reshuffling/jumping.
- * Cell size tracks zoom (~MAP_CELL px wide at the current scale). */
+ *
+ * The cell size is keyed off a scale SNAPPED to the nearest power-of-two octave,
+ * not the live scale: the live scale changes every frame while zooming, which
+ * drifts the cell boundaries so markers hop cells and the bubbles jitter. With
+ * the snap, the grid is fixed across a ~1.4x zoom band and only re-forms once
+ * per octave, so during a zoom the bubbles just glide/scale with the map. */
 static void map_cluster(void)
 {
 	g_cl_count = 0;
 	if (g_map_scale <= 0.0)
 		return;
-	double cellsz = (double)MAP_CELL / g_map_scale;  /* merc units per cell */
+	double qscale = pow(2.0, round(log2(g_map_scale)));  /* octave-snapped */
+	double cellsz = (double)MAP_CELL / qscale;       /* merc units per cell */
 	for (int i = 0; i < g_map_count; i++) {
 		double mx = merc_x(g_map_lon[i]), my = merc_y(g_map_lat[i]);
 		float sx, sy;
@@ -314,30 +336,6 @@ static int map_cluster_at(float x, float y)
 	return -1;
 }
 
-/* a tap/X on cluster c should OPEN its photo (rather than zoom in) when it's a
- * lone marker, or when its members are effectively on the same spot so zooming
- * would never split them (common with photos shot at one place). */
-static int map_should_open(int c)
-{
-	if (c < 0 || c >= g_cl_count)
-		return 0;
-	if (g_cl_n[c] <= 1)
-		return 1;
-	return (g_cl_x1[c] - g_cl_x0[c] < 6.0f &&
-		g_cl_y1[c] - g_cl_y0[c] < 6.0f);
-}
-
-/* recentre on a cluster and zoom in a notch (splits dense bubbles apart) */
-static void map_zoom_into(int c)
-{
-	if (c < 0 || c >= g_cl_count)
-		return;
-	g_map_cx += (g_cl_x[c] - SCREEN_W / 2.0f) / g_map_scale;
-	g_map_cy += (g_cl_y[c] - SCREEN_H / 2.0f) / g_map_scale;
-	g_map_scale *= 2.6;
-	map_clamp_view();
-}
-
 /* resolve a marker's asset to a display slot, opening it in the detail view.
  * the map lists the whole server, so the asset is often not among the pages
  * fetched for the grid — in that case fetch its metadata, append it to the
@@ -379,6 +377,7 @@ static int map_open_marker(int marker_idx, int *out_sel)
 		g_asset_rot[idx] = 0;
 		g_asset_is_video[idx] = !strncmp(tval, "VIDEO", 5);
 		g_asset_local_backed[idx] = 0;
+		g_asset_hidden[idx] = 0;
 		g_thumb[idx] = NULL;
 		g_thumb_failed[idx] = 0;
 		g_tex_err[idx][0] = '\0';
@@ -397,11 +396,11 @@ static int map_open_marker(int marker_idx, int *out_sel)
 }
 
 /* latitude band of the source image, in normalised Web-Mercator. NOT simply
- * image-height/width: MapChart's vertical scale differs slightly from its
+ * image-height/width: the source's vertical scale differs ~0.4% from its
- * horizontal, so these were fit against the real marker coordinates (so the
+ * horizontal, so these were fit against the image's baked-in graticule (the
- * photos land on land, not offset north into the water). ~76.6°N .. -59.9°S. */
+ * equator sits at y=3213 of 6352, ~37px below image centre). ~83.7°N .. -83.3°S. */
-#define MAP_IMG_MY0 0.03993   /* top edge  (~83.5°N) */
+#define MAP_IMG_MY0 0.03814   /* top edge  (~83.7°N) */
-#define MAP_IMG_MY1 0.95395   /* bottom edge (~-83.5°S) */
+#define MAP_IMG_MY1 0.95125   /* bottom edge (~-83.3°S) */
 
 /* ------------------------------------------------------------------ */
 /* raster tile pyramid (app0:maptiles.pak) — the LOD base map.         */
@@ -641,6 +640,41 @@ static void map_draw_grid(void)
 	}
 }
 
+/* Lat/lon graticule, projected with merc_x/merc_y + MAP_LON0/1 + MAP_IMG_MY0/1
+ * (the same maths the markers use), drawn bright over the tiled base map at 10°
+ * spacing. The current city-label base map has no printed grid, so this is the
+ * only graticule; against the graticule export it coincided to ~1px, which is
+ * how the georeferencing was validated. Prime meridian and equator are brighter
+ * to anchor orientation. Toggle with TRIANGLE. */
+static void map_draw_graticule(void)
+{
+	uint32_t reg = RGBA8(225, 45, 45, 140);    /* translucent red */
+	uint32_t axis = RGBA8(255, 90, 90, 230);   /* lon 0 / equator */
+	/* clip the overlay to the base-map rectangle (clamped to the screen) so
+	 * each line spans only where the map is, not the black margins around it */
+	float lx, ty, rx, by;
+	map_project(0.0, MAP_IMG_MY0, &lx, &ty);   /* image top-left  */
+	map_project(1.0, MAP_IMG_MY1, &rx, &by);   /* image bot-right */
+	if (lx < 0) lx = 0;
+	if (ty < 0) ty = 0;
+	if (rx > SCREEN_W) rx = SCREEN_W;
+	if (by > SCREEN_H) by = SCREEN_H;
+	for (int lon = -180; lon <= 180 && by > ty; lon += 10) {
+		float sx, sy;
+		map_project(merc_x(lon), 0.0, &sx, &sy);
+		if (sx >= 0 && sx <= SCREEN_W)
+			vita2d_draw_rectangle(sx, ty, 1, by - ty,
+					      lon == 0 ? axis : reg);
+	}
+	for (int lat = -80; lat <= 80 && rx > lx; lat += 10) {
+		float sx, sy;
+		map_project(0.0, merc_y(lat), &sx, &sy);
+		if (sy >= 0 && sy <= SCREEN_H)
+			vita2d_draw_rectangle(lx, sy, rx - lx, 1,
+					      lat == 0 ? axis : reg);
+	}
+}
+
 /* draw every cluster bubble; `sel` gets a white selection ring */
 static void map_draw_clusters(int sel)
 {
@@ -664,3 +698,114 @@ static void map_draw_clusters(int sel)
 		draw_text(x - w / 2.0f, y + 6.0f, white, 0.8f, b);
 	}
 }
+
+/* ------------------------------------------------------------------ */
+/* cluster gallery                                                     */
+/*                                                                     */
+/* Selecting a bubble shows every photo it groups on the SAME grid as  */
+/* the timeline/search — a filtered view (g_gallery_*). Members already */
+/* paged into the library are reused; the rest are appended as hidden   */
+/* g_asset entries (id + thumb only) whose date/aspect the metadata     */
+/* worker fills in lazily, so the justified grid sorts into month       */
+/* sections and true aspect ratios as the data arrives.                 */
+/* ------------------------------------------------------------------ */
+
+/* g_asset index for an id: an existing entry, or a freshly appended hidden one
+ * (lets the gallery show a marker not yet paged into the library). -1 on OOM. */
+static int asset_for_id(const char *id)
+{
+	for (int i = 0; i < g_asset_count; i++)
+		if (!strcmp(g_asset_ids[i], id))
+			return i;
+	if (!grow_assets(g_asset_count + 1))
+		return -1;
+	int idx = g_asset_count++;
+	snprintf(g_asset_ids[idx], sizeof(g_asset_ids[0]), "%s", id);
+	g_asset_dates[idx][0] = '\0';   /* "" = unresolved; meta_worker fills it */
+	g_asset_ratio[idx] = 0.0f;
+	g_asset_rot[idx] = 0;
+	g_asset_is_video[idx] = 0;
+	g_asset_local_backed[idx] = 0;
+	g_asset_hidden[idx] = 1;        /* gallery-only: kept out of the timeline */
+	g_thumb[idx] = NULL;
+	g_thumb_failed[idx] = 0;
+	g_tex_err[idx][0] = '\0';
+	return idx;
+}
+
+/* open the gallery for cluster c: collect its members (same merc cell as the
+ * bubble) into g_gallery_idx, then rebuild the grid to show them */
+static void gallery_open(int c)
+{
+	g_gallery_count = 0;
+	if (c < 0 || c >= g_cl_count || g_map_scale <= 0.0)
+		return;
+	double qscale = pow(2.0, round(log2(g_map_scale)));
+	double cellsz = (double)MAP_CELL / qscale;
+	int tgx = g_cl_gx[c], tgy = g_cl_gy[c];
+	for (int i = 0; i < g_map_count; i++) {
+		double mx = merc_x(g_map_lon[i]), my = merc_y(g_map_lat[i]);
+		float sx, sy;
+		map_project(mx, my, &sx, &sy);
+		if (sx < -90 || sx > SCREEN_W + 90 ||
+		    sy < -90 || sy > SCREEN_H + 90)
+			continue;
+		if ((int)(mx / cellsz) != tgx || (int)(my / cellsz) != tgy)
+			continue;
+		int idx = asset_for_id(g_map_id[i]);
+		if (idx < 0 || !grow_gallery(g_gallery_count + 1))
+			break;
+		g_gallery_idx[g_gallery_count++] = idx;
+	}
+	g_gallery_active = 1;
+	rebuild_display();
+}
+
+static void gallery_close(void)
+{
+	g_gallery_active = 0;
+	rebuild_display();
+}
+
+/* lazy fill: apply a finished metadata result (re-laying out the grid so the
+ * item drops into its month/aspect), then request the next missing one —
+ * visible slots first. g_meta_target is a g_asset index, so it stays valid
+ * across the rebuilds that reorder g_disp. */
+static void gallery_meta_pump(int first_vis, int last_vis,
+			      int *sel, float *scroll, float *target)
+{
+	if (g_meta_state == META_DONE) {
+		int t = g_meta_target;
+		if (t >= 0 && t < g_asset_count && g_meta_date[0]) {
+			snprintf(g_asset_dates[t], sizeof(g_asset_dates[0]), "%s",
+				 g_meta_date);
+			g_asset_ratio[t] = g_meta_ratio;
+			g_asset_rot[t] = g_meta_rot;
+			g_asset_is_video[t] = (unsigned char)g_meta_is_video;
+		} else if (t >= 0 && t < g_asset_count) {
+			/* fetch failed: stamp a placeholder date so we don't
+			 * spin on it forever (it just won't group by month) */
+			snprintf(g_asset_dates[t], sizeof(g_asset_dates[0]),
+				 "0000-00-00");
+		}
+		g_meta_state = META_IDLE;
+		rebuild_keep_view(sel, scroll, target);
+	}
+	if (g_meta_state != META_IDLE)
+		return;
+	int pick = -1;
+	for (int d = first_vis; pick < 0 && d >= 0 && d <= last_vis &&
+	     d < g_disp_count; d++)
+		if (g_disp[d].src == SRC_SERVER &&
+		    g_asset_dates[g_disp[d].idx][0] == '\0')
+			pick = g_disp[d].idx;
+	for (int k = 0; pick < 0 && k < g_gallery_count; k++)
+		if (g_asset_dates[g_gallery_idx[k]][0] == '\0')
+			pick = g_gallery_idx[k];
+	if (pick < 0)
+		return;
+	g_meta_target = pick;
+	snprintf(g_meta_id, sizeof(g_meta_id), "%s", g_asset_ids[pick]);
+	__sync_synchronize();
+	g_meta_state = META_PENDING;
+}

src/state.c

@@ -63,6 +63,29 @@ static int g_sect_count;
 static int g_sect_cap;
 static float g_content_h; /* total scrollable height incl. headers */
 
+/* map cluster gallery: the photos of one map bubble, shown on the SAME grid as
+ * the timeline/search — a filtered view like g_search_*. g_gallery_idx holds
+ * indices into the g_asset_* arrays for the bubble's members; members not
+ * already paged into the library are appended as g_asset entries flagged
+ * g_asset_hidden (so they appear only here, never in the main timeline). Their
+ * date/aspect are resolved lazily by the metadata worker below, so the grid
+ * reflows into real month sections + true aspect ratios as they arrive. */
+static int g_gallery_active;
+static int *g_gallery_idx;
+static int g_gallery_count;
+static int g_gallery_cap;
+
+/* background metadata resolver: a one-slot handoff (mirroring the thumb worker)
+ * that fetches one asset's date/aspect so the justified grid can place it. */
+enum { META_IDLE, META_PENDING, META_DONE };
+static volatile int g_meta_state = META_IDLE;
+static char g_meta_id[40];           /* asset id to resolve  (main -> worker) */
+static int g_meta_target;            /* g_asset index to fill (main-thread owned) */
+static char g_meta_date[DATELEN];    /* results (worker -> main) */
+static float g_meta_ratio;
+static unsigned char g_meta_rot;
+static int g_meta_is_video;
+
 /* free-text smart (CLIP) search. when active the grid shows only the matching
  * server assets — still date-grouped under month headers like the timeline —
  * instead of the full merged library; TRIANGLE opens the keyboard, CIRCLE (or
@@ -159,6 +182,7 @@ static int grow_assets(int need)
 	    !GROW(g_asset_rot, c, need) ||
 	    !GROW(g_asset_is_video, c, need) ||
 	    !GROW(g_asset_local_backed, c, need) ||
+	    !GROW(g_asset_hidden, c, need) ||
 	    !GROW(g_thumb, c, need) ||
 	    !GROW(g_thumb_failed, c, need) ||
 	    !(g_asset_cap = GROW(g_tex_err, c, need)))
@@ -214,6 +238,17 @@ static int grow_sect(int need)
 	return 1;
 }
 
+static int grow_gallery(int need)
+{
+	if (need <= g_gallery_cap)
+		return 1;
+	int cap = GROW(g_gallery_idx, g_gallery_cap, need);
+	if (!cap)
+		return 0;
+	g_gallery_cap = cap;
+	return 1;
+}
+
 static void log_line(const char *fmt, ...)
 {
 	FILE *f = fopen(LOG_PATH, "a");

tools/png_to_tiles.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
-"""Generate a Web-Mercator tile pyramid (LODs) from a MapChart world PNG and
+"""Generate a Web-Mercator tile pyramid (LODs) from a world map image and
 pack it into one file for the Vita map view.
 
-The source PNG covers the same cropped-Mercator region as before: longitude
+The source image covers a cropped-Mercator region: longitude spans its full
--180..180 across its full width, latitude band [MAP_IMG_MY0, MAP_IMG_MY1].
+width, latitude band [MAP_IMG_MY0, MAP_IMG_MY1]. The default source carries a
+baked-in 10° graticule, against which those bounds were fit (see map.c).
 Each LOD level is the source scaled to a width, padded to whole 256px tiles,
 and cut up; tiles are JPEG (decoded into pooled textures on device, the safe
 path). Everything goes into assets/maptiles.pak:
@@ -18,12 +19,15 @@ offsets are from the start of the JPEG blob.
 import sys, struct, io
 from PIL import Image
 
-SRC = sys.argv[1] if len(sys.argv) > 1 else '/home/sads/Desktop/MapChart_Map (3).png'
+SRC = sys.argv[1] if len(sys.argv) > 1 else '/home/sads/Desktop/world map cities.jpeg'
 OUT = sys.argv[2] if len(sys.argv) > 2 else '/home/sads/Code/vitaImmich/assets/maptiles.pak'
 TILE = 256
-QUALITY = 90
+QUALITY = 94
-# level widths (px) for the full map; last is ~native. heights follow aspect.
+# level widths (px). The last entry (10496 ~= 1.5x the 7000px source) is a
-WIDTHS = [512, 1024, 2048, 4096, 7000]
+# LANCZOS supersample: it adds no true detail beyond native, but lets a zoomed-in
+# view sample crisp pre-upscaled tiles instead of the GPU bilinear-magnifying the
+# native level, so city labels read sharper. heights follow aspect.
+WIDTHS = [512, 1024, 2048, 4096, 7000, 10496]
 
 src = Image.open(SRC).convert('RGB')
 SW, SH = src.size
@@ -31,8 +35,8 @@ print('source', SW, SH, 'aspect', round(SW/SH, 4))
 
 levels = []   # (imgW,imgH,cols,rows,Image-padded)
 for w in WIDTHS:
-    if w > SW:
+    if w > 2 * SW:      # allow a modest supersample, but cap runaway upscales
-        w = SW
+        w = 2 * SW
     h = round(w * SH / SW)
     img = src.resize((w, h), Image.LANCZOS)
     cols = (w + TILE - 1) // TILE