@deck.gl/extensions 9.3.7 → 9.4.0-alpha.2

package/dist/dist.dev.js

@@ -1683,11 +1683,278 @@ vec2 sqrt_fp64(vec2 a) {
 
 @group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;
 
+struct Fp64Bits {
+  sign: u32,
+  exponent: i32,
+  significand: vec2u,
+  isZero: bool,
+  isInf: bool,
+  isNan: bool,
+};
+
 fn fp64_nan(seed: f32) -> f32 {
   let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);
   return bitcast<f32>(nanBits);
 }
 
+fn fp64_u64_is_zero(value: vec2u) -> bool {
+  return value.x == 0u && value.y == 0u;
+}
+
+fn fp64_u64_compare(a: vec2u, b: vec2u) -> i32 {
+  if (a.x != b.x) {
+    return select(-1, 1, a.x > b.x);
+  }
+  if (a.y != b.y) {
+    return select(-1, 1, a.y > b.y);
+  }
+  return 0;
+}
+
+fn fp64_u64_add(a: vec2u, b: vec2u) -> vec2u {
+  let low = a.y + b.y;
+  let carry = select(0u, 1u, low < a.y);
+  return vec2u(a.x + b.x + carry, low);
+}
+
+fn fp64_u64_sub(a: vec2u, b: vec2u) -> vec2u {
+  let borrow = select(0u, 1u, a.y < b.y);
+  return vec2u(a.x - b.x - borrow, a.y - b.y);
+}
+
+fn fp64_u64_shift_left(value: vec2u, shift: u32) -> vec2u {
+  if (shift == 0u) {
+    return value;
+  }
+  if (shift < 32u) {
+    return vec2u((value.x << shift) | (value.y >> (32u - shift)), value.y << shift);
+  }
+  if (shift == 32u) {
+    return vec2u(value.y, 0u);
+  }
+  if (shift < 64u) {
+    return vec2u(value.y << (shift - 32u), 0u);
+  }
+  return vec2u(0u);
+}
+
+fn fp64_u64_shift_right(value: vec2u, shift: u32) -> vec2u {
+  if (shift == 0u) {
+    return value;
+  }
+  if (shift < 32u) {
+    return vec2u(value.x >> shift, (value.y >> shift) | (value.x << (32u - shift)));
+  }
+  if (shift == 32u) {
+    return vec2u(0u, value.x);
+  }
+  if (shift < 64u) {
+    return vec2u(0u, value.x >> (shift - 32u));
+  }
+  return vec2u(0u);
+}
+
+fn fp64_u64_get_bit(value: vec2u, bitIndex: u32) -> bool {
+  if (bitIndex >= 64u) {
+    return false;
+  }
+  if (bitIndex >= 32u) {
+    return ((value.x >> (bitIndex - 32u)) & 1u) != 0u;
+  }
+  return ((value.y >> bitIndex) & 1u) != 0u;
+}
+
+fn fp64_u64_has_bits_below(value: vec2u, bitCount: u32) -> bool {
+  if (bitCount == 0u) {
+    return false;
+  }
+  if (bitCount >= 64u) {
+    return !fp64_u64_is_zero(value);
+  }
+  if (bitCount > 32u) {
+    let highBitCount = bitCount - 32u;
+    let highMask = (1u << highBitCount) - 1u;
+    return value.y != 0u || (value.x & highMask) != 0u;
+  }
+  if (bitCount == 32u) {
+    return value.y != 0u;
+  }
+  let lowMask = (1u << bitCount) - 1u;
+  return (value.y & lowMask) != 0u;
+}
+
+fn fp64_u64_shift_right_sticky(value: vec2u, shift: u32) -> vec2u {
+  var shifted = fp64_u64_shift_right(value, shift);
+  if (fp64_u64_has_bits_below(value, shift)) {
+    shifted.y = shifted.y | 1u;
+  }
+  return shifted;
+}
+
+fn fp64_u64_count_leading_zeros(value: vec2u) -> u32 {
+  if (value.x != 0u) {
+    return countLeadingZeros(value.x);
+  }
+  return 32u + countLeadingZeros(value.y);
+}
+
+fn fp64_round_shift_right_to_u32(value: vec2u, shift: u32) -> u32 {
+  if (shift == 0u) {
+    return value.y;
+  }
+
+  let truncated = fp64_u64_shift_right(value, shift);
+  var rounded = truncated.y;
+  let guard = fp64_u64_get_bit(value, shift - 1u);
+  let hasTrailingBits = fp64_u64_has_bits_below(value, shift - 1u);
+  if (guard && (hasTrailingBits || (rounded & 1u) == 1u)) {
+    rounded = rounded + 1u;
+  }
+  return rounded;
+}
+
+fn fp64_make_f32_bits_from_u64(sign: u32, significand: vec2u, baseExponent: i32) -> u32 {
+  if (fp64_u64_is_zero(significand)) {
+    return sign << 31u;
+  }
+
+  let leadingZeros = fp64_u64_count_leading_zeros(significand);
+  let mostSignificantBit = 63u - leadingZeros;
+  var exponent = baseExponent + i32(mostSignificantBit);
+
+  if (exponent > 127) {
+    return (sign << 31u) | 0x7f800000u;
+  }
+
+  if (exponent >= -126) {
+    let shift = i32(mostSignificantBit) - 23;
+    var significand24: u32;
+    if (shift > 0) {
+      significand24 = fp64_round_shift_right_to_u32(significand, u32(shift));
+    } else {
+      significand24 = fp64_u64_shift_left(significand, u32(-shift)).y;
+    }
+
+    if (significand24 >= 0x1000000u) {
+      significand24 = significand24 >> 1u;
+      exponent = exponent + 1;
+      if (exponent > 127) {
+        return (sign << 31u) | 0x7f800000u;
+      }
+    }
+
+    return (sign << 31u) | (u32(exponent + 127) << 23u) | (significand24 & 0x7fffffu);
+  }
+
+  let scaleExponent = baseExponent + 149;
+  var mantissa: u32;
+  if (scaleExponent >= 0) {
+    mantissa = fp64_u64_shift_left(significand, u32(scaleExponent)).y;
+  } else {
+    mantissa = fp64_round_shift_right_to_u32(significand, u32(-scaleExponent));
+  }
+
+  if (mantissa >= 0x800000u) {
+    return (sign << 31u) | 0x00800000u;
+  }
+  return (sign << 31u) | mantissa;
+}
+
+fn fp64_decode_bits(bits: vec2u) -> Fp64Bits {
+  let sign = bits.x >> 31u;
+  let exponentBits = (bits.x >> 20u) & 0x7ffu;
+  let fractionHigh = bits.x & 0xfffffu;
+  let fractionLow = bits.y;
+  let fraction = vec2u(fractionHigh, fractionLow);
+
+  if (exponentBits == 0x7ffu) {
+    let isInf = fp64_u64_is_zero(fraction);
+    return Fp64Bits(sign, 0, vec2u(0u), false, isInf, !isInf);
+  }
+
+  if (exponentBits == 0u) {
+    let isZero = fp64_u64_is_zero(fraction);
+    return Fp64Bits(sign, -1022, fraction, isZero, false, false);
+  }
+
+  return Fp64Bits(sign, i32(exponentBits) - 1023, vec2u((1u << 20u) | fractionHigh, fractionLow), false, false, false);
+}
+
+fn fp64_finite_magnitude_compare(a: Fp64Bits, b: Fp64Bits) -> i32 {
+  if (a.exponent != b.exponent) {
+    return select(-1, 1, a.exponent > b.exponent);
+  }
+  return fp64_u64_compare(a.significand, b.significand);
+}
+
+fn fp64_add_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {
+  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);
+  let smallSignificand = fp64_u64_shift_right_sticky(
+    fp64_u64_shift_left(smaller.significand, 3u),
+    u32(larger.exponent - smaller.exponent)
+  );
+  let resultSignificand = fp64_u64_add(largeSignificand, smallSignificand);
+  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);
+}
+
+fn fp64_sub_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {
+  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);
+  let smallSignificand = fp64_u64_shift_right_sticky(
+    fp64_u64_shift_left(smaller.significand, 3u),
+    u32(larger.exponent - smaller.exponent)
+  );
+  let resultSignificand = fp64_u64_sub(largeSignificand, smallSignificand);
+  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);
+}
+
+// Subtract two raw binary64 values and round the exact result once to f32.
+// The input words are canonical high/low words: .x contains sign/exponent/high
+// fraction bits, and .y contains the low 32 fraction bits.
+fn sub_fp64u32_to_f32_bits(aBits: vec2u, bBits: vec2u) -> u32 {
+  let a = fp64_decode_bits(aBits);
+  let b = fp64_decode_bits(bBits);
+  let bSubtractionSign = b.sign ^ 1u;
+
+  if (a.isNan || b.isNan) {
+    return 0x7fc00000u;
+  }
+  if (a.isInf && b.isInf) {
+    if (a.sign == bSubtractionSign) {
+      return (a.sign << 31u) | 0x7f800000u;
+    }
+    return 0x7fc00000u;
+  }
+  if (a.isInf) {
+    return (a.sign << 31u) | 0x7f800000u;
+  }
+  if (b.isInf) {
+    return (bSubtractionSign << 31u) | 0x7f800000u;
+  }
+  if (a.isZero && b.isZero) {
+    return select(0u, 0x80000000u, a.sign == 1u && b.sign == 0u);
+  }
+
+  let magnitudeComparison = fp64_finite_magnitude_compare(a, b);
+  if (a.sign == bSubtractionSign) {
+    if (magnitudeComparison >= 0) {
+      return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, a, b);
+    }
+    return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, b, a);
+  }
+
+  if (magnitudeComparison == 0) {
+    return 0u;
+  }
+  if (magnitudeComparison > 0) {
+    return fp64_sub_aligned_magnitudes_to_f32_bits(a.sign, a, b);
+  }
+  return fp64_sub_aligned_magnitudes_to_f32_bits(bSubtractionSign, b, a);
+}
+
+fn sub_fp64u32_to_f32(aBits: vec2u, bBits: vec2u) -> f32 {
+  return bitcast<f32>(sub_fp64u32_to_f32_bits(aBits, bBits));
+}
+
 fn fp64_runtime_zero() -> f32 {
   return fp64arithmetic.ONE * 0.0;
 }
@@ -4113,6 +4380,20 @@ in vec2 mask_texCoords;
 
   // src/utils/projection-utils.ts
   var import_core19 = __toESM(require_core(), 1);
+  var MERCATOR_REFERENCE_VIEWPORT = new import_core19.WebMercatorViewport({
+    width: 1,
+    height: 1,
+    longitude: 0,
+    latitude: 0,
+    zoom: 0
+  });
+  function lngLatToMercatorCommon(lngLat) {
+    const [x, y] = MERCATOR_REFERENCE_VIEWPORT.projectPosition(lngLat);
+    return [x, y];
+  }
+  function getMercatorReferenceViewport(viewport) {
+    return viewport.isGeospatial ? MERCATOR_REFERENCE_VIEWPORT : viewport;
+  }
   function joinLayerBounds(layers, viewport) {
     const bounds = [Infinity, Infinity, -Infinity, -Infinity];
     for (const layer of layers) {
@@ -4138,11 +4419,11 @@ in vec2 mask_texCoords;
     if (bounds[2] <= bounds[0] || bounds[3] <= bounds[1]) {
       return null;
     }
-    const centerWorld = viewport.unprojectPosition([
+    const centerWorld = isGeospatial ? MERCATOR_REFERENCE_VIEWPORT.unprojectPosition([
       (bounds[0] + bounds[2]) / 2,
       (bounds[1] + bounds[3]) / 2,
       0
-    ]);
+    ]) : viewport.unprojectPosition([(bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2, 0]);
     let { width, height, zoom } = opts;
     if (zoom === void 0) {
       width = width - border * 2;
@@ -4483,10 +4764,10 @@ in vec2 mask_texCoords;
   MaskExtension.extensionName = "MaskExtension";
 
   // src/terrain/terrain-extension.ts
-  var import_core27 = __toESM(require_core(), 1);
+  var import_core29 = __toESM(require_core(), 1);
 
   // src/terrain/terrain-effect.ts
-  var import_core26 = __toESM(require_core(), 1);
+  var import_core28 = __toESM(require_core(), 1);
 
   // src/terrain/shader-module.ts
   var import_core23 = __toESM(require_core(), 1);
@@ -4519,12 +4800,22 @@ uniform sampler2D terrain_map;
   var terrainModule = {
     name: "terrain",
     dependencies: [import_core23.project],
-    // eslint-disable-next-line prefer-template
-    vs: uniformBlock5 + /* glsl */
-    "out vec3 commonPos;",
-    // eslint-disable-next-line prefer-template
-    fs: uniformBlock5 + /* glsl */
-    "in vec3 commonPos;",
+    vs: `${uniformBlock5}
+out vec3 commonPos;
+// In globe mode, absolute Mercator position for terrain FBO UV lookups
+out vec2 terrainMercPos;
+out float terrainHeight;
+
+vec2 terrain_globe_to_mercator(vec3 globePosition) {
+  float D = length(globePosition);
+  float sinLat = clamp(globePosition.z / D, -0.999998, 0.999998);
+  float x = atan(globePosition.x, -globePosition.y);
+  float y = atanh(sinLat);
+  return (vec2(x, y) + PI) * WORLD_SCALE;
+}
+`,
+    fs: `${uniformBlock5}in vec2 terrainMercPos;
+in float terrainHeight;`,
     inject: {
       "vs:#main-start": (
         /* glsl */
@@ -4539,19 +4830,35 @@ if (terrain.mode == TERRAIN_MODE_SKIP) {
         /* glsl */
         `
 commonPos = geometry.position.xyz;
+terrainHeight = commonPos.z + project.commonOrigin.z;
+if (project.projectionMode == PROJECTION_MODE_GLOBE) {
+  terrainMercPos = terrain_globe_to_mercator(commonPos);
+  terrainHeight = length(commonPos) - GLOBE_RADIUS;
+} else {
+  terrainMercPos = commonPos.xy;
+}
 if (terrain.mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
-  vec2 texCoords = (commonPos.xy - terrain.bounds.xy) / terrain.bounds.zw;
+  vec2 texCoords = (terrainMercPos - terrain.bounds.xy) / terrain.bounds.zw;
   position = vec4(texCoords * 2.0 - 1.0, 0.0, 1.0);
-  commonPos.z += project.commonOrigin.z;
 }
 if (terrain.mode == TERRAIN_MODE_USE_HEIGHT_MAP) {
   vec3 anchor = geometry.worldPosition;
   anchor.z = 0.0;
   vec3 anchorCommon = project_position(anchor);
-  vec2 texCoords = (anchorCommon.xy - terrain.bounds.xy) / terrain.bounds.zw;
+  vec2 anchorMercPos = project.projectionMode == PROJECTION_MODE_GLOBE
+    ? terrain_globe_to_mercator(anchorCommon)
+    : anchorCommon.xy;
+  vec2 texCoords = (anchorMercPos - terrain.bounds.xy) / terrain.bounds.zw;
   if (texCoords.x >= 0.0 && texCoords.y >= 0.0 && texCoords.x <= 1.0 && texCoords.y <= 1.0) {
     float terrainZ = texture(terrain_map, texCoords).r;
-    geometry.position.z += terrainZ;
+    if (project.projectionMode == PROJECTION_MODE_GLOBE) {
+      // Height map is written in Mercator common space (units = TILE_SIZE / EARTH_CIRCUMFERENCE / cos(lat))
+      // Convert to globe radial units (units = GLOBE_RADIUS / EARTH_RADIUS)
+      terrainZ *= cos(radians(geometry.worldPosition.y)) * PI;
+      geometry.position.xyz += normalize(geometry.position.xyz) * terrainZ;
+    } else {
+      geometry.position.z += terrainZ;
+    }
     position = project_common_position_to_clipspace(geometry.position);
   }
 }
@@ -4561,7 +4868,7 @@ if (terrain.mode == TERRAIN_MODE_USE_HEIGHT_MAP) {
         /* glsl */
         `
 if (terrain.mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
-  fragColor = vec4(commonPos.z, 0.0, 0.0, 1.0);
+  fragColor = vec4(terrainHeight, 0.0, 0.0, 1.0);
   return;
 }
     `
@@ -4570,7 +4877,7 @@ if (terrain.mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
         /* glsl */
         `
 if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_USE_COVER_ONLY)) {
-  vec2 texCoords = (commonPos.xy - terrain.bounds.xy) / terrain.bounds.zw;
+  vec2 texCoords = (terrainMercPos - terrain.bounds.xy) / terrain.bounds.zw;
   vec4 pixel = texture(terrain_map, texCoords);
   if (terrain.mode == TERRAIN_MODE_USE_COVER_ONLY) {
     color = pixel;
@@ -4627,7 +4934,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
         return {
           mode,
           terrain_map: sampler,
-          // Convert bounds to the common space, as [minX, minY, width, height]
+          // Convert bounds to common space, as [minX, minY, width, height]
           bounds: bounds ? [
             bounds[0] - commonOrigin[0],
             bounds[1] - commonOrigin[1],
@@ -4648,6 +4955,9 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
     }
   };
 
+  // src/terrain/terrain-cover.ts
+  var import_core24 = __toESM(require_core(), 1);
+
   // ../../node_modules/@luma.gl/webgl/dist/constants/webgl-constants.js
   var GLEnum;
   (function(GLEnum2) {
@@ -5398,8 +5708,8 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
         if (!this.targetBounds) {
           shouldRedraw = true;
           this.targetBounds = this.tile.boundingBox;
-          const bottomLeftCommon = viewport.projectPosition(this.targetBounds[0]);
-          const topRightCommon = viewport.projectPosition(this.targetBounds[1]);
+          const bottomLeftCommon = lngLatToMercatorCommon(this.targetBounds[0]);
+          const topRightCommon = lngLatToMercatorCommon(this.targetBounds[1]);
           this.targetBoundsCommon = [
             bottomLeftCommon[0],
             bottomLeftCommon[1],
@@ -5410,7 +5720,10 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
       } else if (this.targetBounds !== targetLayer.getBounds()) {
         shouldRedraw = true;
         this.targetBounds = targetLayer.getBounds();
-        this.targetBoundsCommon = joinLayerBounds([targetLayer], viewport);
+        this.targetBoundsCommon = joinLayerBounds(
+          [targetLayer],
+          getMercatorReferenceViewport(viewport)
+        );
       }
       if (!this.targetBoundsCommon) {
         return false;
@@ -5421,7 +5734,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
       } else {
         const oldZoom = this.renderViewport?.zoom;
         shouldRedraw = shouldRedraw || newZoom !== oldZoom;
-        const newBounds = 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;
@@ -5498,7 +5811,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
   }
 
   // src/terrain/terrain-pass.ts
-  var import_core24 = __toESM(require_core(), 1);
+  var import_core25 = __toESM(require_core(), 1);
   var TERRAIN_BLENDING = {
     blendColorOperation: "max",
     blendColorSrcFactor: "one",
@@ -5507,7 +5820,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
     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 = [];
@@ -5572,8 +5885,8 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
   };
 
   // src/terrain/terrain-picking-pass.ts
-  var import_core25 = __toESM(require_core(), 1);
-  var TerrainPickingPass = class extends import_core25._PickLayersPass {
+  var import_core26 = __toESM(require_core(), 1);
+  var TerrainPickingPass = class extends import_core26._PickLayersPass {
     constructor() {
       super(...arguments);
       /** Save layer index for use when drawing to terrain cover.
@@ -5649,6 +5962,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
   };
 
   // src/terrain/height-map-builder.ts
+  var import_core27 = __toESM(require_core(), 1);
   var MAP_MAX_SIZE = 2048;
   var HeightMapBuilder = class {
     constructor(device) {
@@ -5696,13 +6010,13 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
       if (layersChanged) {
         this.layers = layers;
         this.layersBounds = layers.map((layer) => layer.getBounds());
-        this.layersBoundsCommon = joinLayerBounds(layers, viewport);
+        this.layersBoundsCommon = joinLayerBounds(layers, getMercatorReferenceViewport(viewport));
       }
       const viewportChanged = !this.lastViewport || !viewport.equals(this.lastViewport);
       if (!this.layersBoundsCommon) {
         this.renderViewport = null;
       } else if (layersChanged || viewportChanged) {
-        const bounds = 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;
@@ -5712,17 +6026,16 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
         const scale2 = viewport.scale;
         const pixelWidth = (bounds[2] - bounds[0]) * scale2;
         const pixelHeight = (bounds[3] - bounds[1]) * scale2;
+        const centerMerc = viewport.isGeospatial ? lngLatToMercatorCommon([
+          viewport.longitude ?? 0,
+          viewport.latitude ?? 0
+        ]) : [viewport.center[0], viewport.center[1]];
         this.renderViewport = pixelWidth > 0 || pixelHeight > 0 ? makeViewport({
           // It's not important whether the geometry is visible in this viewport, because
           // vertices will not use the standard project_to_clipspace in the DRAW_TO_HEIGHT_MAP shader
           // However the viewport must have the same center and zoom as the screen viewport
           // So that projection uniforms used for calculating z are the same
-          bounds: [
-            viewport.center[0] - 1,
-            viewport.center[1] - 1,
-            viewport.center[0] + 1,
-            viewport.center[1] + 1
-          ],
+          bounds: [centerMerc[0] - 1, centerMerc[1] - 1, centerMerc[0] + 1, centerMerc[1] + 1],
           zoom: viewport.zoom,
           width: Math.min(pixelWidth, MAP_MAX_SIZE),
           height: Math.min(pixelHeight, MAP_MAX_SIZE),
@@ -5764,7 +6077,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
       if (HeightMapBuilder.isSupported(device)) {
         this.heightMap = new HeightMapBuilder(device);
       } else {
-        import_core26.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);
     }
@@ -5933,7 +6246,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
   var defaultProps8 = {
     terrainDrawMode: void 0
   };
-  var TerrainExtension = class extends import_core27.LayerExtension {
+  var TerrainExtension = class extends import_core29.LayerExtension {
     getShaders() {
       return {
         modules: [terrainModule]

package/dist/fill-style/shader-module.d.ts

@@ -35,7 +35,7 @@ export declare const patternShaders: {
             readonly name: "geometry";
             readonly source: "const SMOOTH_EDGE_RADIUS: f32 = 0.5;\n\nstruct VertexGeometry {\n  position: vec4<f32>,\n  worldPosition: vec3<f32>,\n  worldPositionAlt: vec3<f32>,\n  normal: vec3<f32>,\n  uv: vec2<f32>,\n  pickingColor: vec3<f32>,\n};\n\nvar<private> geometry_: VertexGeometry = VertexGeometry(\n  vec4<f32>(0.0, 0.0, 1.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec2<f32>(0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0)\n);\n\nstruct FragmentGeometry {\n  uv: vec2<f32>,\n};\n\nvar<private> fragmentGeometry: FragmentGeometry;\n\nfn smoothedge(edge: f32, x: f32) -> f32 {\n  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n";
             readonly vs: "#define SMOOTH_EDGE_RADIUS 0.5\n\nstruct VertexGeometry {\n  vec4 position;\n  vec3 worldPosition;\n  vec3 worldPositionAlt;\n  vec3 normal;\n  vec2 uv;\n  vec3 pickingColor;\n} geometry = VertexGeometry(\n  vec4(0.0, 0.0, 1.0, 0.0),\n  vec3(0.0),\n  vec3(0.0),\n  vec3(0.0),\n  vec2(0.0),\n  vec3(0.0)\n);\n";
-            readonly fs: "#define SMOOTH_EDGE_RADIUS 0.5\n\nstruct FragmentGeometry {\n  vec2 uv;\n} geometry;\n\nfloat smoothedge(float edge, float x) {\n  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n";
+            readonly fs: "#define SMOOTH_EDGE_RADIUS 0.5\n\nstruct FragmentGeometry {\n  vec2 uv;\n};\nFragmentGeometry geometry;\n\nfloat smoothedge(float edge, float x) {\n  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n";
         }];
         readonly source: string;
         readonly vs: string;