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

package/dist/dist.dev.js

@@ -14338,6 +14338,7 @@ var __exports__ = (() => {
     /* eslint-disable max-statements */
     async _loadData({
       getData,
+      getRequestPriority,
       requestScheduler,
       onLoad,
       onError
@@ -14346,9 +14347,7 @@ var __exports__ = (() => {
       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;
@@ -15224,6 +15223,9 @@ var __exports__ = (() => {
       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) {
@@ -15253,6 +15255,24 @@ var __exports__ = (() => {
       }
       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 dot8 = closest[0] * cx + closest[1] * cy + closest[2] * cz;
+      const magSq = closest[0] * closest[0] + closest[1] * closest[1] + closest[2] * closest[2];
+      return dot8 <= magSq;
+    }
     insideBounds([minX, minY, maxX, maxY]) {
       const scale12 = Math.pow(2, this.z);
       const extent = TILE_SIZE3 / scale12;
@@ -15284,7 +15304,7 @@ var __exports__ = (() => {
     }
   };
   function getOSMTileIndices(viewport, maxZ, zRange, bounds) {
-    const project = viewport instanceof import_core14._GlobeViewport && viewport.resolution ? (
+    const project = viewport instanceof import_core14._GlobeViewport ? (
       // eslint-disable-next-line @typescript-eslint/unbound-method
       viewport.projectPosition
     ) : null;
@@ -15603,6 +15623,9 @@ var __exports__ = (() => {
   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,
@@ -15854,6 +15877,81 @@ var __exports__ = (() => {
       }
       return false;
     }
+    _getRequestPriority(tile) {
+      if (!tile.isSelected && !tile.isVisible) {
+        return -1;
+      }
+      const distance4 = this._getTileDistancePriority(tile);
+      if (tile.isSelected) {
+        return SELECTED_TILE_PRIORITY + distance4;
+      }
+      return VISIBLE_TILE_PRIORITY + distance4;
+    }
+    _getTileDistancePriority(tile) {
+      const { width, height } = this._viewport || {};
+      if (!this._viewport || !width || !height) {
+        return 0;
+      }
+      try {
+        const points = this._getTileScreenCorners(tile.bbox);
+        const center2 = [width / 2, height / 2];
+        if (points.length === 4) {
+          if (this._isPointInPolygon(center2, points)) {
+            return 0;
+          }
+          const distance4 = points.reduce((minDistance, point, i) => {
+            const nextPoint = points[(i + 1) % points.length];
+            return Math.min(
+              minDistance,
+              this._getPointToSegmentDistanceSquared(center2, point, nextPoint)
+            );
+          }, Number.MAX_SAFE_INTEGER);
+          return Math.min(distance4, 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 = [];
@@ -15935,6 +16033,7 @@ var __exports__ = (() => {
       if (tile && needsReload) {
         tile.loadData({
           getData: this.opts.getTileData,
+          getRequestPriority: this._getRequestPriority.bind(this),
           requestScheduler: this._requestScheduler,
           onLoad: this.onTileLoad,
           onError: this.opts.onTileError
@@ -20356,11 +20455,10 @@ in vec3 normals;
 in vec3 colors;
 in vec2 texCoords;
 in vec4 uvRegions;
-in vec3 featureIdsPickingColors;
+in float rowIndexes;
 
 // Instance attributes
 in vec4 instanceColors;
-in vec3 instancePickingColors;
 in vec3 instanceModelMatrixCol0;
 in vec3 instanceModelMatrixCol1;
 in vec3 instanceModelMatrixCol2;
@@ -20386,9 +20484,9 @@ void main(void) {
   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);
@@ -20504,12 +20602,13 @@ void main(void) {
       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
           }
         });
       }
@@ -20594,17 +20693,9 @@ void main(void) {
         }
       );
     }
-    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) {
       super.finalizeState(context);
@@ -32686,6 +32777,10 @@ void main(void) {
 
   // src/terrain-layer/terrain-layer.ts
   var DUMMY_DATA = [1];
+  var TILE_OVERLAP_PIXELS = 1;
+  var MIN_TERRAIN_MESH_MAX_ERROR = 1;
+  var MAX_LATITUDE2 = 90;
+  var MAX_LONGITUDE = 180;
   var defaultProps13 = {
     ...TileLayer.defaultProps,
     // Image url that encodes height data
@@ -32721,6 +32816,31 @@ void main(void) {
     }
     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_LATITUDE2),
+      Math.min(overlappedBounds[2], MAX_LONGITUDE),
+      Math.min(overlappedBounds[3], MAX_LATITUDE2)
+    ];
+  }
+  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_core49.CompositeLayer {
     updateState({ props, oldProps }) {
       const elevationDataChanged = props.elevationData !== oldProps.elevationData;
@@ -32748,14 +32868,15 @@ void main(void) {
       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?.terrain,
           bounds,
-          meshMaxError,
+          meshMaxError: effectiveMeshMaxError,
           elevationDecoder
         }
       };
@@ -32780,9 +32901,14 @@ void main(void) {
         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_core49._GlobeViewport
+      );
       const terrain = this.loadTerrain({
         elevationData: dataUrl,
-        bounds,
+        bounds: overlappedBounds,
         elevationDecoder,
         meshMaxError,
         signal
@@ -32801,12 +32927,19 @@ void main(void) {
         return null;
       }
       const [mesh, texture] = data;
+      const { viewport } = this.context;
+      const isGlobe = viewport instanceof import_core49._GlobeViewport;
+      const boundingBox = mesh?.header?.boundingBox;
+      const hasLngLatBounds = boundingBox && boundingBox.every(
+        ([x, y]) => x >= -MAX_LONGITUDE && x <= MAX_LONGITUDE && y >= -MAX_LATITUDE2 && y <= MAX_LATITUDE2
+      );
+      const coordinateSystem = isGlobe && hasLngLatBounds ? import_core49.COORDINATE_SYSTEM.LNGLAT : import_core49.COORDINATE_SYSTEM.CARTESIAN;
       return new SubLayerClass(props, {
         data: DUMMY_DATA,
         mesh,
         texture,
         _instanced: false,
-        coordinateSystem: import_core49.COORDINATE_SYSTEM.CARTESIAN,
+        coordinateSystem,
         getPosition: (d2) => [0, 0, 0],
         getColor: color,
         wireframe,

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,