leaflet-city-mapper 0.1.0 → 0.1.1

package/src/rendering/drawPipeline.js

@@ -1,44 +1,44 @@
-import { meshPipeline } from '../globals/meshPipeline.js';
-import { alphaBlend } from '../globals/alphaBlend.js';
-
-/**
- * Get or create a cached render pipeline for a mesh and its face/depth settings.
- *
- * @param {Object} renderer Renderer providing the device and color format.
- * @param {Object} mesh Mesh providing the program and ground flag.
- * @param {GPUCullMode} cullMode Face-culling mode.
- * @param {GPUFrontFace} frontFace Front-face winding.
- *
- * @returns {GPURenderPipeline} Cached or newly created pipeline.
- */
-export function drawPipeline(renderer, mesh, cullMode, frontFace) {
-  const { program } = mesh;
-  // Mixed-LOD imagery composites coarse-to-fine; its depth still occludes later 3D objects.
-  // ponytail: self-occlusion during LOD blending needs separate per-LOD depth passes.
-  const depthCompare = program.depthTest === false || (mesh.ground && renderer.groundOverlap)
-    ? 'always' : 'less-equal';
-  const pipelineKey = `${cullMode}:${frontFace}:${depthCompare}`;
-  let pipeline = program.pipelineCache.get(pipelineKey);
-  if (!pipeline) {
-    pipeline = renderer.device.createRenderPipeline((
-      meshPipeline.layout = program.pipelineLayout,
-      meshPipeline.vertex.module = program.vertex,
-      meshPipeline.vertex.buffers = program.vertexBuffers,
-      meshPipeline.fragment.module = program.fragment,
-      meshPipeline.fragment.targets[0].format = renderer.format,
-      meshPipeline.fragment.targets[0].blend = program.transparent ? alphaBlend : undefined,
-      meshPipeline.fragment.targets[0].writeMask = GPUColorWrite.ALL,
-      meshPipeline.primitive.cullMode = cullMode,
-      meshPipeline.primitive.frontFace = frontFace,
-      meshPipeline.depthStencil.depthWriteEnabled = program.depthWrite,
-      meshPipeline.depthStencil.depthCompare = depthCompare,
-      meshPipeline
-    ));
-    meshPipeline.layout = null;
-    meshPipeline.vertex.module = null;
-    meshPipeline.vertex.buffers = null;
-    meshPipeline.fragment.module = null;
-    program.pipelineCache.set(pipelineKey, pipeline);
-  }
-  return pipeline;
-}
+import { meshPipeline } from '../globals/meshPipeline.js';
+import { alphaBlend } from '../globals/alphaBlend.js';
+
+/**
+ * Get or create a cached render pipeline for a mesh and its face/depth settings.
+ *
+ * @param {Object} renderer Renderer providing the device and color format.
+ * @param {Object} mesh Mesh providing the program and ground flag.
+ * @param {GPUCullMode} cullMode Face-culling mode.
+ * @param {GPUFrontFace} frontFace Front-face winding.
+ *
+ * @returns {GPURenderPipeline} Cached or newly created pipeline.
+ */
+export function drawPipeline(renderer, mesh, cullMode, frontFace) {
+  const { program } = mesh;
+  // Mixed-LOD imagery composites coarse-to-fine; its depth still occludes later 3D objects.
+  // ponytail: self-occlusion during LOD blending needs separate per-LOD depth passes.
+  const depthCompare = program.depthTest === false || (mesh.ground && renderer.groundOverlap)
+    ? 'always' : 'less-equal';
+  const pipelineKey = `${cullMode}:${frontFace}:${depthCompare}`;
+  let pipeline = program.pipelineCache.get(pipelineKey);
+  if (!pipeline) {
+    pipeline = renderer.device.createRenderPipeline((
+      meshPipeline.layout = program.pipelineLayout,
+      meshPipeline.vertex.module = program.vertex,
+      meshPipeline.vertex.buffers = program.vertexBuffers,
+      meshPipeline.fragment.module = program.fragment,
+      meshPipeline.fragment.targets[0].format = renderer.format,
+      meshPipeline.fragment.targets[0].blend = program.transparent ? alphaBlend : undefined,
+      meshPipeline.fragment.targets[0].writeMask = GPUColorWrite.ALL,
+      meshPipeline.primitive.cullMode = cullMode,
+      meshPipeline.primitive.frontFace = frontFace,
+      meshPipeline.depthStencil.depthWriteEnabled = program.depthWrite,
+      meshPipeline.depthStencil.depthCompare = depthCompare,
+      meshPipeline
+    ));
+    meshPipeline.layout = null;
+    meshPipeline.vertex.module = null;
+    meshPipeline.vertex.buffers = null;
+    meshPipeline.fragment.module = null;
+    program.pipelineCache.set(pipelineKey, pipeline);
+  }
+  return pipeline;
+}

package/src/rendering/nativeStrokeExpansion.js

@@ -1,11 +1,11 @@
-/**
- * Calculate the extra local-space culling radius needed for a scaled native stroke.
- *
- * @param {Object} mesh Mesh containing stroke uniforms and geometry.
- *
- * @returns {number} Additional bounding radius.
- */
-export function nativeStrokeExpansion(mesh) {
-  const strokeScale = mesh.program?.uniforms?.strokeScale?.value ?? 1;
-  return Math.max(0, strokeScale - 1) * (mesh.geometry.nativeStrokeRadius || 0);
-}
+/**
+ * Calculate the extra local-space culling radius needed for a scaled native stroke.
+ *
+ * @param {Object} mesh Mesh containing stroke uniforms and geometry.
+ *
+ * @returns {number} Additional bounding radius.
+ */
+export function nativeStrokeExpansion(mesh) {
+  const strokeScale = mesh.program?.uniforms?.strokeScale?.value ?? 1;
+  return Math.max(0, strokeScale - 1) * (mesh.geometry.nativeStrokeRadius || 0);
+}

package/src/rendering/prepareFrameBuffer.js

@@ -1,24 +1,24 @@
-import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-import { frameBuffer } from '../globals/frameBuffer.js';
-import { destroyTexture } from '../textures/destroyTexture.js';
-
-/**
- * Ensure the renderer has uniform-buffer capacity for this frame's meshes and shadows.
- *
- * @param {L.Layer} layer Rendering layer.
- * @param {Array<Object>} meshes Meshes to render.
- * @param {Array<Object>} shadowMeshes Shadow-casting meshes.
- */
-export function prepareFrameBuffer(layer, meshes, shadowMeshes) {
-  const renderer = rendererByLayer.get(layer);
-  // Slot 0 holds the camera; 256-byte mesh slots follow (double-sided meshes use two).
-  if (!renderer.uniformBuffer || renderer.uniformBuffer.size < (meshes.length * 2 + shadowMeshes.length + 1) * 256) {
-    if (renderer.uniformBuffer) destroyTexture(layer, renderer.uniformBuffer);
-    renderer.uniformBuffer = renderer.device.createBuffer((
-      frameBuffer.size = Math.max(64, meshes.length * 4 + shadowMeshes.length * 2) * 256,
-      frameBuffer.usage = GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-      frameBuffer
-    ));
-    renderer.uniformData = /* alloc */ new Float32Array(renderer.uniformBuffer.size / 4);
-  }
-}
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { frameBuffer } from '../globals/frameBuffer.js';
+import { destroyTexture } from '../textures/destroyTexture.js';
+
+/**
+ * Ensure the renderer has uniform-buffer capacity for this frame's meshes and shadows.
+ *
+ * @param {L.Layer} layer Rendering layer.
+ * @param {Array<Object>} meshes Meshes to render.
+ * @param {Array<Object>} shadowMeshes Shadow-casting meshes.
+ */
+export function prepareFrameBuffer(layer, meshes, shadowMeshes) {
+  const renderer = rendererByLayer.get(layer);
+  // Slot 0 holds the camera; 256-byte mesh slots follow (double-sided meshes use two).
+  if (!renderer.uniformBuffer || renderer.uniformBuffer.size < (meshes.length * 2 + shadowMeshes.length + 1) * 256) {
+    if (renderer.uniformBuffer) destroyTexture(layer, renderer.uniformBuffer);
+    renderer.uniformBuffer = renderer.device.createBuffer((
+      frameBuffer.size = Math.max(64, meshes.length * 4 + shadowMeshes.length * 2) * 256,
+      frameBuffer.usage = GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+      frameBuffer
+    ));
+    renderer.uniformData = /* alloc */ new Float32Array(renderer.uniformBuffer.size / 4);
+  }
+}

package/src/rendering/prepareMeshUniforms.js

@@ -1,36 +1,36 @@
-import { prepareMeshCutout } from '../materials/prepareMeshCutout.js';
-
-/**
- * Write a mesh's transforms and material values into the next frame uniform slot.
- *
- * @param {Object} renderer Renderer containing uniform data and slot state.
- * @param {Object} mesh Mesh to prepare.
- *
- * @returns {number} Dynamic uniform buffer offset in bytes.
- */
-export function prepareMeshUniforms(renderer, mesh) {
-  const uniforms = mesh.program.uniforms;
-  const offset = renderer.uniformSlot++ * 256;
-  const data = renderer.uniformData, base = offset / 4;
-  data.set(mesh.worldMatrix, base);
-  data.set(uniforms.baseColor.value, base + 16);
-  data[base + 19] = 1;
-  data[base + 20] = uniforms.metallic.value;
-  data[base + 21] = uniforms.roughness.value;
-  data[base + 22] = uniforms.opacity.value * (mesh.ground ? mesh._appearance ?? 1 : 1);
-  data[base + 23] = uniforms.alphaCutoff.value;
-  data.set(uniforms.emissive.value, base + 24);
-  data[base + 27] = uniforms.occlusionStrength.value;
-  data[base + 28] = mesh.terrain?.[0] ?? 0;
-  data[base + 29] = mesh.terrain?.[1] ?? 0;
-  data[base + 30] = mesh.terrain?.[2] ?? 0;
-  data[base + 31] = mesh.terrain?.[3] ?? 0;
-  data[base + 32] = mesh.highlight?.[0] ?? 0;
-  data[base + 33] = mesh.highlight?.[1] ?? 0;
-  data[base + 34] = mesh.program.nightSparkle ? data[55] : 0;
-  data[base + 35] = mesh.ground ? 1 : mesh._appearance ?? 1;
-  prepareMeshCutout(renderer, mesh, base);
-  data[base + 40] = uniforms.strokeScale?.value ?? 1;
-  data[base + 41] = data[base + 42] = data[base + 43] = 0;
-  return offset;
-}
+import { prepareMeshCutout } from '../materials/prepareMeshCutout.js';
+
+/**
+ * Write a mesh's transforms and material values into the next frame uniform slot.
+ *
+ * @param {Object} renderer Renderer containing uniform data and slot state.
+ * @param {Object} mesh Mesh to prepare.
+ *
+ * @returns {number} Dynamic uniform buffer offset in bytes.
+ */
+export function prepareMeshUniforms(renderer, mesh) {
+  const uniforms = mesh.program.uniforms;
+  const offset = renderer.uniformSlot++ * 256;
+  const data = renderer.uniformData, base = offset / 4;
+  data.set(mesh.worldMatrix, base);
+  data.set(uniforms.baseColor.value, base + 16);
+  data[base + 19] = 1;
+  data[base + 20] = uniforms.metallic.value;
+  data[base + 21] = uniforms.roughness.value;
+  data[base + 22] = uniforms.opacity.value * (mesh.ground ? mesh._appearance ?? 1 : 1);
+  data[base + 23] = uniforms.alphaCutoff.value;
+  data.set(uniforms.emissive.value, base + 24);
+  data[base + 27] = uniforms.occlusionStrength.value;
+  data[base + 28] = mesh.terrain?.[0] ?? 0;
+  data[base + 29] = mesh.terrain?.[1] ?? 0;
+  data[base + 30] = mesh.terrain?.[2] ?? 0;
+  data[base + 31] = mesh.terrain?.[3] ?? 0;
+  data[base + 32] = mesh.highlight?.[0] ?? 0;
+  data[base + 33] = mesh.highlight?.[1] ?? 0;
+  data[base + 34] = mesh.program.nightSparkle ? data[55] : 0;
+  data[base + 35] = mesh.ground ? 1 : mesh._appearance ?? 1;
+  prepareMeshCutout(renderer, mesh, base);
+  data[base + 40] = uniforms.strokeScale?.value ?? 1;
+  data[base + 41] = data[base + 42] = data[base + 43] = 0;
+  return offset;
+}

package/src/rendering/revealRoofMesh.js

@@ -1,43 +1,43 @@
-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';
-
-/**
- * Delay revealing a roof mesh while its uncovered raster imagery is still loading.
- *
- * @param {L.Layer} layer Rendering layer.
- * @param {Object} mesh Roof or other mesh being considered.
- * @param {Array<L.Layer>} rasters Raster layers used for roof coverage.
- * @param {number} now Current frame time in milliseconds.
- *
- * @returns {boolean} Whether the mesh may be drawn.
- */
-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;
-}
+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';
+
+/**
+ * Delay revealing a roof mesh while its uncovered raster imagery is still loading.
+ *
+ * @param {L.Layer} layer Rendering layer.
+ * @param {Object} mesh Roof or other mesh being considered.
+ * @param {Array<L.Layer>} rasters Raster layers used for roof coverage.
+ * @param {number} now Current frame time in milliseconds.
+ *
+ * @returns {boolean} Whether the mesh may be drawn.
+ */
+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/addSceneLayer.js

@@ -1,24 +1,24 @@
-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';
-
-/**
- * Dispatch layer attachment according to its registered scene kind.
- *
- * @param {L.Layer} layer Layer being added.
- * @param {L.Map} map Map receiving the layer.
- *
- * @returns {*} Result of the selected add handler, if any.
- */
-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);
-  }
-}
+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';
+
+/**
+ * Dispatch layer attachment according to its registered scene kind.
+ *
+ * @param {L.Layer} layer Layer being added.
+ * @param {L.Map} map Map receiving the layer.
+ *
+ * @returns {*} Result of the selected add handler, if any.
+ */
+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/callLayer.js

@@ -1,34 +1,34 @@
-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';
-
-/**
- * Dispatch supported source methods or invoke the layer's own method.
- *
- * @param {string} method Method name.
- * @param {L.Layer} layer Target layer.
- * @param {...*} args Arguments forwarded to the method.
- *
- * @returns {*} Result of the selected method.
- */
-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);
-}
+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';
+
+/**
+ * Dispatch supported source methods or invoke the layer's own method.
+ *
+ * @param {string} method Method name.
+ * @param {L.Layer} layer Target layer.
+ * @param {...*} args Arguments forwarded to the method.
+ *
+ * @returns {*} Result of the selected method.
+ */
+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/createLayer.js

@@ -1,13 +1,13 @@
-import { L } from '../globals/L.js';
-import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
-
-/**
- * Create a Leaflet layer with the given options.
- *
- * @param {Object} [options] Layer options.
- *
- * @returns {L.Layer} New layer.
- */
-export function createLayer(options = sceneEmptyOptions) {
-  return /* alloc */ new L.Layer(options);
-}
+import { L } from '../globals/L.js';
+import { sceneEmptyOptions } from '../globals/sceneEmptyOptions.js';
+
+/**
+ * Create a Leaflet layer with the given options.
+ *
+ * @param {Object} [options] Layer options.
+ *
+ * @returns {L.Layer} New layer.
+ */
+export function createLayer(options = sceneEmptyOptions) {
+  return /* alloc */ new L.Layer(options);
+}

package/src/scene/getLocation.js

@@ -1,12 +1,12 @@
-import { locationByLayer } from '../weakmaps/locationByLayer.js';
-
-/**
- * Read the geographic origin stored for a layer.
- *
- * @param {L.Layer} layer Layer to inspect.
- *
- * @returns {L.LatLng|undefined} Stored origin, if initialized.
- */
-export function getLocation(layer) {
-  return locationByLayer.get(layer);
-}
+import { locationByLayer } from '../weakmaps/locationByLayer.js';
+
+/**
+ * Read the geographic origin stored for a layer.
+ *
+ * @param {L.Layer} layer Layer to inspect.
+ *
+ * @returns {L.LatLng|undefined} Stored origin, if initialized.
+ */
+export function getLocation(layer) {
+  return locationByLayer.get(layer);
+}

package/src/scene/isNativeLayer.js

@@ -1,19 +1,19 @@
-import { state3dByLayer } from '../weakmaps/state3dByLayer.js';
-import { L } from '../globals/L.js';
-
-/**
- * Identify supported native Leaflet layers that are not already 3D layers.
- *
- * @param {L.Layer} layer Layer to inspect.
- *
- * @returns {boolean} Whether the layer is supported as native content.
- */
-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)
-  );
-}
+import { state3dByLayer } from '../weakmaps/state3dByLayer.js';
+import { L } from '../globals/L.js';
+
+/**
+ * Identify supported native Leaflet layers that are not already 3D layers.
+ *
+ * @param {L.Layer} layer Layer to inspect.
+ *
+ * @returns {boolean} Whether the layer is supported as native content.
+ */
+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/removeSceneLayer.js

@@ -1,22 +1,22 @@
-import { kindByLayer } from '../weakmaps/kindByLayer.js';
-import { onRemove3DLayer } from './onRemove3DLayer.js';
-import { onPMTileRemove } from '../raster/onPMTileRemove.js';
-import { onTerrainRemove } from '../terrain/onTerrainRemove.js';
-import { removeTimeLayer } from '../sunlight/removeTimeLayer.js';
-
-/**
- * Dispatch layer removal according to its registered scene kind.
- *
- * @param {L.Layer} layer Layer being removed.
- * @param {L.Map} map Map containing the layer.
- *
- * @returns {*} Result of the selected remove handler, if any.
- */
-export function removeSceneLayer(layer, map) {
-  switch (kindByLayer.get(layer)) {
-    case '3d': return onRemove3DLayer(layer, map);
-    case 'raster': return onPMTileRemove(layer, map);
-    case 'terrain': return onTerrainRemove(layer, map);
-    case 'time': return removeTimeLayer.call(layer, map);
-  }
-}
+import { kindByLayer } from '../weakmaps/kindByLayer.js';
+import { onRemove3DLayer } from './onRemove3DLayer.js';
+import { onPMTileRemove } from '../raster/onPMTileRemove.js';
+import { onTerrainRemove } from '../terrain/onTerrainRemove.js';
+import { removeTimeLayer } from '../sunlight/removeTimeLayer.js';
+
+/**
+ * Dispatch layer removal according to its registered scene kind.
+ *
+ * @param {L.Layer} layer Layer being removed.
+ * @param {L.Map} map Map containing the layer.
+ *
+ * @returns {*} Result of the selected remove handler, if any.
+ */
+export function removeSceneLayer(layer, map) {
+  switch (kindByLayer.get(layer)) {
+    case '3d': return onRemove3DLayer(layer, map);
+    case 'raster': return onPMTileRemove(layer, map);
+    case 'terrain': return onTerrainRemove(layer, map);
+    case 'time': return removeTimeLayer.call(layer, map);
+  }
+}

package/src/scene/reportLayerError.js

@@ -1,9 +1,9 @@
-/**
- * Emit an error event on a source layer.
- *
- * @param {L.Layer} source Layer receiving the event.
- * @param {Error} error Error to report.
- */
-export function reportError(source, error) {
-  source.fire('error', /* alloc */ { error });
-}
+/**
+ * Emit an error event on a source layer.
+ *
+ * @param {L.Layer} source Layer receiving the event.
+ * @param {Error} error Error to report.
+ */
+export function reportError(source, error) {
+  source.fire('error', /* alloc */ { error });
+}