@deck.gl/extensions 9.4.0 → 9.4.1

package/dist/dist.dev.js

@@ -4272,52 +4272,38 @@ vec4 project_position_to_clipspace(
   var import_core7 = __toESM(require_core(), 1);
 
   // src/path-style/shaders.glsl.ts
-  var dashShaders = {
+  var pathStylePipelineShaders = {
     inject: {
-      "vs:#decl": `
-in vec2 instanceDashArrays;
-#ifdef HIGH_PRECISION_DASH
-// [distance from the start of the path, total length of the path], in common space.
-in vec2 instanceDashOffsets;
+      "vs:#main-end": `
+#ifdef PATH_STYLE_OFFSET
+  float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
+  float offsetDir = sign(instanceOffsets);
+  vPathPosition.x = (vPathPosition.x + offsetDir) * offsetWidth - offsetDir;
+  vPathPosition.y *= offsetWidth;
+  vPathLength *= offsetWidth;
+#ifdef DASH_ENABLED
+  vPathBounds *= offsetWidth;
+#endif
 #endif
-out vec2 vDashArray;
-out float vDashOffset;
-out float vDashPathLength;
 
-// Also declared in the fragment stage. The vertex stage needs dashAlignMode so that it can
-// reduce the dash phase modulo the same period the fragment stage will test against, and
-// dashUnits to scale the dash array into that period's units.
-layout(std140) uniform pathStyleUniforms {
-  float dashAlignMode;
-  bool dashGapPickable;
-  highp int dashUnits;
-} pathStyle;
-`,
-      "vs:#main-end": `
-// How many screen pixels one unit of vPathPosition.y covers. The two extrusion branches of
-// the path layer leave this in different units, and both differences have to be undone here
-// for a billboarded path to dash like a flat one.
-//
-// Flat paths extrude in common space, so \`width\` is in common units and a unit of
-// vPathPosition.y is width.x * project.scale pixels.
-//
-// Billboarded paths extrude in clip space, so \`width\` is already in pixels at this point -
-// the clip-space conversion happens inside getLineJoinOffset. That conversion also folds in
-// project.focalDistance, which scales the half-width the segment delta is divided by but not
-// the delta itself, so a unit of vPathPosition.y ends up focalDistance pixels wider than the
-// stroke it is supposed to be relative to.
-float dashWidthPixels = path.billboard
-  ? width.x * project.focalDistance
-  : width.x * project.scale;
+#ifdef DASH_ENABLED
+// DECKGL_FILTER_SIZE may have widened width for offset geometry. Dash coordinates are measured
+// against the pre-offset stroke, so recover its half-width before converting dash units.
+float strokeHalfWidth = width.x;
+#ifdef PATH_STYLE_OFFSET
+strokeHalfWidth /= offsetWidth;
+#endif
 
-// The actual half stroke width on screen, which is what 'widths' is relative to. It differs
-// from dashWidthPixels by exactly the spurious focalDistance above, so expressing 'widths'
-// as a ratio of the two corrects the billboard case onto the flat one - getDashArray is
-// documented relative to the stroke, and flat paths already honor that.
-float strokeHalfWidthPixels = path.billboard ? width.x : width.x * project.scale;
+// How many screen pixels one unit of vPathPosition.y covers. Flat paths extrude in common space;
+// billboarded paths extrude in clip space, whose conversion also includes focalDistance.
+float dashWidthPixels = path.billboard
+  ? strokeHalfWidth * project.focalDistance
+  : strokeHalfWidth * project.scale;
+float strokeHalfWidthPixels = path.billboard
+  ? strokeHalfWidth
+  : strokeHalfWidth * project.scale;
 
-// Everything reduces to "how many screen pixels is one dash unit", divided through by the
-// pixels per unit of vPathPosition.y, so the fragment shader needs no notion of units at all.
+// Convert every public dash unit to the half-width coordinate used by the fragment shader.
 // Keep the cases in sync with DASH_UNITS in path-style-extension.ts.
 float dashUnitPixels = strokeHalfWidthPixels;
 if (pathStyle.dashUnits == 1) {
@@ -4349,6 +4335,67 @@ vDashOffset = dashPeriod > 0.0 ? mod(dashOffsetAndLength.x, dashPeriod) : 0.0;
 vDashOffset = 0.0;
 vDashPathLength = 0.0;
 #endif
+#endif
+`,
+      "fs:#main-end": `
+#ifdef DASH_ENABLED
+  // PathLayer computes analytic-edge derivatives in its fragment body. A discard in
+  // #main-start can remove helper invocations and make those derivatives undefined, so all
+  // dash-related termination is deferred until the layer has completed that work.
+  #ifdef ANTIALIASING
+  if (inRoundedDashGap) {
+    // The rounded dash cap and PathLayer silhouette are two geometric constraints on the
+    // same fragment. Intersect their coverage instead of multiplying two edge ramps; at the
+    // cap/body shoulder both ramps are half covered and multiplication would create a dark
+    // quarter-covered notch. Keep the sub-pixel duty cycle separable from the path silhouette.
+    float pathCoverage = smoothedge(0.0, edgePixels);
+    float resolvedCapMultiplier =
+      min(pathCoverage, roundedDashResolvedCoverage) / max(pathCoverage, 1e-6);
+    dashCoverage = mix(
+      resolvedCapMultiplier,
+      roundedDashDutyCycle,
+      roundedDashSubPixelBlend
+    );
+  }
+  #endif
+  if (shouldDiscardDash) {
+    discard;
+  }
+  fragColor.a *= dashCoverage;
+#endif
+#ifdef PATH_STYLE_OFFSET
+#ifndef ANTIALIASING
+  // With analytic antialiasing, PathLayer evaluates this boundary using the remapped
+  // vPathPosition and retains the complete centered coverage ramp. The hard clip remains for
+  // the original non-AA path.
+  if (abs(vPathPosition.x) > 1.0) {
+    discard;
+  }
+#endif
+#endif
+`
+    }
+  };
+  var dashShaders = {
+    inject: {
+      "vs:#decl": `
+in vec2 instanceDashArrays;
+#ifdef HIGH_PRECISION_DASH
+// [distance from the start of the path, total length of the path], in common space.
+in vec2 instanceDashOffsets;
+#endif
+out vec2 vDashArray;
+out float vDashOffset;
+out float vDashPathLength;
+
+// Also declared in the fragment stage. The vertex stage needs dashAlignMode so that it can
+// reduce the dash phase modulo the same period the fragment stage will test against, and
+// dashUnits to scale the dash array into that period's units.
+layout(std140) uniform pathStyleUniforms {
+  float dashAlignMode;
+  bool dashGapPickable;
+  highp int dashUnits;
+} pathStyle;
 `,
       "fs:#decl": `
 layout(std140) uniform pathStyleUniforms {
@@ -4501,31 +4548,6 @@ float dashPatternCoverage(
     // Fully transparent fragments would still write depth and occlude whatever is behind.
     shouldDiscardDash = shouldDiscardDash || dashCoverage <= 0.0;
   }
-`,
-      "fs:#main-end": `
-  // PathLayer computes analytic-edge derivatives in its fragment body. A discard in
-  // #main-start can remove helper invocations and make those derivatives undefined, so all
-  // dash-related termination is deferred until the layer has completed that work.
-  #ifdef ANTIALIASING
-  if (inRoundedDashGap) {
-    // The rounded dash cap and PathLayer silhouette are two geometric constraints on the
-    // same fragment. Intersect their coverage instead of multiplying two edge ramps; at the
-    // cap/body shoulder both ramps are half covered and multiplication would create a dark
-    // quarter-covered notch. Keep the sub-pixel duty cycle separable from the path silhouette.
-    float pathCoverage = smoothedge(0.0, edgePixels);
-    float resolvedCapMultiplier =
-      min(pathCoverage, roundedDashResolvedCoverage) / max(pathCoverage, 1e-6);
-    dashCoverage = mix(
-      resolvedCapMultiplier,
-      roundedDashDutyCycle,
-      roundedDashSubPixelBlend
-    );
-  }
-  #endif
-  if (shouldDiscardDash) {
-    discard;
-  }
-  fragColor.a *= dashCoverage;
 `
     }
   };
@@ -4740,49 +4762,6 @@ in float instanceOffsets;
       "vs:DECKGL_FILTER_SIZE": `
   float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
   size *= offsetWidth;
-`,
-      "vs:#main-end": `
-  float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
-  float offsetDir = sign(instanceOffsets);
-  vPathPosition.x = (vPathPosition.x + offsetDir) * offsetWidth - offsetDir;
-  vPathPosition.y *= offsetWidth;
-  vPathLength *= offsetWidth;
-#ifdef DASH_ENABLED
-  // DECKGL_FILTER_SIZE above widened the stroke by offsetWidth, so these rescalings restore
-  // units of the original half-width. The dash block merges ahead of this one.
-  if (pathStyle.dashUnits != 0) {
-    // Absolute dash units must not inherit the artificial width used to build offset
-    // geometry. Relative 'widths' units intentionally remain tied to the original stroke.
-    vDashArray *= offsetWidth;
-  }
-  vPathBounds *= offsetWidth;
-#ifdef HIGH_PRECISION_DASH
-  vDashPathLength *= offsetWidth;
-  // The dash block reduced the CPU path offset modulo a period expressed in widened-width
-  // units. Multiplying that remainder cannot recover the original phase after wrapping, so
-  // redo the reduction with both the restored path offset and restored justified period.
-  float restoredDashUnitLength = vDashArray.x + vDashArray.y;
-  float restoredDashPeriod = pathStyle.dashAlignMode == 0.0
-    ? restoredDashUnitLength
-    : vDashPathLength /
-      max(round(vDashPathLength / max(restoredDashUnitLength, 0.0001)), 1.0);
-  vDashOffset = restoredDashPeriod > 0.0
-    ? mod(dashOffsetAndLength.x * offsetWidth, restoredDashPeriod)
-    : 0.0;
-#else
-  vDashOffset *= offsetWidth;
-#endif
-#endif
-`,
-      "fs:#main-end": `
-#ifndef ANTIALIASING
-  // With analytic antialiasing, PathLayer evaluates this boundary using the remapped
-  // vPathPosition and retains the complete centered coverage ramp. The hard clip remains for
-  // the original non-AA path.
-  if (abs(vPathPosition.x) > 1.0) {
-    discard;
-  }
-#endif
 `
     }
   };
@@ -4949,6 +4928,9 @@ in float instanceOffsets;
         return { modules: [pathStyle2] };
       }
       let result = {};
+      if (extension.opts.dash || extension.opts.offset) {
+        result = (0, import_core7._mergeShaders)(result, pathStylePipelineShaders);
+      }
       const defines = {};
       if (extension.opts.dash) {
         result = (0, import_core7._mergeShaders)(result, dashShaders);
@@ -6433,6 +6415,7 @@ in vec2 mask_texCoords;
 
   // src/utils/projection-utils.ts
   var import_core19 = __toESM(require_core(), 1);
+  var GLOBE_METERS_TO_COMMON = 256 / 6370972;
   var MERCATOR_REFERENCE_VIEWPORT = new import_core19.WebMercatorViewport({
     width: 1,
     height: 1,
@@ -6447,6 +6430,9 @@ in vec2 mask_texCoords;
   function getMercatorReferenceViewport(viewport) {
     return viewport.isGeospatial ? MERCATOR_REFERENCE_VIEWPORT : viewport;
   }
+  function isFlatViewport(viewport) {
+    return !(viewport instanceof import_core19._GlobeViewport);
+  }
   function joinLayerBounds(layers, viewport) {
     const bounds = [Infinity, Infinity, -Infinity, -Infinity];
     for (const layer of layers) {
@@ -6544,6 +6530,9 @@ in vec2 mask_texCoords;
     if (!layerBounds) {
       return [0, 0, 1, 1];
     }
+    if (!isFlatViewport(viewport)) {
+      return layerBounds;
+    }
     const viewportBounds = getViewportBounds(viewport, zRange);
     const paddedBounds = doubleBounds(viewportBounds);
     if (layerBounds[2] - layerBounds[0] <= paddedBounds[2] - paddedBounds[0] && layerBounds[3] - layerBounds[1] <= paddedBounds[3] - paddedBounds[1]) {

package/dist/index.cjs

@@ -1031,27 +1031,30 @@ var import_core6 = require("@deck.gl/core");
 var import_core7 = require("@math.gl/core");
 
 // dist/path-style/shaders.glsl.js
-var dashShaders = {
+var pathStylePipelineShaders = {
   inject: {
-    "vs:#decl": `
-in vec2 instanceDashArrays;
-#ifdef HIGH_PRECISION_DASH
-in vec2 instanceDashOffsets;
-#endif
-out vec2 vDashArray;
-out float vDashOffset;
-out float vDashPathLength;
-layout(std140) uniform pathStyleUniforms {
-float dashAlignMode;
-bool dashGapPickable;
-highp int dashUnits;
-} pathStyle;
-`,
     "vs:#main-end": `
+#ifdef PATH_STYLE_OFFSET
+float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
+float offsetDir = sign(instanceOffsets);
+vPathPosition.x = (vPathPosition.x + offsetDir) * offsetWidth - offsetDir;
+vPathPosition.y *= offsetWidth;
+vPathLength *= offsetWidth;
+#ifdef DASH_ENABLED
+vPathBounds *= offsetWidth;
+#endif
+#endif
+#ifdef DASH_ENABLED
+float strokeHalfWidth = width.x;
+#ifdef PATH_STYLE_OFFSET
+strokeHalfWidth /= offsetWidth;
+#endif
 float dashWidthPixels = path.billboard
-? width.x * project.focalDistance
-: width.x * project.scale;
-float strokeHalfWidthPixels = path.billboard ? width.x : width.x * project.scale;
+? strokeHalfWidth * project.focalDistance
+: strokeHalfWidth * project.scale;
+float strokeHalfWidthPixels = path.billboard
+? strokeHalfWidth
+: strokeHalfWidth * project.scale;
 float dashUnitPixels = strokeHalfWidthPixels;
 if (pathStyle.dashUnits == 1) {
 dashUnitPixels = 1.0;
@@ -1073,6 +1076,52 @@ vDashOffset = dashPeriod > 0.0 ? mod(dashOffsetAndLength.x, dashPeriod) : 0.0;
 vDashOffset = 0.0;
 vDashPathLength = 0.0;
 #endif
+#endif
+`,
+    "fs:#main-end": `
+#ifdef DASH_ENABLED
+#ifdef ANTIALIASING
+if (inRoundedDashGap) {
+float pathCoverage = smoothedge(0.0, edgePixels);
+float resolvedCapMultiplier =
+min(pathCoverage, roundedDashResolvedCoverage) / max(pathCoverage, 1e-6);
+dashCoverage = mix(
+resolvedCapMultiplier,
+roundedDashDutyCycle,
+roundedDashSubPixelBlend
+);
+}
+#endif
+if (shouldDiscardDash) {
+discard;
+}
+fragColor.a *= dashCoverage;
+#endif
+#ifdef PATH_STYLE_OFFSET
+#ifndef ANTIALIASING
+if (abs(vPathPosition.x) > 1.0) {
+discard;
+}
+#endif
+#endif
+`
+  }
+};
+var dashShaders = {
+  inject: {
+    "vs:#decl": `
+in vec2 instanceDashArrays;
+#ifdef HIGH_PRECISION_DASH
+in vec2 instanceDashOffsets;
+#endif
+out vec2 vDashArray;
+out float vDashOffset;
+out float vDashPathLength;
+layout(std140) uniform pathStyleUniforms {
+float dashAlignMode;
+bool dashGapPickable;
+highp int dashUnits;
+} pathStyle;
 `,
     "fs:#decl": `
 layout(std140) uniform pathStyleUniforms {
@@ -1174,24 +1223,6 @@ dashCoverage = mix(dashCoverage, roundedDutyCycle, subPixelBlend);
 dashCoverage = clamp(dashCoverage, 0.0, 1.0);
 shouldDiscardDash = shouldDiscardDash || dashCoverage <= 0.0;
 }
-`,
-    "fs:#main-end": `
-#ifdef ANTIALIASING
-if (inRoundedDashGap) {
-float pathCoverage = smoothedge(0.0, edgePixels);
-float resolvedCapMultiplier =
-min(pathCoverage, roundedDashResolvedCoverage) / max(pathCoverage, 1e-6);
-dashCoverage = mix(
-resolvedCapMultiplier,
-roundedDashDutyCycle,
-roundedDashSubPixelBlend
-);
-}
-#endif
-if (shouldDiscardDash) {
-discard;
-}
-fragColor.a *= dashCoverage;
 `
   }
 };
@@ -1385,39 +1416,6 @@ in float instanceOffsets;
     "vs:DECKGL_FILTER_SIZE": `
 float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
 size *= offsetWidth;
-`,
-    "vs:#main-end": `
-float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
-float offsetDir = sign(instanceOffsets);
-vPathPosition.x = (vPathPosition.x + offsetDir) * offsetWidth - offsetDir;
-vPathPosition.y *= offsetWidth;
-vPathLength *= offsetWidth;
-#ifdef DASH_ENABLED
-if (pathStyle.dashUnits != 0) {
-vDashArray *= offsetWidth;
-}
-vPathBounds *= offsetWidth;
-#ifdef HIGH_PRECISION_DASH
-vDashPathLength *= offsetWidth;
-float restoredDashUnitLength = vDashArray.x + vDashArray.y;
-float restoredDashPeriod = pathStyle.dashAlignMode == 0.0
-? restoredDashUnitLength
-: vDashPathLength /
-max(round(vDashPathLength / max(restoredDashUnitLength, 0.0001)), 1.0);
-vDashOffset = restoredDashPeriod > 0.0
-? mod(dashOffsetAndLength.x * offsetWidth, restoredDashPeriod)
-: 0.0;
-#else
-vDashOffset *= offsetWidth;
-#endif
-#endif
-`,
-    "fs:#main-end": `
-#ifndef ANTIALIASING
-if (abs(vPathPosition.x) > 1.0) {
-discard;
-}
-#endif
 `
   }
 };
@@ -1567,6 +1565,9 @@ var PathStyleExtension = class extends import_core6.LayerExtension {
       return { modules: [pathStyle2] };
     }
     let result = {};
+    if (extension.opts.dash || extension.opts.offset) {
+      result = (0, import_core6._mergeShaders)(result, pathStylePipelineShaders);
+    }
     const defines = {};
     if (extension.opts.dash) {
       result = (0, import_core6._mergeShaders)(result, dashShaders);
@@ -2849,7 +2850,7 @@ CollisionFilterExtension.extensionName = "CollisionFilterExtension";
 var collision_filter_extension_default = CollisionFilterExtension;
 
 // dist/mask/mask-extension.js
-var import_core21 = require("@deck.gl/core");
+var import_core22 = require("@deck.gl/core");
 
 // dist/mask/shader-module.js
 var import_core16 = require("@deck.gl/core");
@@ -2974,8 +2975,8 @@ var shader_module_default3 = {
 };
 
 // dist/mask/mask-effect.js
-var import_core19 = require("@deck.gl/core");
-var import_core20 = require("@math.gl/core");
+var import_core20 = require("@deck.gl/core");
+var import_core21 = require("@math.gl/core");
 
 // dist/mask/mask-pass.js
 var import_core17 = require("@deck.gl/core");
@@ -3033,6 +3034,8 @@ var MaskPass = class extends import_core17._LayersPass {
 
 // dist/utils/projection-utils.js
 var import_core18 = require("@deck.gl/core");
+var import_core19 = require("@math.gl/core");
+var GLOBE_METERS_TO_COMMON = 256 / 6370972;
 var MERCATOR_REFERENCE_VIEWPORT = new import_core18.WebMercatorViewport({
   width: 1,
   height: 1,
@@ -3047,6 +3050,9 @@ function lngLatToMercatorCommon(lngLat) {
 function getMercatorReferenceViewport(viewport) {
   return viewport.isGeospatial ? MERCATOR_REFERENCE_VIEWPORT : viewport;
 }
+function isFlatViewport(viewport) {
+  return !(viewport instanceof import_core18._GlobeViewport);
+}
 function joinLayerBounds(layers, viewport) {
   const bounds = [Infinity, Infinity, -Infinity, -Infinity];
   for (const layer of layers) {
@@ -3144,6 +3150,9 @@ function getRenderBounds(layerBounds, viewport, zRange) {
   if (!layerBounds) {
     return [0, 0, 1, 1];
   }
+  if (!isFlatViewport(viewport)) {
+    return layerBounds;
+  }
   const viewportBounds = getViewportBounds(viewport, zRange);
   const paddedBounds = doubleBounds(viewportBounds);
   if (layerBounds[2] - layerBounds[0] <= paddedBounds[2] - paddedBounds[0] && layerBounds[3] - layerBounds[1] <= paddedBounds[3] - paddedBounds[1]) {
@@ -3198,7 +3207,7 @@ var MaskEffect = class {
     const viewport = viewports[0];
     const viewportChanged = !this.lastViewport || !this.lastViewport.equals(viewport);
     if (viewport.resolution !== void 0) {
-      import_core19.log.warn("MaskExtension is not supported in GlobeView")();
+      import_core20.log.warn("MaskExtension is not supported in GlobeView")();
       return { didRender };
     }
     for (const maskId in channelMap) {
@@ -3241,7 +3250,7 @@ var MaskEffect = class {
       this.lastViewport = viewport;
       const layerBounds = joinLayerBounds(channelInfo.layers, viewport);
       channelInfo.bounds = layerBounds && getRenderBounds(layerBounds, viewport);
-      if (maskChanged || !(0, import_core20.equals)(channelInfo.bounds, oldChannelInfo.bounds)) {
+      if (maskChanged || !(0, import_core21.equals)(channelInfo.bounds, oldChannelInfo.bounds)) {
         const { maskPass, maskMap } = this;
         const maskViewport = layerBounds && makeViewport({
           bounds: channelInfo.bounds,
@@ -3292,7 +3301,7 @@ var MaskEffect = class {
       let channelInfo = channelMap[id];
       if (!channelInfo) {
         if (++channelCount > 4) {
-          import_core19.log.warn("Too many mask layers. The max supported is 4")();
+          import_core20.log.warn("Too many mask layers. The max supported is 4")();
           continue;
         }
         channelInfo = {
@@ -3353,7 +3362,7 @@ var defaultProps7 = {
   maskByInstance: void 0,
   maskInverted: false
 };
-var MaskExtension = class extends import_core21.LayerExtension {
+var MaskExtension = class extends import_core22.LayerExtension {
   initializeState() {
     var _a;
     (_a = this.context.deck) == null ? void 0 : _a._addDefaultEffect(new MaskEffect());
@@ -3381,8 +3390,8 @@ var MaskExtension = class extends import_core21.LayerExtension {
       maskProps.enabled = true;
       maskProps.channel = index;
       maskProps.inverted = maskInverted;
-      if (fromCoordinateSystem === import_core21.COORDINATE_SYSTEM.DEFAULT) {
-        fromCoordinateSystem = viewport.isGeospatial ? import_core21.COORDINATE_SYSTEM.LNGLAT : import_core21.COORDINATE_SYSTEM.CARTESIAN;
+      if (fromCoordinateSystem === import_core22.COORDINATE_SYSTEM.DEFAULT) {
+        fromCoordinateSystem = viewport.isGeospatial ? import_core22.COORDINATE_SYSTEM.LNGLAT : import_core22.COORDINATE_SYSTEM.CARTESIAN;
       }
       const opts = { modelMatrix: null, fromCoordinateOrigin, fromCoordinateSystem };
       const bl = this.projectPosition([bounds[0], bounds[1], 0], opts);
@@ -3390,7 +3399,7 @@ var MaskExtension = class extends import_core21.LayerExtension {
       maskProps.bounds = [bl[0], bl[1], tr[0], tr[1]];
     } else {
       if (maskId) {
-        import_core21.log.warn(`Could not find a mask layer with id: ${maskId}`)();
+        import_core22.log.warn(`Could not find a mask layer with id: ${maskId}`)();
       }
       maskProps.enabled = false;
     }
@@ -3402,13 +3411,13 @@ MaskExtension.extensionName = "MaskExtension";
 var mask_extension_default = MaskExtension;
 
 // dist/terrain/terrain-extension.js
-var import_core28 = require("@deck.gl/core");
+var import_core29 = require("@deck.gl/core");
 
 // dist/terrain/terrain-effect.js
-var import_core27 = require("@deck.gl/core");
+var import_core28 = require("@deck.gl/core");
 
 // dist/terrain/shader-module.js
-var import_core22 = require("@deck.gl/core");
+var import_core23 = require("@deck.gl/core");
 var TERRAIN_MODE = {
   NONE: 0,
   /** A terrain layer rendering encoded ground elevation into the height map */
@@ -3437,7 +3446,7 @@ uniform sampler2D terrain_map;
 );
 var terrainModule = {
   name: "terrain",
-  dependencies: [import_core22.project],
+  dependencies: [import_core23.project],
   vs: `${uniformBlock5}
 out vec3 commonPos;
 // In globe mode, absolute Mercator position for terrain FBO UV lookups
@@ -3535,7 +3544,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
     }
     if ("terrainSkipRender" in opts || "drawToTerrainHeightMap" in opts) {
       const { drawToTerrainHeightMap, heightMap, heightMapBounds, dummyHeightMap, terrainCover, useTerrainHeightMap, terrainSkipRender } = opts;
-      const projectUniforms = import_core22.project.getUniforms(opts.project);
+      const projectUniforms = import_core23.project.getUniforms(opts.project);
       const { commonOrigin } = projectUniforms;
       let mode = terrainSkipRender ? TERRAIN_MODE.SKIP : TERRAIN_MODE.NONE;
       let sampler = dummyHeightMap;
@@ -3586,7 +3595,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
 };
 
 // dist/terrain/terrain-cover.js
-var import_core23 = require("@deck.gl/core");
+var import_core24 = require("@deck.gl/core");
 
 // dist/terrain/utils.js
 var import_constants = require("@luma.gl/webgl/constants");
@@ -3703,7 +3712,7 @@ var TerrainCover = class {
     } else {
       const oldZoom = (_a = this.renderViewport) == null ? void 0 : _a.zoom;
       shouldRedraw = shouldRedraw || newZoom !== oldZoom;
-      const newBounds = viewport instanceof import_core23._GlobeViewport ? this.targetBoundsCommon : getRenderBounds(this.targetBoundsCommon, viewport);
+      const newBounds = viewport instanceof import_core24._GlobeViewport ? this.targetBoundsCommon : getRenderBounds(this.targetBoundsCommon, viewport);
       const oldBounds = this.bounds;
       shouldRedraw = shouldRedraw || !oldBounds || newBounds.some((x, i) => x !== oldBounds[i]);
       this.bounds = newBounds;
@@ -3780,7 +3789,7 @@ function intersect(b1, b2) {
 }
 
 // dist/terrain/terrain-pass.js
-var import_core24 = require("@deck.gl/core");
+var import_core25 = require("@deck.gl/core");
 var TERRAIN_BLENDING = {
   blendColorOperation: "max",
   blendColorSrcFactor: "one",
@@ -3789,7 +3798,7 @@ var TERRAIN_BLENDING = {
   blendAlphaSrcFactor: "one",
   blendAlphaDstFactor: "one"
 };
-var TerrainPass = class extends import_core24._LayersPass {
+var TerrainPass = class extends import_core25._LayersPass {
   getRenderableLayers(viewport, opts) {
     const { layers } = opts;
     const result = [];
@@ -3854,8 +3863,8 @@ var TerrainPass = class extends import_core24._LayersPass {
 };
 
 // dist/terrain/terrain-picking-pass.js
-var import_core25 = require("@deck.gl/core");
-var TerrainPickingPass = class extends import_core25._PickLayersPass {
+var import_core26 = require("@deck.gl/core");
+var TerrainPickingPass = class extends import_core26._PickLayersPass {
   constructor() {
     super(...arguments);
     this.drawParameters = {};
@@ -3926,7 +3935,7 @@ var TerrainPickingPass = class extends import_core25._PickLayersPass {
 };
 
 // dist/terrain/height-map-builder.js
-var import_core26 = require("@deck.gl/core");
+var import_core27 = require("@deck.gl/core");
 var MAP_MAX_SIZE = 2048;
 var HeightMapBuilder = class {
   static isSupported(device) {
@@ -3973,7 +3982,7 @@ var HeightMapBuilder = class {
     if (!this.layersBoundsCommon) {
       this.renderViewport = null;
     } else if (layersChanged || viewportChanged) {
-      const bounds = viewport instanceof import_core26._GlobeViewport ? this.layersBoundsCommon : getRenderBounds(this.layersBoundsCommon, viewport);
+      const bounds = viewport instanceof import_core27._GlobeViewport ? this.layersBoundsCommon : getRenderBounds(this.layersBoundsCommon, viewport);
       if (bounds[2] <= bounds[0] || bounds[3] <= bounds[1]) {
         this.renderViewport = null;
         return false;
@@ -4031,7 +4040,7 @@ var TerrainEffect = class {
     if (HeightMapBuilder.isSupported(device)) {
       this.heightMap = new HeightMapBuilder(device);
     } else {
-      import_core27.log.warn("Terrain offset mode is not supported by this browser")();
+      import_core28.log.warn("Terrain offset mode is not supported by this browser")();
     }
     deck._addDefaultShaderModule(terrainModule);
   }
@@ -4199,7 +4208,7 @@ var TerrainEffect = class {
 var defaultProps8 = {
   terrainDrawMode: void 0
 };
-var TerrainExtension = class extends import_core28.LayerExtension {
+var TerrainExtension = class extends import_core29.LayerExtension {
   getShaders() {
     return {
       modules: [terrainModule]