leaflet-city-mapper 0.0.3 → 0.0.4

package/src/core/bypassNativeEvent.js

@@ -0,0 +1,11 @@
+import { updateNativeHover } from './updateNativeHover.js';
+
+export function bypassNativeEvent(map, context, event, type) {
+  const target = event.target;
+  const dom = target instanceof Element &&
+    target.closest('.leaflet-marker-icon,.leaflet-popup,.leaflet-tooltip,.leaflet-control');
+  if (dom && context.hovered && (type === context.move || type === context.out)) {
+    updateNativeHover(map, context, event, null);
+  }
+  return dom || type === context.move && (map.dragging?.moving() || map._animatingZoom);
+}

package/src/core/cameraCircleBounds.js

@@ -1,6 +1,7 @@
-import { indexState } from '../constants/indexState.js';
+import { boundsMethods } from '../globals/boundsMethods.js';
+
 
 export function cameraCircleBounds() {
   this._project();
-  return indexState.boundsMethods.get(this).call(this);
+  return boundsMethods.get(this).call(this);
 }

package/src/core/cameraMarkerDrag.js

@@ -1,18 +1,21 @@
+import { dragByHandler } from '../globals/dragByHandler.js';
+
+
 import { cameraMarkerOnDrag } from './cameraMarkerOnDrag.js';
 import { adjustCameraMarkerPan } from './adjustCameraMarkerPan.js';
 
 export function cameraMarkerDrag() {
-  if (!this.dragging || this.dragging._cameraDrag) return;
-  const drag = this.dragging, original = drag._onDrag, adjustPan = drag._adjustPan;
-  drag._cameraOriginalOnDrag = original;
-  drag._cameraOriginalAdjustPan = adjustPan;
-  drag._onDrag = cameraMarkerOnDrag;
-  drag._adjustPan = adjustCameraMarkerPan;
-  // The handler may already be enabled and listening with its original method.
-  const enabled = drag.enabled();
-  if (enabled) {
-    drag._draggable.off('drag', original, drag);
-    drag._draggable.on('drag', drag._onDrag, drag);
-  }
-  drag._cameraDrag = true;
+  if (!this.dragging || dragByHandler.has(this.dragging)) return;
+  const drag = this.dragging, original = drag._onDrag, adjustPan = drag._adjustPan;
+  dragByHandler.set(drag, /* alloc */ {
+    _cameraOriginalOnDrag: original, _cameraOriginalAdjustPan: adjustPan,
+  });
+  drag._onDrag = cameraMarkerOnDrag;
+  drag._adjustPan = adjustCameraMarkerPan;
+  // The handler may already be enabled and listening with its original method.
+  const enabled = drag.enabled();
+  if (enabled) {
+    drag._draggable.off('drag', original, drag);
+    drag._draggable.on('drag', drag._onDrag, drag);
+  }
 }

package/src/core/cameraMarkerOnDrag.js

@@ -1,8 +1,13 @@
+import { L } from '../globals/L.js';
+import { dragByHandler } from '../globals/dragByHandler.js';
+
+
+
 export function cameraMarkerOnDrag(event) {
   const map = this._marker._map;
   const screen = L.DomUtil.getPosition(this._marker._icon).add(map._getMapPanePos());
   const point = map.containerPointToLayerPoint(screen);
   L.DomUtil.setPosition(this._marker._icon, point);
-  this._cameraOriginalOnDrag.call(this, event);
+  dragByHandler.get(this)._cameraOriginalOnDrag.call(this, event);
   this._marker._setPos(point);
-}
+}

package/src/core/cancelGridFade.js

@@ -1,10 +1,14 @@
-import { indexState } from '../constants/indexState.js';
+import { pendingGridFades } from '../globals/pendingGridFades.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { gridFadeFrame } from '../globals/gridFadeFrame.js';
+
+
 
 export function cancelGridFade(layer) {
-  indexState.pendingGridFades.delete(layer);
-  layer._fadeFrame = null;
-  if (!indexState.pendingGridFades.size && indexState.gridFadeFrame !== null) {
-    cancelAnimationFrame(indexState.gridFadeFrame);
-    indexState.gridFadeFrame = null;
+  pendingGridFades.delete(layer);
+  sceneByLayer.get(layer)._fadeFrame = null;
+  if (!pendingGridFades.size && gridFadeFrame.value !== null) {
+    cancelAnimationFrame(gridFadeFrame.value);
+    gridFadeFrame.value = null;
   }
 }

package/src/core/closestCameraLayerPoint.js

@@ -1,7 +1,8 @@
-import { indexState } from '../constants/indexState.js';
+import { closestMethods } from '../globals/closestMethods.js';
+
 
 export function closestCameraLayerPoint(point) {
   this._project();
   this._parts = this._rings;
-  return indexState.closestMethods.get(this).call(this, point);
+  return closestMethods.get(this).call(this, point);
 }

package/src/core/current.js

@@ -1,3 +1,6 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 export function current(state) {
-  return state.source._nativeGPU === state && state.map.hasLayer(state.source);
+  return sceneByLayer.get(state.source)._nativeGPU === state && state.map.hasLayer(state.source);
 }

package/src/core/disposeNativeLayer.js

@@ -1,3 +1,6 @@
+import { nativeRenderByLayer } from '../globals/nativeRenderByLayer.js';
+
+
 import { refreshNativeEvent } from './refreshNativeEvent.js';
 import { updateNativeLayerView } from './updateNativeLayerView.js';
 import { removeNativeEvents } from './removeNativeEvents.js';
@@ -9,13 +12,14 @@ import { removeImageState } from './removeImageState.js';
 
 export function disposeNativeLayer() {
   const state = this;
+  if (state.disposed) return;
+  state.disposed = true;
   const { source, map, backend, meshes, textures, images } = state;
   const events = 'load tileload tileunload move drag';
   source.off(events, refreshNativeEvent, state);
   map.off('zoomend', refreshNativeEvent, state);
   if (state.marker) map.off('move zoom rotate pitch resize viewreset', updateNativeLayerView, state);
   removeNativeEvents(state);
-  state.refresh = state.reorder = null;
   let name, methods, mesh, texture, image;
   for ([name, methods] of state.methods) {
     if (methods.own) Object.defineProperty(source, name, methods.own);
@@ -30,6 +34,6 @@ export function disposeNativeLayer() {
     image.removeEventListener('error', nativeImageError);
     removeImageState(image, state);
   }
-  backend._beforeRender = null;
+  nativeRenderByLayer.delete(backend);
   backend.remove();
 }

package/src/core/fireRasterLoad.js

@@ -1,5 +1,6 @@
-import { indexState } from '../constants/indexState.js';
+import { pendingRasterLoads } from '../globals/pendingRasterLoads.js';
+
 
 export function fireRasterLoad() {
-  indexState.pendingRasterLoads.shift()?.fire('load');
+  pendingRasterLoads.shift()?.fire('load');
 }

package/src/core/forwardNativeError.js

@@ -1,3 +1,3 @@
 export function forwardNativeError({ error }) {
-  this.source.fire('error', { error });
-}
+  this.source.fire('error', /* alloc */ { error });
+}

package/src/core/gridlayerGetEvents.js

@@ -1,7 +1,10 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { L } from '../globals/L.js';
+import { gridEvents } from '../globals/gridEvents.js';
+
+
 
 export function gridlayerGetEvents() {
-  const events = mapCameraState.gridEvents.call(this);
-  this._cameraGridUpdate ||= L.Util.throttle(this._onMoveEnd, this.options.updateInterval, this);
-  return { ...events, rotate: this._cameraGridUpdate, pitch: this._cameraGridUpdate };
+  const events = gridEvents.value.call(this);
+  events.rotate = events.pitch = L.Util.throttle(this._onMoveEnd, this.options.updateInterval, this);
+  return events;
 }

package/src/core/gridlayerGetTiledPixelBounds.js

@@ -1,8 +1,12 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { L } from '../globals/L.js';
+import { tiledBounds } from '../globals/tiledBounds.js';
+
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
 
 export function gridlayerGetTiledPixelBounds(center) {
-  if (!this._map.getBearing() && !this._map.getPitch()) return mapCameraState.tiledBounds.call(this, center);
-  const bounds = this._map.getBounds();
-  return new L.Bounds(this._map.project(bounds.getNorthWest(), this._tileZoom),
+  if (!mapGetBearing(this._map) && !mapGetPitch(this._map)) return tiledBounds.value.call(this, center);
+  const bounds = this._map.getBounds();
+  return /* alloc */ new L.Bounds(this._map.project(bounds.getNorthWest(), this._tileZoom),
     this._map.project(bounds.getSouthEast(), this._tileZoom));
 }

package/src/core/handleNativeMapEvent.js

@@ -1,47 +1,27 @@
-import { nativeEventMaps } from '../constants/nativeEventMaps.js';
-import { cityMapper } from '../constants/cityMapper.js';
-import { raycast } from '../picking/raycast.js';
-import { compareNativeHits } from './compareNativeHits.js';
+import { nativeEventMaps } from '../globals/nativeEventMaps.js';
+import { renderers } from '../globals/renderers.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { coreEventTypes } from '../globals/coreEventTypes.js';
+
+
+
+import { nativeEventSource } from './nativeEventSource.js';
+import { updateNativeHover } from './updateNativeHover.js';
+import { bypassNativeEvent } from './bypassNativeEvent.js';
 
 export function handleNativeMapEvent(event, type = event.type, targets) {
   const map = this, context = nativeEventMaps.get(map), fireDOMEvent = context.fireDOMEvent;
-  const owner = cityMapper.renderers.get(map);
-  if (!owner?.renderer || targets || !['click', 'preclick', 'dblclick', 'contextmenu',
-    'mousedown', 'mouseup', 'mousemove', 'mouseover', 'mouseout',
-    'pointerdown', 'pointerup', 'pointermove', 'pointerover', 'pointerout'].includes(type)) {
+  const owner = renderers.get(map);
+  if (!sceneByLayer.get(owner)?.renderer || targets || !coreEventTypes.has(type)) {
     return fireDOMEvent.call(this, event, type, targets);
   }
-  const target = event.target;
-  const dom = target instanceof Element &&
-    target.closest('.leaflet-marker-icon,.leaflet-popup,.leaflet-tooltip,.leaflet-control');
-  if (dom && context.hovered && (type === context.move || type === context.out)) {
-    fireDOMEvent.call(map, event, context.out, [context.hovered]);
-    context.hovered = null;
-    map.getContainer().style.cursor = '';
-  }
-  if (dom || type === context.move && (map.dragging?.moving() || map._animatingZoom)) {
+  if (bypassNativeEvent(map, context, event, type)) {
     return fireDOMEvent.call(this, event, type, targets);
   }
-  const hits = [];
-  let candidate, source2, backend;
-  if (type !== context.out) {
-    for (candidate of context.states) {
-      ({ source: source2, backend } = candidate);
-      if (source2 instanceof L.Marker || source2.options.interactive === false ||
-        !(source2 instanceof L.Path) && !source2.options.interactive) continue;
-      hits.push(...raycast(backend, event, candidate.meshes.values(), false));
-    }
-  }
-  hits.sort(compareNativeHits);
-  let source = hits[0]?.object._nativeSource || null;
+  let source = nativeEventSource(context, event, type);
   if ((type === 'click' || type === 'preclick') && source && map._draggableMoved(source)) source = null;
   if (type === context.move || type === context.out) {
-    if (context.hovered !== source) {
-      if (context.hovered) fireDOMEvent.call(map, event, context.out, [context.hovered]);
-      context.hovered = source;
-      if (source) fireDOMEvent.call(map, event, context.over, [source]);
-      map.getContainer().style.cursor = source ? 'pointer' : '';
-    }
+    updateNativeHover(map, context, event, source);
   }
-  return fireDOMEvent.call(this, event, type, source ? [source] : undefined);
+  return fireDOMEvent.call(this, event, type, source ? /* alloc */ [source] : undefined);
 }

package/src/core/hideTargets.js

@@ -1,14 +1,16 @@
+import { L } from '../globals/L.js';
 export function hideTargets(state) {
   const { source } = state;
   const htmlIcon = source instanceof L.Marker && source.options.icon instanceof L.DivIcon;
-  const targets = [htmlIcon ? null : source._icon, htmlIcon ? null : source._shadow];
-  let element;
+  const icon = htmlIcon ? null : source._icon, shadow = htmlIcon ? null : source._shadow;
+  let i, element;
   for (element of state.hidden) {
-    if (targets.includes(element)) continue;
+    if (element === icon || element === shadow) continue;
     element.classList.remove('leaflet-webgpu-target');
     state.hidden.delete(element);
   }
-  for (element of targets) {
+  for (i = 0; i < 2; i++) {
+    element = i ? shadow : icon;
     if (!element || state.hidden.has(element)) continue;
     element.classList.add('leaflet-webgpu-target');
     state.hidden.add(element);

package/src/core/initNativeGPU.js

@@ -1,3 +1,6 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 import { nativeLayer } from './nativeLayer.js';
 import { hideTargets } from './hideTargets.js';
 import { removeTargets } from './removeTargets.js';
@@ -5,17 +8,18 @@ import { readyNativeGPU } from './readyNativeGPU.js';
 import { reportError } from '../scene/reportError.js';
 
 export function initNativeGPU(source, map) {
-  if (source._nativeGPU) return;
+  if (sceneByLayer.get(source)._nativeGPU) return;
   if (!document.getElementById('leaflet-webgpu-targets')) {
     const style = document.createElement('style');
     style.id = 'leaflet-webgpu-targets';
     style.textContent = '.leaflet-webgpu-target{opacity:0!important}';
     document.head.append(style);
   }
-  const state = source._nativeGPU = { source, map, hidden: new Set() };
-  state.hide = hideTargets.bind(null, state);
-  state.hide();
+  const state = sceneByLayer.get(source)._nativeGPU = /* alloc */ {
+    source, map, hidden: /* alloc */ new Set(),
+  };
+  hideTargets(state);
   source.once('remove', removeTargets.bind(null, state));
-  source.ready = Promise.resolve().then(readyNativeGPU.bind(null, state));
-  source.ready.catch(reportError.bind(null, source));
+  sceneByLayer.get(source).ready = Promise.resolve().then(readyNativeGPU.bind(null, state));
+  sceneByLayer.get(source).ready.catch(reportError.bind(null, source));
 }

package/src/core/initializeGridContainer.js

@@ -1,6 +1,7 @@
-import { indexState } from '../constants/indexState.js';
+import { gridInitializers } from '../globals/gridInitializers.js';
+
 
 export function initializeGridContainer() {
-  indexState.gridInitializers.get(this).call(this);
+  gridInitializers.get(this).call(this);
   this._container.remove();
 }

package/src/core/initializeNativeLayer.js

@@ -1,42 +1,40 @@
+import { L } from '../globals/L.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { closestMethods } from '../globals/closestMethods.js';
+import { boundsMethods } from '../globals/boundsMethods.js';
+import { gridInitializers } from '../globals/gridInitializers.js';
+
+
 import { noOperation } from '../utils/noOperation.js';
 import { emptyEvents } from '../scene/emptyEvents.js';
 import { refreshNativeLayerContract } from './refreshNativeLayerContract.js';
-import { bringNativeLayerToFront } from './bringNativeLayerToFront.js';
-import { bringNativeLayerToBack } from './bringNativeLayerToBack.js';
-import { indexState } from '../constants/indexState.js';
+
 import { closestCameraLayerPoint } from './closestCameraLayerPoint.js';
 import { cameraCircleBounds } from './cameraCircleBounds.js';
 import { initializeGridContainer } from './initializeGridContainer.js';
 import { updateGridOpacity } from './updateGridOpacity.js';
 import { addRasterImage } from './addRasterImage.js';
+import { redrawPath } from './redrawPath.js';
 
 export function initializeNativeLayer() {
   if (this instanceof L.Polyline || this instanceof L.CircleMarker) {
-    this.beforeAdd = this.onAdd = this.onRemove = this._updateBounds = noOperation;
-    this.getEvents = emptyEvents;
-    this._renderer = {
-      options: { tolerance: 0 },
-      _updatePath: refreshNativeLayerContract,
-      _updateStyle: refreshNativeLayerContract,
-      _bringToFront: bringNativeLayerToFront,
-      _bringToBack: bringNativeLayerToBack,
-    };
+    this.beforeAdd = this._updateBounds = noOperation;
+    this.redraw = redrawPath;
+    sceneByLayer.get(this).kind = 'path';
     if (this instanceof L.Polyline) {
-      indexState.closestMethods.set(this, this.closestLayerPoint);
+      closestMethods.set(this, this.closestLayerPoint);
       this.closestLayerPoint = closestCameraLayerPoint;
     }
     if (this instanceof L.Circle) {
-      indexState.boundsMethods.set(this, this.getBounds);
+      boundsMethods.set(this, this.getBounds);
       this.getBounds = cameraCircleBounds;
     }
   } else if (this instanceof L.GridLayer) {
-    indexState.gridInitializers.set(this, this._initContainer);
+    gridInitializers.set(this, this._initContainer);
     this._initContainer = initializeGridContainer;
     this._updateOpacity = updateGridOpacity;
   } else if (this instanceof L.ImageOverlay && !(this instanceof L.VideoOverlay) && !(this instanceof L.SVGOverlay)) {
-    this.onAdd = addRasterImage;
-    this.onRemove = noOperation;
-    this.getEvents = emptyEvents;
+    sceneByLayer.get(this).kind = 'image';
     this._reset = refreshNativeLayerContract;
   }
 }

package/src/core/layerCallInitHooks.js

@@ -0,0 +1,14 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { layerCallInitHooks as sharedLayerCallInitHooks } from '../globals/layerCallInitHooks.js';
+
+
+import { initializeNativeLayer } from './initializeNativeLayer.js';
+
+export function layerCallInitHooks() {
+  if (!sceneByLayer.has(this)) {
+    sceneByLayer.set(this, /* alloc */ {});
+  }
+  const initialized = this._initHooksCalled;
+  sharedLayerCallInitHooks.value.call(this);
+  if (!initialized) initializeNativeLayer.call(this);
+}

package/src/core/localPixelForGeometry.js

@@ -1,6 +1,7 @@
+import { geometryPixelStates } from '../globals/geometryPixelStates.js';
+
 import { localPixel } from './localPixel.js';
-import { nativeLayerState } from '../constants/nativeLayerState.js';
 
 export function localPixelForGeometry(point) {
-  return localPixel(nativeLayerState.geometryPixelStates[nativeLayerState.geometryPixelStates.length - 1], point);
+  return localPixel(geometryPixelStates[geometryPixelStates.length - 1], point);
 }

package/src/core/localPosition.js

@@ -1,6 +1,10 @@
+import { radians } from '../globals/radians.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+
 export function localPosition(state, latlng) {
   const { map, backend } = state, crs = map.options.crs;
-  const origin = crs.project(backend.location), point = crs.project(latlng);
-  const metres = Math.cos(backend.location.lat * Math.PI / 180);
-  return [(point.x - origin.x) * metres, 0, -(point.y - origin.y) * metres];
-}
+  const origin = crs.project(sceneByLayer.get(backend).location), point = crs.project(latlng);
+  const metres = Math.cos(sceneByLayer.get(backend).location.lat * radians);
+  return /* alloc */ [(point.x - origin.x) * metres, 0, -(point.y - origin.y) * metres];
+}

package/src/core/markerCameraIconPoint.js

@@ -1,9 +1,12 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { L } from '../globals/L.js';
+import { radians } from '../globals/radians.js';
 
-export function markerCameraIconPoint(x, y) {
-  let rotation = this.options.rotation + (this.options.rotateWithView ? this._map.getBearing() * mapCameraState.radians : 0);
-  if (this.options.keepUpright && Math.cos(rotation) < 0) rotation += Math.PI;
-  const scale = this.options.scale;
-  return new L.Point((x * Math.cos(rotation) - y * Math.sin(rotation)) * scale,
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+export function markerCameraIconPoint(marker, x, y) {
+  let rotation = marker.options.rotation + (marker.options.rotateWithView ? mapGetBearing(marker._map) * radians : 0);
+  if (marker.options.keepUpright && Math.cos(rotation) < 0) rotation += Math.PI;
+  const scale = marker.options.scale;
+  return /* alloc */ new L.Point((x * Math.cos(rotation) - y * Math.sin(rotation)) * scale,
     (x * Math.sin(rotation) + y * Math.cos(rotation)) * scale);
 }

package/src/core/markerGetEvents.js

@@ -1,5 +1,9 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { markerMethods } from '../globals/markerMethods.js';
+
+
 
 export function markerGetEvents() {
-  return { ...mapCameraState.markerMethods.getEvents.call(this), rotate: this.update, pitch: this.update, move: this.update };
+  const events = markerMethods.value.getEvents.call(this);
+  events.rotate = events.pitch = events.move = this.update;
+  return events;
 }

package/src/core/markerImageBounds.js

@@ -0,0 +1,11 @@
+export function markerImageBounds(state, key, image) {
+  const options = state.source.options.icon.options;
+  const dimensions = options[key === 'shadow' ? 'shadowSize' : 'iconSize'];
+  const bounds = state.markerImageBounds ||= /* alloc */ [0, 0, 0, 0];
+  bounds[0] = dimensions ? dimensions.x ?? dimensions[0] : image.naturalWidth;
+  bounds[1] = dimensions ? dimensions.y ?? dimensions[1] : image.naturalHeight;
+  const anchor = (key === 'shadow' && options.shadowAnchor) || options.iconAnchor;
+  bounds[2] = anchor ? anchor.x ?? anchor[0] : Math.floor(bounds[0] / 2);
+  bounds[3] = anchor ? anchor.y ?? anchor[1] : Math.floor(bounds[1] / 2);
+  return bounds;
+}

package/src/core/markerInitInteraction.js

@@ -1,8 +1,10 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { markerMethods } from '../globals/markerMethods.js';
+
+
 import { cameraMarkerDrag } from './cameraMarkerDrag.js';
 
 export function markerInitInteraction() {
-  const result = mapCameraState.markerMethods._initInteraction.call(this);
+  const result = markerMethods.value._initInteraction.call(this);
   cameraMarkerDrag.call(this);
   return result;
 }

package/src/core/markerQuadCorners.js

@@ -1,31 +1,48 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { coreMatrixKeys } from '../globals/coreMatrixKeys.js';
+import { markerCameraIconPoint } from './markerCameraIconPoint.js';
+
 import { localPosition } from './localPosition.js';
 
+import { transformNativePoint } from './transformNativePoint.js';
+import { markerImageBounds } from './markerImageBounds.js';
+
 export function markerQuadCorners(state, key, image) {
   const { source, map, backend } = state;
-  const world = new DOMPoint(...localPosition(state, source.getLatLng()), 1)
-    .matrixTransform(new DOMMatrix(backend.root.worldMatrix));
-  const clip = world.matrixTransform(new DOMMatrix(backend.camera.projectionViewMatrix));
-  const inverse = new DOMMatrix(backend.camera.projectionViewMatrix).inverse();
-  const toLocal = new DOMMatrix(backend.root.worldMatrix).inverse();
-  const options = source.options.icon.options, size = map.getSize();
-  const dimensions = options[key === 'shadow' ? 'shadowSize' : 'iconSize'] ||
-    [image.naturalWidth, image.naturalHeight];
-  const width = dimensions.x ?? dimensions[0], height = dimensions.y ?? dimensions[1];
-  const anchor = (key === 'shadow' && options.shadowAnchor) ||
-    options.iconAnchor || [Math.floor(width / 2), Math.floor(height / 2)];
-  const center = new L.Point((clip.x / clip.w + 1) * size.x / 2, (1 - clip.y / clip.w) * size.y / 2);
-  const left = center.x - (anchor.x ?? anchor[0]), top = center.y - (anchor.y ?? anchor[1]);
-  const screenCorners = [[left, top], [left + width, top],
-    [left, top + height], [left + width, top + height]];
-  const corners = [];
-  let pointX, pointY, offset, x, y, p, result;
-  for ([pointX, pointY] of screenCorners) {
-    offset = source._cameraIconPoint(pointX - center.x, pointY - center.y);
-    x = center.x + offset.x, y = center.y + offset.y;
-    p = new DOMPoint(x / size.x * 2 - 1,
-      1 - y / size.y * 2, clip.z / clip.w, 1).matrixTransform(inverse);
-    result = new DOMPoint(p.x / p.w, p.y / p.w, p.z / p.w, 1).matrixTransform(toLocal);
-    corners.push([result.x, result.y, result.z]);
+  const position = localPosition(state, source.getLatLng());
+  const size = map.getSize();
+  const matrices = state.markerMatrices ||= /* alloc */ {
+    root: /* alloc */ new DOMMatrix(),
+    camera: /* alloc */ new DOMMatrix(),
+    point: /* alloc */ { x: 0, y: 0, z: 0, w: 1 },
+  };
+  const root = matrices.root, camera = matrices.camera, point = matrices.point;
+  const worldMatrix = sceneByLayer.get(backend).root.worldMatrix, projection = sceneByLayer.get(backend).camera.projectionViewMatrix;
+  let i, keyName;
+  for (i = 0; i < 16; i++) {
+    keyName = coreMatrixKeys[i];
+    root[keyName] = worldMatrix[i];
+    camera[keyName] = projection[i];
+  }
+  transformNativePoint(point, root, position[0], position[1], position[2], 1);
+  transformNativePoint(point, camera, point.x, point.y, point.z, point.w);
+  const clipX = point.x, clipY = point.y, clipZ = point.z, clipW = point.w;
+  camera.invertSelf();
+  root.invertSelf();
+  const [width, height, anchorX, anchorY] = markerImageBounds(state, key, image);
+  const centerX = (clipX / clipW + 1) * size.x / 2, centerY = (1 - clipY / clipW) * size.y / 2;
+  const left = centerX - anchorX;
+  const top = centerY - anchorY;
+  const corners = /* alloc */ [];
+  let pointX, pointY, offset, x, y;
+  for (i = 0; i < 4; i++) {
+    pointX = left + (i % 2 ? width : 0);
+    pointY = top + (i < 2 ? 0 : height);
+    offset = markerCameraIconPoint(source, pointX - centerX, pointY - centerY);
+    x = centerX + offset.x, y = centerY + offset.y;
+    transformNativePoint(point, camera, x / size.x * 2 - 1, 1 - y / size.y * 2, clipZ / clipW, 1);
+    transformNativePoint(point, root, point.x / point.w, point.y / point.w, point.z / point.w, 1);
+    corners.push(/* alloc */ [point.x, point.y, point.z]);
   }
   return corners;
 }

package/src/core/markerSetIcon.js

@@ -1,9 +1,12 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { L } from '../globals/L.js';
+import { markerMethods } from '../globals/markerMethods.js';
+
+
 import { initNativeGPU } from './initNativeGPU.js';
 
 export function markerSetIcon(icon) {
   if (!(icon instanceof L.DivIcon)) icon.options.crossOrigin ||= true;
-  const result = mapCameraState.markerMethods.setIcon.call(this, icon);
+  const result = markerMethods.value.setIcon.call(this, icon);
   if (this._map && !(icon instanceof L.DivIcon)) initNativeGPU(this, this._map);
   return result;
 }

package/src/core/markerSetPos.js

@@ -1,12 +1,17 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
+import { markerMethods } from '../globals/markerMethods.js';
+
+import { markerCameraIconPoint } from './markerCameraIconPoint.js';
+
 import { displayPoint } from '../camera/displayPoint.js';
 
 export function markerSetPos(point) {
-  mapCameraState.markerMethods._setPos.call(this, displayPoint(this._map, point));
-  let element, key, direction, options, anchor;
-  for ([element, key] of [[this._icon, 'iconAnchor'], [this._shadow, 'shadowAnchor']]) {
+  markerMethods.value._setPos.call(this, displayPoint(this._map, point));
+  let i, element, key, direction, options, anchor;
+  for (i = 0; i < 2; i++) {
+    element = i ? this._shadow : this._icon;
+    key = i ? 'shadowAnchor' : 'iconAnchor';
     if (!element) continue;
-    direction = this._cameraIconPoint(1, 0), options = this.options.icon.options;
+    direction = markerCameraIconPoint(this, 1, 0), options = this.options.icon.options;
     anchor = options[key] || options.iconAnchor;
     element.style.transformOrigin = anchor ? `${anchor.x ?? anchor[0]}px ${anchor.y ?? anchor[1]}px` : 'center';
     element.style.transform += ` rotate(${Math.atan2(direction.y, direction.x)}rad) scale(${this.options.scale})`;

package/src/core/markerSetRotation.js

@@ -1,7 +1,9 @@
-export function markerSetRotation(rotation) {
-  if (!Number.isFinite(rotation)) throw new TypeError('Marker rotation must be finite');
-  this.options.rotation = rotation;
-  this.update();
-  this._nativeGPU?.refresh?.();
-  return this;
-}
+import { refreshNativeLayerContract } from './refreshNativeLayerContract.js';
+
+export function markerSetRotation(marker, rotation) {
+  if (!Number.isFinite(rotation)) throw /* alloc */ new TypeError('Marker rotation must be finite');
+  marker.options.rotation = rotation;
+  marker.update();
+  refreshNativeLayerContract(marker);
+  return marker;
+}