leaflet-city-mapper 0.0.3 → 0.0.4

package/src/raster/addRasterTile.js

@@ -1,114 +1,69 @@
-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 { radians } from '../globals/radians.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { rasterPoint } from '../globals/rasterPoint.js';
+import { nextId } from '../globals/nextId.js';
+import { rasterProgram } from '../terrain/rasterProgram.js';
+import { terrainBuffers } from '../terrain/terrainBuffers.js';
 import { setParent } from '../scene/setParent.js';
 import { update } from '../scene/update.js';
+import { terrainTileGeometry } from './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)) {
+  const ready = await sceneByLayer.get(backend)._terrainPromise;
+  if (!ready || !backend._map || cameraByMap.get(backend._map)._terrain3D !== backend || sceneByLayer.get(layer)._terrain3D !== backend ||
+    tile.request.signal.aborted || !sceneByLayer.get(layer)._rasterTiles.has(`${coords.z}/${coords.x}/${coords.y}`) ||
+    sceneByLayer.get(backend)._rasterTiles.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 divisions = Math.max(1, Math.min(64, 256 / 2 ** (coords.z - sceneByLayer.get(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 origin = crs.project(sceneByLayer.get(backend).location), metres = Math.cos(sceneByLayer.get(backend).location.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 ** (sceneByLayer.get(backend)._terrainZoom - 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 = sceneByLayer.get(backend).renderer.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(backend, texture);
+  const attributes = terrainBuffers(backend, divisions);
+  const base = sceneByLayer.get(backend)._terrainOriginElevation;
   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(backend, 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 - sceneByLayer.get(backend)._terrainBounds.min.x * 256,
+      coords.y * 256 * terrainScale - sceneByLayer.get(backend)._terrainBounds.min.y * 256,
       256 * terrainScale,
       base,
     ],
     tile,
     opacity: layer.options.opacity ?? 1,
-    id: cityMapper.nextId++,
+    id: nextId.value++,
     renderOrder: layer.options.zIndex || 0,
     fadeDuration: 250,
     fadeStart: tile.loadedAt,
     ground: true,
+    _rasterSource: layer,
   };
   tile.mesh.visible = false;
-  setParent(mesh, backend.root);
+  setParent(mesh, sceneByLayer.get(backend).root);
   update(backend);
-  backend._rasterTiles.set(tile, mesh);
+  sceneByLayer.get(backend)._rasterTiles.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/createGeometry.js

@@ -1,22 +1,29 @@
+import { rasterBuffer } from '../globals/rasterBuffer.js';
+import { rasterPositions } from '../globals/rasterPositions.js';
+import { rasterNormals } from '../globals/rasterNormals.js';
+import { rasterUVs } from '../globals/rasterUVs.js';
+import { rasterIndices } from '../globals/rasterIndices.js';
 
 
 export function createGeometry(device) {
-  const attributes = {
-    position: { size: 3, data: new Float32Array([0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1]) },
-    normal: { size: 3, data: new Float32Array([0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0]) },
-    uv: { size: 2, data: new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]) },
-    index: { data: new Uint16Array([0, 2, 1, 1, 2, 3]) },
+  const attributes = /* alloc */ {
+    position: /* alloc */ { size: 3, data: /* alloc */ new Float32Array(rasterPositions) },
+    normal: /* alloc */ { size: 3, data: /* alloc */ new Float32Array(rasterNormals) },
+    uv: /* alloc */ { size: 2, data: /* alloc */ new Float32Array(rasterUVs) },
+    index: /* alloc */ { data: /* alloc */ new Uint16Array(rasterIndices) },
   };
   let name, attribute;
   for ([name, attribute] of Object.entries(attributes)) {
     attribute.count = attribute.data.length / (attribute.size || 1);
     attribute.indexFormat = 'uint16';
-    attribute.buffer = device.createBuffer({
-      size: attribute.data.byteLength,
-      usage: name === 'index' ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+    attribute.buffer = device.createBuffer((
+      rasterBuffer.size = attribute.data.byteLength,
+      rasterBuffer.usage = name === 'index' ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
         : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-    });
+      rasterBuffer
+    ));
+
     device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
   }
-  return { device, attributes, drawRange: { start: 0, count: attributes.index.count } };
+  return /* alloc */ { device, attributes, drawRange: /* alloc */ { start: 0, count: attributes.index.count } };
 }

package/src/raster/createRasterMesh.js

@@ -1,47 +1,76 @@
-import { cityMapper } from "../constants/cityMapper.js";
+import { radians } from '../globals/radians.js';
+import { rasterTexture } from '../globals/rasterTexture.js';
+import { rasterSampler } from '../globals/rasterSampler.js';
+import { sceneByLayer } from '../globals/sceneByLayer.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 "../rendering/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);
+export function createRasterMesh(backend, tile) {
+  const device = sceneByLayer.get(backend).renderer.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 (!sceneByLayer.get(backend)._rasterProgram) {
+    sceneByLayer.get(backend)._rasterProgram = createProgram(backend, /* alloc */ {
+      baseTexture: texture, unlit: true, alphaMode: 'BLEND', doubleSided: backend.options.doubleSided,
+    });
+  }
+  if (!sceneByLayer.get(backend)._rasterGeometry) sceneByLayer.get(backend)._rasterGeometry = createGeometry(device);
+  const { coords } = tile;
+  const crs = backend._map.options.crs;
+  const origin = crs.project(sceneByLayer.get(backend).location);
+  const metres = Math.cos(sceneByLayer.get(backend).location.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: sceneByLayer.get(backend)._rasterGeometry,
+    program: sceneByLayer.get(backend)._rasterProgram, texture,
+    opacity: backend.options.opacity, id: nextId.value++,
+    renderOrder: backend.options.zIndex || 0, tile, fadeDuration: 250, ground: true,
+    _rasterSource: backend,
+  };
+  setParent(tile.mesh, sceneByLayer.get(backend).root);
 }

package/src/raster/finishAttachment.js

@@ -1,11 +1,15 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
+
 import { setRasterTerrain } from "./setRasterTerrain.js";
 
 export async function finishAttachment(backend, map, attached) {
   try {
     await attached;
-    backend._added.resolve();
-    setRasterTerrain(backend, map._terrain3D);
+    sceneByLayer.get(backend)._added.resolve();
+    setRasterTerrain(backend, cameraByMap.get(map)._terrain3D);
   } catch (error) {
-    backend.fire('error', { error });
+    backend.fire('error', /* alloc */ { error });
   }
 }

package/src/raster/finishRasterTile.js

@@ -1,47 +1,61 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { blobParts } from '../globals/blobParts.js';
+
 import { update } from "../scene/update.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(backend, tile) {
+  try {
+    await sceneByLayer.get(backend).ready;
+    const result = await getZxy(backend.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(backend, tile);
+    tile.loadedAt = performance.now();
+    tile.done = true;
+    sceneByLayer.get(backend)._rasterVersion = (sceneByLayer.get(backend)._rasterVersion || 0) + 1;
+    registerTerrainTile(backend, tile.coords, tile);
+    backend.fire('tileload', /* alloc */ { tile, coords: tile.coords });
+    update(backend);
+  } catch (error) {
+    if (tile.request.signal.aborted) return;
+    tile.error = error.message;
+    sceneByLayer.get(backend)._rasterVersion = (sceneByLayer.get(backend)._rasterVersion || 0) + 1;
+    backend.fire('tileerror', /* alloc */ { tile, coords: tile.coords, error });
+    backend.fire('error', /* alloc */ { error, coords: tile.coords });
+  } finally {
+    sceneByLayer.get(backend)._loadingTiles--;
+    if (backend._map) {
+      pumpRasterTiles(backend);
+      pruneRasterTiles(backend);
+      if (!sceneByLayer.get(backend)._loadingTiles) backend.fire('load');
+      update(backend);
+    }
+  }
 }

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,3 +1,7 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { isLoading } from './isLoading.js';
 import { getRasterEvents } from './getRasterEvents.js';
 import { readyRaster } from './readyRaster.js';
@@ -13,26 +17,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 };
+  sceneByLayer.get(layer).kind = '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)
+  sceneByLayer.get(layer).root = emptyNode();
+  sceneByLayer.get(layer)._areas = /* alloc */ new Map();
+  sceneByLayer.get(layer)._rasterTiles = /* alloc */ new Map();
+  sceneByLayer.get(layer)._loadingTiles = 0;
+  sceneByLayer.get(layer)._added = Promise.withResolvers();
+  sceneByLayer.get(layer).url = /* alloc */ new URL(options.url, document.baseURI).href;
+  sceneByLayer.get(layer)._directories = /* alloc */ new Map();
+  sceneByLayer.get(layer).ready = Promise.resolve(layer.options.archive || layer)
     .then(readyRaster.bind(null, layer))
     .catch(reportError.bind(null, layer));
 }

package/src/raster/isLoading.js

@@ -1,5 +1,7 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
 
 
-export function isLoading(layer) {
-  return layer._loadingTiles > 0;
+
+export function isLoading(layer) {
+  return sceneByLayer.get(layer)._loadingTiles > 0;
 }

package/src/raster/loadRasterTile.js

@@ -1,10 +1,13 @@
+import { sceneByLayer } from '../globals/sceneByLayer.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(backend, tile) {
+  tile.started = true;
+  const first = sceneByLayer.get(backend)._loadingTiles === 0;
+  sceneByLayer.get(backend)._loadingTiles++;
+  backend.fire('tileloadstart', /* alloc */ { tile, coords: tile.coords });
+  if (first) backend.fire('loading');
+  return finishRasterTile(backend, tile);
 }

package/src/raster/onPMTileAdd.js

@@ -1,9 +1,12 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { finishAttachment } from './finishAttachment.js';
 import { updateAttachedTiles } from './updateAttachedTiles.js';
 import { attach } from '../scene/attach.js';
 
 export function onPMTileAdd(backend, map) {
-  if (!backend.location) backend.location = map.getCenter();
+  if (!sceneByLayer.get(backend).location) sceneByLayer.get(backend).location = map.getCenter();
   const attached = attach(backend, map);
   finishAttachment(backend, map, attached);
   updateAttachedTiles(backend, map, attached);

package/src/raster/onPMTileRemove.js

@@ -1,8 +1,11 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { releaseRasterTiles } from './releaseRasterTiles.js';
 import { onRemove3DLayer } from '../scene/onRemove3DLayer.js';
 
 export function onPMTileRemove(backend, map) {
   releaseRasterTiles(backend);
-  backend._terrain3D = null;
+  sceneByLayer.get(backend)._terrain3D = null;
   onRemove3DLayer(backend, map);
 }

package/src/raster/pruneRasterTiles.js

@@ -1,26 +1,29 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { releaseRasterTile } from './releaseRasterTile.js';
 
 export function pruneRasterTiles(backend) {
-  const wanted = backend._wantedRasterTiles;
+  const wanted = sceneByLayer.get(backend)._wantedRasterTiles;
   const now = performance.now();
-  if (backend._pruneVersion === backend._rasterVersion && backend._pruneWanted === wanted &&
-    now < backend._pruneAfter) return Number.isFinite(backend._pruneAfter);
-  backend._pruneVersion = backend._rasterVersion;
-  backend._pruneWanted = wanted;
-  backend._pruneAfter = Infinity;
-  const pending = [];
+  if (sceneByLayer.get(backend)._pruneVersion === sceneByLayer.get(backend)._rasterVersion && sceneByLayer.get(backend)._pruneWanted === wanted &&
+    now < sceneByLayer.get(backend)._pruneAfter) return Number.isFinite(sceneByLayer.get(backend)._pruneAfter);
+  sceneByLayer.get(backend)._pruneVersion = sceneByLayer.get(backend)._rasterVersion;
+  sceneByLayer.get(backend)._pruneWanted = wanted;
+  sceneByLayer.get(backend)._pruneAfter = Infinity;
+  const pending = /* alloc */ [];
   let key, tile, parts, overlaps, coords, zoom;
   for (key of wanted) {
-    tile = backend._rasterTiles.get(key);
+    tile = sceneByLayer.get(backend)._rasterTiles.get(key);
     if (tile?.done && now - tile.loadedAt < 250) {
-      backend._pruneAfter = Math.min(backend._pruneAfter, tile.loadedAt + 250);
+      sceneByLayer.get(backend)._pruneAfter = Math.min(sceneByLayer.get(backend)._pruneAfter, tile.loadedAt + 250);
     }
     if (!tile?.done || now - tile.loadedAt < 250) {
       parts = key.split('/');
-      pending.push({ z: Number(parts[0]), x: Number(parts[1]), y: Number(parts[2]) });
+      pending.push(/* alloc */ { z: Number(parts[0]), x: Number(parts[1]), y: Number(parts[2]) });
     }
   }
-  for ([key, tile] of backend._rasterTiles) {
+  for ([key, tile] of sceneByLayer.get(backend)._rasterTiles) {
     if (wanted.has(key)) continue;
     overlaps = false;
     for (coords of pending) {
@@ -33,5 +36,5 @@ export function pruneRasterTiles(backend) {
     }
     if (!overlaps) releaseRasterTile(backend, tile);
   }
-  return Number.isFinite(backend._pruneAfter);
+  return Number.isFinite(sceneByLayer.get(backend)._pruneAfter);
 }