Skip to content

Commit 7c4fef4

Browse files
cryptobenchclaude
cryptobench
and
claude
committed
Add tile pyramid system for massive browser performance improvement
Performance optimization that generates composite tiles at zoomed-out levels, dramatically reducing DOM elements and improving browser framerate. Changes: - Add CompositeTileGenerator.java for server-side tile compositing - At zoom -4, combines 16x16 (256) chunks into single tiles - Reduces DOM elements from ~20,000 to ~40 at full zoom out - Add enableTilePyramids config option (default: true) - Update frontend to request composite tiles at negative zoom levels - Center map on single player when only one is online Expected performance impact: - Full zoom out: ~20,000 DOM elements → ~80 DOM elements - Memory for visible tiles: ~400MB → ~2MB - Pan/zoom framerate: 15-30 FPS → 60 FPS Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
1 parent cfd2c9a commit 7c4fef4

File tree

4 files changed

+296
-8
lines changed

4 files changed

+296
-8
lines changed

‎src/main/java/com/easywebmap/config/MapConfig.java‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,11 @@ private void load() {
6161
this.data.useDiskCache = defaults.useDiskCache;
6262
needsSave = true;
6363
}
64+
// Tile pyramid configuration
65+
if (!jsonObj.has("enableTilePyramids")) {
66+
this.data.enableTilePyramids = defaults.enableTilePyramids;
67+
needsSave = true;
68+
}
6469
// SSL configuration migration
6570
if (!jsonObj.has("enableHttps")) {
6671
this.data.enableHttps = defaults.enableHttps;
@@ -160,6 +165,10 @@ public boolean isUseDiskCache() {
160165
return this.data.useDiskCache;
161166
}
162167

168+
public boolean isEnableTilePyramids() {
169+
return this.data.enableTilePyramids;
170+
}
171+
163172
public boolean isHttpsEnabled() {
164173
return this.data.enableHttps;
165174
}
@@ -192,6 +201,7 @@ private static class ConfigData {
192201
int tileRefreshRadius = 5;
193202
long tileRefreshIntervalMs = 60000;
194203
boolean useDiskCache = true;
204+
boolean enableTilePyramids = true; // Enable composite tiles for zoomed-out views
195205

196206
// SSL/HTTPS configuration
197207
boolean enableHttps = false;

‎src/main/java/com/easywebmap/map/CompositeTileGenerator.java‎

Lines changed: 155 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,155 @@
1+
package com.easywebmap.map;
2+
3+
import com.easywebmap.EasyWebMap;
4+
import java.awt.Graphics2D;
5+
import java.awt.RenderingHints;
6+
import java.awt.image.BufferedImage;
7+
import java.io.ByteArrayInputStream;
8+
import java.io.ByteArrayOutputStream;
9+
import java.io.IOException;
10+
import java.util.ArrayList;
11+
import java.util.List;
12+
import java.util.concurrent.CompletableFuture;
13+
import javax.imageio.ImageIO;
14+
15+
/**
16+
* Generates composite tiles at zoomed-out levels by combining multiple base tiles.
17+
*
18+
* Zoom Level | Chunks per Tile | Grid Size
19+
* -----------|-----------------|----------
20+
* 0 | 1x1 (1 chunk) | 1x1
21+
* -1 | 2x2 (4 chunks) | 2x2
22+
* -2 | 4x4 (16 chunks) | 4x4
23+
* -3 | 8x8 (64 chunks) | 8x8
24+
* -4 | 16x16 (256) | 16x16
25+
*/
26+
public class CompositeTileGenerator {
27+
private final EasyWebMap plugin;
28+
private final TileManager tileManager;
29+
30+
public CompositeTileGenerator(EasyWebMap plugin, TileManager tileManager) {
31+
this.plugin = plugin;
32+
this.tileManager = tileManager;
33+
}
34+
35+
/**
36+
* Get the number of base chunks per axis for a given zoom level.
37+
* zoom -1 = 2, zoom -2 = 4, zoom -3 = 8, zoom -4 = 16
38+
*/
39+
public int getChunksPerAxis(int zoom) {
40+
if (zoom >= 0) {
41+
return 1;
42+
}
43+
return 1 << (-zoom); // 2^(-zoom)
44+
}
45+
46+
/**
47+
* Generate a composite tile at the given negative zoom level.
48+
*
49+
* @param worldName The world to generate for
50+
* @param zoom Negative zoom level (-1 to -4)
51+
* @param tileX X coordinate at this zoom level
52+
* @param tileZ Z coordinate at this zoom level
53+
* @return PNG-encoded composite tile
54+
*/
55+
public CompletableFuture<byte[]> generateCompositeTile(String worldName, int zoom, int tileX, int tileZ) {
56+
if (zoom >= 0) {
57+
// Not a composite tile, delegate back to base tile generation
58+
return this.tileManager.getBaseTile(worldName, tileX, tileZ);
59+
}
60+
61+
int chunksPerAxis = getChunksPerAxis(zoom);
62+
int tileSize = this.plugin.getConfig().getTileSize();
63+
64+
// Calculate base chunk coordinates
65+
// At zoom -1, composite tile (0,0) covers base tiles (0,0), (1,0), (0,1), (1,1)
66+
// At zoom -2, composite tile (0,0) covers base tiles (0,0) to (3,3)
67+
int baseChunkX = tileX * chunksPerAxis;
68+
int baseChunkZ = tileZ * chunksPerAxis;
69+
70+
// Fetch all base tiles in parallel
71+
List<CompletableFuture<TileWithPosition>> futures = new ArrayList<>();
72+
for (int dz = 0; dz < chunksPerAxis; dz++) {
73+
for (int dx = 0; dx < chunksPerAxis; dx++) {
74+
int chunkX = baseChunkX + dx;
75+
int chunkZ = baseChunkZ + dz;
76+
final int posX = dx;
77+
final int posZ = dz;
78+
79+
CompletableFuture<TileWithPosition> tileFuture = this.tileManager.getBaseTile(worldName, chunkX, chunkZ)
80+
.thenApply(data -> new TileWithPosition(data, posX, posZ));
81+
futures.add(tileFuture);
82+
}
83+
}
84+
85+
// Combine all tiles into a composite image
86+
return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
87+
.thenApply(v -> {
88+
List<TileWithPosition> tiles = new ArrayList<>();
89+
for (CompletableFuture<TileWithPosition> future : futures) {
90+
tiles.add(future.join());
91+
}
92+
return this.compositeToImage(tiles, chunksPerAxis, tileSize);
93+
});
94+
}
95+
96+
private byte[] compositeToImage(List<TileWithPosition> tiles, int chunksPerAxis, int outputSize) {
97+
// Create output image
98+
BufferedImage composite = new BufferedImage(outputSize, outputSize, BufferedImage.TYPE_INT_ARGB);
99+
Graphics2D g = composite.createGraphics();
100+
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
101+
g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
102+
103+
// Calculate size of each sub-tile in the composite
104+
int subTileSize = outputSize / chunksPerAxis;
105+
boolean hasAnyContent = false;
106+
107+
for (TileWithPosition tile : tiles) {
108+
if (tile.data == null || tile.data.length < 500) {
109+
// Empty tile, leave transparent
110+
continue;
111+
}
112+
113+
try {
114+
BufferedImage subImage = ImageIO.read(new ByteArrayInputStream(tile.data));
115+
if (subImage != null) {
116+
// Draw scaled sub-tile at correct position
117+
int destX = tile.posX * subTileSize;
118+
int destY = tile.posZ * subTileSize;
119+
g.drawImage(subImage, destX, destY, subTileSize, subTileSize, null);
120+
hasAnyContent = true;
121+
}
122+
} catch (IOException e) {
123+
// Skip this tile
124+
}
125+
}
126+
127+
g.dispose();
128+
129+
// If no content, return empty tile
130+
if (!hasAnyContent) {
131+
return PngEncoder.encodeEmpty(outputSize);
132+
}
133+
134+
// Encode composite to PNG
135+
ByteArrayOutputStream out = new ByteArrayOutputStream();
136+
try {
137+
ImageIO.write(composite, "png", out);
138+
} catch (IOException e) {
139+
return PngEncoder.encodeEmpty(outputSize);
140+
}
141+
return out.toByteArray();
142+
}
143+
144+
private static class TileWithPosition {
145+
final byte[] data;
146+
final int posX;
147+
final int posZ;
148+
149+
TileWithPosition(byte[] data, int posX, int posZ) {
150+
this.data = data;
151+
this.posX = posX;
152+
this.posZ = posZ;
153+
}
154+
}
155+
}

‎src/main/java/com/easywebmap/map/TileManager.java‎

Lines changed: 110 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -20,19 +20,36 @@ public class TileManager {
2020
private final DiskTileCache diskCache;
2121
private final ConcurrentHashMap<String, CompletableFuture<byte[]>> pendingRequests;
2222
private final ConcurrentHashMap<String, CachedChunkIndexes> chunkIndexCache;
23+
private CompositeTileGenerator compositeTileGenerator;
2324

2425
public TileManager(EasyWebMap plugin) {
2526
this.plugin = plugin;
2627
this.memoryCache = new TileCache(plugin.getConfig().getTileCacheSize());
2728
this.diskCache = new DiskTileCache(plugin.getDataDirectory());
2829
this.pendingRequests = new ConcurrentHashMap<>();
2930
this.chunkIndexCache = new ConcurrentHashMap<>();
31+
// Initialize composite generator after this object is constructed
32+
this.compositeTileGenerator = new CompositeTileGenerator(plugin, this);
3033
}
3134

3235
public CompletableFuture<byte[]> getTile(String worldName, int zoom, int tileX, int tileZ) {
36+
// Route negative zoom levels to composite tile generator
37+
if (zoom < 0 && this.plugin.getConfig().isEnableTilePyramids()) {
38+
return this.getCompositeTile(worldName, zoom, tileX, tileZ);
39+
}
40+
41+
// For zoom >= 0, use base tile logic
42+
return this.getBaseTile(worldName, tileX, tileZ);
43+
}
44+
45+
/**
46+
* Get a composite tile at a negative zoom level.
47+
* Composite tiles combine multiple base tiles into one.
48+
*/
49+
private CompletableFuture<byte[]> getCompositeTile(String worldName, int zoom, int tileX, int tileZ) {
3350
String cacheKey = TileCache.createKey(worldName, zoom, tileX, tileZ);
3451

35-
// 1. Check memory cache first (fastest)
52+
// 1. Check memory cache first
3653
byte[] memoryCached = this.memoryCache.get(cacheKey);
3754
if (memoryCached != null) {
3855
return CompletableFuture.completedFuture(memoryCached);
@@ -44,11 +61,71 @@ public CompletableFuture<byte[]> getTile(String worldName, int zoom, int tileX,
4461
return pending;
4562
}
4663

47-
// 3. Check disk cache if enabled
64+
// 3. Check disk cache
4865
if (this.plugin.getConfig().isUseDiskCache()) {
4966
byte[] diskCached = this.diskCache.get(worldName, zoom, tileX, tileZ);
5067
if (diskCached != null) {
5168
long tileAge = this.diskCache.getTileAge(worldName, zoom, tileX, tileZ);
69+
// Use longer refresh interval for composite tiles (they're more expensive)
70+
long refreshInterval = this.plugin.getConfig().getTileRefreshIntervalMs() * 2;
71+
72+
if (tileAge < refreshInterval) {
73+
this.memoryCache.put(cacheKey, diskCached);
74+
return CompletableFuture.completedFuture(diskCached);
75+
}
76+
77+
// Check if any players are in the area covered by this composite tile
78+
int chunksPerAxis = this.compositeTileGenerator.getChunksPerAxis(zoom);
79+
int baseChunkX = tileX * chunksPerAxis;
80+
int baseChunkZ = tileZ * chunksPerAxis;
81+
World world = Universe.get().getWorld(worldName);
82+
83+
if (world == null || !this.arePlayersInArea(world, baseChunkX, baseChunkZ, chunksPerAxis)) {
84+
this.memoryCache.put(cacheKey, diskCached);
85+
return CompletableFuture.completedFuture(diskCached);
86+
}
87+
}
88+
}
89+
90+
// 4. Generate composite tile
91+
CompletableFuture<byte[]> future = this.compositeTileGenerator.generateCompositeTile(worldName, zoom, tileX, tileZ);
92+
this.pendingRequests.put(cacheKey, future);
93+
future.whenComplete((data, ex) -> {
94+
this.pendingRequests.remove(cacheKey);
95+
if (data != null && data.length > 0 && ex == null) {
96+
this.memoryCache.put(cacheKey, data);
97+
if (this.plugin.getConfig().isUseDiskCache()) {
98+
this.diskCache.put(worldName, zoom, tileX, tileZ, data);
99+
}
100+
}
101+
});
102+
return future;
103+
}
104+
105+
/**
106+
* Get a base tile (zoom level 0) for a single chunk.
107+
* This is called by the composite tile generator.
108+
*/
109+
public CompletableFuture<byte[]> getBaseTile(String worldName, int tileX, int tileZ) {
110+
String cacheKey = TileCache.createKey(worldName, 0, tileX, tileZ);
111+
112+
// 1. Check memory cache first (fastest)
113+
byte[] memoryCached = this.memoryCache.get(cacheKey);
114+
if (memoryCached != null) {
115+
return CompletableFuture.completedFuture(memoryCached);
116+
}
117+
118+
// 2. Check if already generating
119+
CompletableFuture<byte[]> pending = this.pendingRequests.get(cacheKey);
120+
if (pending != null) {
121+
return pending;
122+
}
123+
124+
// 3. Check disk cache if enabled
125+
if (this.plugin.getConfig().isUseDiskCache()) {
126+
byte[] diskCached = this.diskCache.get(worldName, 0, tileX, tileZ);
127+
if (diskCached != null) {
128+
long tileAge = this.diskCache.getTileAge(worldName, 0, tileX, tileZ);
52129
long refreshInterval = this.plugin.getConfig().getTileRefreshIntervalMs();
53130

54131
// If tile is fresh enough, serve from disk
@@ -70,14 +147,14 @@ public CompletableFuture<byte[]> getTile(String worldName, int zoom, int tileX,
70147
}
71148

72149
// 4. Generate new tile
73-
CompletableFuture<byte[]> future = this.generateTile(worldName, zoom, tileX, tileZ);
150+
CompletableFuture<byte[]> future = this.generateTile(worldName, 0, tileX, tileZ);
74151
this.pendingRequests.put(cacheKey, future);
75152
future.whenComplete((data, ex) -> {
76153
this.pendingRequests.remove(cacheKey);
77154
if (data != null && data.length > 0 && ex == null) {
78155
this.memoryCache.put(cacheKey, data);
79156
if (this.plugin.getConfig().isUseDiskCache()) {
80-
this.diskCache.put(worldName, zoom, tileX, tileZ, data);
157+
this.diskCache.put(worldName, 0, tileX, tileZ, data);
81158
}
82159
}
83160
});
@@ -109,6 +186,35 @@ private boolean arePlayersNearby(World world, int tileX, int tileZ) {
109186
return false;
110187
}
111188

189+
/**
190+
* Check if any players are within the area covered by a composite tile.
191+
*/
192+
private boolean arePlayersInArea(World world, int baseChunkX, int baseChunkZ, int chunksPerAxis) {
193+
int radius = this.plugin.getConfig().getTileRefreshRadius();
194+
195+
for (PlayerRef playerRef : world.getPlayerRefs()) {
196+
try {
197+
Transform transform = playerRef.getTransform();
198+
if (transform == null) continue;
199+
200+
Vector3d pos = transform.getPosition();
201+
int playerChunkX = ChunkUtil.chunkCoordinate((int) pos.x);
202+
int playerChunkZ = ChunkUtil.chunkCoordinate((int) pos.z);
203+
204+
// Check if player is within the area (with buffer for refresh radius)
205+
if (playerChunkX >= baseChunkX - radius &&
206+
playerChunkX < baseChunkX + chunksPerAxis + radius &&
207+
playerChunkZ >= baseChunkZ - radius &&
208+
playerChunkZ < baseChunkZ + chunksPerAxis + radius) {
209+
return true;
210+
}
211+
} catch (Exception e) {
212+
// Skip this player
213+
}
214+
}
215+
return false;
216+
}
217+
112218
private CompletableFuture<byte[]> generateTile(String worldName, int zoom, int tileX, int tileZ) {
113219
World world = Universe.get().getWorld(worldName);
114220
if (world == null) {

0 commit comments

Comments
 (0)