@deck.gl/geo-layers 9.3.7 → 9.4.0-alpha.2

package/dist/index.cjs

@@ -667,14 +667,12 @@ var Tile2DHeader = class {
     return result;
   }
   /* eslint-disable max-statements */
-  async _loadData({ getData, requestScheduler, onLoad, onError }) {
+  async _loadData({ getData, getRequestPriority, requestScheduler, onLoad, onError }) {
     const { index, id, bbox, userData, zoom } = this;
     const loaderId = this._loaderId;
     this._abortController = new AbortController();
     const { signal } = this._abortController;
-    const requestToken = await requestScheduler.scheduleRequest(this, (tile) => {
-      return tile.isSelected ? 1 : -1;
-    });
+    const requestToken = await requestScheduler.scheduleRequest(this, getRequestPriority);
     if (!requestToken) {
       this._isCancelled = true;
       return;
@@ -788,6 +786,9 @@ var OSMNode = class {
     if (isInside < 0) {
       return false;
     }
+    if (project && this.beyondHorizon(viewport.cameraPosition, project, elevationBounds[1])) {
+      return false;
+    }
     if (!this.childVisible) {
       let { z } = this;
       if (z < maxZ && z >= minZ) {
@@ -817,6 +818,24 @@ var OSMNode = class {
     }
     return result;
   }
+  beyondHorizon(cameraPosition, project, elevation) {
+    const cx = cameraPosition[0];
+    const cy = cameraPosition[1];
+    const cz = cameraPosition[2];
+    const cMag = Math.sqrt(cx * cx + cy * cy + cz * cz);
+    const camLng = Math.atan2(cx, -cy) * 180 / Math.PI;
+    const camLat = Math.asin(cz / cMag) * 180 / Math.PI;
+    const [west, north] = osmTile2lngLat(this.x, this.y, this.z);
+    const [east, south] = osmTile2lngLat(this.x + 1, this.y + 1, this.z);
+    const tileCenterLng = (west + east) / 2;
+    const wrappedCamLng = tileCenterLng + ((camLng - tileCenterLng + 540) % 360 - 180);
+    const closestLng = Math.max(west, Math.min(wrappedCamLng, east));
+    const closestLat = Math.max(south, Math.min(camLat, north));
+    const closest = project([closestLng, closestLat, elevation]);
+    const dot = closest[0] * cx + closest[1] * cy + closest[2] * cz;
+    const magSq = closest[0] * closest[0] + closest[1] * closest[1] + closest[2] * closest[2];
+    return dot <= magSq;
+  }
   insideBounds([minX, minY, maxX, maxY]) {
     const scale = Math.pow(2, this.z);
     const extent = TILE_SIZE2 / scale;
@@ -845,7 +864,7 @@ var OSMNode = class {
   }
 };
 function getOSMTileIndices(viewport, maxZ, zRange, bounds) {
-  const project = viewport instanceof import_core5._GlobeViewport && viewport.resolution ? (
+  const project = viewport instanceof import_core5._GlobeViewport ? (
     // eslint-disable-next-line @typescript-eslint/unbound-method
     viewport.projectPosition
   ) : null;
@@ -1138,6 +1157,9 @@ var STRATEGY_NEVER = "never";
 var STRATEGY_REPLACE = "no-overlap";
 var STRATEGY_DEFAULT = "best-available";
 var DEFAULT_CACHE_SCALE = 5;
+var SELECTED_TILE_PRIORITY = 0;
+var VISIBLE_TILE_PRIORITY = 1e8;
+var MAX_TILE_DISTANCE_PRIORITY = VISIBLE_TILE_PRIORITY - SELECTED_TILE_PRIORITY - 1;
 var STRATEGIES = {
   [STRATEGY_DEFAULT]: updateTileStateDefault,
   [STRATEGY_REPLACE]: updateTileStateReplace,
@@ -1379,6 +1401,78 @@ var Tileset2D = class {
     }
     return false;
   }
+  _getRequestPriority(tile) {
+    if (!tile.isSelected && !tile.isVisible) {
+      return -1;
+    }
+    const distance = this._getTileDistancePriority(tile);
+    if (tile.isSelected) {
+      return SELECTED_TILE_PRIORITY + distance;
+    }
+    return VISIBLE_TILE_PRIORITY + distance;
+  }
+  _getTileDistancePriority(tile) {
+    const { width, height } = this._viewport || {};
+    if (!this._viewport || !width || !height) {
+      return 0;
+    }
+    try {
+      const points = this._getTileScreenCorners(tile.bbox);
+      const center = [width / 2, height / 2];
+      if (points.length === 4) {
+        if (this._isPointInPolygon(center, points)) {
+          return 0;
+        }
+        const distance = points.reduce((minDistance, point, i) => {
+          const nextPoint = points[(i + 1) % points.length];
+          return Math.min(minDistance, this._getPointToSegmentDistanceSquared(center, point, nextPoint));
+        }, Number.MAX_SAFE_INTEGER);
+        return Math.min(distance, MAX_TILE_DISTANCE_PRIORITY);
+      }
+    } catch {
+    }
+    return MAX_TILE_DISTANCE_PRIORITY;
+  }
+  _getTileScreenCorners(bbox) {
+    const coordinates = "west" in bbox ? [
+      [bbox.west, bbox.south],
+      [bbox.east, bbox.south],
+      [bbox.east, bbox.north],
+      [bbox.west, bbox.north]
+    ] : [
+      [bbox.left, bbox.top],
+      [bbox.right, bbox.top],
+      [bbox.right, bbox.bottom],
+      [bbox.left, bbox.bottom]
+    ];
+    return coordinates.map((coordinate) => this._viewport.project(coordinate)).filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y));
+  }
+  _isPointInPolygon(point, polygon) {
+    let inside = false;
+    const [x, y] = point;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+      const [xi, yi] = polygon[i];
+      const [xj, yj] = polygon[j];
+      if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) {
+        inside = !inside;
+      }
+    }
+    return inside;
+  }
+  _getPointToSegmentDistanceSquared(point, segmentStart, segmentEnd) {
+    const [x, y] = point;
+    const [x1, y1] = segmentStart;
+    const [x2, y2] = segmentEnd;
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const lengthSquared = dx * dx + dy * dy;
+    const t = lengthSquared ? Math.max(0, Math.min(1, ((x - x1) * dx + (y - y1) * dy) / lengthSquared)) : 0;
+    const segmentX = x1 + t * dx;
+    const segmentY = y1 + t * dy;
+    const distanceX = x - segmentX;
+    const distanceY = y - segmentY;
+    return distanceX * distanceX + distanceY * distanceY;
+  }
   _pruneRequests() {
     const { maxRequests = 0 } = this.opts;
     const abortCandidates = [];
@@ -1461,6 +1555,7 @@ var Tileset2D = class {
     if (tile && needsReload) {
       tile.loadData({
         getData: this.opts.getTileData,
+        getRequestPriority: this._getRequestPriority.bind(this),
         requestScheduler: this._requestScheduler,
         onLoad: this.onTileLoad,
         onError: this.opts.onTileError
@@ -2094,9 +2189,8 @@ in vec3 normals;
 in vec3 colors;
 in vec2 texCoords;
 in vec4 uvRegions;
-in vec3 featureIdsPickingColors;
+in float rowIndexes;
 in vec4 instanceColors;
-in vec3 instancePickingColors;
 in vec3 instanceModelMatrixCol0;
 in vec3 instanceModelMatrixCol1;
 in vec3 instanceModelMatrixCol2;
@@ -2116,9 +2210,9 @@ void main(void) {
 vec2 uv = applyUVRegion(texCoords);
 geometry.uv = uv;
 if (mesh.pickFeatureIds) {
-geometry.pickingColor = featureIdsPickingColors;
+geometry.pickingColor = picking_getPickingColorFromIndex(rowIndexes);
 } else {
-geometry.pickingColor = instancePickingColors;
+geometry.pickingColor = picking_getPickingColorFromInstanceID();
 }
 mat3 instanceModelMatrix = mat3(instanceModelMatrixCol0, instanceModelMatrixCol1, instanceModelMatrixCol2);
 vTexCoord = uv;
@@ -2211,12 +2305,13 @@ var MeshLayer = class extends import_mesh_layers.SimpleMeshLayer {
     const attributeManager = this.getAttributeManager();
     if (featureIds) {
       attributeManager.add({
-        featureIdsPickingColors: {
-          type: "uint8",
-          size: 3,
+        /** Feature id for each mesh vertex. */
+        rowIndexes: {
+          type: "uint32",
+          size: 1,
           noAlloc: true,
           // eslint-disable-next-line @typescript-eslint/unbound-method
-          update: this.calculateFeatureIdsPickingColors
+          update: this.calculateFeatureIdsPickingIndexes
         }
       });
     }
@@ -2294,17 +2389,9 @@ var MeshLayer = class extends import_mesh_layers.SimpleMeshLayer {
       useTangents: false
     });
   }
-  calculateFeatureIdsPickingColors(attribute) {
+  calculateFeatureIdsPickingIndexes(attribute) {
     const featureIds = this.props.featureIds;
-    const value = new Uint8ClampedArray(featureIds.length * attribute.size);
-    const pickingColor = [];
-    for (let index = 0; index < featureIds.length; index++) {
-      this.encodePickingColor(featureIds[index], pickingColor);
-      value[index * 3] = pickingColor[0];
-      value[index * 3 + 1] = pickingColor[1];
-      value[index * 3 + 2] = pickingColor[2];
-    }
-    attribute.value = value;
+    attribute.value = new Uint32Array(featureIds);
   }
   finalizeState(context) {
     var _a;
@@ -2645,6 +2732,10 @@ var import_core13 = require("@deck.gl/core");
 var import_mesh_layers3 = require("@deck.gl/mesh-layers");
 var import_terrain = require("@loaders.gl/terrain");
 var DUMMY_DATA = [1];
+var TILE_OVERLAP_PIXELS = 1;
+var MIN_TERRAIN_MESH_MAX_ERROR = 1;
+var MAX_LATITUDE = 90;
+var MAX_LONGITUDE = 180;
 var defaultProps13 = {
   ...tile_layer_default.defaultProps,
   // Image url that encodes height data
@@ -2680,6 +2771,31 @@ function urlTemplateToUpdateTrigger(template) {
   }
   return template || "";
 }
+function getOverlappedBounds(bounds, tileSize, clampLngLat) {
+  const xPad = (bounds[2] - bounds[0]) / tileSize * TILE_OVERLAP_PIXELS;
+  const yPad = (bounds[3] - bounds[1]) / tileSize * TILE_OVERLAP_PIXELS;
+  const overlappedBounds = [
+    bounds[0] - xPad,
+    bounds[1] - yPad,
+    bounds[2] + xPad,
+    bounds[3] + yPad
+  ];
+  if (!clampLngLat) {
+    return overlappedBounds;
+  }
+  return [
+    Math.max(overlappedBounds[0], -MAX_LONGITUDE),
+    Math.max(overlappedBounds[1], -MAX_LATITUDE),
+    Math.min(overlappedBounds[2], MAX_LONGITUDE),
+    Math.min(overlappedBounds[3], MAX_LATITUDE)
+  ];
+}
+function getEffectiveMeshMaxError(meshMaxError) {
+  if (!Number.isFinite(meshMaxError) || meshMaxError <= 0) {
+    return MIN_TERRAIN_MESH_MAX_ERROR;
+  }
+  return Math.max(meshMaxError, MIN_TERRAIN_MESH_MAX_ERROR);
+}
 var TerrainLayer = class extends import_core13.CompositeLayer {
   updateState({ props, oldProps }) {
     const elevationDataChanged = props.elevationData !== oldProps.elevationData;
@@ -2701,14 +2817,15 @@ var TerrainLayer = class extends import_core13.CompositeLayer {
     if (!elevationData) {
       return null;
     }
+    const effectiveMeshMaxError = getEffectiveMeshMaxError(meshMaxError);
     let loadOptions = this.getLoadOptions();
     loadOptions = {
       ...loadOptions,
       terrain: {
-        skirtHeight: this.state.isTiled ? meshMaxError * 2 : 0,
+        skirtHeight: this.state.isTiled ? effectiveMeshMaxError * 2 : 0,
         ...loadOptions == null ? void 0 : loadOptions.terrain,
         bounds,
-        meshMaxError,
+        meshMaxError: effectiveMeshMaxError,
         elevationDecoder
       }
     };
@@ -2733,9 +2850,10 @@ var TerrainLayer = class extends import_core13.CompositeLayer {
       topRight = [bbox.right, bbox.top];
     }
     const bounds = [bottomLeft[0], bottomLeft[1], topRight[0], topRight[1]];
+    const overlappedBounds = getOverlappedBounds(bounds, this.props.tileSize, viewport instanceof import_core13._GlobeViewport);
     const terrain = this.loadTerrain({
       elevationData: dataUrl,
-      bounds,
+      bounds: overlappedBounds,
       elevationDecoder,
       meshMaxError,
       signal
@@ -2747,6 +2865,7 @@ var TerrainLayer = class extends import_core13.CompositeLayer {
     return Promise.all([terrain, surface]);
   }
   renderSubLayers(props) {
+    var _a;
     const SubLayerClass = this.getSubLayerClass("mesh", import_mesh_layers3.SimpleMeshLayer);
     const { color, wireframe, material } = this.props;
     const { data } = props;
@@ -2754,12 +2873,17 @@ var TerrainLayer = class extends import_core13.CompositeLayer {
       return null;
     }
     const [mesh, texture] = data;
+    const { viewport } = this.context;
+    const isGlobe = viewport instanceof import_core13._GlobeViewport;
+    const boundingBox = (_a = mesh == null ? void 0 : mesh.header) == null ? void 0 : _a.boundingBox;
+    const hasLngLatBounds = boundingBox && boundingBox.every(([x, y]) => x >= -MAX_LONGITUDE && x <= MAX_LONGITUDE && y >= -MAX_LATITUDE && y <= MAX_LATITUDE);
+    const coordinateSystem = isGlobe && hasLngLatBounds ? import_core13.COORDINATE_SYSTEM.LNGLAT : import_core13.COORDINATE_SYSTEM.CARTESIAN;
     return new SubLayerClass(props, {
       data: DUMMY_DATA,
       mesh,
       texture,
       _instanced: false,
-      coordinateSystem: import_core13.COORDINATE_SYSTEM.CARTESIAN,
+      coordinateSystem,
       getPosition: (d) => [0, 0, 0],
       getColor: color,
       wireframe,