@deck.gl/extensions 8.9.0-beta.2 → 8.9.0-beta.4

package/dist/dist.dev.js

@@ -7,8 +7,8 @@ var deck = (() => {
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __commonJS = (cb, mod2) => function __require() {
-    return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __export = (target, all) => {
     for (var name in all)
@@ -22,12 +22,12 @@ var deck = (() => {
     }
     return to;
   };
-  var __reExport = (target, mod2, secondTarget) => (__copyProps(target, mod2, "default"), secondTarget && __copyProps(secondTarget, mod2, "default"));
-  var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
-    isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
-    mod2
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
   ));
-  var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
   var __publicField = (obj, key, value) => {
     __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
     return value;
@@ -52,13 +52,13 @@ var deck = (() => {
   __export(bundle_exports, {
     BrushingExtension: () => BrushingExtension,
     ClipExtension: () => ClipExtension,
-    CollideExtension: () => CollideExtension,
+    CollisionFilterExtension: () => CollisionFilterExtension,
     DataFilterExtension: () => DataFilterExtension,
     FillStyleExtension: () => FillStyleExtension,
     Fp64Extension: () => Fp64Extension,
     MaskExtension: () => MaskExtension,
     PathStyleExtension: () => PathStyleExtension,
-    TerrainExtension: () => TerrainExtension,
+    _TerrainExtension: () => TerrainExtension,
     project64: () => project64_default
   });
 
@@ -1117,7 +1117,7 @@ void main() {
     onFilteredItemsChange: {
       type: "function",
       value: null,
-      compare: false
+      optional: true
     },
     filterEnabled: true,
     filterRange: [-1, 1],
@@ -2121,36 +2121,36 @@ varying vec2 clip_commonPosition;
   __publicField(ClipExtension, "defaultProps", defaultProps5);
   __publicField(ClipExtension, "extensionName", "ClipExtension");
 
-  // src/collide/collide.ts
+  // src/collision-filter/collision-filter.ts
   var import_core26 = __toESM(require_core());
 
-  // src/collide/shader-module.ts
+  // src/collision-filter/shader-module.ts
   var import_core14 = __toESM(require_core());
   var vs3 = `
 #ifdef NON_INSTANCED_MODEL
-attribute float collidePriorities;
+attribute float collisionPriorities;
 #else
-attribute float instanceCollidePriorities;
+attribute float instanceCollisionPriorities;
 #endif
 
-uniform sampler2D collide_texture;
-uniform bool collide_sort;
-uniform bool collide_enabled;
+uniform sampler2D collision_texture;
+uniform bool collision_sort;
+uniform bool collision_enabled;
 
-vec2 collide_getCoords(vec4 position) {
-  vec4 collide_clipspace = project_common_position_to_clipspace(position);
-  return (1.0 + collide_clipspace.xy / collide_clipspace.w) / 2.0;
+vec2 collision_getCoords(vec4 position) {
+  vec4 collision_clipspace = project_common_position_to_clipspace(position);
+  return (1.0 + collision_clipspace.xy / collision_clipspace.w) / 2.0;
 }
 
-float collide_match(vec2 tex, vec3 pickingColor) {
-  vec4 collide_pickingColor = texture2D(collide_texture, tex);
-  float delta = dot(abs(collide_pickingColor.rgb - pickingColor), vec3(1.0));
+float collision_match(vec2 tex, vec3 pickingColor) {
+  vec4 collision_pickingColor = texture2D(collision_texture, tex);
+  float delta = dot(abs(collision_pickingColor.rgb - pickingColor), vec3(1.0));
   float e = 0.001;
   return step(delta, e);
 }
 
-float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
-  if (!collide_enabled) {
+float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
+  if (!collision_enabled) {
     return 1.0;
   }
 
@@ -2166,7 +2166,7 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
   for(int i = -N; i <= N; i++) {
     delta.x = -step.x * floatN;
     for(int j = -N; j <= N; j++) {
-      accumulator += collide_match(texCoords + delta, pickingColor);
+      accumulator += collision_match(texCoords + delta, pickingColor);
       delta.x += step.x;
     }
     delta.y += step.y;
@@ -2178,62 +2178,62 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
 `;
   var inject4 = {
     "vs:#decl": `
-  float collide_fade = 1.0;
+  float collision_fade = 1.0;
 `,
     "vs:DECKGL_FILTER_GL_POSITION": `
-  if (collide_sort) {
+  if (collision_sort) {
     #ifdef NON_INSTANCED_MODEL
-    float collidePriority = collidePriorities;
+    float collisionPriority = collisionPriorities;
     #else
-    float collidePriority = instanceCollidePriorities;
+    float collisionPriority = instanceCollisionPriorities;
     #endif
-    position.z = -0.001 * collidePriority * position.w; // Support range -1000 -> 1000
+    position.z = -0.001 * collisionPriority * position.w; // Support range -1000 -> 1000
   }
 
-  if (collide_enabled) {
-    vec4 collide_common_position = project_position(vec4(geometry.worldPosition, 1.0));
-    vec2 collide_texCoords = collide_getCoords(collide_common_position);
-    collide_fade = collide_isVisible(collide_texCoords, geometry.pickingColor / 255.0);
-    if (collide_fade < 0.0001) {
+  if (collision_enabled) {
+    vec4 collision_common_position = project_position(vec4(geometry.worldPosition, 1.0));
+    vec2 collision_texCoords = collision_getCoords(collision_common_position);
+    collision_fade = collision_isVisible(collision_texCoords, geometry.pickingColor / 255.0);
+    if (collision_fade < 0.0001) {
       position = vec4(0.);
     }
   }
   `,
     "vs:DECKGL_FILTER_COLOR": `
-  color.a *= collide_fade;
+  color.a *= collision_fade;
   `
   };
-  var getCollideUniforms = (opts, uniforms) => {
-    if (!opts || !("dummyCollideMap" in opts)) {
+  var getCollisionUniforms = (opts, uniforms) => {
+    if (!opts || !("dummyCollisionMap" in opts)) {
       return {};
     }
     const {
-      collideFBO,
-      drawToCollideMap,
-      dummyCollideMap
+      collisionFBO,
+      drawToCollisionMap,
+      dummyCollisionMap
     } = opts;
     return {
-      collide_sort: Boolean(drawToCollideMap),
-      collide_texture: !drawToCollideMap && collideFBO ? collideFBO : dummyCollideMap
+      collision_sort: Boolean(drawToCollisionMap),
+      collision_texture: !drawToCollisionMap && collisionFBO ? collisionFBO : dummyCollisionMap
     };
   };
   var shader_module_default2 = {
-    name: "collide",
+    name: "collision",
     dependencies: [import_core14.project],
     vs: vs3,
     inject: inject4,
-    getUniforms: getCollideUniforms
+    getUniforms: getCollisionUniforms
   };
 
-  // src/collide/collide-effect.ts
+  // src/collision-filter/collision-filter-effect.ts
   var import_core23 = __toESM(require_core2());
   var import_core25 = __toESM(require_core());
 
-  // src/collide/collide-pass.ts
+  // src/collision-filter/collision-filter-pass.ts
   var import_core15 = __toESM(require_core2());
   var import_core16 = __toESM(require_core());
-  var CollidePass = class extends import_core16._LayersPass {
-    renderCollideMap(target, options) {
+  var CollisionFilterPass = class extends import_core16._LayersPass {
+    renderCollisionMap(target, options) {
       const gl = this.gl;
       const padding = 1;
       return (0, import_core15.withParameters)(gl, {
@@ -2246,12 +2246,12 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
       }, () => this.render({
         ...options,
         target,
-        pass: "collide"
+        pass: "collision"
       }));
     }
     getModuleParameters() {
       return {
-        drawToCollideMap: true,
+        drawToCollisionMap: true,
         pickingActive: 1,
         pickingAttribute: false,
         lightSources: {}
@@ -2317,194 +2317,122 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
     }
   };
 
-  // src/mask/utils.ts
+  // src/utils/projection-utils.ts
   var import_core19 = __toESM(require_core());
-
-  // ../../node_modules/@math.gl/web-mercator/dist/esm/math-utils.js
-  function clamp2(x, min, max) {
-    return x < min ? min : x > max ? max : x;
-  }
-  function ieLog2(x) {
-    return Math.log(x) * Math.LOG2E;
-  }
-  var log2 = Math.log2 || ieLog2;
-
-  // ../../node_modules/@math.gl/web-mercator/dist/esm/assert.js
-  function assert(condition, message) {
-    if (!condition) {
-      throw new Error(message || "@math.gl/web-mercator: assertion failed.");
-    }
-  }
-
-  // ../../node_modules/@math.gl/web-mercator/dist/esm/web-mercator-utils.js
-  var PI = Math.PI;
-  var PI_4 = PI / 4;
-  var DEGREES_TO_RADIANS2 = PI / 180;
-  var RADIANS_TO_DEGREES2 = 180 / PI;
-  var TILE_SIZE = 512;
-  var MAX_LATITUDE = 85.051129;
-  function lngLatToWorld(lngLat) {
-    const [lng, lat] = lngLat;
-    assert(Number.isFinite(lng));
-    assert(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude");
-    const lambda2 = lng * DEGREES_TO_RADIANS2;
-    const phi2 = lat * DEGREES_TO_RADIANS2;
-    const x = TILE_SIZE * (lambda2 + PI) / (2 * PI);
-    const y = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI);
-    return [x, y];
-  }
-  function worldToLngLat(xy) {
-    const [x, y] = xy;
-    const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
-    const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
-    return [lambda2 * RADIANS_TO_DEGREES2, phi2 * RADIANS_TO_DEGREES2];
-  }
-
-  // ../../node_modules/@math.gl/web-mercator/dist/esm/fit-bounds.js
-  function fitBounds(options) {
-    const {
-      width,
-      height,
-      bounds,
-      minExtent = 0,
-      maxZoom = 24,
-      offset = [0, 0]
-    } = options;
-    const [[west, south], [east, north]] = bounds;
-    const padding = getPaddingObject(options.padding);
-    const nw = lngLatToWorld([west, clamp2(north, -MAX_LATITUDE, MAX_LATITUDE)]);
-    const se = lngLatToWorld([east, clamp2(south, -MAX_LATITUDE, MAX_LATITUDE)]);
-    const size = [Math.max(Math.abs(se[0] - nw[0]), minExtent), Math.max(Math.abs(se[1] - nw[1]), minExtent)];
-    const targetSize = [width - padding.left - padding.right - Math.abs(offset[0]) * 2, height - padding.top - padding.bottom - Math.abs(offset[1]) * 2];
-    assert(targetSize[0] > 0 && targetSize[1] > 0);
-    const scaleX = targetSize[0] / size[0];
-    const scaleY = targetSize[1] / size[1];
-    const offsetX = (padding.right - padding.left) / 2 / scaleX;
-    const offsetY = (padding.bottom - padding.top) / 2 / scaleY;
-    const center = [(se[0] + nw[0]) / 2 + offsetX, (se[1] + nw[1]) / 2 + offsetY];
-    const centerLngLat = worldToLngLat(center);
-    const zoom = Math.min(maxZoom, log2(Math.abs(Math.min(scaleX, scaleY))));
-    assert(Number.isFinite(zoom));
-    return {
-      longitude: centerLngLat[0],
-      latitude: centerLngLat[1],
-      zoom
-    };
-  }
-  function getPaddingObject(padding = 0) {
-    if (typeof padding === "number") {
-      return {
-        top: padding,
-        bottom: padding,
-        left: padding,
-        right: padding
-      };
-    }
-    assert(Number.isFinite(padding.top) && Number.isFinite(padding.bottom) && Number.isFinite(padding.left) && Number.isFinite(padding.right));
-    return padding;
-  }
-
-  // ../../node_modules/@math.gl/web-mercator/dist/esm/get-bounds.js
-  var DEGREES_TO_RADIANS3 = Math.PI / 180;
-
-  // src/mask/utils.ts
-  function getMaskBounds({
-    layers,
-    viewport
-  }) {
-    let bounds = null;
+  function joinLayerBounds(layers, viewport) {
+    const bounds = [Infinity, Infinity, -Infinity, -Infinity];
     for (const layer of layers) {
-      const subLayerBounds = layer.getBounds();
-      if (subLayerBounds) {
-        if (bounds) {
-          bounds[0] = Math.min(bounds[0], subLayerBounds[0][0]);
-          bounds[1] = Math.min(bounds[1], subLayerBounds[0][1]);
-          bounds[2] = Math.max(bounds[2], subLayerBounds[1][0]);
-          bounds[3] = Math.max(bounds[3], subLayerBounds[1][1]);
-        } else {
-          bounds = [subLayerBounds[0][0], subLayerBounds[0][1], subLayerBounds[1][0], subLayerBounds[1][1]];
-        }
+      const layerBounds = layer.getBounds();
+      if (layerBounds) {
+        const bottomLeftCommon = layer.projectPosition(layerBounds[0], {
+          viewport,
+          autoOffset: false
+        });
+        const topRightCommon = layer.projectPosition(layerBounds[1], {
+          viewport,
+          autoOffset: false
+        });
+        bounds[0] = Math.min(bounds[0], bottomLeftCommon[0]);
+        bounds[1] = Math.min(bounds[1], bottomLeftCommon[1]);
+        bounds[2] = Math.max(bounds[2], topRightCommon[0]);
+        bounds[3] = Math.max(bounds[3], topRightCommon[1]);
       }
     }
-    const viewportBounds = viewport.getBounds();
-    if (!bounds) {
-      return viewportBounds;
-    }
-    const paddedBounds = _doubleBounds(viewportBounds);
-    if (bounds[2] - bounds[0] < paddedBounds[2] - paddedBounds[0] || bounds[3] - bounds[1] < paddedBounds[3] - paddedBounds[1]) {
+    if (Number.isFinite(bounds[0])) {
       return bounds;
     }
-    bounds[0] = Math.max(bounds[0], paddedBounds[0]);
-    bounds[1] = Math.max(bounds[1], paddedBounds[1]);
-    bounds[2] = Math.min(bounds[2], paddedBounds[2]);
-    bounds[3] = Math.min(bounds[3], paddedBounds[3]);
-    return bounds;
+    return null;
   }
-  function getMaskViewport({
-    bounds,
-    viewport,
-    width,
-    height
-  }) {
+  var MAX_VIEWPORT_SIZE = 2048;
+  function makeViewport(opts) {
+    const {
+      bounds,
+      viewport,
+      border = 0
+    } = opts;
+    const {
+      isGeospatial
+    } = viewport;
     if (bounds[2] <= bounds[0] || bounds[3] <= bounds[1]) {
       return null;
     }
-    if (viewport.resolution !== void 0) {
-      import_core19.log.warn("MaskExtension is not supported in GlobeView")();
-      return null;
-    }
-    const padding = 1;
-    width -= padding * 2;
-    height -= padding * 2;
-    if (viewport.isGeospatial) {
-      const {
-        longitude,
-        latitude,
-        zoom
-      } = fitBounds({
-        width,
-        height,
-        bounds: [[bounds[0], bounds[1]], [bounds[2], bounds[3]]],
-        maxZoom: 20
-      });
-      return new import_core19.WebMercatorViewport({
-        longitude,
-        latitude,
-        zoom,
-        x: padding,
-        y: padding,
-        width,
-        height
-      });
-    }
-    const center = [(bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2, 0];
-    const scale = Math.min(
-      1048576,
-      width / (bounds[2] - bounds[0]),
-      height / (bounds[3] - bounds[1])
-    );
-    return new import_core19.OrthographicView({
-      x: padding,
-      y: padding
-    }).makeViewport({
+    const centerWorld = viewport.unprojectPosition([(bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2, 0]);
+    let {
       width,
       height,
-      viewState: {
-        target: center,
-        zoom: Math.log2(scale)
+      zoom
+    } = opts;
+    if (zoom === void 0) {
+      width = width - border * 2;
+      height = height - border * 2;
+      const scale = Math.min(width / (bounds[2] - bounds[0]), height / (bounds[3] - bounds[1]));
+      zoom = Math.min(Math.log2(scale), 20);
+    } else if (!width || !height) {
+      const scale = 2 ** zoom;
+      width = Math.round(Math.abs(bounds[2] - bounds[0]) * scale);
+      height = Math.round(Math.abs(bounds[3] - bounds[1]) * scale);
+      const maxSize = MAX_VIEWPORT_SIZE - border * 2;
+      if (width > maxSize || height > maxSize) {
+        const r = maxSize / Math.max(width, height);
+        width = Math.round(width * r);
+        height = Math.round(height * r);
+        zoom += Math.log2(r);
       }
+    }
+    return isGeospatial ? new import_core19.WebMercatorViewport({
+      x: border,
+      y: border,
+      width,
+      height,
+      longitude: centerWorld[0],
+      latitude: centerWorld[1],
+      zoom,
+      orthographic: true
+    }) : new import_core19.OrthographicViewport({
+      x: border,
+      y: border,
+      width,
+      height,
+      target: centerWorld,
+      zoom,
+      flipY: false
     });
   }
-  function _doubleBounds(bounds) {
-    const size = {
-      x: bounds[2] - bounds[0],
-      y: bounds[3] - bounds[1]
-    };
-    const center = {
-      x: bounds[0] + 0.5 * size.x,
-      y: bounds[1] + 0.5 * size.y
-    };
-    return [center.x - size.x, center.y - size.y, center.x + size.x, center.y + size.y];
+  function getViewportBounds(viewport, zRange) {
+    let viewportBoundsWorld;
+    if (zRange && zRange.length === 2) {
+      const [minZ, maxZ] = zRange;
+      const bounds0 = viewport.getBounds({
+        z: minZ
+      });
+      const bounds1 = viewport.getBounds({
+        z: maxZ
+      });
+      viewportBoundsWorld = [Math.min(bounds0[0], bounds1[0]), Math.min(bounds0[1], bounds1[1]), Math.max(bounds0[2], bounds1[2]), Math.max(bounds0[3], bounds1[3])];
+    } else {
+      viewportBoundsWorld = viewport.getBounds();
+    }
+    const viewportBottomLeftCommon = viewport.projectPosition(viewportBoundsWorld.slice(0, 2));
+    const viewportTopRightCommon = viewport.projectPosition(viewportBoundsWorld.slice(2, 4));
+    return [viewportBottomLeftCommon[0], viewportBottomLeftCommon[1], viewportTopRightCommon[0], viewportTopRightCommon[1]];
+  }
+  function getRenderBounds(layerBounds, viewport, zRange) {
+    if (!layerBounds) {
+      return [0, 0, 1, 1];
+    }
+    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]) {
+      return layerBounds;
+    }
+    return [Math.max(layerBounds[0], paddedBounds[0]), Math.max(layerBounds[1], paddedBounds[1]), Math.min(layerBounds[2], paddedBounds[2]), Math.min(layerBounds[3], paddedBounds[3])];
+  }
+  function doubleBounds(bounds) {
+    const dx = bounds[2] - bounds[0];
+    const dy = bounds[3] - bounds[1];
+    const centerX = (bounds[0] + bounds[2]) / 2;
+    const centerY = (bounds[1] + bounds[3]) / 2;
+    return [centerX - dx, centerY - dy, centerX + dx, centerY + dy];
   }
 
   // src/mask/mask-effect.ts
@@ -2553,6 +2481,12 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
       const channelMap = this._sortMaskChannels(maskLayers);
       const viewport = viewports[0];
       const viewportChanged = !this.lastViewport || !this.lastViewport.equals(viewport);
+      if (viewport.resolution !== void 0) {
+        import_core20.log.warn("MaskExtension is not supported in GlobeView")();
+        return {
+          didRender
+        };
+      }
       for (const maskId in channelMap) {
         const result = this._renderChannel(channelMap[maskId], {
           layerFilter,
@@ -2579,26 +2513,25 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
       if (!oldChannelInfo) {
         return didRender;
       }
-      const maskChanged = channelInfo === oldChannelInfo || oldChannelInfo.layers.length !== channelInfo.layers.length || channelInfo.layerBounds.some((b, i) => b !== oldChannelInfo.layerBounds[i]);
+      const maskChanged = channelInfo === oldChannelInfo || channelInfo.layers.length !== oldChannelInfo.layers.length || channelInfo.layers.some((layer, i) => layer !== oldChannelInfo.layers[i] || layer.props.transitions) || channelInfo.layerBounds.some((b, i) => b !== oldChannelInfo.layerBounds[i]);
       channelInfo.bounds = oldChannelInfo.bounds;
       channelInfo.maskBounds = oldChannelInfo.maskBounds;
       this.channels[channelInfo.index] = channelInfo;
       if (maskChanged || viewportChanged) {
         this.lastViewport = viewport;
-        channelInfo.bounds = getMaskBounds({
-          layers: channelInfo.layers,
-          viewport
-        });
+        const layerBounds = joinLayerBounds(channelInfo.layers, viewport);
+        channelInfo.bounds = layerBounds && getRenderBounds(layerBounds, viewport);
         if (maskChanged || !equals(channelInfo.bounds, oldChannelInfo.bounds)) {
           const {
             maskPass,
             maskMap
           } = this;
-          const maskViewport = getMaskViewport({
+          const maskViewport = layerBounds && makeViewport({
             bounds: channelInfo.bounds,
             viewport,
             width: maskMap.width,
-            height: maskMap.height
+            height: maskMap.height,
+            border: 1
           });
           channelInfo.maskBounds = maskViewport ? maskViewport.getBounds() : [0, 0, 1, 1];
           maskPass.render({
@@ -2687,15 +2620,15 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
     }
   };
 
-  // src/collide/collide-effect.ts
+  // src/collision-filter/collision-filter-effect.ts
   var DOWNSCALE = 2;
-  var CollideEffect = class {
-    id = "collide-effect";
+  var CollisionFilterEffect = class {
+    id = "collision-filter-effect";
     props = null;
     useInPicking = true;
     order = 1;
     channels = {};
-    collideFBOs = {};
+    collisionFBOs = {};
     preRender(gl, {
       effects: allEffects,
       layers,
@@ -2706,8 +2639,8 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
       isPicking,
       preRenderStats = {}
     }) {
-      if (!this.dummyCollideMap) {
-        this.dummyCollideMap = new import_core23.Texture2D(gl, {
+      if (!this.dummyCollisionMap) {
+        this.dummyCollisionMap = new import_core23.Texture2D(gl, {
           width: 1,
           height: 1
         });
@@ -2715,32 +2648,32 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
       if (isPicking) {
         return;
       }
-      const collideLayers = layers.filter(
+      const collisionLayers = layers.filter(
         ({
           props: {
             visible,
-            collideEnabled
+            collisionEnabled
           }
-        }) => visible && collideEnabled
+        }) => visible && collisionEnabled
       );
-      if (collideLayers.length === 0) {
+      if (collisionLayers.length === 0) {
         this.channels = {};
         return;
       }
-      if (!this.collidePass) {
-        this.collidePass = new CollidePass(gl, {
-          id: "default-collide"
+      if (!this.collisionFilterPass) {
+        this.collisionFilterPass = new CollisionFilterPass(gl, {
+          id: "default-collision-filter"
         });
       }
       const effects = allEffects?.filter((e) => e.constructor === MaskEffect);
       const maskEffectRendered = preRenderStats["mask-effect"]?.didRender;
-      const channels = this._groupByCollideGroup(gl, collideLayers);
+      const channels = this._groupByCollisionGroup(gl, collisionLayers);
       const viewport = viewports[0];
       const viewportChanged = !this.lastViewport || !this.lastViewport.equals(viewport) || maskEffectRendered;
-      for (const collideGroup in channels) {
-        const collideFBO = this.collideFBOs[collideGroup];
-        const renderInfo = channels[collideGroup];
-        collideFBO.resize({
+      for (const collisionGroup in channels) {
+        const collisionFBO = this.collisionFBOs[collisionGroup];
+        const renderInfo = channels[collisionGroup];
+        collisionFBO.resize({
           width: gl.canvas.width / DOWNSCALE,
           height: gl.canvas.height / DOWNSCALE
         });
@@ -2763,19 +2696,19 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
       viewportChanged
     }) {
       const {
-        collideGroup
+        collisionGroup
       } = renderInfo;
-      const oldRenderInfo = this.channels[collideGroup];
+      const oldRenderInfo = this.channels[collisionGroup];
       if (!oldRenderInfo) {
         return;
       }
-      const needsRender = viewportChanged || renderInfo === oldRenderInfo || !(0, import_core25._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 0) || renderInfo.layerBounds.some((b, i) => !equals(b, oldRenderInfo.layerBounds[i]));
-      this.channels[collideGroup] = renderInfo;
+      const needsRender = viewportChanged || renderInfo === oldRenderInfo || !(0, import_core25._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 1) || renderInfo.layerBounds.some((b, i) => !equals(b, oldRenderInfo.layerBounds[i])) || renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || renderInfo.layers.some((layer) => layer.props.transitions);
+      this.channels[collisionGroup] = renderInfo;
       if (needsRender) {
         this.lastViewport = viewport;
-        const collideFBO = this.collideFBOs[collideGroup];
-        this.collidePass.renderCollideMap(collideFBO, {
-          pass: "collide",
+        const collisionFBO = this.collisionFBOs[collisionGroup];
+        this.collisionFilterPass.renderCollisionMap(collisionFBO, {
+          pass: "collision-filter",
           isPicking: true,
           layers: renderInfo.layers,
           effects,
@@ -2784,76 +2717,80 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
           onViewportActive,
           views,
           moduleParameters: {
-            dummyCollideMap: this.dummyCollideMap,
-            devicePixelRatio: (0, import_core23.cssToDeviceRatio)(collideFBO.gl) / DOWNSCALE
+            dummyCollisionMap: this.dummyCollisionMap,
+            devicePixelRatio: (0, import_core23.cssToDeviceRatio)(collisionFBO.gl) / DOWNSCALE
           }
         });
       }
     }
-    _groupByCollideGroup(gl, collideLayers) {
+    _groupByCollisionGroup(gl, collisionLayers) {
       const channelMap = {};
-      for (const layer of collideLayers) {
+      for (const layer of collisionLayers) {
         const {
-          collideGroup
+          collisionGroup
         } = layer.props;
-        let channelInfo = channelMap[collideGroup];
+        let channelInfo = channelMap[collisionGroup];
         if (!channelInfo) {
           channelInfo = {
-            collideGroup,
+            collisionGroup,
             layers: [],
-            layerBounds: []
+            layerBounds: [],
+            allLayersLoaded: true
           };
-          channelMap[collideGroup] = channelInfo;
+          channelMap[collisionGroup] = channelInfo;
         }
         channelInfo.layers.push(layer);
         channelInfo.layerBounds.push(layer.getBounds());
+        if (!layer.isLoaded) {
+          channelInfo.allLayersLoaded = false;
+        }
       }
-      for (const collideGroup of Object.keys(channelMap)) {
-        if (!this.collideFBOs[collideGroup]) {
-          this.createFBO(gl, collideGroup);
+      for (const collisionGroup of Object.keys(channelMap)) {
+        if (!this.collisionFBOs[collisionGroup]) {
+          this.createFBO(gl, collisionGroup);
         }
-        if (!this.channels[collideGroup]) {
-          this.channels[collideGroup] = channelMap[collideGroup];
+        if (!this.channels[collisionGroup]) {
+          this.channels[collisionGroup] = channelMap[collisionGroup];
         }
       }
-      for (const collideGroup of Object.keys(this.collideFBOs)) {
-        if (!channelMap[collideGroup]) {
-          this.destroyFBO(collideGroup);
+      for (const collisionGroup of Object.keys(this.collisionFBOs)) {
+        if (!channelMap[collisionGroup]) {
+          this.destroyFBO(collisionGroup);
         }
       }
       return channelMap;
     }
     getModuleParameters(layer) {
       const {
-        collideGroup
+        collisionGroup
       } = layer.props;
       const {
-        collideFBOs,
-        dummyCollideMap
+        collisionFBOs,
+        dummyCollisionMap
       } = this;
       return {
-        collideFBO: collideFBOs[collideGroup],
-        dummyCollideMap
+        collisionFBO: collisionFBOs[collisionGroup],
+        dummyCollisionMap
       };
     }
     cleanup() {
-      if (this.dummyCollideMap) {
-        this.dummyCollideMap.delete();
-        this.dummyCollideMap = void 0;
+      if (this.dummyCollisionMap) {
+        this.dummyCollisionMap.delete();
+        this.dummyCollisionMap = void 0;
       }
       this.channels = {};
-      for (const collideGroup of Object.keys(this.collideFBOs)) {
-        this.destroyFBO(collideGroup);
+      for (const collisionGroup of Object.keys(this.collisionFBOs)) {
+        this.destroyFBO(collisionGroup);
       }
-      this.collideFBOs = {};
+      this.collisionFBOs = {};
       this.lastViewport = void 0;
     }
-    createFBO(gl, collideGroup) {
+    createFBO(gl, collisionGroup) {
       const {
         width,
         height
       } = gl.canvas;
-      const collideMap = new import_core23.Texture2D(gl, {
+      const collisionMap = new import_core23.Texture2D(gl, {
         width,
         height,
         parameters: {
@@ -2868,40 +2805,40 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
         width,
         height
       });
-      this.collideFBOs[collideGroup] = new import_core23.Framebuffer(gl, {
-        id: `Collide-${collideGroup}`,
+      this.collisionFBOs[collisionGroup] = new import_core23.Framebuffer(gl, {
+        id: `Collision-${collisionGroup}`,
         width,
         height,
         attachments: {
-          [gl.COLOR_ATTACHMENT0]: collideMap,
+          [gl.COLOR_ATTACHMENT0]: collisionMap,
           [gl.DEPTH_ATTACHMENT]: depthBuffer
         }
       });
     }
-    destroyFBO(collideGroup) {
-      const fbo = this.collideFBOs[collideGroup];
+    destroyFBO(collisionGroup) {
+      const fbo = this.collisionFBOs[collisionGroup];
       for (const attachment of Object.values(fbo.attachments)) {
         attachment.delete();
       }
       fbo.delete();
-      delete this.collideFBOs[collideGroup];
+      delete this.collisionFBOs[collisionGroup];
     }
   };
 
-  // src/collide/collide.ts
+  // src/collision-filter/collision-filter.ts
   var defaultProps6 = {
-    getCollidePriority: {
+    getCollisionPriority: {
       type: "accessor",
       value: 0
     },
-    collideEnabled: true,
-    collideGroup: {
+    collisionEnabled: true,
+    collisionGroup: {
       type: "string",
       value: "default"
     },
-    collideTestProps: {}
+    collisionTestProps: {}
   };
-  var CollideExtension = class extends import_core26.LayerExtension {
+  var CollisionFilterExtension = class extends import_core26.LayerExtension {
     getShaders() {
       return {
         modules: [shader_module_default2]
@@ -2913,33 +2850,33 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
       moduleParameters
     }) {
       const {
-        collideEnabled
+        collisionEnabled
       } = this.props;
       const {
-        collideFBO,
-        drawToCollideMap
+        collisionFBO,
+        drawToCollisionMap
       } = moduleParameters;
-      const enabled = collideEnabled && Boolean(collideFBO);
-      uniforms.collide_enabled = enabled;
-      if (drawToCollideMap) {
-        this.props = this.clone(this.props.collideTestProps).props;
+      const enabled = collisionEnabled && Boolean(collisionFBO);
+      uniforms.collision_enabled = enabled;
+      if (drawToCollisionMap) {
+        this.props = this.clone(this.props.collisionTestProps).props;
       }
     }
     initializeState(context, extension) {
       if (this.getAttributeManager() === null) {
         return;
       }
-      this.context.deck?._addDefaultEffect(new CollideEffect());
+      this.context.deck?._addDefaultEffect(new CollisionFilterEffect());
       const attributeManager = this.getAttributeManager();
       attributeManager.add({
-        collidePriorities: {
+        collisionPriorities: {
           size: 1,
-          accessor: "getCollidePriority",
+          accessor: "getCollisionPriority",
           shaderAttributes: {
-            collidePriorities: {
+            collisionPriorities: {
               divisor: 0
             },
-            instanceCollidePriorities: {
+            instanceCollisionPriorities: {
               divisor: 1
             }
           }
@@ -2947,11 +2884,11 @@ float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
       });
     }
     getNeedsPickingBuffer() {
-      return this.props.collideEnabled;
+      return this.props.collisionEnabled;
     }
   };
-  __publicField(CollideExtension, "defaultProps", defaultProps6);
-  __publicField(CollideExtension, "extensionName", "CollideExtension");
+  __publicField(CollisionFilterExtension, "defaultProps", defaultProps6);
+  __publicField(CollisionFilterExtension, "extensionName", "CollisionFilterExtension");
 
   // src/mask/mask.ts
   var import_core28 = __toESM(require_core());
@@ -3109,11 +3046,11 @@ varying vec2 mask_texCoords;
   __publicField(MaskExtension, "extensionName", "MaskExtension");
 
   // src/terrain/terrain.ts
-  var import_core39 = __toESM(require_core());
+  var import_core38 = __toESM(require_core());
 
   // src/terrain/terrain-effect.ts
-  var import_core37 = __toESM(require_core2());
-  var import_core38 = __toESM(require_core());
+  var import_core36 = __toESM(require_core2());
+  var import_core37 = __toESM(require_core());
 
   // src/terrain/shader-module.ts
   var import_core29 = __toESM(require_core());
@@ -3258,122 +3195,6 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
     });
   }
 
-  // src/common/projection-utils.ts
-  var import_core31 = __toESM(require_core());
-  function joinLayerBounds(layers, viewport) {
-    const bounds = [Infinity, Infinity, -Infinity, -Infinity];
-    for (const layer of layers) {
-      const layerBounds = layer.getBounds();
-      if (layerBounds) {
-        const bottomLeftCommon = layer.projectPosition(layerBounds[0], {
-          viewport,
-          autoOffset: false
-        });
-        const topRightCommon = layer.projectPosition(layerBounds[1], {
-          viewport,
-          autoOffset: false
-        });
-        bounds[0] = Math.min(bounds[0], bottomLeftCommon[0]);
-        bounds[1] = Math.min(bounds[1], bottomLeftCommon[1]);
-        bounds[2] = Math.max(bounds[2], topRightCommon[0]);
-        bounds[3] = Math.max(bounds[3], topRightCommon[1]);
-      }
-    }
-    if (Number.isFinite(bounds[0])) {
-      return bounds;
-    }
-    return null;
-  }
-  var MAX_VIEWPORT_SIZE = 2048;
-  function makeViewport(opts) {
-    const {
-      bounds,
-      viewport,
-      border = 0
-    } = opts;
-    const {
-      isGeospatial
-    } = viewport;
-    if (bounds[2] <= bounds[0] || bounds[3] <= bounds[1]) {
-      return null;
-    }
-    const centerWorld = viewport.unprojectPosition([(bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2, 0]);
-    const maxSize = MAX_VIEWPORT_SIZE - border * 2;
-    let {
-      width,
-      height,
-      zoom
-    } = opts;
-    if (zoom === void 0) {
-      const scale = Math.min(width / (bounds[2] - bounds[0]), height / (bounds[3] - bounds[1]));
-      zoom = Math.min(Math.log2(scale), 20);
-    } else if (!width || !height) {
-      const scale = 2 ** zoom;
-      width = Math.round(Math.abs(bounds[2] - bounds[0]) * scale);
-      height = Math.round(Math.abs(bounds[3] - bounds[1]) * scale);
-      if (width > maxSize || height > maxSize) {
-        const r = maxSize / Math.max(width, height);
-        width = Math.round(width * r);
-        height = Math.round(height * r);
-        zoom += Math.log2(r);
-      }
-    }
-    return isGeospatial ? new import_core31.WebMercatorViewport({
-      x: border,
-      y: border,
-      width,
-      height,
-      longitude: centerWorld[0],
-      latitude: centerWorld[1],
-      zoom,
-      orthographic: true
-    }) : new import_core31.OrthographicViewport({
-      x: border,
-      y: border,
-      width,
-      height,
-      target: centerWorld,
-      zoom,
-      flipY: false
-    });
-  }
-  function getViewportBounds(viewport, zRange) {
-    let viewportBoundsWorld;
-    if (zRange && zRange.length === 2) {
-      const [minZ, maxZ] = zRange;
-      const bounds0 = viewport.getBounds({
-        z: minZ
-      });
-      const bounds1 = viewport.getBounds({
-        z: maxZ
-      });
-      viewportBoundsWorld = [Math.min(bounds0[0], bounds1[0]), Math.min(bounds0[1], bounds1[1]), Math.max(bounds0[2], bounds1[2]), Math.max(bounds0[3], bounds1[3])];
-    } else {
-      viewportBoundsWorld = viewport.getBounds();
-    }
-    const viewportBottomLeftCommon = viewport.projectPosition(viewportBoundsWorld.slice(0, 2));
-    const viewportTopRightCommon = viewport.projectPosition(viewportBoundsWorld.slice(2, 4));
-    return [viewportBottomLeftCommon[0], viewportBottomLeftCommon[1], viewportTopRightCommon[0], viewportTopRightCommon[1]];
-  }
-  function getRenderBounds(layerBounds, viewport, zRange) {
-    if (!layerBounds) {
-      return [0, 0, 1, 1];
-    }
-    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]) {
-      return layerBounds;
-    }
-    return [Math.max(layerBounds[0], paddedBounds[0]), Math.max(layerBounds[1], paddedBounds[1]), Math.min(layerBounds[2], paddedBounds[2]), Math.min(layerBounds[3], paddedBounds[3])];
-  }
-  function doubleBounds(bounds) {
-    const dx = bounds[2] - bounds[0];
-    const dy = bounds[3] - bounds[1];
-    const centerX = (bounds[0] + bounds[2]) / 2;
-    const centerY = (bounds[1] + bounds[3]) / 2;
-    return [centerX - dx, centerY - dy, centerX + dx, centerY + dy];
-  }
-
   // src/terrain/terrain-cover.ts
   var TerrainCover = class {
     isDirty = true;
@@ -3537,9 +3358,9 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
   }
 
   // src/terrain/terrain-pass.ts
-  var import_core32 = __toESM(require_core2());
-  var import_core33 = __toESM(require_core());
-  var TerrainPass = class extends import_core33._LayersPass {
+  var import_core31 = __toESM(require_core2());
+  var import_core32 = __toESM(require_core());
+  var TerrainPass = class extends import_core32._LayersPass {
     getRenderableLayers(viewport, opts) {
       const {
         layers
@@ -3561,7 +3382,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         return;
       }
       target.resize(viewport);
-      (0, import_core32.withParameters)(this.gl, {
+      (0, import_core31.withParameters)(this.gl, {
         clearColor: [0, 0, 0, 0],
         blend: true,
         blendFunc: [esm_default.ONE, esm_default.ONE],
@@ -3584,7 +3405,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
       }
       const layers = terrainCover.filterLayers(opts.layers);
       target.resize(viewport);
-      (0, import_core32.withParameters)(this.gl, {
+      (0, import_core31.withParameters)(this.gl, {
         depthTest: false
       }, () => this.render({
         ...opts,
@@ -3598,9 +3419,9 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
   };
 
   // src/terrain/terrain-picking-pass.ts
-  var import_core34 = __toESM(require_core());
-  var import_core35 = __toESM(require_core2());
-  var TerrainPickingPass = class extends import_core34._PickLayersPass {
+  var import_core33 = __toESM(require_core());
+  var import_core34 = __toESM(require_core2());
+  var TerrainPickingPass = class extends import_core33._PickLayersPass {
     drawParameters = {};
     getRenderableLayers(viewport, opts) {
       const {
@@ -3631,7 +3452,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         layers.unshift(terrainLayer);
       }
       target.resize(viewport);
-      (0, import_core35.withParameters)(this.gl, {
+      (0, import_core34.withParameters)(this.gl, {
         depthTest: false
       }, () => this.render({
         ...opts,
@@ -3656,7 +3477,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
   };
 
   // src/terrain/height-map-builder.ts
-  var import_core36 = __toESM(require_core2());
+  var import_core35 = __toESM(require_core2());
   var MAP_MAX_SIZE = 2048;
   var HeightMapBuilder = class {
     renderViewport = null;
@@ -3666,7 +3487,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
     layersBoundsCommon = null;
     lastViewport = null;
     static isSupported(gl) {
-      return import_core36.Framebuffer.isSupported(gl, {
+      return import_core35.Framebuffer.isSupported(gl, {
         colorBufferFloat: true
       });
     }
@@ -3733,7 +3554,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
     isDrapingEnabled = false;
     terrainCovers = /* @__PURE__ */ new Map();
     initialize(gl) {
-      this.dummyHeightMap = new import_core37.Texture2D(gl, {
+      this.dummyHeightMap = new import_core36.Texture2D(gl, {
         width: 1,
         height: 1,
         data: new Uint8Array([0, 0, 0, 0])
@@ -3747,9 +3568,9 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
       if (HeightMapBuilder.isSupported(gl)) {
         this.heightMap = new HeightMapBuilder(gl);
       } else {
-        import_core38.log.warn("Terrain offset mode is not supported by this browser")();
+        import_core37.log.warn("Terrain offset mode is not supported by this browser")();
       }
-      import_core37.ProgramManager.getDefaultProgramManager(gl).addDefaultModule(terrainModule);
+      import_core36.ProgramManager.getDefaultProgramManager(gl).addDefaultModule(terrainModule);
     }
     preRender(gl, opts) {
       if (!this.dummyHeightMap) {
@@ -3779,25 +3600,25 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         return;
       }
       if (!isPicking) {
-        const offsetLayers = layers.filter((l) => l.state.terrainFittingMode === "offset");
+        const offsetLayers = layers.filter((l) => l.state.terrainDrawMode === "offset");
         if (offsetLayers.length > 0) {
           this._updateHeightMap(terrainLayers, viewport, opts);
         }
       }
-      const drapeLayers = layers.filter((l) => l.state.terrainFittingMode === "drape");
+      const drapeLayers = layers.filter((l) => l.state.terrainDrawMode === "drape");
       this._updateTerrainCovers(terrainLayers, drapeLayers, viewport, opts);
     }
     getModuleParameters(layer) {
       const {
-        terrainFittingMode
+        terrainDrawMode
       } = layer.state;
       return {
         heightMap: this.heightMap?.getRenderFramebuffer(),
         heightMapBounds: this.heightMap?.bounds,
         dummyHeightMap: this.dummyHeightMap,
         terrainCover: this.isDrapingEnabled ? this.terrainCovers.get(layer.id) : null,
-        useTerrainHeightMap: terrainFittingMode === "offset",
-        terrainSkipRender: terrainFittingMode === "drape" || !layer.props.operation.includes("draw")
+        useTerrainHeightMap: terrainDrawMode === "offset",
+        terrainSkipRender: terrainDrawMode === "drape" || !layer.props.operation.includes("draw")
       };
     }
     cleanup() {
@@ -3900,9 +3721,9 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
 
   // src/terrain/terrain.ts
   var defaultProps8 = {
-    terrainFittingMode: void 0
+    terrainDrawMode: void 0
   };
-  var TerrainExtension = class extends import_core39.LayerExtension {
+  var TerrainExtension = class extends import_core38.LayerExtension {
     getShaders() {
       return {
         modules: [terrainModule]
@@ -3916,25 +3737,25 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         props,
         oldProps
       } = params;
-      if (this.state.terrainFittingMode && props.terrainFittingMode === oldProps.terrainFittingMode && props.extruded === oldProps.extruded) {
+      if (this.state.terrainDrawMode && props.terrainDrawMode === oldProps.terrainDrawMode && props.extruded === oldProps.extruded) {
         return;
       }
       let {
-        terrainFittingMode
+        terrainDrawMode
       } = props;
-      if (!terrainFittingMode) {
+      if (!terrainDrawMode) {
         const is3d = this.props.extruded;
         const attributes = this.getAttributeManager()?.attributes;
         const hasAnchor = attributes && "instancePositions" in attributes;
-        terrainFittingMode = is3d || hasAnchor ? "offset" : "drape";
+        terrainDrawMode = is3d || hasAnchor ? "offset" : "drape";
       }
       this.setState({
-        terrainFittingMode
+        terrainDrawMode
       });
     }
     onNeedsRedraw() {
       const state = this.state;
-      if (state.terrainFittingMode === "drape") {
+      if (state.terrainDrawMode === "drape") {
         state.terrainCoverNeedsRedraw = true;
       }
     }