leaflet-city-mapper 0.0.3 → 0.0.5

package/src/projections/toPoint.js

@@ -0,0 +1,5 @@
+import { L } from '../globals/L.js';
+export function pointOf(point) {
+  return /* alloc */ new L.Point(
+    Array.isArray(point) ? point[0] : point.x, Array.isArray(point) ? point[1] : point.y);
+}

package/src/{camera/animationPoint.js → projections/transformZoomAnimationPoint.js}

@@ -1,5 +1,9 @@
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+
+
+
 export function animationPoint(map, point, inverse = false) {
-  const view = map._cameraView;
+  const view = cameraViewByMap.get(map);
   if (!view) return point;
   const half = map.getSize().divideBy(2), scale = map.getZoomScale(view.zoom);
   const shift = map.project(map.getCenter(), view.zoom).subtract(map.project(view.center, view.zoom));

package/src/projections/walkerLocalPosition.js

@@ -0,0 +1,18 @@
+
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { radians } from '../globals/radians.js';
+import { mapElevationOf } from '../terrain/mapElevationOf.js';
+
+export function local(output) {
+  const { layer, state } = this;
+  const map = layer._map, crs = map.options.crs
+  const location = locationByLayer.get(layer), root = rootByLayer.get(layer);
+  const origin = crs.project(location), metres = Math.cos(location.lat * radians);
+  const p = crs.project(state.latlng);
+  const ground = mapElevationOf(map, state.latlng) || 0;
+  output[0] = (p.x - origin.x) * metres;
+  output[1] = ground + (state.height ?? 0) - root.position[1];
+  output[2] = -(p.y - origin.y) * metres;
+  return output;
+}

package/src/raster/addRasterTile.js

@@ -1,114 +1,79 @@
-import { cityMapper } from '../constants/cityMapper.js';
-import { createProgram } from '../rendering/createProgram.js';
-import { destroyTexture } from '../rendering/destroyTexture.js';
-import { terrainAtlas } from '../terrain/terrainAtlas.js';
-import { terrainGrid } from '../terrain/terrainGrid.js';
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
+import { terrainBoundsByLayer } from '../weakmaps/terrainBoundsByLayer.js';
+import { terrainOriginElevationByLayer } from '../weakmaps/terrainOriginElevationByLayer.js';
+import { terrainPromiseByLayer } from '../weakmaps/terrainPromiseByLayer.js';
+import { terrainZoomByLayer } from '../weakmaps/terrainZoomByLayer.js';
+import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+
+
+import { radians } from '../globals/radians.js';
+import { rasterPoint } from '../globals/rasterPoint.js';
+import { nextId } from '../globals/nextId.js';
+import { rasterProgram } from '../materials/terrainRasterProgram.js';
+import { terrainBuffers } from '../geometry/terrainBuffers.js';
 import { setParent } from '../scene/setParent.js';
-import { update } from '../scene/update.js';
+import { update } from '../scene/scheduleSceneUpdate.js';
+import { terrainTileGeometry } from '../geometry/terrainTileGeometry.js';
 
-export async function addRasterTile(backend, layer, coords, tile) {
-  const ready = await backend._terrainPromise;
-  if (!ready || !backend._map || backend._map._terrain3D !== backend || layer._terrain3D !== backend ||
-    tile.request.signal.aborted || !layer._rasterTiles.has(`${coords.z}/${coords.x}/${coords.y}`) ||
-    backend._rasterTiles.has(tile)) {
+export async function addRasterTile(layer, rasterLayer, coords, tile) {
+  const ready = await terrainPromiseByLayer.get(layer);
+  if (!ready || !layer._map || terrain3DByMap.get(layer._map) !== layer || terrain3DByLayer.get(rasterLayer) !== layer ||
+    tile.request.signal.aborted || !rasterTilesByLayer.get(rasterLayer).has(`${coords.z}/${coords.x}/${coords.y}`) ||
+    rasterTilesByLayer.get(layer).has(tile)) {
     return;
   }
   // Match DEM pixel spacing, capped at 64 subdivisions per tile.
-  const divisions = Math.max(1, Math.min(64, 256 / 2 ** (coords.z - backend._terrainZoom)));
-  const map = backend._map, crs = map.options.crs;
-  const origin = crs.project(backend.location), metres = Math.cos(backend.location.lat * Math.PI / 180);
+  const divisions = Math.max(1, Math.min(64, 256 / 2 ** (coords.z - terrainZoomByLayer.get(layer))));
+  const map = layer._map, crs = map.options.crs;
+  const origin = crs.project(locationByLayer.get(layer)), metres = Math.cos(locationByLayer.get(layer).lat * radians);
   // Tile pixels map linearly to projected metres: one scaled unit grid per tile, elevation in the vertex shader.
-  const scale = crs.scale(coords.z), terrainScale = 2 ** (backend._terrainZoom - coords.z);
-  const corner = crs.transformation.untransform(new L.Point(coords.x * 256, coords.y * 256), scale);
-  const opposite = crs.transformation.untransform(new L.Point((coords.x + 1) * 256, (coords.y + 1) * 256), scale);
-  const device = backend.renderer.device;
+  const scale = crs.scale(coords.z), terrainScale = 2 ** (terrainZoomByLayer.get(layer) - coords.z);
+  const point = rasterPoint;
+  point.x = coords.x * 256; point.y = coords.y * 256;
+  const corner = crs.transformation.untransform(point, scale);
+  point.x = (coords.x + 1) * 256; point.y = (coords.y + 1) * 256;
+  const opposite = crs.transformation.untransform(point, scale);
+  const device = rendererByLayer.get(layer).device;
   const texture = tile.texture;
-  if (!backend._rasterProgram || backend._rasterProgram.device !== device) {
-    // DEM atlas over the archive's tile grid; invalid or missing samples become -1e9 (the shader's no-data).
-    // ponytail: one texture, capped by maxTextureDimension2D (32×32 DEM tiles at 8192 px); split it for larger archives.
-    const bounds = backend._terrainBounds, columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
-    const { elevations, low, high } = terrainAtlas(backend._terrainTiles, bounds);
-    if (backend._dem) destroyTexture(backend, backend._dem.texture);
-    backend._dem = {
-      texture: device.createTexture({
-        size: [columns * 256, rows * 256],
-        format: 'r32float',
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
-      }),
-      low: Number.isFinite(low) ? low : backend._terrainOriginElevation,
-      high: Number.isFinite(high) ? high : backend._terrainOriginElevation,
-    };
-    device.queue.writeTexture({ texture: backend._dem.texture }, elevations,
-      { bytesPerRow: columns * 1024 }, [columns * 256, rows * 256]);
-    backend._terrainGrids = new Map();
-    backend._rasterProgram = createProgram(backend, {
-      baseTexture: texture,
-      unlit: true,
-      terrain: backend._dem,
-      alphaMode: 'BLEND',
-      depthWrite: true,
-    });
-  }
-  let attributes = backend._terrainGrids.get(divisions);
-  let name, attribute;
-  if (!attributes) {
-    attributes = terrainGrid(divisions);
-    for ([name, attribute] of Object.entries(attributes)) {
-      attribute.size ||= 1;
-      attribute.count = attribute.data.length / attribute.size;
-      attribute.indexFormat = 'uint16';
-      attribute.buffer = device.createBuffer({
-        size: Math.max(4, attribute.data.byteLength),
-        usage: name === 'index'
-          ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
-          : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-      });
-      device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-    }
-    backend._terrainGrids.set(divisions, attributes);
-  }
-  const base = backend._terrainOriginElevation;
-  const bottom = Math.min(backend._dem.low, base) - base, top = Math.max(backend._dem.high, base) - base;
+  const program = rasterProgram(layer, texture);
+  const attributes = terrainBuffers(layer, divisions);
+  const base = terrainOriginElevationByLayer.get(layer);
   const sizeX = (opposite.x - corner.x) * metres, sizeZ = -(opposite.y - corner.y) * metres;
   // ponytail: ray picking sees the flat unit grid; read the DEM back if terrain must be pickable.
-  const geometry = {
-    device,
-    attributes,
-    drawRange: { start: 0, count: attributes.index.count },
-    // Local bounds whose radius, scaled by the largest axis, still covers the displaced tile.
-    bounds: {
-      min: [0, bottom, 0], max: [1, top, 1], center: [0.5, (bottom + top) / 2, 0.5],
-      radius: Math.hypot(sizeX, top - bottom, sizeZ) / 2 / Math.max(sizeX, 1, sizeZ),
-    },
-  };
-  const mesh = {
-    position: [(corner.x - origin.x) * metres, 0, -(corner.y - origin.y) * metres],
-    rotation: [0, 0, 0],
-    scale: [sizeX, 1, sizeZ],
-    worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-    children: [],
+  const geometry = terrainTileGeometry(layer, attributes, sizeX, sizeZ);
+  const mesh = /* alloc */ {
+    position: /* alloc */ [(corner.x - origin.x) * metres, 0, -(corner.y - origin.y) * metres],
+    rotation: /* alloc */ [0, 0, 0],
+    scale: /* alloc */ [sizeX, 1, sizeZ],
+    worldMatrix: /* alloc */ [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    children: /* alloc */ [],
     visible: true,
     device,
     geometry,
-    program: backend._rasterProgram,
+    program,
     texture,
     // DEM pixel of the tile's corner, DEM pixels per tile, and the elevation at the layer origin.
-    terrain: [
-      coords.x * 256 * terrainScale - backend._terrainBounds.min.x * 256,
-      coords.y * 256 * terrainScale - backend._terrainBounds.min.y * 256,
+    terrain: /* alloc */ [
+      coords.x * 256 * terrainScale - terrainBoundsByLayer.get(layer).min.x * 256,
+      coords.y * 256 * terrainScale - terrainBoundsByLayer.get(layer).min.y * 256,
       256 * terrainScale,
       base,
     ],
     tile,
-    opacity: layer.options.opacity ?? 1,
-    id: cityMapper.nextId++,
-    renderOrder: layer.options.zIndex || 0,
+    opacity: rasterLayer.options.opacity ?? 1,
+    id: nextId.value++,
+    renderOrder: rasterLayer.options.zIndex || 0,
     fadeDuration: 250,
     fadeStart: tile.loadedAt,
     ground: true,
+    _rasterSource: rasterLayer,
   };
   tile.mesh.visible = false;
-  setParent(mesh, backend.root);
-  update(backend);
-  backend._rasterTiles.set(tile, mesh);
+  setParent(mesh, rootByLayer.get(layer));
+  update(layer);
+  rasterTilesByLayer.get(layer).set(tile, mesh);
 }

package/src/raster/comparePendingTiles.js

@@ -1,5 +1,5 @@
 
 
-export function comparePendingTiles(a, b) {
-  return a.tile.coords.z - b.tile.coords.z || a.distance - b.distance;
+export function comparePendingTiles(a, b) {
+  return a.tile.coords.z - b.tile.coords.z || a.distance - b.distance;
 }

package/src/raster/createRasterMesh.js

@@ -1,47 +1,81 @@
-import { cityMapper } from "../constants/cityMapper.js";
-import { createProgram } from "../rendering/createProgram.js";
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { rasterGeometryByLayer } from '../weakmaps/rasterGeometryByLayer.js';
+import { rasterProgramByLayer } from '../weakmaps/rasterProgramByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+
+import { radians } from '../globals/radians.js';
+import { rasterTexture } from '../globals/rasterTexture.js';
+import { rasterSampler } from '../globals/rasterSampler.js';
+import { meshImage } from '../globals/meshImage.js';
+import { meshTarget } from '../globals/meshTarget.js';
+import { meshCopySize } from '../globals/meshCopySize.js';
+import { rasterPoint } from '../globals/rasterPoint.js';
+import { TILE_SIZE } from '../globals/TILE_SIZE.js';
+import { nextId } from '../globals/nextId.js';
+
+
+
+import { createProgram } from "../materials/createProgram.js";
 import { setParent } from "../scene/setParent.js";
-import { TILE_SIZE } from "../constants/TILE_SIZE.js";
-import { createGeometry } from './createGeometry.js';
 
-export function createRasterMesh(backend, tile) {
-  const device = backend.renderer.device;
-  const texture = {
-    device,
-    texture: device.createTexture({
-      size: [tile.image.width, tile.image.height],
-      format: 'rgba8unorm',
-      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-    }),
-    sampler: device.createSampler({ addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge',
-      magFilter: 'linear', minFilter: 'linear' }),
-    image: tile.image, format: 'rgba8unorm', srgb: false, uploaded: null,
-  };
-  if (!backend._rasterProgram) {
-    backend._rasterProgram = createProgram(backend, {
-      baseTexture: texture, unlit: true, alphaMode: 'BLEND',
-    });
-  }
-  if (!backend._rasterGeometry) backend._rasterGeometry = createGeometry(device);
-  const { coords } = tile;
-  const crs = backend._map.options.crs;
-  const origin = crs.project(backend.location);
-  const metres = Math.cos(backend.location.lat * Math.PI / 180);
-  const scale = crs.scale(coords.z);
-  const corner = crs.transformation.untransform(new L.Point(coords.x * TILE_SIZE, coords.y * TILE_SIZE), scale);
-  const opposite = crs.transformation.untransform(new L.Point((coords.x + 1) * TILE_SIZE, (coords.y + 1) * TILE_SIZE), scale);
-  const sizeX = (opposite.x - corner.x) * metres;
-  const sizeZ = -(opposite.y - corner.y) * metres;
-  tile.texture = texture;
-  tile.mesh = {
-    position: [(corner.x - origin.x) * metres, 0, -(corner.y - origin.y) * metres],
-    rotation: [0, 0, 0],
-    scale: [sizeX, 1, sizeZ],
-    worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-    children: [], visible: true, device, geometry: backend._rasterGeometry,
-    program: backend._rasterProgram, texture,
-    opacity: backend.options.opacity, id: cityMapper.nextId++,
-    renderOrder: backend.options.zIndex || 0, tile, fadeDuration: 250, ground: true,
-  };
-  setParent(tile.mesh, backend.root);
+import { createGeometry } from '../geometry/createRasterQuadGeometry.js';
+
+export function createRasterMesh(layer, tile) {
+  const device = rendererByLayer.get(layer).device;
+  const texture = /* alloc */ {
+    device,
+    texture: device.createTexture((
+    rasterTexture.size[0] = tile.image.width,
+    rasterTexture.size[1] = tile.image.height,
+    rasterTexture.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+    rasterTexture
+  )),
+    sampler: device.createSampler(rasterSampler),
+    image: tile.image, format: 'rgba8unorm', srgb: false, uploaded: null,
+  };
+  const source = meshImage;
+  const destination = meshTarget;
+  const dimensions = meshCopySize;
+  source.source = tile.image;
+  source.flipY = false;
+  destination.texture = texture.texture;
+  dimensions[0] = tile.image.width;
+  dimensions[1] = tile.image.height;
+  device.queue.copyExternalImageToTexture(source, destination, dimensions);
+  source.source = null;
+  destination.texture = null;
+  texture.uploaded = tile.image;
+
+  if (!rasterProgramByLayer.get(layer)) {
+    rasterProgramByLayer.set(layer, createProgram(layer, /* alloc */ {
+      baseTexture: texture, unlit: true, alphaMode: 'BLEND', doubleSided: layer.options.doubleSided,
+    }));
+  }
+  if (!rasterGeometryByLayer.get(layer)) rasterGeometryByLayer.set(layer, createGeometry(device));
+  const { coords } = tile;
+  const crs = layer._map.options.crs;
+  const origin = crs.project(locationByLayer.get(layer));
+  const metres = Math.cos(locationByLayer.get(layer).lat * radians);
+  const scale = crs.scale(coords.z);
+  const point = rasterPoint;
+  point.x = coords.x * TILE_SIZE; point.y = coords.y * TILE_SIZE;
+  const corner = crs.transformation.untransform(point, scale);
+  point.x = (coords.x + 1) * TILE_SIZE; point.y = (coords.y + 1) * TILE_SIZE;
+  const opposite = crs.transformation.untransform(point, scale);
+  const sizeX = (opposite.x - corner.x) * metres;
+  const sizeZ = -(opposite.y - corner.y) * metres;
+  tile.texture = texture;
+  tile.mesh = /* alloc */ {
+    position: /* alloc */ [(corner.x - origin.x) * metres, 0, -(corner.y - origin.y) * metres],
+    rotation: /* alloc */ [0, 0, 0],
+    scale: /* alloc */ [sizeX, 1, sizeZ],
+    worldMatrix: /* alloc */ [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    children: /* alloc */ [], visible: true, device, geometry: rasterGeometryByLayer.get(layer),
+    program: rasterProgramByLayer.get(layer), texture,
+    opacity: layer.options.opacity, id: nextId.value++,
+    renderOrder: layer.options.zIndex || 0, tile, fadeDuration: 250, ground: true,
+    _rasterSource: layer,
+  };
+  setParent(tile.mesh, rootByLayer.get(layer));
 }

package/src/raster/finishRasterAttachment.js

@@ -0,0 +1,17 @@
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+
+
+
+
+import { setRasterTerrain } from "./setRasterTerrain.js";
+
+export async function finishAttachment(layer, map, attached) {
+  try {
+    await attached;
+    addedByLayer.get(layer).resolve();
+    setRasterTerrain(layer, terrain3DByMap.get(map));
+  } catch (error) {
+    layer.fire('error', /* alloc */ { error });
+  }
+}

package/src/raster/finishRasterTile.js

@@ -1,47 +1,64 @@
-import { update } from "../scene/update.js";
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+import { rasterVersionByLayer } from '../weakmaps/rasterVersionByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+
+import { blobParts } from '../globals/blobParts.js';
+
+import { update } from "../scene/scheduleSceneUpdate.js";
 import { registerTerrainTile } from "./registerTerrainTile.js";
 import { pruneRasterTiles } from "./pruneRasterTiles.js";
 import { pumpRasterTiles } from './pumpRasterTiles.js';
 import { createRasterMesh } from './createRasterMesh.js';
+import { getZxy } from '../archives/getZxy.js';
 
-export async function finishRasterTile(backend, tile) {
-  try {
-    await backend.ready;
-    const result = await backend.options.archive.getZxy(
-      tile.coords.z, tile.coords.x, tile.coords.y, tile.request.signal
-    );
-    if (tile.request.signal.aborted) return;
-    if (!result) throw new Error(`Tile ${tile.coords.z}/${tile.coords.x}/${tile.coords.y} is not in the offline archive`);
-    try {
-      tile.image = await createImageBitmap(new Blob([result.data]));
-    } catch {
-      throw new Error(`Unable to decode tile ${tile.coords.z}/${tile.coords.x}/${tile.coords.y}`);
-    }
-    if (tile.request.signal.aborted) {
-      tile.image.close();
-      tile.image = null;
-      return;
-    }
-    createRasterMesh(backend, tile);
-    tile.loadedAt = performance.now();
-    tile.done = true;
-    backend._rasterVersion = (backend._rasterVersion || 0) + 1;
-    registerTerrainTile(backend, tile.coords, tile);
-    backend.fire('tileload', { tile, coords: tile.coords });
-    update(backend);
-  } catch (error) {
-    if (tile.request.signal.aborted) return;
-    tile.error = error.message;
-    backend._rasterVersion = (backend._rasterVersion || 0) + 1;
-    backend.fire('tileerror', { tile, coords: tile.coords, error });
-    backend.fire('error', { error, coords: tile.coords });
-  } finally {
-    backend._loadingTiles--;
-    if (backend._map) {
-      pumpRasterTiles(backend);
-      pruneRasterTiles(backend);
-      if (!backend._loadingTiles) backend.fire('load');
-      update(backend);
-    }
-  }
+export async function finishRasterTile(layer, tile) {
+  try {
+    await readyByLayer.get(layer);
+    const result = await getZxy(layer.options.archive,
+      tile.coords.z, tile.coords.x, tile.coords.y, tile.request.signal
+    );
+    if (tile.request.signal.aborted) {
+      result?.image?.close();
+      return;
+    }
+    if (!result) throw /* alloc */ new Error(`Tile ${tile.coords.z}/${tile.coords.x}/${tile.coords.y} is not in the offline archive`);
+    try {
+      if (result.image) tile.image = result.image;
+      else {
+        blobParts[0] = result.data;
+        const blob = /* alloc */ new Blob(blobParts);
+        blobParts[0] = null;
+        tile.image = await createImageBitmap(blob);
+      }
+    } catch {
+      blobParts[0] = null;
+      throw /* alloc */ new Error(`Unable to decode tile ${tile.coords.z}/${tile.coords.x}/${tile.coords.y}`);
+    }
+    if (tile.request.signal.aborted) {
+      tile.image.close();
+      tile.image = null;
+      return;
+    }
+    createRasterMesh(layer, tile);
+    tile.loadedAt = performance.now();
+    tile.done = true;
+    rasterVersionByLayer.set(layer, (rasterVersionByLayer.get(layer) || 0) + 1);
+    registerTerrainTile(layer, tile.coords, tile);
+    layer.fire('tileload', /* alloc */ { tile, coords: tile.coords });
+    update(layer);
+  } catch (error) {
+    if (tile.request.signal.aborted) return;
+    tile.error = error.message;
+    rasterVersionByLayer.set(layer, (rasterVersionByLayer.get(layer) || 0) + 1);
+    layer.fire('tileerror', /* alloc */ { tile, coords: tile.coords, error });
+    layer.fire('error', /* alloc */ { error, coords: tile.coords });
+  } finally {
+    loadingTilesByLayer.set(layer, loadingTilesByLayer.get(layer) - 1);
+    if (layer._map) {
+      pumpRasterTiles(layer);
+      pruneRasterTiles(layer);
+      if (!loadingTilesByLayer.get(layer)) layer.fire('load');
+      update(layer);
+    }
+  }
 }

package/src/raster/getRasterEvents.js

@@ -1,6 +1,6 @@
 import { updateRasterTiles } from "./updateRasterTiles.js";
 
-export function getRasterEvents(layer) {
-  const update = updateRasterTiles.bind(null, layer);
-  return { moveend: update, zoomend: update, rotate: update, pitch: update, resize: update };
+export function getRasterEvents(layer) {
+  const update = updateRasterTiles.bind(null, layer);
+  return /* alloc */ { moveend: update, zoomend: update, rotate: update, pitch: update, resize: update };
 }

package/src/raster/getRasterTileSize.js

@@ -1,5 +1,7 @@
-import { TILE_SIZE } from '../constants/TILE_SIZE.js';
+import { L } from '../globals/L.js';
+import { TILE_SIZE } from '../globals/TILE_SIZE.js';
 
-export function getRasterTileSize() {
-  return new L.Point(TILE_SIZE, TILE_SIZE);
+
+export function getRasterTileSize() {
+  return /* alloc */ new L.Point(TILE_SIZE, TILE_SIZE);
 }

package/src/raster/initRaster.js

@@ -1,9 +1,22 @@
-import { isLoading } from './isLoading.js';
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+import { directoriesByLayer } from '../weakmaps/directoriesByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { urlByLayer } from '../weakmaps/urlByLayer.js';
+
+import { L } from '../globals/L.js';
+
+
+import { isLoading } from './isRasterLoading.js';
 import { getRasterEvents } from './getRasterEvents.js';
 import { readyRaster } from './readyRaster.js';
-import { reportError } from './reportError.js';
-import { emptyNode } from '../scene/emptyNode.js';
-import { read } from '../archives/read.js';
+import { reportError } from './reportRasterError.js';
+import { emptyNode } from '../scene/createSceneNode.js';
+import { read } from '../archives/readArchiveRange.js';
 import { getHeader } from '../archives/getHeader.js';
 import { getZxy } from '../archives/getZxy.js';
 import { onPMTileAdd } from './onPMTileAdd.js';
@@ -13,26 +26,17 @@ import { setPMTileOpacity } from './setPMTileOpacity.js';
 import { setPMTileZIndex } from './setPMTileZIndex.js';
 
 export function initRaster(layer, options) {
-  layer._read = read.bind(null, layer);
-  layer.getHeader = getHeader.bind(null, layer);
-  layer.getZxy = getZxy.bind(null, layer);
-  layer.getTileSize = getRasterTileSize;
-  layer.isLoading = isLoading.bind(null, layer);
-  layer.setOpacity = setPMTileOpacity.bind(null, layer);
-  layer.setZIndex = setPMTileZIndex.bind(null, layer);
-  layer.onAdd = onPMTileAdd.bind(null, layer);
-  layer.onRemove = onPMTileRemove.bind(null, layer);
-  layer.getEvents = getRasterEvents.bind(null, layer);
-  options = { ariaLabel: 'PMTiles raster', maxZoom: 18, opacity: 1, zIndex: 0, ...options };
+  kindByLayer.set(layer, 'raster');
+  options = /* alloc */ { ariaLabel: 'PMTiles raster', maxZoom: 18, opacity: 1, zIndex: 0, ...options };
   L.Util.setOptions(layer, options);
-  layer.root = emptyNode();
-  layer._areas = new Map();
-  layer._rasterTiles = new Map();
-  layer._loadingTiles = 0;
-  layer._added = Promise.withResolvers();
-  layer.url = new URL(options.url, document.baseURI).href;
-  layer._directories = new Map();
-  layer.ready = Promise.resolve(layer.options.archive || layer)
+  rootByLayer.set(layer, emptyNode());
+  areasByLayer.set(layer, /* alloc */ new Map());
+  rasterTilesByLayer.set(layer, /* alloc */ new Map());
+  loadingTilesByLayer.set(layer, 0);
+  addedByLayer.set(layer, Promise.withResolvers());
+  urlByLayer.set(layer, /* alloc */ new URL(options.url, document.baseURI).href);
+  directoriesByLayer.set(layer, /* alloc */ new Map());
+  readyByLayer.set(layer, Promise.resolve(layer.options.archive || layer)
     .then(readyRaster.bind(null, layer))
-    .catch(reportError.bind(null, layer));
+    .catch(reportError.bind(null, layer)));
 }

package/src/raster/isRasterLoading.js

@@ -0,0 +1,8 @@
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+
+
+
+
+export function isLoading(layer) {
+  return loadingTilesByLayer.get(layer) > 0;
+}

package/src/raster/loadRasterTile.js

@@ -1,10 +1,14 @@
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+
+
+
 import { finishRasterTile } from './finishRasterTile.js';
 
-export function loadRasterTile(backend, tile) {
-  tile.started = true;
-  const first = backend._loadingTiles === 0;
-  backend._loadingTiles++;
-  backend.fire('tileloadstart', { tile, coords: tile.coords });
-  if (first) backend.fire('loading');
-  return finishRasterTile(backend, tile);
+export function loadRasterTile(layer, tile) {
+  tile.started = true;
+  const first = loadingTilesByLayer.get(layer) === 0;
+  loadingTilesByLayer.set(layer, loadingTilesByLayer.get(layer) + 1);
+  layer.fire('tileloadstart', /* alloc */ { tile, coords: tile.coords });
+  if (first) layer.fire('loading');
+  return finishRasterTile(layer, tile);
 }

package/src/raster/onPMTileAdd.js

@@ -1,10 +1,14 @@
-import { finishAttachment } from './finishAttachment.js';
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+
+
+
+import { finishAttachment } from './finishRasterAttachment.js';
 import { updateAttachedTiles } from './updateAttachedTiles.js';
-import { attach } from '../scene/attach.js';
+import { attach } from '../scene/attachSharedScene.js';
 
-export function onPMTileAdd(backend, map) {
-  if (!backend.location) backend.location = map.getCenter();
-  const attached = attach(backend, map);
-  finishAttachment(backend, map, attached);
-  updateAttachedTiles(backend, map, attached);
+export function onPMTileAdd(layer, map) {
+  if (!locationByLayer.get(layer)) locationByLayer.set(layer, map.getCenter());
+  const attached = attach(layer, map);
+  finishAttachment(layer, map, attached);
+  updateAttachedTiles(layer, map, attached);
 }

package/src/raster/onPMTileRemove.js

@@ -1,8 +1,12 @@
+import { terrain3DByLayer } from '../weakmaps/terrain3DByLayer.js';
+
+
+
 import { releaseRasterTiles } from './releaseRasterTiles.js';
 import { onRemove3DLayer } from '../scene/onRemove3DLayer.js';
 
-export function onPMTileRemove(backend, map) {
-  releaseRasterTiles(backend);
-  backend._terrain3D = null;
-  onRemove3DLayer(backend, map);
+export function onPMTileRemove(layer, map) {
+  releaseRasterTiles(layer);
+  terrain3DByLayer.set(layer, null);
+  onRemove3DLayer(layer, map);
 }