@cesium/engine 2.1.0 → 2.2.0

package/Source/Scene/ResourceCache.js

@@ -69,20 +69,17 @@ ResourceCache.get = function (cacheKey) {
 };
 
 /**
- * Loads a resource and adds it to the cache.
+ * Adds it to the cache.
  *
- * @param {object} options Object with the following properties:
- * @param {ResourceLoader} options.resourceLoader The resource.
+ * @param {ResourceLoader} resourceLoader The resource.
+ * @returns {ResourceLoader} The resource.
  *
- * @exception {DeveloperError} Resource with this cacheKey is already in the cach
+ * @exception {DeveloperError} Resource with this cacheKey is already in the cache
  * @private
  */
-ResourceCache.load = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const resourceLoader = options.resourceLoader;
-
+ResourceCache.add = function (resourceLoader) {
   //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("options.resourceLoader", resourceLoader);
+  Check.typeOf.object("resourceLoader", resourceLoader);
   //>>includeEnd('debug');
 
   const cacheKey = resourceLoader.cacheKey;
@@ -99,7 +96,7 @@ ResourceCache.load = function (options) {
 
   ResourceCache.cacheEntries[cacheKey] = new CacheEntry(resourceLoader);
 
-  resourceLoader.load();
+  return resourceLoader;
 };
 
 /**
@@ -136,18 +133,18 @@ ResourceCache.unload = function (resourceLoader) {
 };
 
 /**
- * Loads a schema from the cache.
+ * Gets an existing schema loader from the cache, or creates a new loader if one does not already exist.
  *
  * @param {object} options Object with the following properties:
  * @param {object} [options.schema] An object that explicitly defines a schema JSON. Mutually exclusive with options.resource.
  * @param {Resource} [options.resource] The {@link Resource} pointing to the schema JSON. Mutually exclusive with options.schema.
  *
- * @returns {MetadataSchemaLoader} The schema resource.
+ * @returns {MetadataSchemaLoader} The cached schema resource.
  *
  * @exception {DeveloperError} One of options.schema and options.resource must be defined.
  * @private
  */
-ResourceCache.loadSchema = function (options) {
+ResourceCache.getSchemaLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const schema = options.schema;
   const resource = options.resource;
@@ -176,25 +173,21 @@ ResourceCache.loadSchema = function (options) {
     cacheKey: cacheKey,
   });
 
-  ResourceCache.load({
-    resourceLoader: schemaLoader,
-  });
-
-  return schemaLoader;
+  return ResourceCache.add(schemaLoader);
 };
 
 /**
- * Load an embedded buffer from the cache.
+ * Gets an existing embedded buffer loader from the cache, or creates a new loader if one does not already exist.
  *
  * @param {object} options Object with the following properties:
  * @param {Resource} options.parentResource The {@link Resource} containing the embedded buffer.
  * @param {number} options.bufferId A unique identifier of the embedded buffer within the parent resource.
  * @param {Uint8Array} [options.typedArray] The typed array containing the embedded buffer contents.
  *
- * @returns {BufferLoader} The buffer loader.
+ * @returns {BufferLoader} The cached buffer loader.
  * @private
  */
-ResourceCache.loadEmbeddedBuffer = function (options) {
+ResourceCache.getEmbeddedBufferLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const parentResource = options.parentResource;
   const bufferId = options.bufferId;
@@ -224,23 +217,19 @@ ResourceCache.loadEmbeddedBuffer = function (options) {
     cacheKey: cacheKey,
   });
 
-  ResourceCache.load({
-    resourceLoader: bufferLoader,
-  });
-
-  return bufferLoader;
+  return ResourceCache.add(bufferLoader);
 };
 
 /**
- * Loads an external buffer from the cache.
+ * Gets an existing external buffer from loader the cache, or creates a new loader if one does not already exist.
  *
  * @param {object} options Object with the following properties:
  * @param {Resource} options.resource The {@link Resource} pointing to the external buffer.
  *
- * @returns {BufferLoader} The buffer loader.
+ * @returns {BufferLoader} The cached buffer loader.
  * @private
  */
-ResourceCache.loadExternalBuffer = function (options) {
+ResourceCache.getExternalBufferLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const resource = options.resource;
 
@@ -262,15 +251,11 @@ ResourceCache.loadExternalBuffer = function (options) {
     cacheKey: cacheKey,
   });
 
-  ResourceCache.load({
-    resourceLoader: bufferLoader,
-  });
-
-  return bufferLoader;
+  return ResourceCache.add(bufferLoader);
 };
 
 /**
- * Loads a glTF JSON from the cache.
+ * Gets an existing glTF JSON loader from the cache, or creates a new loader if one does not already exist.
  *
  * @param {object} options Object with the following properties:
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
@@ -278,10 +263,10 @@ ResourceCache.loadExternalBuffer = function (options) {
  * @param {Uint8Array} [options.typedArray] The typed array containing the glTF contents.
  * @param {object} [options.gltfJson] The parsed glTF JSON contents.
  *
- * @returns {GltfJsonLoader} The glTF JSON.
+ * @returns {GltfJsonLoader} The cached glTF JSON loader.
  * @private
  */
-ResourceCache.loadGltfJson = function (options) {
+ResourceCache.getGltfJsonLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const gltfResource = options.gltfResource;
   const baseResource = options.baseResource;
@@ -311,15 +296,11 @@ ResourceCache.loadGltfJson = function (options) {
     cacheKey: cacheKey,
   });
 
-  ResourceCache.load({
-    resourceLoader: gltfJsonLoader,
-  });
-
-  return gltfJsonLoader;
+  return ResourceCache.add(gltfJsonLoader);
 };
 
 /**
- * Loads a glTF buffer view from the cache.
+ * Gets an existing glTF buffer view from the cache, or creates a new loader if one does not already exist.
  *
  * @param {object} options Object with the following properties:
  * @param {object} options.gltf The glTF JSON.
@@ -327,10 +308,10 @@ ResourceCache.loadGltfJson = function (options) {
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
  *
- * @returns {GltfBufferViewLoader} The buffer view loader.
+ * @returns {GltfBufferViewLoader} The cached buffer view loader.
  * @private
  */
-ResourceCache.loadBufferView = function (options) {
+ResourceCache.getBufferViewLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const gltf = options.gltf;
   const bufferViewId = options.bufferViewId;
@@ -365,15 +346,11 @@ ResourceCache.loadBufferView = function (options) {
     cacheKey: cacheKey,
   });
 
-  ResourceCache.load({
-    resourceLoader: bufferViewLoader,
-  });
-
-  return bufferViewLoader;
+  return ResourceCache.add(bufferViewLoader);
 };
 
 /**
- * Loads Draco data from the cache.
+ * Gets an existing Draco data from the cache, or creates a new loader if one does not already exist.
  *
  * @param {object} options Object with the following properties:
  * @param {object} options.gltf The glTF JSON.
@@ -381,10 +358,10 @@ ResourceCache.loadBufferView = function (options) {
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
  *
- * @returns {GltfDracoLoader} The Draco loader.
+ * @returns {GltfDracoLoader} The cached Draco loader.
  * @private
  */
-ResourceCache.loadDraco = function (options) {
+ResourceCache.getDracoLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const gltf = options.gltf;
   const draco = options.draco;
@@ -419,15 +396,11 @@ ResourceCache.loadDraco = function (options) {
     cacheKey: cacheKey,
   });
 
-  ResourceCache.load({
-    resourceLoader: dracoLoader,
-  });
-
-  return dracoLoader;
+  return ResourceCache.add(dracoLoader);
 };
 
 /**
- * Loads a glTF vertex buffer from the cache.
+ * Gets an existing glTF vertex buffer from the cache, or creates a new loader if one does not already exist.
  *
  * @param {object} options Object with the following properties:
  * @param {object} options.gltf The glTF JSON.
@@ -446,10 +419,10 @@ ResourceCache.loadDraco = function (options) {
  * @exception {DeveloperError} When options.draco is defined options.attributeSemantic must also be defined.
  * @exception {DeveloperError} When options.draco is defined options.accessorId must also be defined.
  *
- * @returns {GltfVertexBufferLoader} The vertex buffer loader.
+ * @returns {GltfVertexBufferLoader} The cached vertex buffer loader.
  * @private
  */
-ResourceCache.loadVertexBuffer = function (options) {
+ResourceCache.getVertexBufferLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const gltf = options.gltf;
   const gltfResource = options.gltfResource;
@@ -539,18 +512,7 @@ ResourceCache.loadVertexBuffer = function (options) {
     loadTypedArray: loadTypedArray,
   });
 
-  ResourceCache.load({
-    resourceLoader: vertexBufferLoader,
-  });
-
-  const promise = ResourceCache.statistics.addGeometryLoader(
-    vertexBufferLoader
-  );
-
-  // Needed for unit testing
-  ResourceCache.cacheEntries[cacheKey]._statisticsPromise = promise;
-
-  return vertexBufferLoader;
+  return ResourceCache.add(vertexBufferLoader);
 };
 
 function hasDracoCompression(draco, semantic) {
@@ -562,7 +524,7 @@ function hasDracoCompression(draco, semantic) {
 }
 
 /**
- * Loads a glTF index buffer from the cache.
+ * Gets an existing glTF index buffer from the cache, or creates a new loader if one does not already exist.
  *
  * @param {object} options Object with the following properties:
  * @param {object} options.gltf The glTF JSON.
@@ -574,10 +536,10 @@ function hasDracoCompression(draco, semantic) {
  * @param {boolean} [options.asynchronous=true] Determines if WebGL resource creation will be spread out over several frames or block until all WebGL resources are created.
  * @param {boolean} [options.loadBuffer=false] Load index buffer as a GPU index buffer.
  * @param {boolean} [options.loadTypedArray=false] Load index buffer as a typed array.
- * @returns {GltfIndexBufferLoader} The index buffer loader.
+ * @returns {GltfIndexBufferLoader} The cached index buffer loader.
  * @private
  */
-ResourceCache.loadIndexBuffer = function (options) {
+ResourceCache.getIndexBufferLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const gltf = options.gltf;
   const accessorId = options.accessorId;
@@ -631,19 +593,11 @@ ResourceCache.loadIndexBuffer = function (options) {
     loadTypedArray: loadTypedArray,
   });
 
-  ResourceCache.load({
-    resourceLoader: indexBufferLoader,
-  });
-  const promise = ResourceCache.statistics.addGeometryLoader(indexBufferLoader);
-
-  // Needed for unit testing
-  ResourceCache.cacheEntries[cacheKey]._statisticsPromise = promise;
-
-  return indexBufferLoader;
+  return ResourceCache.add(indexBufferLoader);
 };
 
 /**
- * Loads a glTF image from the cache.
+ * Gets an existing glTF image from the cache, or creates a new loader if one does not already exist.
  *
  * @param {object} options Object with the following properties:
  * @param {object} options.gltf The glTF JSON.
@@ -651,10 +605,10 @@ ResourceCache.loadIndexBuffer = function (options) {
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
  *
- * @returns {GltfImageLoader} The image loader.
+ * @returns {GltfImageLoader} The cached image loader.
  * @private
  */
-ResourceCache.loadImage = function (options) {
+ResourceCache.getImageLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const gltf = options.gltf;
   const imageId = options.imageId;
@@ -689,15 +643,11 @@ ResourceCache.loadImage = function (options) {
     cacheKey: cacheKey,
   });
 
-  ResourceCache.load({
-    resourceLoader: imageLoader,
-  });
-
-  return imageLoader;
+  return ResourceCache.add(imageLoader);
 };
 
 /**
- * Loads a glTF texture from the cache.
+ * Gets an existing glTF texture from the cache, or creates a new loader if one does not already exist.
  *
  * @param {object} options Object with the following properties:
  * @param {object} options.gltf The glTF JSON.
@@ -708,10 +658,10 @@ ResourceCache.loadImage = function (options) {
  * @param {FrameState} options.frameState The frame state.
  * @param {boolean} [options.asynchronous=true] Determines if WebGL resource creation will be spread out over several frames or block until all WebGL resources are created.
  *
- * @returns {GltfTextureLoader} The texture loader.
+ * @returns {GltfTextureLoader} The cached texture loader.
  * @private
  */
-ResourceCache.loadTexture = function (options) {
+ResourceCache.getTextureLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const gltf = options.gltf;
   const textureInfo = options.textureInfo;
@@ -755,15 +705,7 @@ ResourceCache.loadTexture = function (options) {
     asynchronous: asynchronous,
   });
 
-  ResourceCache.load({
-    resourceLoader: textureLoader,
-  });
-  const promise = ResourceCache.statistics.addTextureLoader(textureLoader);
-
-  // Needed for unit testing
-  ResourceCache.cacheEntries[cacheKey]._statisticsPromise = promise;
-
-  return textureLoader;
+  return ResourceCache.add(textureLoader);
 };
 
 /**

package/Source/Scene/ResourceCacheStatistics.js

@@ -47,17 +47,14 @@ ResourceCacheStatistics.prototype.clear = function () {
 };
 
 /**
- * Track the resources for a vertex or index buffer loader. This is implemented
- * asynchronously since resources may not be immediately available to count.
+ * Track the resources for a vertex or index buffer loader. This should be called after a loader is ready; that
+ * is it has been loaded and processed.
  * This method handles the following cases gracefully:
  * <ul>
  *   <li>If the loader is added twice, its resources will not be double-counted</li>
  *   <li>If the geometry has a CPU copy of the GPU buffer, it will be added to the count</li>
- *   <li>If the resource loading failed, its resources will not be counted</li>
- *   <li>If removeLoader() was called before the loader promise resolves, its resources will not be counted</li>
  * </ul>
  * @param {GltfVertexBufferLoader|GltfIndexBufferLoader} loader The geometry buffer with resources to track
- * @returns {Promise} A promise that resolves once the count is updated.
  *
  * @private
  */
@@ -75,47 +72,29 @@ ResourceCacheStatistics.prototype.addGeometryLoader = function (loader) {
 
   this._geometrySizes[cacheKey] = 0;
 
-  const that = this;
-  return loader.promise
-    .then(function (loader) {
-      // loader was unloaded before its promise resolved
-      if (!that._geometrySizes.hasOwnProperty(cacheKey)) {
-        return;
-      }
-
-      const buffer = loader.buffer;
-      const typedArray = loader.typedArray;
-
-      let totalSize = 0;
-
-      if (defined(buffer)) {
-        totalSize += buffer.sizeInBytes;
-      }
-
-      if (defined(typedArray)) {
-        totalSize += typedArray.byteLength;
-      }
-
-      that.geometryByteLength += totalSize;
-      that._geometrySizes[cacheKey] = totalSize;
-    })
-    .catch(function () {
-      // If the resource failed to load, remove it from the cache
-      delete that._geometrySizes[cacheKey];
-    });
+  const buffer = loader.buffer;
+  const typedArray = loader.typedArray;
+
+  let totalSize = 0;
+
+  if (defined(buffer)) {
+    totalSize += buffer.sizeInBytes;
+  }
+
+  if (defined(typedArray)) {
+    totalSize += typedArray.byteLength;
+  }
+
+  this.geometryByteLength += totalSize;
+  this._geometrySizes[cacheKey] = totalSize;
 };
 
 /**
- * Track the resources for a texture loader. This is implemented
- * asynchronously since resources may not be immediately available to count.
- * This method handles the following cases gracefully:
- * <ul>
- *   <li>If the loader is added twice, its resources will not be double-counted</li>
- *   <li>If the resource loading failed, its resources will not be counted</li>
- *   <li>If removeLoader() was called before the loader promise resolves, its resources will not be counted</li>
- * </ul>
+ * Track the resources for a texture loader. This should be called after a loader is ready; that
+ * is it has been loaded and processed.
+ * If the loader is added twice, its resources will not be double-counted.
+ *
  * @param {GltfTextureLoader} loader The texture loader with resources to track
- * @returns {Promise} A promise that resolves once the count is updated.
  *
  * @private
  */
@@ -132,22 +111,9 @@ ResourceCacheStatistics.prototype.addTextureLoader = function (loader) {
   }
 
   this._textureSizes[cacheKey] = 0;
-
-  const that = this;
-  return loader.promise
-    .then(function (loader) {
-      // loader was unloaded before its promise resolved
-      if (!that._textureSizes.hasOwnProperty(cacheKey)) {
-        return;
-      }
-
-      const totalSize = loader.texture.sizeInBytes;
-      that.texturesByteLength += loader.texture.sizeInBytes;
-      that._textureSizes[cacheKey] = totalSize;
-    })
-    .catch(function () {
-      delete that._textureSizes[cacheKey];
-    });
+  const totalSize = loader.texture.sizeInBytes;
+  this.texturesByteLength += loader.texture.sizeInBytes;
+  this._textureSizes[cacheKey] = totalSize;
 };
 
 /**

package/Source/Scene/ResourceLoader.js

@@ -20,21 +20,6 @@ import RuntimeError from "../Core/RuntimeError.js";
 function ResourceLoader() {}
 
 Object.defineProperties(ResourceLoader.prototype, {
-  /**
-   * A promise that resolves to the resource when the resource is ready, or undefined if the resource hasn't started loading.
-   *
-   * @memberof ResourceLoader.prototype
-   *
-   * @type {Promise<ResourceLoader>|undefined}
-   * @readonly
-   * @private
-   */
-  promise: {
-    // eslint-disable-next-line getter-return
-    get: function () {
-      DeveloperError.throwInstantiationError();
-    },
-  },
   /**
    * The cache key of the resource.
    *
@@ -71,9 +56,12 @@ ResourceLoader.prototype.unload = function () {};
  * Processes the resource until it becomes ready.
  *
  * @param {FrameState} frameState The frame state.
+ * @returns {boolean} true once all resourced are ready.
  * @private
  */
-ResourceLoader.prototype.process = function (frameState) {};
+ResourceLoader.prototype.process = function (frameState) {
+  return false;
+};
 
 /**
  * Constructs a {@link RuntimeError} from an errorMessage and an error.
@@ -89,7 +77,7 @@ ResourceLoader.prototype.getError = function (errorMessage, error) {
   Check.typeOf.string("errorMessage", errorMessage);
   //>>includeEnd('debug');
 
-  if (defined(error)) {
+  if (defined(error) && defined(error.message)) {
     errorMessage += `\n${error.message}`;
   }
 

package/Source/Scene/ResourceLoaderState.js

@@ -21,13 +21,21 @@ const ResourceLoaderState = {
    */
   LOADING: 1,
   /**
-   * The resource has finished loading, but requires further processing. GPU resources are allocated in this state as needed.
+   * The resource has finished loading, but requires further processing.
    *
    * @type {number}
    * @constant
    * @private
    */
-  PROCESSING: 2,
+  LOADED: 2,
+  /**
+   * The resource is processing. GPU resources are allocated in this state as needed.
+   *
+   * @type {Number}
+   * @constant
+   * @private
+   */
+  PROCESSING: 3,
   /**
    * The resource has finished loading and processing; the results are ready to be used.
    *
@@ -35,7 +43,7 @@ const ResourceLoaderState = {
    * @constant
    * @private
    */
-  READY: 3,
+  READY: 4,
   /**
    * The resource loading or processing has failed due to an error.
    *
@@ -43,6 +51,6 @@ const ResourceLoaderState = {
    * @constant
    * @private
    */
-  FAILED: 4,
+  FAILED: 5,
 };
 export default Object.freeze(ResourceLoaderState);

package/Source/Scene/Scene.js

@@ -3,6 +3,7 @@ import BoundingSphere from "../Core/BoundingSphere.js";
 import BoxGeometry from "../Core/BoxGeometry.js";
 import Cartesian3 from "../Core/Cartesian3.js";
 import Cartographic from "../Core/Cartographic.js";
+import Check from "../Core/Check.js";
 import clone from "../Core/clone.js";
 import Color from "../Core/Color.js";
 import ColorGeometryInstanceAttribute from "../Core/ColorGeometryInstanceAttribute.js";
@@ -638,6 +639,7 @@ function Scene(options) {
     requestRenderAfterFrame(this)
   );
   this._removeGlobeCallbacks = [];
+  this._removeTerrainProviderReadyListener = undefined;
 
   const viewport = new BoundingRectangle(
     0,
@@ -1104,6 +1106,11 @@ Object.defineProperties(Scene.prototype, {
       return this.globe.terrainProvider;
     },
     set: function (terrainProvider) {
+      // Cancel any in-progress terrain update
+      this._removeTerrainProviderReadyListener =
+        this._removeTerrainProviderReadyListener &&
+        this._removeTerrainProviderReadyListener();
+
       if (defined(this.globe)) {
         this.globe.terrainProvider = terrainProvider;
       }
@@ -4377,6 +4384,61 @@ Scene.prototype.morphTo3D = function (duration) {
   this._transitioner.morphTo3D(duration, ellipsoid);
 };
 
+function setTerrain(scene, terrain) {
+  // Cancel any in-progress terrain update
+  scene._removeTerrainProviderReadyListener =
+    scene._removeTerrainProviderReadyListener &&
+    scene._removeTerrainProviderReadyListener();
+
+  // If the terrain is already loaded, set it immediately
+  if (terrain.ready) {
+    if (defined(scene.globe)) {
+      scene.globe.terrainProvider = terrain.provider;
+    }
+    return;
+  }
+  // Otherwise, set a placeholder
+  scene.globe.terrainProvider = undefined;
+  scene._removeTerrainProviderReadyListener = terrain.readyEvent.addEventListener(
+    (provider) => {
+      if (defined(scene) && defined(scene.globe)) {
+        scene.globe.terrainProvider = provider;
+      }
+
+      scene._removeTerrainProviderReadyListener();
+    }
+  );
+}
+
+/**
+ * Update the terrain providing surface geometry for the globe.
+ *
+ * @param {Terrain} terrain The terrain provider async helper
+ * @returns {Terrain} terrain The terrain provider async helper
+ *
+ * @example
+ * // Use Cesium World Terrain
+ * scene.setTerrain(Cesium.Terrain.fromWorldTerrain());
+ *
+ * @example
+ * // Use a custom terrain provider
+ * const terrain = new Cesium.Terrain(Cesium.CesiumTerrainProvider.fromUrl("https://myTestTerrain.com"));
+ * scene.setTerrain(terrain);
+ *
+ * terrain.errorEvent.addEventListener(error => {
+ *   alert(`Encountered an error while creating terrain! ${error}`);
+ * });
+ */
+Scene.prototype.setTerrain = function (terrain) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("terrain", terrain);
+  //>>includeEnd('debug');
+
+  setTerrain(this, terrain);
+
+  return terrain;
+};
+
 /**
  * Returns true if this object was destroyed; otherwise, false.
  * <br /><br />
@@ -4421,6 +4483,9 @@ Scene.prototype.destroy = function () {
   this._groundPrimitives =
     this._groundPrimitives && this._groundPrimitives.destroy();
   this._globe = this._globe && this._globe.destroy();
+  this._removeTerrainProviderReadyListener =
+    this._removeTerrainProviderReadyListener &&
+    this._removeTerrainProviderReadyListener();
   this.skyBox = this.skyBox && this.skyBox.destroy();
   this.skyAtmosphere = this.skyAtmosphere && this.skyAtmosphere.destroy();
   this._debugSphere = this._debugSphere && this._debugSphere.destroy();

package/Source/Scene/ScreenSpaceCameraController.js

@@ -245,7 +245,7 @@ function ScreenSpaceCameraController(scene) {
   this.minimumTrackBallHeight = 7500000.0;
   this._minimumTrackBallHeight = this.minimumTrackBallHeight;
   /**
-   * Enables or disables camera collision detection with terrain.
+   * When disabled, the values of <code>maximumZoomDistance</code> and <code>minimumZoomDistance</code> are ignored.
    * @type {boolean}
    * @default true
    */