@cesium/engine 2.1.0 → 2.3.0

package/Source/Scene/Model/Model3DTileContent.js

@@ -2,6 +2,7 @@ import Color from "../../Core/Color.js";
 import combine from "../../Core/combine.js";
 import defined from "../../Core/defined.js";
 import destroyObject from "../../Core/destroyObject.js";
+import deprecationWarning from "../../Core/deprecationWarning.js";
 import DeveloperError from "../../Core/DeveloperError.js";
 import Pass from "../../Renderer/Pass.js";
 import ModelAnimationLoop from "../ModelAnimationLoop.js";
@@ -14,6 +15,8 @@ import Model from "./Model.js";
  * <p>
  * Implements the {@link Cesium3DTileContent} interface.
  * </p>
+ * This object is normally not instantiated directly, use {@link Model3DTileContent.fromGltf}, {@link Model3DTileContent.fromB3dm}, {@link Model3DTileContent.fromI3dm}, {@link Model3DTileContent.fromPnts}, or {@link Model3DTileContent.fromGeoJson}.
+ *
  * @alias Model3DTileContent
  * @constructor
  * @private
@@ -24,9 +27,12 @@ function Model3DTileContent(tileset, tile, resource) {
   this._resource = resource;
 
   this._model = undefined;
-  this._readyPromise = undefined;
   this._metadata = undefined;
   this._group = undefined;
+  this._ready = false;
+
+  this._resolveContent = undefined;
+  this._readyPromise = undefined;
 }
 
 Object.defineProperties(Model3DTileContent.prototype, {
@@ -83,8 +89,37 @@ Object.defineProperties(Model3DTileContent.prototype, {
     },
   },
 
+  /**
+   * Returns true when the tile's content is ready to render; otherwise false
+   *
+   * @memberof Model3DTileContent.prototype
+   *
+   * @type {boolean}
+   * @readonly
+   * @private
+   */
+  ready: {
+    get: function () {
+      return this._ready;
+    },
+  },
+
+  /**
+   * Gets the promise that will be resolved when the tile's content is ready to render.
+   *
+   * @memberof Model3DTileContent.prototype
+   *
+   * @type {Promise<Model3DTileContent>}
+   * @readonly
+   * @deprecated
+   * @private
+   */
   readyPromise: {
     get: function () {
+      deprecationWarning(
+        "Model3DTileContent.readyPromise",
+        "Model3DTileContent.readyPromise was deprecated in CesiumJS 1.104. It will be removed in 1.107. Wait for Model3DTileContent.ready to return true instead."
+      );
       return this._readyPromise;
     },
   },
@@ -244,6 +279,16 @@ Model3DTileContent.prototype.update = function (tileset, frameState) {
   }
 
   model.update(frameState);
+
+  if (!this._ready && model.ready) {
+    // Animation can only be added once the model is ready
+    model.activeAnimations.addAll({
+      loop: ModelAnimationLoop.REPEAT,
+    });
+
+    this._ready = true;
+    this._resolveContent = this._resolveContent && this._resolveContent(this);
+  }
 };
 
 Model3DTileContent.prototype.isDestroyed = function () {
@@ -255,7 +300,7 @@ Model3DTileContent.prototype.destroy = function () {
   return destroyObject(this);
 };
 
-Model3DTileContent.fromGltf = function (tileset, tile, resource, gltf) {
+Model3DTileContent.fromGltf = async function (tileset, tile, resource, gltf) {
   const content = new Model3DTileContent(tileset, tile, resource);
 
   const additionalOptions = {
@@ -276,20 +321,18 @@ Model3DTileContent.fromGltf = function (tileset, tile, resource, gltf) {
 
   modelOptions.classificationType = classificationType;
 
-  const model = Model.fromGltf(modelOptions);
+  const model = await Model.fromGltfAsync(modelOptions);
   content._model = model;
-  // Include the animation setup in the ready promise to avoid an uncaught exception
-  content._readyPromise = model.readyPromise.then(function (model) {
-    model.activeAnimations.addAll({
-      loop: ModelAnimationLoop.REPEAT,
-    });
-    return model;
+
+  // This is for backwards compatibility. It can be removed once readyPromise is removed.
+  content._readyPromise = new Promise((resolve) => {
+    content._resolveContent = resolve;
   });
 
   return content;
 };
 
-Model3DTileContent.fromB3dm = function (
+Model3DTileContent.fromB3dm = async function (
   tileset,
   tile,
   resource,
@@ -317,20 +360,18 @@ Model3DTileContent.fromB3dm = function (
 
   modelOptions.classificationType = classificationType;
 
-  const model = Model.fromB3dm(modelOptions);
+  const model = await Model.fromB3dm(modelOptions);
   content._model = model;
-  // Include the animation setup in the ready promise to avoid an uncaught exception
-  content._readyPromise = model.readyPromise.then(function (model) {
-    model.activeAnimations.addAll({
-      loop: ModelAnimationLoop.REPEAT,
-    });
-    return model;
+
+  // This is for backwards compatibility. It can be removed once readyPromise is removed.
+  content._readyPromise = new Promise((resolve) => {
+    content._resolveContent = resolve;
   });
 
   return content;
 };
 
-Model3DTileContent.fromI3dm = function (
+Model3DTileContent.fromI3dm = async function (
   tileset,
   tile,
   resource,
@@ -352,20 +393,18 @@ Model3DTileContent.fromI3dm = function (
     additionalOptions
   );
 
-  const model = Model.fromI3dm(modelOptions);
+  const model = await Model.fromI3dm(modelOptions);
   content._model = model;
-  // Include the animation setup in the ready promise to avoid an uncaught exception
-  content._readyPromise = model.readyPromise.then(function (model) {
-    model.activeAnimations.addAll({
-      loop: ModelAnimationLoop.REPEAT,
-    });
-    return model;
+
+  // This is for backwards compatibility. It can be removed once readyPromise is removed.
+  content._readyPromise = new Promise((resolve) => {
+    content._resolveContent = resolve;
   });
 
   return content;
 };
 
-Model3DTileContent.fromPnts = function (
+Model3DTileContent.fromPnts = async function (
   tileset,
   tile,
   resource,
@@ -386,14 +425,23 @@ Model3DTileContent.fromPnts = function (
     content,
     additionalOptions
   );
-  const model = Model.fromPnts(modelOptions);
+  const model = await Model.fromPnts(modelOptions);
   content._model = model;
-  content._readyPromise = model.readyPromise;
+
+  // This is for backwards compatibility. It can be removed once readyPromise is removed.
+  content._readyPromise = new Promise((resolve) => {
+    content._resolveContent = resolve;
+  });
 
   return content;
 };
 
-Model3DTileContent.fromGeoJson = function (tileset, tile, resource, geoJson) {
+Model3DTileContent.fromGeoJson = async function (
+  tileset,
+  tile,
+  resource,
+  geoJson
+) {
   const content = new Model3DTileContent(tileset, tile, resource);
 
   const additionalOptions = {
@@ -407,9 +455,13 @@ Model3DTileContent.fromGeoJson = function (tileset, tile, resource, geoJson) {
     content,
     additionalOptions
   );
-  const model = Model.fromGeoJson(modelOptions);
+  const model = await Model.fromGeoJson(modelOptions);
   content._model = model;
-  content._readyPromise = model.readyPromise;
+
+  // This is for backwards compatibility. It can be removed once readyPromise is removed.
+  content._readyPromise = new Promise((resolve) => {
+    content._resolveContent = resolve;
+  });
 
   return content;
 };

package/Source/Scene/Model/ModelAnimationCollection.js

@@ -123,7 +123,7 @@ function addAnimation(collection, animation, options) {
  * @param {ModelAnimation.AnimationTimeCallback} [options.animationTime=undefined] If defined, computes the local animation time for this animation.
  * @returns {ModelAnimation} The animation that was added to the collection.
  *
- * @exception {DeveloperError} Animations are not loaded.  Wait for the {@link Model#readyPromise} to resolve.
+ * @exception {DeveloperError} Animations are not loaded.  Wait for the {@link Model#ready} to return trues.
  * @exception {DeveloperError} options.name must be a valid animation name.
  * @exception {DeveloperError} options.index must be a valid animation index.
  * @exception {DeveloperError} Either options.name or options.index must be defined.
@@ -174,7 +174,7 @@ ModelAnimationCollection.prototype.add = function (options) {
   //>>includeStart('debug', pragmas.debug);
   if (!model.ready) {
     throw new DeveloperError(
-      "Animations are not loaded.  Wait for Model.readyPromise to resolve."
+      "Animations are not loaded.  Wait for Model.ready to be true."
     );
   }
   //>>includeEnd('debug');
@@ -258,7 +258,7 @@ ModelAnimationCollection.prototype.addAll = function (options) {
   //>>includeStart('debug', pragmas.debug);
   if (!model.ready) {
     throw new DeveloperError(
-      "Animations are not loaded.  Wait for Model.readyPromise to resolve."
+      "Animations are not loaded.  Wait for Model.ready to be true."
     );
   }
 

package/Source/Scene/Model/ModelDrawCommand.js

@@ -437,9 +437,8 @@ function updateShadows(drawCommand) {
   const receiveShadows = ShadowMode.receiveShadows(shadows);
 
   const derivedCommands = drawCommand._derivedCommands;
-  const length = derivedCommands.length;
 
-  for (let i = 0; i < length; ++i) {
+  for (let i = 0; i < derivedCommands.length; ++i) {
     const derivedCommand = derivedCommands[i];
     if (derivedCommand.updateShadows) {
       const command = derivedCommand.command;
@@ -451,11 +450,9 @@ function updateShadows(drawCommand) {
 
 function updateBackFaceCulling(drawCommand) {
   const backFaceCulling = drawCommand.backFaceCulling;
-
   const derivedCommands = drawCommand._derivedCommands;
-  const length = derivedCommands.length;
 
-  for (let i = 0; i < length; ++i) {
+  for (let i = 0; i < derivedCommands.length; ++i) {
     const derivedCommand = derivedCommands[i];
     if (derivedCommand.updateBackFaceCulling) {
       const command = derivedCommand.command;
@@ -468,11 +465,9 @@ function updateBackFaceCulling(drawCommand) {
 
 function updateCullFace(drawCommand) {
   const cullFace = drawCommand.cullFace;
-
   const derivedCommands = drawCommand._derivedCommands;
-  const length = derivedCommands.length;
 
-  for (let i = 0; i < length; ++i) {
+  for (let i = 0; i < derivedCommands.length; ++i) {
     const derivedCommand = derivedCommands[i];
     if (derivedCommand.updateCullFace) {
       const command = derivedCommand.command;
@@ -485,11 +480,9 @@ function updateCullFace(drawCommand) {
 
 function updateDebugShowBoundingVolume(drawCommand) {
   const debugShowBoundingVolume = drawCommand.debugShowBoundingVolume;
-
   const derivedCommands = drawCommand._derivedCommands;
-  const length = derivedCommands.length;
 
-  for (let i = 0; i < length; ++i) {
+  for (let i = 0; i < derivedCommands.length; ++i) {
     const derivedCommand = derivedCommands[i];
     if (derivedCommand.updateDebugShowBoundingVolume) {
       const command = derivedCommand.command;
@@ -537,15 +530,10 @@ ModelDrawCommand.prototype.pushCommands = function (frameState, result) {
   }
 
   if (this._needsSkipLevelOfDetailCommands) {
-    const content = this._model.content;
-    const tileset = content.tileset;
-    const tile = content.tile;
-
-    const hasMixedContent = tileset._hasMixedContent;
-    const finalResolution = tile._finalResolution;
+    const { tileset, tile } = this._model.content;
 
-    if (hasMixedContent) {
-      if (!finalResolution) {
+    if (tileset.hasMixedContent) {
+      if (!tile._finalResolution) {
         pushCommand(
           tileset._backfaceCommands,
           this._skipLodBackfaceCommand,
@@ -846,13 +834,14 @@ function deriveSkipLodStencilCommand(command) {
   const stencilCommand = DrawCommand.shallowClone(command);
   const renderState = clone(command.renderState, true);
   // The stencil reference is updated dynamically; see updateSkipLodStencilCommand().
-  renderState.stencilTest.enabled = true;
-  renderState.stencilTest.mask = StencilConstants.SKIP_LOD_MASK;
-  renderState.stencilTest.reference = StencilConstants.CESIUM_3D_TILE_MASK;
-  renderState.stencilTest.frontFunction = StencilFunction.GREATER_OR_EQUAL;
-  renderState.stencilTest.frontOperation.zPass = StencilOperation.REPLACE;
-  renderState.stencilTest.backFunction = StencilFunction.GREATER_OR_EQUAL;
-  renderState.stencilTest.backOperation.zPass = StencilOperation.REPLACE;
+  const { stencilTest } = renderState;
+  stencilTest.enabled = true;
+  stencilTest.mask = StencilConstants.SKIP_LOD_MASK;
+  stencilTest.reference = StencilConstants.CESIUM_3D_TILE_MASK;
+  stencilTest.frontFunction = StencilFunction.GREATER_OR_EQUAL;
+  stencilTest.frontOperation.zPass = StencilOperation.REPLACE;
+  stencilTest.backFunction = StencilFunction.GREATER_OR_EQUAL;
+  stencilTest.backOperation.zPass = StencilOperation.REPLACE;
   renderState.stencilMask =
     StencilConstants.CESIUM_3D_TILE_MASK | StencilConstants.SKIP_LOD_MASK;
 

package/Source/Scene/Model/ModelUtility.js

@@ -20,29 +20,27 @@ function ModelUtility() {}
 /**
  * Create a function for reporting when a model fails to load
  *
- * @param {Model} model The model to report about
  * @param {string} type The type of object to report about
  * @param {string} path The URI of the model file
- * @returns {Function} An error function that throws an error for the failed model
+ * @param {Error} [error] The error which caused the failure
+ * @returns {RuntimeError} An error for the failed model
  *
  * @private
  */
-ModelUtility.getFailedLoadFunction = function (model, type, path) {
-  return function (error) {
-    let message = `Failed to load ${type}: ${path}`;
-    if (defined(error)) {
-      message += `\n${error.message}`;
-    }
+ModelUtility.getError = function (type, path, error) {
+  let message = `Failed to load ${type}: ${path}`;
+  if (defined(error) && defined(error.message)) {
+    message += `\n${error.message}`;
+  }
 
-    const runtimeError = new RuntimeError(message);
-    if (defined(error)) {
-      // the original call stack is often more useful than the new error's stack,
-      // so add the information here
-      runtimeError.stack = `Original stack:\n${error.stack}\nHandler stack:\n${runtimeError.stack}`;
-    }
+  const runtimeError = new RuntimeError(message);
+  if (defined(error)) {
+    // the original call stack is often more useful than the new error's stack,
+    // so add the information here
+    runtimeError.stack = `Original stack:\n${error.stack}\nHandler stack:\n${runtimeError.stack}`;
+  }
 
-    return Promise.reject(runtimeError);
-  };
+  return runtimeError;
 };
 
 /**
@@ -372,6 +370,8 @@ ModelUtility.supportedExtensions = {
  * a {@link RuntimeError} with the extension name.
  *
  * @param {string[]} extensionsRequired The extensionsRequired array in the glTF.
+ *
+ * @exception {RuntimeError} Unsupported glTF Extension
  */
 ModelUtility.checkSupportedExtensions = function (extensionsRequired) {
   const length = extensionsRequired.length;

package/Source/Scene/Model/PntsLoader.js

@@ -66,7 +66,7 @@ function PntsLoader(options) {
   this._decodedAttributes = undefined;
 
   this._promise = undefined;
-  this._process = function (frameState) {};
+  this._error = undefined;
   this._state = ResourceLoaderState.UNLOADED;
   this._buffers = [];
 
@@ -81,20 +81,6 @@ if (defined(Object.create)) {
 }
 
 Object.defineProperties(PntsLoader.prototype, {
-  /**
-   * A promise that resolves to the resource when the resource is ready, or undefined if the resource hasn't started loading.
-   *
-   * @memberof PntsLoader.prototype
-   *
-   * @type {Promise<PntsLoader>|undefined}
-   * @readonly
-   * @private
-   */
-  promise: {
-    get: function () {
-      return this._promise;
-    },
-  },
   /**
    * The cache key of the resource
    *
@@ -148,28 +134,36 @@ Object.defineProperties(PntsLoader.prototype, {
  * @private
  */
 PntsLoader.prototype.load = function () {
+  if (defined(this._promise)) {
+    return this._promise;
+  }
+
   this._parsedContent = PntsParser.parse(this._arrayBuffer, this._byteOffset);
   this._state = ResourceLoaderState.PROCESSING;
 
-  const loader = this;
-  this._promise = new Promise(function (resolve, reject) {
-    loader._process = function (frameState) {
-      if (loader._state === ResourceLoaderState.PROCESSING) {
-        if (defined(loader._decodePromise)) {
-          return;
-        }
-
-        const decodePromise = decodeDraco(loader, frameState.context);
-        if (defined(decodePromise)) {
-          decodePromise.then(resolve).catch(reject);
-        }
-      }
-    };
-  });
+  this._promise = Promise.resolve(this);
 };
 
 PntsLoader.prototype.process = function (frameState) {
-  this._process(frameState);
+  if (defined(this._error)) {
+    const error = this._error;
+    this._error = undefined;
+    throw error;
+  }
+
+  if (this._state === ResourceLoaderState.READY) {
+    return true;
+  }
+
+  if (this._state === ResourceLoaderState.PROCESSING) {
+    if (defined(this._decodePromise)) {
+      return false;
+    }
+
+    this._decodePromise = decodeDraco(this, frameState.context);
+  }
+
+  return false;
 };
 
 function decodeDraco(loader, context) {
@@ -207,7 +201,8 @@ function decodeDraco(loader, context) {
       loader.unload();
       loader._state = ResourceLoaderState.FAILED;
       const errorMessage = "Failed to load Draco pnts";
-      return Promise.reject(loader.getError(errorMessage, error));
+      // This error will be thrown next time process is called;
+      loader._error = loader.getError(errorMessage, error);
     });
 }
 

package/Source/Scene/Model/UniformType.js

@@ -104,7 +104,7 @@ const UniformType = {
    * @type {string}
    * @constant
    */
-  MAT3: "mat2",
+  MAT3: "mat3",
   /**
    * A 3x3 matrix of floating point values.
    *