leaflet-city-mapper 0.0.3 → 0.0.5

package/src/rendering/resizeRenderer.js

@@ -1,19 +1,26 @@
-import { destroyTexture } from './destroyTexture.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { sizeByLayer } from '../weakmaps/sizeByLayer.js';
 
-export function resizeRenderer(backend, size) {
-  if (!backend._size || !backend._size.equals(size)) {
-    backend.renderer.width = size.x;
-    backend.renderer.height = size.y;
-    backend.renderer.canvas.width = Math.round(size.x * backend.renderer.dpr);
-    backend.renderer.canvas.height = Math.round(size.y * backend.renderer.dpr);
-    backend.renderer.canvas.style.width = `${size.x}px`;
-    backend.renderer.canvas.style.height = `${size.y}px`;
-    if (backend.renderer.depthTexture) destroyTexture(backend, backend.renderer.depthTexture);
-    backend.renderer.depthTexture = backend.renderer.device.createTexture({
-      size: [backend.renderer.canvas.width, backend.renderer.canvas.height],
-      format: 'depth24plus',
-      usage: GPUTextureUsage.RENDER_ATTACHMENT,
-    });
-    backend._size = size;
+import { depthTexture as sharedDepthTexture } from '../globals/depthTexture.js';
+
+
+import { destroyTexture } from '../textures/destroyTexture.js';
+
+export function resizeRenderer(layer, size) {
+  if (!sizeByLayer.get(layer) || !sizeByLayer.get(layer).equals(size)) {
+    rendererByLayer.get(layer).width = size.x;
+    rendererByLayer.get(layer).height = size.y;
+    rendererByLayer.get(layer).canvas.width = Math.round(size.x * rendererByLayer.get(layer).dpr);
+    rendererByLayer.get(layer).canvas.height = Math.round(size.y * rendererByLayer.get(layer).dpr);
+    rendererByLayer.get(layer).canvas.style.width = `${size.x}px`;
+    rendererByLayer.get(layer).canvas.style.height = `${size.y}px`;
+    if (rendererByLayer.get(layer).depthTexture) destroyTexture(layer, rendererByLayer.get(layer).depthTexture);
+    rendererByLayer.get(layer).depthTexture = rendererByLayer.get(layer).device.createTexture((
+      sharedDepthTexture.size[0] = rendererByLayer.get(layer).canvas.width,
+      sharedDepthTexture.size[1] = rendererByLayer.get(layer).canvas.height,
+      sharedDepthTexture.usage = GPUTextureUsage.RENDER_ATTACHMENT,
+      sharedDepthTexture
+    ));
+    sizeByLayer.set(layer, size);
   }
 }

package/src/rendering/revealRoofMesh.js

@@ -0,0 +1,34 @@
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { loadingTilesByLayer } from '../weakmaps/loadingTilesByLayer.js';
+import { roofRasterByLayer } from '../weakmaps/roofRasterByLayer.js';
+import { walkByMap } from '../weakmaps/walkByMap.js';
+
+import { roofCoverage } from '../geometry/roofCoverage.js';
+
+export function revealRoofMesh(layer, mesh, rasters, now) {
+  let raster, loading;
+  if (mesh.program.uniforms.roofTexture && !rasters.length) mesh._roofRevealed = true;
+  if (mesh.program.uniforms.roofTexture && !mesh._roofRevealed && rasters.length) {
+    if (walkByMap.get(layer._map)?.control?._walk?.saved) {
+      mesh._roofRevealed = true;
+      mesh.fadeStart = now - (mesh.fadeDuration || 0);
+    }
+    if (mesh._roofCoverageSignature !== roofRasterByLayer.get(layer)?.signature) {
+      mesh._roofCoverageSignature = roofRasterByLayer.get(layer)?.signature;
+      mesh._roofCovered = roofCoverage(mesh, layer, rasters);
+    }
+    loading = false;
+    for (raster of rasters) {
+      if (!headerByLayer.get(raster) || loadingTilesByLayer.get(raster) > 0) {
+        loading = true;
+        break;
+      }
+    }
+    if (!mesh._roofRevealed && !mesh._roofCovered && loading) {
+      mesh._appearance = 0;
+      return false;
+    }
+    mesh._roofRevealed = true;
+  }
+  return true;
+}

package/src/scene/addRegisteredLayer.js

@@ -0,0 +1,47 @@
+import { eventMapByLayer } from '../weakmaps/eventMapByLayer.js';
+import { eventsByLayer } from '../weakmaps/eventsByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { state3dByLayer } from '../weakmaps/state3dByLayer.js';
+
+import { L } from '../globals/L.js';
+import { layerProto } from '../globals/layerProto.js';
+
+
+
+import { initNativeGPU } from '../native/initNativeGPU.js';
+import { removeLayerEvents } from './removeLayerEvents.js';
+import { addSceneLayer } from './addSceneLayer.js';
+import { get3DEvents } from './get3DEvents.js';
+import { getRasterEvents } from '../raster/getRasterEvents.js';
+import { emptyEvents } from './emptyEvents.js';
+import { isNativeLayer } from './isNativeLayer.js';
+
+export function layerLayerAdd(event) {
+  const native = isNativeLayer(this);
+  if (native) {
+    if (this instanceof L.GridLayer || this instanceof L.ImageOverlay) {
+      this.options.crossOrigin ||= true;
+    }
+    if (this instanceof L.Marker) this.options.icon.options.crossOrigin ||= true;
+  }
+  const map = event.target
+  if (!map.hasLayer(this)) return;
+  if (kindByLayer.get(this)) {
+    this._map = map;
+    this._zoomAnimated = map._zoomAnimated;
+    if (kindByLayer.get(this) !== 'pending' && kindByLayer.get(this) !== 'time') {
+      eventsByLayer.set(this, kindByLayer.get(this) === 'raster' ? getRasterEvents(this) :
+        state3dByLayer.get(this) ? get3DEvents(this) : emptyEvents());
+      eventMapByLayer.set(this, map);
+      map.on(eventsByLayer.get(this), this);
+      this.once('remove', removeLayerEvents, this);
+    }
+    addSceneLayer(this, map);
+    this.fire('add');
+    map.fire('layeradd', /* alloc */ { layer: this });
+  } else {
+    layerProto.value._layerAdd.call(this, event);
+  }
+  if (!native || !event.target.hasLayer(this)) return;
+  initNativeGPU(this, event.target);
+}

package/src/scene/addSceneLayer.js

@@ -0,0 +1,18 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
+
+import { onAdd3DLayer } from './onAdd3DLayer.js';
+import { onPMTileAdd } from '../raster/onPMTileAdd.js';
+import { onTerrainAdd } from '../terrain/onTerrainAdd.js';
+import { addRasterImage } from '../textures/attachRasterImage.js';
+import { addTimeLayer } from '../sunlight/addTimeLayer.js';
+
+export function addSceneLayer(layer, map) {
+  switch (kindByLayer.get(layer)) {
+    case '3d': return onAdd3DLayer(layer, map);
+    case 'raster': return onPMTileAdd(layer, map);
+    case 'terrain': return onTerrainAdd(layer, map);
+    case 'image': return addRasterImage.call(layer, map);
+    case 'time': return addTimeLayer.call(layer, map);
+  }
+}

package/src/scene/attachLayer.js

@@ -1,10 +1,14 @@
-import * as attach from './attach.js';
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
 
-export async function attachLayer(backend, map) {
+
+
+import * as attach from './attachSharedScene.js';
+
+export async function attachLayer(layer, map) {
   try {
-    await attach.attach(backend, map);
-    backend._added.resolve();
+    await attach.attach(layer, map);
+    addedByLayer.get(layer).resolve();
   } catch (error) {
-    backend.fire('error', { error });
+    layer.fire('error', /* alloc */ { error });
   }
 }

package/src/scene/attachSharedScene.js

@@ -0,0 +1,69 @@
+import { cameraByLayer } from '../weakmaps/cameraByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { layersByLayer } from '../weakmaps/layersByLayer.js';
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { rendererReadyByLayer } from '../weakmaps/rendererReadyByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { sceneByLayer } from '../weakmaps/sceneByLayer.js';
+import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
+import { sharedByLayer } from '../weakmaps/sharedByLayer.js';
+import { terrainBaseYByLayer } from '../weakmaps/terrainBaseYByLayer.js';
+
+import { radians } from '../globals/radians.js';
+import { renderers } from '../weakmaps/renderers.js';
+import { setParent } from './setParent.js';
+import { render } from '../rendering/render.js';
+import { update } from './scheduleSceneUpdate.js';
+import { updateArea } from '../sources/updateArea.js';
+import { setTerrainHeight } from '../terrain/setTerrainHeight.js';
+import { noOperation } from '../utils/noOperation.js';
+import { restoreObject } from './restoreObject.js';
+import { traverse } from './traverse.js';
+import { initializeSharedRenderer } from '../gpu/initializeSharedRenderer.js';
+
+/**
+ * Join/create this map's shared scene and rebuild GPU objects if its context changed.
+ * Buffer/program handles belong to one context; typed arrays and decoded images do not.
+ * @private
+ */
+export async function attach(layer, map) {
+  let shared = renderers.get(map);
+
+  if (rendererReadyByLayer.get(shared)) {
+    await rendererReadyByLayer.get(shared).promise;
+  }
+  if (!shared) {
+    shared = layer;
+    rendererReadyByLayer.set(layer, Promise.withResolvers());
+    rendererReadyByLayer.get(layer).promise.catch(noOperation);
+    renderers.set(map, shared);
+    await initializeSharedRenderer(layer, map);
+    rendererReadyByLayer.get(layer).resolve();
+    rendererReadyByLayer.delete(shared);
+    render(shared);
+    renderers.set(map, shared);
+  }
+
+  const origin = map.options.crs.project(sceneOriginByLayer.get(shared));
+  const point = map.options.crs.project(locationByLayer.get(layer));
+  const metres = Math.cos(sceneOriginByLayer.get(shared).lat * radians);
+  if (terrainBaseYByLayer.get(layer) == null) terrainBaseYByLayer.set(layer, rootByLayer.get(layer).position[1]);
+  rootByLayer.get(layer).position[0] = (point.x - origin.x) * metres;
+  rootByLayer.get(layer).position[1] = terrainBaseYByLayer.get(layer);
+  rootByLayer.get(layer).position[2] = -(point.y - origin.y) * metres;
+  setTerrainHeight(layer);
+  // Each group's metres are measured at its own latitude, not the shared camera origin.
+  rootByLayer.get(layer).scale.fill(metres / Math.cos(locationByLayer.get(layer).lat * radians));
+  sharedByLayer.set(layer, shared);
+  rendererByLayer.set(layer, rendererByLayer.get(shared));
+  sceneByLayer.set(layer, sceneByLayer.get(shared));
+  cameraByLayer.set(layer, cameraByLayer.get(shared));
+  layersByLayer.get(shared).add(layer);
+  setParent(rootByLayer.get(layer), sceneByLayer.get(shared));
+  traverse(rootByLayer.get(layer), restoreObject, layer);
+  update(shared);
+  if ((headerByLayer.get(layer) && kindByLayer.get(layer) !== 'raster') || geojsonByLayer.get(layer)) updateArea(layer);
+}

package/src/scene/callLayer.js

@@ -0,0 +1,28 @@
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+
+
+import { setGeoJSONData } from '../sources/setGeoJSONData.js';
+import { getHeader } from '../archives/getHeader.js';
+import { getZxy } from '../archives/getZxy.js';
+import { getRasterTileSize } from '../raster/getRasterTileSize.js';
+import { isLoading } from '../raster/isRasterLoading.js';
+import { setPMTileOpacity } from '../raster/setPMTileOpacity.js';
+import { setPMTileZIndex } from '../raster/setPMTileZIndex.js';
+
+
+export function callLayer(method, layer, ...args) {
+
+  if (method === 'setData' && geojsonByLayer.get(layer)) return setGeoJSONData(layer, ...args);
+  if (kindByLayer.get(layer) === 'raster') {
+    switch (method) {
+      case 'getHeader': return getHeader(layer);
+      case 'getZxy': return getZxy(layer, ...args);
+      case 'getTileSize': return getRasterTileSize();
+      case 'isLoading': return isLoading(layer);
+      case 'setOpacity': return setPMTileOpacity(layer, ...args);
+      case 'setZIndex': return setPMTileZIndex(layer, ...args);
+    }
+  }
+  return layer[method](...args);
+}

package/src/scene/cancelUpdate.js

@@ -1,9 +1,13 @@
-import { pendingUpdates } from '../constants/pendingUpdates.js';
+import { frameByLayer } from '../weakmaps/frameByLayer.js';
 
-export function cancelUpdate(backend) {
-  const frame = backend._frame;
-  pendingUpdates.delete(backend);
-  backend._frame = null;
+import { pendingUpdates } from '../globals/pendingUpdates.js';
+
+
+
+export function cancelUpdate(layer) {
+  const frame = frameByLayer.get(layer);
+  pendingUpdates.delete(layer);
+  frameByLayer.set(layer, null);
   if (!pendingUpdates.size && frame != null) {
     cancelAnimationFrame(frame);
   }

package/src/scene/createLayer.js

@@ -0,0 +1,7 @@
+import { L } from '../globals/L.js';
+import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
+
+
+export function createLayer(options = sceneEmptyOptions) {
+  return /* alloc */ new L.Layer(options);
+}

package/src/scene/createSceneNode.js

@@ -0,0 +1,12 @@
+/** A fresh, empty scene-graph node. */
+export function emptyNode() {
+  return /* alloc */ {
+    position: /* alloc */ [0, 0, 0],
+    rotation: /* alloc */ [0, 0, 0],
+    scale: /* alloc */ [1, 1, 1],
+    worldMatrix: /* alloc */ [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    children: /* alloc */ [],
+    highlightRange: /* alloc */ [0, 0],
+    visible: true,
+  };
+}

package/src/scene/emptyEvents.js

@@ -1,3 +1,3 @@
 export function emptyEvents() {
-  return {};
+  return /* alloc */ {};
 }

package/src/scene/failAttachment.js

@@ -1,9 +1,13 @@
-import { showWebGPUWarning } from './showWebGPUWarning.js';
-import { cityMapper } from '../constants/cityMapper.js';
+import { rendererReadyByLayer } from '../weakmaps/rendererReadyByLayer.js';
 
-export function failAttachment(error, backend, map) {
+import { renderers } from '../weakmaps/renderers.js';
+
+
+import { showWebGPUWarning } from '../gpu/showWebGPUWarning.js';
+
+export function failAttachment(error, layer, map) {
   showWebGPUWarning(map);
-  backend._rendererReady.reject(error);
-  cityMapper.renderers.delete(map);
+  rendererReadyByLayer.get(layer).reject(error);
+  renderers.delete(map);
   throw error;
 }

package/src/scene/get3DEvents.js

@@ -1,13 +1,18 @@
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { urlByLayer } from '../weakmaps/urlByLayer.js';
+
+
+
 import { updateArea } from '../sources/updateArea.js';
 import { onTerrainChange } from '../terrain/onTerrainChange.js';
 
-export function get3DEvents(layer) {
-  const events = {};
-  if (layer.url) {
-    events.moveend = events.zoomend = events.rotate = events.pitch = events.resize = updateArea.bind(null, layer);
-  }
-  if (layer._geojson || layer.url) {
-    events.terrainchange = onTerrainChange.bind(null, layer);
-  }
-  return events;
+export function get3DEvents(layer) {
+  const events = /* alloc */ {};
+  if (urlByLayer.get(layer)) {
+    events.moveend = events.zoomend = events.rotate = events.pitch = events.resize = updateArea.bind(null, layer);
+  }
+  if (geojsonByLayer.get(layer) || urlByLayer.get(layer)) {
+    events.terrainchange = onTerrainChange.bind(null, layer);
+  }
+  return events;
 }

package/src/scene/getLocation.js

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

package/src/scene/init3D.js

@@ -1,30 +1,45 @@
-import { attach } from './attach.js';
-import { emptyNode } from './emptyNode.js';
-import { onAdd3DLayer } from './onAdd3DLayer.js';
-import { onRemove3DLayer } from './onRemove3DLayer.js';
-import { update } from './update.js';
-import { updateArea } from '../sources/updateArea.js';
-import { onTerrainChange } from '../terrain/onTerrainChange.js';
-import { getHeader } from '../archives/getHeader.js';
-import { loadModel } from '../models/loadModel.js';
-import { get3DEvents } from './get3DEvents.js';
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { areasByLayer } from '../weakmaps/areasByLayer.js';
+import { countStatusByLayer } from '../weakmaps/countStatusByLayer.js';
+import { directoriesByLayer } from '../weakmaps/directoriesByLayer.js';
+import { geojsonByLayer } from '../weakmaps/geojsonByLayer.js';
+import { inflightByLayer } from '../weakmaps/inflightByLayer.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+import { modelUrlByLayer } from '../weakmaps/modelUrlByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+import { state3dByLayer } from '../weakmaps/state3dByLayer.js';
+import { urlByLayer } from '../weakmaps/urlByLayer.js';
+
+import { L } from '../globals/L.js';
+import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
+
+
 import { ready3D } from './ready3D.js';
+import { noOperation } from '../utils/noOperation.js';
+import { updateLayerCount } from '../layer-controls/updateLayerCount.js';
 
-export function init3D(layer, options = {}) {
-  layer._3d = true;
-  L.Util.setOptions(layer, { ariaLabel: '3D scene', ...options });
-  layer.onAdd = onAdd3DLayer.bind(null, layer);
-  layer.onRemove = onRemove3DLayer.bind(null, layer);
-  layer.getEvents = get3DEvents.bind(null, layer);
-  const isModel = !layer._geojson && /\.(glb|gltf)(?:[?#]|$)/i.test(layer.options.url);
-  layer.modelUrl = isModel ? layer.options.url : null;
-  layer.url = layer.options.url && !isModel && !layer._geojson ? new URL(layer.options.url, document.baseURI).href : null;
-  layer._directories = new Map();
+export function init3D(layer, options = sceneEmptyOptions) {
+  state3dByLayer.set(layer, true);
+  L.Util.setOptions(layer, /* alloc */ { ariaLabel: '3D scene', ...options });
+  kindByLayer.set(layer, '3d');
+  const isModel = !geojsonByLayer.get(layer) && /\.(glb|gltf)(?:[?#]|$)/i.test(layer.options.url);
+  modelUrlByLayer.set(layer, isModel ? layer.options.url : null);
+  urlByLayer.set(layer, layer.options.url && !isModel && !geojsonByLayer.get(layer) ? /* alloc */ new URL(layer.options.url, document.baseURI).href : null);
+  directoriesByLayer.set(layer, /* alloc */ new Map());
   if (layer.options.center) {
-    layer.location = new L.LatLng(layer.options.center[0], layer.options.center[1]);
+    locationByLayer.set(layer, /* alloc */ new L.LatLng(layer.options.center[0], layer.options.center[1]));
+  }
+  areasByLayer.set(layer, /* alloc */ new Map());
+  inflightByLayer.set(layer, 0);
+  if (urlByLayer.get(layer) || geojsonByLayer.get(layer) || isModel) {
+    const status = L.DomUtil.create('small', 'layer-count');
+    status.style.cssText = 'float:right;margin-left:12px;color:#555;font-variant-numeric:tabular-nums';
+    countStatusByLayer.set(layer, status);
+    layer.on('add error', updateLayerCount);
+    layer.on('ready progress', L.Util.throttle(updateLayerCount, 250, layer));
   }
-  layer._areas = new Map();
-  layer._inflight = 0;
-  layer._added = Promise.withResolvers();
-  queueMicrotask(ready3D.bind(null, layer));
+  addedByLayer.set(layer, Promise.withResolvers());
+  readyByLayer.set(layer, Promise.resolve().then(ready3D.bind(null, layer)));
+  readyByLayer.get(layer).catch(noOperation);
 }

package/src/scene/initializeLayer.js

@@ -1,16 +1,24 @@
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+
+import { reportError } from './reportLayerError.js';
+
+
 export function initializeLayer(task) {
   const { layer, ready } = task;
+  if (task.error) {
+    reportError(layer, task.error);
+    return Promise.reject(task.error);
+  }
   try {
-    if (task.error) throw task.error;
     const map = layer._map;
     map?.removeLayer(layer);
-    delete layer.onAdd;
-    delete layer.onRemove;
+    kindByLayer.delete(layer);
     task.initialize(layer, task.settings);
     map?.addLayer(layer);
-    return layer.ready === ready ? layer : layer.ready;
+    return readyByLayer.get(layer) === ready ? layer : readyByLayer.get(layer);
   } catch (error) {
-    layer.fire('error', { error });
+    layer.fire('error', /* alloc */ { error });
     throw error;
   }
 }

package/src/scene/initializerFor.js

@@ -2,13 +2,15 @@ import { initializeGeoJSON } from '../sources/initializeGeoJSON.js';
 import { initRaster } from '../raster/initRaster.js';
 import { initTerrain } from '../terrain/initTerrain.js';
 import { initTraffic } from '../traffic/initTraffic.js';
+import { initCog } from '../cog/initCog.js';
 
 export function initializerFor(type) {
   switch (type) {
     case 'geojson': return initializeGeoJSON;
     case 'pmtiles': return initRaster;
+    case 'cog': return initCog;
     case 'terrain': return initTerrain;
     case 'traffic': return initTraffic;
-    default: throw new Error(`Unknown layer type: ${type}`);
+    default: return null;
   }
 }

package/src/scene/isNativeLayer.js

@@ -0,0 +1,13 @@
+import { state3dByLayer } from '../weakmaps/state3dByLayer.js';
+
+import { L } from '../globals/L.js';
+
+export function isNativeLayer(layer) {
+  return !state3dByLayer.get(layer) && (
+    layer instanceof L.GridLayer ||
+    layer instanceof L.Polyline ||
+    layer instanceof L.CircleMarker ||
+    layer instanceof L.Marker && !(layer.options.icon instanceof L.DivIcon) ||
+    layer instanceof L.ImageOverlay && !(layer instanceof L.VideoOverlay) && !(layer instanceof L.SVGOverlay)
+  );
+}

package/src/scene/layerInitialize.js

@@ -1,12 +1,27 @@
-import { indexState } from '../constants/indexState.js';
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { readyByLayer } from '../weakmaps/readyByLayer.js';
+import { sceneLayers } from '../weakmaps/sceneLayers.js';
+import { typeByLayer } from '../weakmaps/typeByLayer.js';
+
+import { L } from '../globals/L.js';
+import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
+import { layerProto } from '../globals/layerProto.js';
+import { pendingInitializations } from '../globals/pendingInitializations.js';
+import { loading } from '../globals/loading.js';
+
+
+
 import { init3D } from './init3D.js';
 import { noOperation } from '../utils/noOperation.js';
 import { resolveNextInitialization } from './resolveNextInitialization.js';
 import { initializeLayer } from './initializeLayer.js';
 
-export function layerInitialize(options = {}) {
-  if (Object.getPrototypeOf(this) !== L.Layer.prototype || !options.source) {
-    if (indexState.layerProto.initialize) return indexState.layerProto.initialize.apply(this, arguments);
+export function layerInitialize(options = sceneEmptyOptions) {
+  if (!sceneLayers.has(this)) {
+    sceneLayers.add(this);
+  }
+  if (Object.getPrototypeOf(this) !== L.Layer.prototype || !options?.source) {
+    if (layerProto.value.initialize) return layerProto.value.initialize.apply(this, arguments);
     L.Util.setOptions(this, options);
     return;
   }
@@ -14,25 +29,25 @@ export function layerInitialize(options = {}) {
     source: {
       type = options.source.data?.type === 'FeatureCollection'
         ? 'geojson'
-        : /\.pmtiles(?:[?#]|$)/i.test(options.source.url) ? 'pmtiles' : '3d',
+        : /\.pmtiles(?:[?#]|$)/i.test(options.source.url) ? 'pmtiles'
+        : /\.tiff?(?:[?#]|$)/i.test(options.source.url) ? 'cog' : '3d',
       ...source
     },
     ...core
   } = options;
-  const settings = { ...source, ...core };
+  const settings = /* alloc */ { ...source, ...core };
   L.Util.setOptions(this, core);
-  this._type = type;
+  typeByLayer.set(this, type);
   if (type === '3d') {
     init3D(this, settings);
     return;
   }
-  this.onAdd = noOperation;
-  this.onRemove = noOperation;
-  // ponytail: type methods (setOpacity, add, ...) exist only once `ready` resolves.
-  const task = { layer: this, type, settings, ready: null };
-  indexState.pendingInitializations.push(task);
-  indexState.loading = indexState.loading.catch(noOperation).then(resolveNextInitialization);
-  const ready = this.ready = indexState.loading.then(initializeLayer);
+  kindByLayer.set(this, 'pending');
+  const task = /* alloc */ { layer: this, type, settings, ready: null };
+  pendingInitializations.push(task);
+  loading.value = loading.value.catch(noOperation).then(resolveNextInitialization);
+  const ready = loading.value.then(initializeLayer);
+  readyByLayer.set(this, ready);
   task.ready = ready;
   ready.catch(noOperation);
 }