@cesium/engine 0.1.0 → 1.1.0

package/Source/Scene/I3SLayer.js

@@ -35,6 +35,11 @@ function I3SLayer(dataProvider, layerData, index) {
       .concat(`${layerData.href}`);
   }
 
+  this._version = layerData.store.version;
+  const splitVersion = this._version.split(".");
+  this._majorVersion = parseInt(splitVersion[0]);
+  this._minorVersion = splitVersion.length > 1 ? parseInt(splitVersion[1]) : 0;
+
   this._resource = new Resource({ url: tilesetUrl });
   this._resource.setQueryParameters(
     this._dataProvider.resource.queryParameters
@@ -98,11 +103,68 @@ Object.defineProperties(I3SLayer.prototype, {
       return this._data;
     },
   },
+
+  /**
+   * The version string of the loaded I3S dataset
+   * @memberof I3SLayer.prototype
+   * @type {String}
+   * @readonly
+   */
+  version: {
+    get: function () {
+      return this._version;
+    },
+  },
+
+  /**
+   * The major version number of the loaded I3S dataset
+   * @memberof I3SLayer.prototype
+   * @type {Number}
+   * @readonly
+   */
+  majorVersion: {
+    get: function () {
+      return this._majorVersion;
+    },
+  },
+
+  /**
+   * The minor version number of the loaded I3S dataset
+   * @memberof I3SLayer.prototype
+   * @type {Number}
+   * @readonly
+   */
+  minorVersion: {
+    get: function () {
+      return this._minorVersion;
+    },
+  },
+
+  /**
+   * When <code>true</code>, when the loaded I3S version is 1.6 or older
+   * @memberof I3SLayer.prototype
+   * @type {Boolean}
+   * @readonly
+   */
+  legacyVersion16: {
+    get: function () {
+      if (!defined(this.version)) {
+        return undefined;
+      }
+      if (
+        this.majorVersion < 1 ||
+        (this.majorVersion === 1 && this.minorVersion <= 6)
+      ) {
+        return true;
+      }
+      return false;
+    },
+  },
 });
 
 /**
  * Loads the content, including the root node definition and its children
- * @returns {Promise.<void>} A promise that is resolved when the layer data is loaded
+ * @returns {Promise} A promise that is resolved when the layer data is loaded
  * @private
  */
 I3SLayer.prototype.load = function () {
@@ -121,7 +183,7 @@ I3SLayer.prototype.load = function () {
       return that._tileset.readyPromise.then(function () {
         that._rootNode._tile = that._tileset._root;
         that._tileset._root._i3sNode = that._rootNode;
-        if (that._data.store.version === "1.6") {
+        if (that.legacyVersion16) {
           return that._rootNode._loadChildren();
         }
       });

package/Source/Scene/I3SNode.js

@@ -240,6 +240,52 @@ I3SNode.prototype.loadFields = function () {
   return Promise.all(promises);
 };
 
+/**
+ * Returns the fields for a given picked position
+ * @param {Cartesian3} pickedPosition The picked position
+ * @returns {Object} Object containing field names and their values
+ */
+I3SNode.prototype.getFieldsForPickedPosition = function (pickedPosition) {
+  const geometry = this.geometryData[0];
+  if (!defined(geometry.customAttributes.featureIndex)) {
+    return {};
+  }
+
+  const location = geometry.getClosestPointIndexOnTriangle(
+    pickedPosition.x,
+    pickedPosition.y,
+    pickedPosition.z
+  );
+
+  if (
+    location.index === -1 ||
+    location.index > geometry.customAttributes.featureIndex.length
+  ) {
+    return {};
+  }
+
+  const featureIndex = geometry.customAttributes.featureIndex[location.index];
+  return this.getFieldsForFeature(featureIndex);
+};
+
+/**
+ * Returns the fields for a given feature
+ * @param {Number} featureIndex Index of the feature whose attributes we want to get
+ * @returns {Object} Object containing field names and their values
+ */
+I3SNode.prototype.getFieldsForFeature = function (featureIndex) {
+  const featureFields = {};
+  for (const fieldName in this.fields) {
+    if (this.fields.hasOwnProperty(fieldName)) {
+      const field = this.fields[fieldName];
+      if (featureIndex >= 0 && featureIndex < field.values.length) {
+        featureFields[field.name] = field.values[featureIndex];
+      }
+    }
+  }
+  return featureFields;
+};
+
 /**
  * @private
  */
@@ -336,11 +382,6 @@ I3SNode.prototype._loadFeatureData = function () {
       this._featureData.push(newFeatureData);
       featurePromises.push(newFeatureData.load());
     }
-  } else if (defined(this._data.mesh) && defined(this._data.mesh.attribute)) {
-    const featureURI = `./features/0`;
-    const newFeatureData = new I3SFeature(this, featureURI);
-    this._featureData.push(newFeatureData);
-    featurePromises.push(newFeatureData.load());
   }
 
   return Promise.all(featurePromises);
@@ -661,7 +702,10 @@ I3SNode.prototype._createContentURL = function () {
   };
 
   // Load the geometry data
-  const dataPromises = [this._loadFeatureData(), this._loadGeometryData()];
+  const dataPromises = [this._loadGeometryData()];
+  if (this._dataProvider.legacyVersion16) {
+    dataPromises.push(this._loadFeatureData());
+  }
 
   const that = this;
   return Promise.all(dataPromises).then(function () {

package/Source/Scene/ImplicitMetadataView.js

@@ -56,7 +56,7 @@ Object.defineProperties(ImplicitMetadataView.prototype, {
   },
 
   /**
-   * Extras in the JSON object.
+   * Extra user-defined properties.
    *
    * @memberof ImplicitMetadataView.prototype
    * @type {Object}
@@ -69,7 +69,7 @@ Object.defineProperties(ImplicitMetadataView.prototype, {
   },
 
   /**
-   * Extensions in the JSON object.
+   * An object containing extensions.
    *
    * @memberof ImplicitMetadataView.prototype
    * @type {Object}

package/Source/Scene/ImplicitSubtreeCache.js

@@ -0,0 +1,127 @@
+import defaultValue from "../Core/defaultValue.js";
+import DeveloperError from "../Core/DeveloperError.js";
+import DoubleEndedPriorityQueue from "../Core/DoubleEndedPriorityQueue.js";
+
+/**
+ * @alias ImplicitSubtreeCache
+ * @constructor
+ *
+ * @param {Object} [options] Object with the following properties
+ * @param {Number} [options.maximumSubtreeCount=0] The total number of subtrees this cache can store. If adding a new subtree would exceed this limit, the lowest priority subtrees will be removed until there is room, unless the subtree that is going to be removed is the parent of the new subtree, in which case it will not be removed and the new subtree will still be added, exceeding the memory limit.
+ *
+ * @private
+ */
+function ImplicitSubtreeCache(options) {
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+  /**
+   * @type {Number}
+   * @private
+   */
+  this._maximumSubtreeCount = defaultValue(options.maximumSubtreeCount, 0);
+
+  /**
+   * A counter that goes up whenever a subtree is added. Used to sort subtrees by recency.
+   * @type {Number}
+   * @private
+   */
+  this._subtreeRequestCounter = 0;
+
+  /**
+   * @type {DoubleEndedPriorityQueue}
+   * @private
+   */
+  this._queue = new DoubleEndedPriorityQueue({
+    comparator: ImplicitSubtreeCache.comparator,
+  });
+}
+
+/**
+ * @param {ImplicitSubtree} subtree
+ */
+ImplicitSubtreeCache.prototype.addSubtree = function (subtree) {
+  const cacheNode = new ImplicitSubtreeCacheNode(
+    subtree,
+    this._subtreeRequestCounter
+  );
+  this._subtreeRequestCounter++;
+  this._queue.insert(cacheNode);
+
+  // Make sure the parent subtree exists in the cache
+  const subtreeCoord = subtree.implicitCoordinates;
+  if (subtreeCoord.level > 0) {
+    const parentCoord = subtreeCoord.getParentSubtreeCoordinates();
+    const parentNode = this.find(parentCoord);
+
+    //>>includeStart('debug', pragmas.debug)
+    if (parentNode === undefined) {
+      throw new DeveloperError("parent node needs to exist");
+    }
+    //>>includeEnd('debug');
+  }
+
+  if (this._maximumSubtreeCount > 0) {
+    while (this._queue.length > this._maximumSubtreeCount) {
+      const lowestPriorityNode = this._queue.getMinimum();
+      if (lowestPriorityNode === cacheNode) {
+        // Don't remove itself
+        break;
+      }
+
+      this._queue.removeMinimum();
+    }
+  }
+};
+
+/**
+ * @param {ImplicitTileCoordinates} subtreeCoord
+ * @returns {ImplicitSubtree|undefined}
+ */
+ImplicitSubtreeCache.prototype.find = function (subtreeCoord) {
+  const queue = this._queue;
+  const array = queue.internalArray;
+  const arrayLength = queue.length;
+
+  for (let i = 0; i < arrayLength; i++) {
+    const other = array[i];
+    const otherSubtree = other.subtree;
+    const otherCoord = otherSubtree.implicitCoordinates;
+    if (subtreeCoord.isEqual(otherCoord)) {
+      return other.subtree;
+    }
+  }
+  return undefined;
+};
+
+/**
+ * @param {ImplicitSubtreeCacheNode} a
+ * @param {ImplicitSubtreeCacheNode} b
+ * @returns {Number}
+ */
+ImplicitSubtreeCache.comparator = function (a, b) {
+  const aCoord = a.subtree.implicitCoordinates;
+  const bCoord = b.subtree.implicitCoordinates;
+  if (aCoord.isAncestor(bCoord)) {
+    // Technically this shouldn't happen because the ancestor subtree was supposed to be added to the cache first.
+    return +1.0;
+  } else if (bCoord.isAncestor(aCoord)) {
+    return -1.0;
+  }
+  return a.stamp - b.stamp;
+};
+
+/**
+ * @alias ImplicitSubtreeCacheNode
+ * @constructor
+ *
+ * @param {ImplicitSubtree} subtree
+ * @param {Number} stamp
+ *
+ * @private
+ */
+function ImplicitSubtreeCacheNode(subtree, stamp) {
+  this.subtree = subtree;
+  this.stamp = stamp;
+}
+
+export default ImplicitSubtreeCache;

package/Source/Scene/ImplicitSubtreeMetadata.js

@@ -54,7 +54,7 @@ Object.defineProperties(ImplicitSubtreeMetadata.prototype, {
   },
 
   /**
-   * Extras in the JSON object.
+   * Extra user-defined properties.
    *
    * @memberof ImplicitSubtreeMetadata.prototype
    * @type {Object}
@@ -68,7 +68,7 @@ Object.defineProperties(ImplicitSubtreeMetadata.prototype, {
   },
 
   /**
-   * Extensions in the JSON object.
+   * An object containing extensions.
    *
    * @memberof ImplicitSubtreeMetadata.prototype
    * @type {Object}

package/Source/Scene/ImplicitTileset.js

@@ -64,10 +64,11 @@ function ImplicitTileset(baseResource, tileJson, metadataSchema) {
   if (
     !defined(boundingVolume.box) &&
     !defined(boundingVolume.region) &&
-    !hasExtension(boundingVolume, "3DTILES_bounding_volume_S2")
+    !hasExtension(boundingVolume, "3DTILES_bounding_volume_S2") &&
+    !hasExtension(boundingVolume, "3DTILES_bounding_volume_cylinder")
   ) {
     throw new RuntimeError(
-      "Only box, region and 3DTILES_bounding_volume_S2 are supported for implicit tiling"
+      "Only box, region, 3DTILES_bounding_volume_S2, and 3DTILES_bounding_volume_cylinder are supported for implicit tiling"
     );
   }
 

package/Source/Scene/KeyframeNode.js

@@ -0,0 +1,47 @@
+const LoadState = Object.freeze({
+  UNLOADED: 0, // Has no data and is in dormant state
+  RECEIVING: 1, // Is waiting on data from the provider
+  RECEIVED: 2, // Received data from the provider
+  LOADED: 3, // Processed data from provider
+  FAILED: 4, // Failed to receive data from the provider
+  UNAVAILABLE: 5, // No data available for this tile
+});
+
+/**
+ * @alias KeyframeNode
+ * @constructor
+ *
+ * @param {SpatialNode} spatialNode
+ * @param {Number} keyframe
+ *
+ * @private
+ */
+function KeyframeNode(spatialNode, keyframe) {
+  this.spatialNode = spatialNode;
+  this.keyframe = keyframe;
+  this.state = LoadState.UNLOADED;
+  this.metadatas = [];
+  this.megatextureIndex = -1;
+  this.priority = -Number.MAX_VALUE;
+  this.highPriorityFrameNumber = -1;
+}
+
+/**
+ * @param {KeyframeNode} a
+ * @param {KeyframeNode} b
+ */
+KeyframeNode.priorityComparator = function (a, b) {
+  return a.priority - b.priority;
+};
+
+/**
+ * @param {KeyframeNode} a
+ * @param {KeyframeNode} b
+ */
+KeyframeNode.searchComparator = function (a, b) {
+  return a.keyframe - b.keyframe;
+};
+
+KeyframeNode.LoadState = LoadState;
+
+export default KeyframeNode;