@cesium/engine 2.1.0 → 2.2.0

package/Source/Core/IonResource.js

@@ -16,7 +16,7 @@ import RuntimeError from "./RuntimeError.js";
  * @augments Resource
  *
  * @param {object} endpoint The result of the Cesium ion asset endpoint service.
- * @param {Resource} endpointResource The resource used to retreive the endpoint.
+ * @param {Resource} endpointResource The resource used to retrieve the endpoint.
  *
  * @see Ion
  * @see IonImageryProvider
@@ -87,8 +87,14 @@ if (defined(Object.create)) {
  * @returns {Promise<IonResource>} A Promise to am instance representing the Cesium ion Asset.
  *
  * @example
- * //Load a Cesium3DTileset with asset ID of 124624234
- * viewer.scene.primitives.add(new Cesium.Cesium3DTileset({ url: Cesium.IonResource.fromAssetId(124624234) }));
+ * // Load a Cesium3DTileset with asset ID of 124624234
+ * try {
+ *   const resource = await Cesium.IonResource.fromAssetId(124624234);
+ *   const tileset = await Cesium.Cesium3DTileset.fromUrl(resource);
+ *   scene.primitives.add(tileset);
+ * } catch (error) {
+ *   console.error(`Error creating tileset: ${error}`);
+ * }
  *
  * @example
  * //Load a CZML file with asset ID of 10890
@@ -197,6 +203,11 @@ IonResource.prototype._makeRequest = function (options) {
     options.headers = {};
   }
   options.headers.Authorization = `Bearer ${this._ionEndpoint.accessToken}`;
+  options.headers["X-Cesium-Client"] = "CesiumJS";
+  /* global CESIUM_VERSION */
+  if (typeof CESIUM_VERSION !== "undefined") {
+    options.headers["X-Cesium-Client-Version"] = CESIUM_VERSION;
+  }
 
   return Resource.prototype._makeRequest.call(this, options);
 };

package/Source/Core/OrientedBoundingBox.js

@@ -24,7 +24,7 @@ import Rectangle from "./Rectangle.js";
  *
  * @param {Cartesian3} [center=Cartesian3.ZERO] The center of the box.
  * @param {Matrix3} [halfAxes=Matrix3.ZERO] The three orthogonal half-axes of the bounding box.
- *                                          Equivalently, the transformation matrix, to rotate and scale a 1x1x1
+ *                                          Equivalently, the transformation matrix, to rotate and scale a 2x2x2
  *                                          cube centered at the origin.
  *
  *
@@ -46,7 +46,9 @@ function OrientedBoundingBox(center, halfAxes) {
    */
   this.center = Cartesian3.clone(defaultValue(center, Cartesian3.ZERO));
   /**
-   * The transformation matrix, to rotate the box to the right position.
+   * The three orthogonal half-axes of the bounding box. Equivalently, the
+   * transformation matrix, to rotate and scale a 2x2x2 cube centered at the
+   * origin.
    * @type {Matrix3}
    * @default {@link Matrix3.ZERO}
    */

package/Source/Core/RequestScheduler.js

@@ -76,7 +76,7 @@ RequestScheduler.maximumRequestsPerServer = 6;
  */
 RequestScheduler.requestsByServer = {
   "api.cesium.com:443": 18,
-  "assets.cesium.com:443": 18,
+  "assets.ion.cesium.com:443": 18,
 };
 
 /**

package/Source/Core/Resource.js

@@ -721,7 +721,7 @@ Resource.prototype.getDerivedResource = function (options) {
 /**
  * Called when a resource fails to load. This will call the retryCallback function if defined until retryAttempts is reached.
  *
- * @param {Error} [error] The error that was encountered.
+ * @param {RequestErrorEvent} [error] The error that was encountered.
  *
  * @returns {Promise<boolean>} A promise to a boolean, that if true will cause the resource request to be retried.
  *
@@ -2301,7 +2301,7 @@ Resource.DEFAULT = Object.freeze(
  * @callback Resource.RetryCallback
  *
  * @param {Resource} [resource] The resource that failed to load.
- * @param {Error} [error] The error that occurred during the loading of the resource.
+ * @param {RequestErrorEvent} [error] The error that occurred during the loading of the resource.
  * @returns {boolean|Promise<boolean>} If true or a promise that resolved to true, the resource will be retried. Otherwise the failure will be returned.
  */
 export default Resource;

package/Source/Core/TerrainProvider.js

@@ -22,7 +22,7 @@ function TerrainProvider() {
 
 Object.defineProperties(TerrainProvider.prototype, {
   /**
-   * Gets an event that is raised when the terrain provider encounters an asynchronous error..  By subscribing
+   * Gets an event that is raised when the terrain provider encounters an asynchronous error.  By subscribing
    * to the event, you will be notified of the error and can potentially recover from it.  Event listeners
    * are passed an instance of {@link TileProviderError}.
    * @memberof TerrainProvider.prototype
@@ -35,8 +35,7 @@ Object.defineProperties(TerrainProvider.prototype, {
 
   /**
    * Gets the credit to display when this terrain provider is active.  Typically this is used to credit
-   * the source of the terrain. This function should
-   * not be called before {@link TerrainProvider#ready} returns true.
+   * the source of the terrain.
    * @memberof TerrainProvider.prototype
    * @type {Credit}
    * @readonly
@@ -46,8 +45,7 @@ Object.defineProperties(TerrainProvider.prototype, {
   },
 
   /**
-   * Gets the tiling scheme used by the provider.  This function should
-   * not be called before {@link TerrainProvider#ready} returns true.
+   * Gets the tiling scheme used by the provider.
    * @memberof TerrainProvider.prototype
    * @type {TilingScheme}
    * @readonly
@@ -61,6 +59,7 @@ Object.defineProperties(TerrainProvider.prototype, {
    * @memberof TerrainProvider.prototype
    * @type {boolean}
    * @readonly
+   * @deprecated
    */
   ready: {
     get: DeveloperError.throwInstantiationError,
@@ -71,6 +70,7 @@ Object.defineProperties(TerrainProvider.prototype, {
    * @memberof TerrainProvider.prototype
    * @type {Promise<boolean>}
    * @readonly
+   * @deprecated
    */
   readyPromise: {
     get: DeveloperError.throwInstantiationError,
@@ -79,8 +79,7 @@ Object.defineProperties(TerrainProvider.prototype, {
   /**
    * Gets a value indicating whether or not the provider includes a water mask.  The water mask
    * indicates which areas of the globe are water rather than land, so they can be rendered
-   * as a reflective surface with animated waves.  This function should not be
-   * called before {@link TerrainProvider#ready} returns true.
+   * as a reflective surface with animated waves.
    * @memberof TerrainProvider.prototype
    * @type {boolean}
    * @readonly
@@ -91,7 +90,6 @@ Object.defineProperties(TerrainProvider.prototype, {
 
   /**
    * Gets a value indicating whether or not the requested tiles include vertex normals.
-   * This function should not be called before {@link TerrainProvider#ready} returns true.
    * @memberof TerrainProvider.prototype
    * @type {boolean}
    * @readonly
@@ -102,8 +100,7 @@ Object.defineProperties(TerrainProvider.prototype, {
 
   /**
    * Gets an object that can be used to determine availability of terrain from this provider, such as
-   * at points and in rectangles.  This function should not be called before
-   * {@link TerrainProvider#ready} returns true.  This property may be undefined if availability
+   * at points and in rectangles. This property may be undefined if availability
    * information is not available.
    * @memberof TerrainProvider.prototype
    * @type {TileAvailability}
@@ -399,8 +396,7 @@ TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap = function (
 };
 
 /**
- * Requests the geometry for a given tile.  This function should not be called before
- * {@link TerrainProvider#ready} returns true.  The result must include terrain data and
+ * Requests the geometry for a given tile. The result must include terrain data and
  * may optionally include a water mask and an indication of which child tiles are available.
  * @function
  *
@@ -417,8 +413,7 @@ TerrainProvider.prototype.requestTileGeometry =
   DeveloperError.throwInstantiationError;
 
 /**
- * Gets the maximum geometric error allowed in a tile at a given level.  This function should not be
- * called before {@link TerrainProvider#ready} returns true.
+ * Gets the maximum geometric error allowed in a tile at a given level.
  * @function
  *
  * @param {number} level The tile level for which to get the maximum geometric error.

package/Source/Core/TileProviderError.js

@@ -92,14 +92,14 @@ function TileProviderError(
  * @param {TileProviderError} previousError The error instance returned by this function the last
  *        time it was called for this error, or undefined if this is the first time this error has
  *        occurred.
- * @param {ImageryProvider|TerrainProvider} provider The imagery or terrain provider that encountered the error.
- * @param {Event} event The event to raise to inform listeners of the error.
- * @param {string} message The message describing the error.
- * @param {number} x The X coordinate of the tile that experienced the error, or undefined if the
+ * @param {ImageryProvider|TerrainProvider} [provider] The imagery or terrain provider that encountered the error.
+ * @param {Event} [event] The event to raise to inform listeners of the error.
+ * @param {string} [message] The message describing the error.
+ * @param {number} [x] The X coordinate of the tile that experienced the error, or undefined if the
  *        error is not specific to a particular tile.
- * @param {number} y The Y coordinate of the tile that experienced the error, or undefined if the
+ * @param {number} [y] The Y coordinate of the tile that experienced the error, or undefined if the
  *        error is not specific to a particular tile.
- * @param {number} level The level-of-detail of the tile that experienced the error, or undefined if the
+ * @param {number} [level] The level-of-detail of the tile that experienced the error, or undefined if the
  *        error is not specific to a particular tile.
  * @param {Error} [errorDetails] The error or exception that occurred, if any.
  * @returns {TileProviderError} The error instance that was passed to the event listeners and that
@@ -138,9 +138,9 @@ TileProviderError.reportError = function (
     ++error.timesRetried;
   }
 
-  if (event.numberOfListeners > 0) {
+  if (defined(event) && event.numberOfListeners > 0) {
     event.raiseEvent(error);
-  } else {
+  } else if (defined(provider)) {
     console.log(
       `An error occurred in "${provider.constructor.name}": ${formatError(
         message

package/Source/Core/VRTheWorldTerrainProvider.js

@@ -1,7 +1,8 @@
+import Check from "./Check.js";
 import Credit from "./Credit.js";
 import defaultValue from "./defaultValue.js";
 import defined from "./defined.js";
-import DeveloperError from "./DeveloperError.js";
+import deprecationWarning from "./deprecationWarning.js";
 import Ellipsoid from "./Ellipsoid.js";
 import Event from "./Event.js";
 import GeographicTilingScheme from "./GeographicTilingScheme.js";
@@ -20,38 +21,143 @@ function DataRectangle(rectangle, maxLevel) {
 }
 
 /**
+ * @typedef {Object} VRTheWorldTerrainProvider.ConstructorOptions
+ *
+ * Initialization options for the VRTheWorldTerrainProvider constructor
+ *
+ * @property {Ellipsoid} [ellipsoid] The ellipsoid.  If not specified, the WGS84 ellipsoid is used.
+ * @property {Credit|string} [credit] A credit for the data source, which is displayed on the canvas.
+ * @property {Resource|string} [url] The URL of the VR-TheWorld TileMap. Deprecated.
+ */
+
+/**
+ * Used to track creation details while fetching initial metadata
+ *
+ * @constructor
+ * @private
+ *
+ * @param {VRTheWorldTerrainProvider.ConstructorOptions} options An object describing initialization options
+ */
+function TerrainProviderBuilder(options) {
+  this.ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.WGS84);
+  this.tilingScheme = undefined;
+  this.heightmapWidth = undefined;
+  this.heightmapHeight = undefined;
+  this.levelZeroMaximumGeometricError = undefined;
+  this.rectangles = [];
+}
+
+TerrainProviderBuilder.prototype.build = function (provider) {
+  provider._tilingScheme = this.tilingScheme;
+  provider._heightmapWidth = this.heightmapWidth;
+  provider._heightmapHeight = this.heightmapHeight;
+  provider._levelZeroMaximumGeometricError = this.levelZeroMaximumGeometricError;
+  provider._rectangles = this.rectangles;
+  provider._ready = true;
+};
+
+function metadataSuccess(terrainProviderBuilder, xml) {
+  const srs = xml.getElementsByTagName("SRS")[0].textContent;
+  if (srs === "EPSG:4326") {
+    terrainProviderBuilder.tilingScheme = new GeographicTilingScheme({
+      ellipsoid: terrainProviderBuilder.ellipsoid,
+    });
+  } else {
+    throw new RuntimeError(`SRS ${srs} is not supported`);
+  }
+
+  const tileFormat = xml.getElementsByTagName("TileFormat")[0];
+  terrainProviderBuilder.heightmapWidth = parseInt(
+    tileFormat.getAttribute("width"),
+    10
+  );
+  terrainProviderBuilder.heightmapHeight = parseInt(
+    tileFormat.getAttribute("height"),
+    10
+  );
+  terrainProviderBuilder.levelZeroMaximumGeometricError = TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap(
+    terrainProviderBuilder.ellipsoid,
+    Math.min(
+      terrainProviderBuilder.heightmapWidth,
+      terrainProviderBuilder.heightmapHeight
+    ),
+    terrainProviderBuilder.tilingScheme.getNumberOfXTilesAtLevel(0)
+  );
+
+  const dataRectangles = xml.getElementsByTagName("DataExtent");
+
+  for (let i = 0; i < dataRectangles.length; ++i) {
+    const dataRectangle = dataRectangles[i];
+
+    const west = CesiumMath.toRadians(
+      parseFloat(dataRectangle.getAttribute("minx"))
+    );
+    const south = CesiumMath.toRadians(
+      parseFloat(dataRectangle.getAttribute("miny"))
+    );
+    const east = CesiumMath.toRadians(
+      parseFloat(dataRectangle.getAttribute("maxx"))
+    );
+    const north = CesiumMath.toRadians(
+      parseFloat(dataRectangle.getAttribute("maxy"))
+    );
+    const maxLevel = parseInt(dataRectangle.getAttribute("maxlevel"), 10);
+
+    terrainProviderBuilder.rectangles.push(
+      new DataRectangle(new Rectangle(west, south, east, north), maxLevel)
+    );
+  }
+}
+
+function metadataFailure(resource, error, provider) {
+  let message = `An error occurred while accessing ${resource.url}`;
+
+  if (defined(error) && defined(error.message)) {
+    message = `${message}: ${error.message}`;
+  }
+
+  TileProviderError.reportError(
+    undefined,
+    provider,
+    defined(provider) ? provider._errorEvent : undefined,
+    message
+  );
+
+  throw new RuntimeError(message);
+}
+
+async function requestMetadata(terrainProviderBuilder, resource, provider) {
+  try {
+    const xml = await resource.fetchXML();
+    metadataSuccess(terrainProviderBuilder, xml);
+  } catch (error) {
+    metadataFailure(resource, error, provider);
+  }
+}
+
+/**
+ * <div class="notice">
+ * To construct a VRTheWorldTerrainProvider, call {@link VRTheWorldTerrainProvider.fromUrl}. Do not call the constructor directly.
+ * </div>
+ *
  * A {@link TerrainProvider} that produces terrain geometry by tessellating height maps
  * retrieved from a {@link http://vr-theworld.com/|VT MÄK VR-TheWorld server}.
  *
  * @alias VRTheWorldTerrainProvider
  * @constructor
  *
- * @param {object} options Object with the following properties:
- * @param {Resource|string} options.url The URL of the VR-TheWorld TileMap.
- * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid.  If this parameter is not
- *                    specified, the WGS84 ellipsoid is used.
- * @param {Credit|string} [options.credit] A credit for the data source, which is displayed on the canvas.
- *
+ * @param {VRTheWorldTerrainProvider.ConstructorOptions} [options] An object describing initialization options.
  *
  * @example
- * const terrainProvider = new Cesium.VRTheWorldTerrainProvider({
- *   url : 'https://www.vr-theworld.com/vr-theworld/tiles1.0.0/73/'
- * });
+ * const terrainProvider = await Cesium.VRTheWorldTerrainProvider.fromUrl(
+ *   "https://www.vr-theworld.com/vr-theworld/tiles1.0.0/73/"
+ * );
  * viewer.terrainProvider = terrainProvider;
  *
  * @see TerrainProvider
  */
 function VRTheWorldTerrainProvider(options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(options.url)) {
-    throw new DeveloperError("options.url is required.");
-  }
-  //>>includeEnd('debug');
-
-  const resource = Resource.createIfNeeded(options.url);
-
-  this._resource = resource;
 
   this._errorEvent = new Event();
   this._ready = false;
@@ -76,80 +182,26 @@ function VRTheWorldTerrainProvider(options) {
   this._tilingScheme = undefined;
   this._rectangles = [];
 
-  const that = this;
-  let metadataError;
-  const ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.WGS84);
-
-  function metadataSuccess(xml) {
-    const srs = xml.getElementsByTagName("SRS")[0].textContent;
-    if (srs === "EPSG:4326") {
-      that._tilingScheme = new GeographicTilingScheme({ ellipsoid: ellipsoid });
-    } else {
-      return Promise.reject(new RuntimeError(`SRS ${srs} is not supported.`));
-    }
-
-    const tileFormat = xml.getElementsByTagName("TileFormat")[0];
-    that._heightmapWidth = parseInt(tileFormat.getAttribute("width"), 10);
-    that._heightmapHeight = parseInt(tileFormat.getAttribute("height"), 10);
-    that._levelZeroMaximumGeometricError = TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap(
-      ellipsoid,
-      Math.min(that._heightmapWidth, that._heightmapHeight),
-      that._tilingScheme.getNumberOfXTilesAtLevel(0)
+  if (defined(options.url)) {
+    deprecationWarning(
+      "VRTheWorldTerrainProvider options.url",
+      "options.url was deprecated in CesiumJS 1.104.  It will be in CesiumJS 1.107.  VRTheWorldTerrainProvider.fromUrl instead."
     );
-
-    const dataRectangles = xml.getElementsByTagName("DataExtent");
-
-    for (let i = 0; i < dataRectangles.length; ++i) {
-      const dataRectangle = dataRectangles[i];
-
-      const west = CesiumMath.toRadians(
-        parseFloat(dataRectangle.getAttribute("minx"))
-      );
-      const south = CesiumMath.toRadians(
-        parseFloat(dataRectangle.getAttribute("miny"))
-      );
-      const east = CesiumMath.toRadians(
-        parseFloat(dataRectangle.getAttribute("maxx"))
-      );
-      const north = CesiumMath.toRadians(
-        parseFloat(dataRectangle.getAttribute("maxy"))
-      );
-      const maxLevel = parseInt(dataRectangle.getAttribute("maxlevel"), 10);
-
-      that._rectangles.push(
-        new DataRectangle(new Rectangle(west, south, east, north), maxLevel)
-      );
-    }
-
-    that._ready = true;
-    return Promise.resolve(true);
-  }
-
-  function metadataFailure(e) {
-    const message = defaultValue(
-      defined(e) ? e.message : undefined,
-      `An error occurred while accessing ${that._resource.url}.`
-    );
-    metadataError = TileProviderError.reportError(
-      metadataError,
-      that,
-      that._errorEvent,
-      message
-    );
-    if (metadataError.retry) {
-      return requestMetadata();
-    }
-    return Promise.reject(new RuntimeError(message));
-  }
-
-  function requestMetadata() {
-    return that._resource
-      .fetchXML()
-      .then(metadataSuccess)
-      .catch(metadataFailure);
+    const that = this;
+    const terrainProviderBuilder = new TerrainProviderBuilder(options);
+    const resource = Resource.createIfNeeded(options.url);
+
+    this._resource = resource;
+
+    this._readyPromise = requestMetadata(
+      terrainProviderBuilder,
+      resource,
+      that
+    ).then(() => {
+      terrainProviderBuilder.build(that);
+      return true;
+    });
   }
-
-  this._readyPromise = requestMetadata();
 }
 
 Object.defineProperties(VRTheWorldTerrainProvider.prototype, {
@@ -169,7 +221,7 @@ Object.defineProperties(VRTheWorldTerrainProvider.prototype, {
 
   /**
    * Gets the credit to display when this terrain provider is active.  Typically this is used to credit
-   * the source of the terrain.  This function should not be called before {@link VRTheWorldTerrainProvider#ready} returns true.
+   * the source of the terrain.
    * @memberof VRTheWorldTerrainProvider.prototype
    * @type {Credit}
    * @readonly
@@ -181,22 +233,13 @@ Object.defineProperties(VRTheWorldTerrainProvider.prototype, {
   },
 
   /**
-   * Gets the tiling scheme used by this provider.  This function should
-   * not be called before {@link VRTheWorldTerrainProvider#ready} returns true.
+   * Gets the tiling scheme used by this provider.
    * @memberof VRTheWorldTerrainProvider.prototype
    * @type {GeographicTilingScheme}
    * @readonly
    */
   tilingScheme: {
     get: function () {
-      //>>includeStart('debug', pragmas.debug);
-      if (!this.ready) {
-        throw new DeveloperError(
-          "requestTileGeometry must not be called before ready returns true."
-        );
-      }
-      //>>includeEnd('debug');
-
       return this._tilingScheme;
     },
   },
@@ -206,9 +249,14 @@ Object.defineProperties(VRTheWorldTerrainProvider.prototype, {
    * @memberof VRTheWorldTerrainProvider.prototype
    * @type {boolean}
    * @readonly
+   * @deprecated
    */
   ready: {
     get: function () {
+      deprecationWarning(
+        "VRTheWorldTerrainProvider.ready",
+        "VRTheWorldTerrainProvider.ready was deprecated in CesiumJS 1.104.  It will be in CesiumJS 1.107.  Use VRTheWorldTerrainProvider.fromUrl instead."
+      );
       return this._ready;
     },
   },
@@ -218,9 +266,14 @@ Object.defineProperties(VRTheWorldTerrainProvider.prototype, {
    * @memberof VRTheWorldTerrainProvider.prototype
    * @type {Promise<boolean>}
    * @readonly
+   * @deprecated
    */
   readyPromise: {
     get: function () {
+      deprecationWarning(
+        "VRTheWorldTerrainProvider.readyPromise",
+        "VRTheWorldTerrainProvider.readyPromise was deprecated in CesiumJS 1.104.  It will be in CesiumJS 1.107.  Use VRTheWorldTerrainProvider.fromUrl instead."
+      );
       return this._readyPromise;
     },
   },
@@ -228,8 +281,7 @@ Object.defineProperties(VRTheWorldTerrainProvider.prototype, {
   /**
    * Gets a value indicating whether or not the provider includes a water mask.  The water mask
    * indicates which areas of the globe are water rather than land, so they can be rendered
-   * as a reflective surface with animated waves.  This function should not be
-   * called before {@link VRTheWorldTerrainProvider#ready} returns true.
+   * as a reflective surface with animated waves.
    * @memberof VRTheWorldTerrainProvider.prototype
    * @type {boolean}
    * @readonly
@@ -242,7 +294,6 @@ Object.defineProperties(VRTheWorldTerrainProvider.prototype, {
 
   /**
    * Gets a value indicating whether or not the requested tiles include vertex normals.
-   * This function should not be called before {@link VRTheWorldTerrainProvider#ready} returns true.
    * @memberof VRTheWorldTerrainProvider.prototype
    * @type {boolean}
    * @readonly
@@ -254,8 +305,7 @@ Object.defineProperties(VRTheWorldTerrainProvider.prototype, {
   },
   /**
    * Gets an object that can be used to determine availability of terrain from this provider, such as
-   * at points and in rectangles.  This function should not be called before
-   * {@link TerrainProvider#ready} returns true.  This property may be undefined if availability
+   * at points and in rectangles. This property may be undefined if availability
    * information is not available.
    * @memberof VRTheWorldTerrainProvider.prototype
    * @type {TileAvailability}
@@ -269,8 +319,42 @@ Object.defineProperties(VRTheWorldTerrainProvider.prototype, {
 });
 
 /**
- * Requests the geometry for a given tile.  This function should not be called before
- * {@link VRTheWorldTerrainProvider#ready} returns true.  The result includes terrain
+ * Creates a {@link TerrainProvider} that produces terrain geometry by tessellating height maps
+ * retrieved from a {@link http://vr-theworld.com/|VT MÄK VR-TheWorld server}.
+ *
+ * @param {Resource|String} url The URL of the VR-TheWorld TileMap.
+ * @param {VRTheWorldTerrainProvider.ConstructorOptions} [options] An object describing initialization options.
+ * @returns {Promise<VRTheWorldTerrainProvider>}
+ *
+ * @example
+ * const terrainProvider = await Cesium.VRTheWorldTerrainProvider.fromUrl(
+ *   "https://www.vr-theworld.com/vr-theworld/tiles1.0.0/73/"
+ * );
+ * viewer.terrainProvider = terrainProvider;
+ *
+ * @exception {RuntimeError} metadata specifies and unknown SRS
+ */
+VRTheWorldTerrainProvider.fromUrl = async function (url, options) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("url", url);
+  //>>includeEnd('debug');
+
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+  const terrainProviderBuilder = new TerrainProviderBuilder(options);
+  const resource = Resource.createIfNeeded(url);
+
+  await requestMetadata(terrainProviderBuilder, resource);
+
+  const provider = new VRTheWorldTerrainProvider(options);
+  terrainProviderBuilder.build(provider);
+  provider._resource = resource;
+
+  return provider;
+};
+
+/**
+ * Requests the geometry for a given tile. The result includes terrain
  * data and indicates that all child tiles are available.
  *
  * @param {number} x The X coordinate of the tile for which to request geometry.
@@ -287,14 +371,6 @@ VRTheWorldTerrainProvider.prototype.requestTileGeometry = function (
   level,
   request
 ) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!this.ready) {
-    throw new DeveloperError(
-      "requestTileGeometry must not be called before ready returns true."
-    );
-  }
-  //>>includeEnd('debug');
-
   const yTiles = this._tilingScheme.getNumberOfYTilesAtLevel(level);
   const resource = this._resource.getDerivedResource({
     url: `${level}/${x}/${yTiles - y - 1}.tif`,
@@ -331,13 +407,6 @@ VRTheWorldTerrainProvider.prototype.requestTileGeometry = function (
 VRTheWorldTerrainProvider.prototype.getLevelMaximumGeometricError = function (
   level
 ) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!this.ready) {
-    throw new DeveloperError(
-      "requestTileGeometry must not be called before ready returns true."
-    );
-  }
-  //>>includeEnd('debug');
   return this._levelZeroMaximumGeometricError / (1 << level);
 };
 

package/Source/Core/buildModuleUrl.js

@@ -98,9 +98,10 @@ let implementation;
  *
  * @example
  * const viewer = new Cesium.Viewer("cesiumContainer", {
- *   imageryProvider: new Cesium.TileMapServiceImageryProvider({
- *   url: Cesium.buildModuleUrl("Assets/Textures/NaturalEarthII"),
- *   }),
+ *   baseLayer: Cesium.ImageryLayer.fromProviderAsync(
+ *     Cesium.TileMapServiceImageryProvider.fromUrl(
+ *       Cesium.buildModuleUrl("Assets/Textures/NaturalEarthII"),
+ *     )),
  *   baseLayerPicker: false,
  * });
  */