@cesium/engine 2.0.0 → 2.2.0

package/Source/Scene/SkyAtmosphere.js

@@ -46,7 +46,7 @@ function SkyAtmosphere(ellipsoid) {
   /**
    * Determines if the atmosphere is shown.
    *
-   * @type {Boolean}
+   * @type {boolean}
    * @default true
    */
   this.show = true;
@@ -55,7 +55,7 @@ function SkyAtmosphere(ellipsoid) {
    * Compute atmosphere per-fragment instead of per-vertex.
    * This produces better looking atmosphere with a slight performance penalty.
    *
-   * @type {Boolean}
+   * @type {boolean}
    * @default false
    */
   this.perFragmentAtmosphere = false;
@@ -83,7 +83,7 @@ function SkyAtmosphere(ellipsoid) {
   /**
    * The intensity of the light that is used for computing the sky atmosphere color.
    *
-   * @type {Number}
+   * @type {number}
    * @default 50.0
    */
   this.atmosphereLightIntensity = 50.0;
@@ -107,7 +107,7 @@ function SkyAtmosphere(ellipsoid) {
   /**
    * The Rayleigh scale height used in the atmospheric scattering equations for the sky atmosphere, in meters.
    *
-   * @type {Number}
+   * @type {number}
    * @default 10000.0
    */
   this.atmosphereRayleighScaleHeight = 10000.0;
@@ -115,7 +115,7 @@ function SkyAtmosphere(ellipsoid) {
   /**
    * The Mie scale height used in the atmospheric scattering equations for the sky atmosphere, in meters.
    *
-   * @type {Number}
+   * @type {number}
    * @default 3200.0
    */
   this.atmosphereMieScaleHeight = 3200.0;
@@ -125,7 +125,7 @@ function SkyAtmosphere(ellipsoid) {
    * <p>
    * Valid values are between -1.0 and 1.0.
    * </p>
-   * @type {Number}
+   * @type {number}
    * @default 0.9
    */
   this.atmosphereMieAnisotropy = 0.9;
@@ -133,7 +133,7 @@ function SkyAtmosphere(ellipsoid) {
   /**
    * The hue shift to apply to the atmosphere. Defaults to 0.0 (no shift).
    * A hue shift of 1.0 indicates a complete rotation of the hues available.
-   * @type {Number}
+   * @type {number}
    * @default 0.0
    */
   this.hueShift = 0.0;
@@ -141,7 +141,7 @@ function SkyAtmosphere(ellipsoid) {
   /**
    * The saturation shift to apply to the atmosphere. Defaults to 0.0 (no shift).
    * A saturation shift of -1.0 is monochrome.
-   * @type {Number}
+   * @type {number}
    * @default 0.0
    */
   this.saturationShift = 0.0;
@@ -149,7 +149,7 @@ function SkyAtmosphere(ellipsoid) {
   /**
    * The brightness shift to apply to the atmosphere. Defaults to 0.0 (no shift).
    * A brightness shift of -1.0 is complete darkness, which will let space show through.
-   * @type {Number}
+   * @type {number}
    * @default 0.0
    */
   this.brightnessShift = 0.0;
@@ -368,7 +368,7 @@ function hasColorCorrection(skyAtmosphere) {
  * If this object was destroyed, it should not be used; calling any function other than
  * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
  *
- * @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+ * @returns {boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
  *
  * @see SkyAtmosphere#destroy
  */

package/Source/Scene/SkyBox.js

@@ -30,9 +30,9 @@ import SceneMode from "./SceneMode.js";
  * @alias SkyBox
  * @constructor
  *
- * @param {Object} options Object with the following properties:
- * @param {Object} [options.sources] The source URL or <code>Image</code> object for each of the six cube map faces.  See the example below.
- * @param {Boolean} [options.show=true] Determines if this primitive will be shown.
+ * @param {object} options Object with the following properties:
+ * @param {object} [options.sources] The source URL or <code>Image</code> object for each of the six cube map faces.  See the example below.
+ * @param {boolean} [options.show=true] Determines if this primitive will be shown.
  *
  *
  * @example
@@ -57,7 +57,7 @@ function SkyBox(options) {
    * <code>negativeY</code>, <code>positiveZ</code>, and <code>negativeZ</code> properties.
    * These can be either URLs or <code>Image</code> objects.
    *
-   * @type Object
+   * @type {object}
    * @default undefined
    */
   this.sources = options.sources;
@@ -66,7 +66,7 @@ function SkyBox(options) {
   /**
    * Determines if the sky box will be shown.
    *
-   * @type {Boolean}
+   * @type {boolean}
    * @default true
    */
   this.show = defaultValue(options.show, true);
@@ -217,7 +217,7 @@ SkyBox.prototype.update = function (frameState, useHdr) {
  * If this object was destroyed, it should not be used; calling any function other than
  * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
  *
- * @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+ * @returns {boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
  *
  * @see SkyBox#destroy
  */

package/Source/Scene/SpatialNode.js

@@ -11,12 +11,12 @@ import OrientedBoundingBox from "../Core/OrientedBoundingBox.js";
  * @alias SpatialNode
  * @constructor
  *
- * @param {Number} level
- * @param {Number} x
- * @param {Number} y
- * @param {Number} z
+ * @param {number} level
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
  * @param {SpatialNode} parent
- * @param {VoxelShapeType} shape
+ * @param {VoxelShape} shape
  * @param {Cartesian3} voxelDimensions
  *
  * @private
@@ -65,16 +65,6 @@ function SpatialNode(level, x, y, z, parent, shape, voxelDimensions) {
   this.computeBoundingVolumes(shape, voxelDimensions);
 }
 
-/**
- * @param {SpatialNode} a
- * @param {SpatialNode} b
- * @returns {Boolean}
- */
-SpatialNode.spatialComparator = function (a, b) {
-  // The higher of the two screen space errors is prioritized
-  return b.screenSpaceError - a.screenSpaceError;
-};
-
 const scratchObbHalfScale = new Cartesian3();
 
 /**
@@ -102,10 +92,41 @@ SpatialNode.prototype.computeBoundingVolumes = function (
     maximumScale / Cartesian3.minimumComponent(voxelDimensions);
 };
 
+/**
+ * @param {VoxelShape} shape The shape of the parent VoxelPrimitive
+ * @param {Cartesian3} voxelDimensions
+ * @private
+ */
+SpatialNode.prototype.constructChildNodes = function (shape, voxelDimensions) {
+  const { level, x, y, z } = this;
+  const xMin = x * 2;
+  const yMin = y * 2;
+  const zMin = z * 2;
+  const yMax = yMin + 1;
+  const xMax = xMin + 1;
+  const zMax = zMin + 1;
+  const childLevel = level + 1;
+
+  const childCoords = [
+    [childLevel, xMin, yMin, zMin],
+    [childLevel, xMax, yMin, zMin],
+    [childLevel, xMin, yMax, zMin],
+    [childLevel, xMax, yMax, zMin],
+    [childLevel, xMin, yMin, zMax],
+    [childLevel, xMax, yMin, zMax],
+    [childLevel, xMin, yMax, zMax],
+    [childLevel, xMax, yMax, zMax],
+  ];
+
+  this.children = childCoords.map(([level, x, y, z]) => {
+    return new SpatialNode(level, x, y, z, this, shape, voxelDimensions);
+  });
+};
+
 /**
  * @param {FrameState} frameState
- * @param {Number} visibilityPlaneMask
- * @returns {Number} A plane mask as described in {@link CullingVolume#computeVisibilityWithPlaneMask}.
+ * @param {number} visibilityPlaneMask
+ * @returns {number} A plane mask as described in {@link CullingVolume#computeVisibilityWithPlaneMask}.
  */
 SpatialNode.prototype.visibility = function (frameState, visibilityPlaneMask) {
   const obb = this.orientedBoundingBox;
@@ -115,7 +136,7 @@ SpatialNode.prototype.visibility = function (frameState, visibilityPlaneMask) {
 
 /**
  * @param {Cartesian3} cameraPosition
- * @param {Number} screenSpaceErrorMultiplier
+ * @param {number} screenSpaceErrorMultiplier
  */
 SpatialNode.prototype.computeScreenSpaceError = function (
   cameraPosition,
@@ -139,9 +160,9 @@ const scratchBinarySearchKeyframeNode = {
 /**
  * Find the index of a given key frame position within an array of KeyframeNodes,
  * or the complement (~) of the index where it would be in the sorted array.
- * @param {Number} keyframe
+ * @param {number} keyframe
  * @param {KeyframeNode[]} keyframeNodes
- * @returns {Number}
+ * @returns {number}
  * @private
  */
 function findKeyframeIndex(keyframe, keyframeNodes) {
@@ -156,7 +177,7 @@ function findKeyframeIndex(keyframe, keyframeNodes) {
 /**
  * Computes the most suitable keyframes for rendering, balancing between temporal and visual quality.
  *
- * @param {Number} keyframeLocation
+ * @param {number} keyframeLocation
  */
 SpatialNode.prototype.computeSurroundingRenderableKeyframeNodes = function (
   keyframeLocation
@@ -173,66 +194,43 @@ SpatialNode.prototype.computeSurroundingRenderableKeyframeNodes = function (
   let minimumDistanceNext = +Number.MAX_VALUE;
 
   while (defined(spatialNode)) {
-    const renderableKeyframeNodes = spatialNode.renderableKeyframeNodes;
+    const { renderableKeyframeNodes } = spatialNode;
 
     if (renderableKeyframeNodes.length >= 1) {
-      let keyframeNodeIndexPrev = findKeyframeIndex(
+      const indexPrev = getKeyframeIndexPrev(
         targetKeyframePrev,
         renderableKeyframeNodes
       );
-      if (keyframeNodeIndexPrev < 0) {
-        keyframeNodeIndexPrev = CesiumMath.clamp(
-          ~keyframeNodeIndexPrev - 1,
-          0,
-          renderableKeyframeNodes.length - 1
-        );
-      }
-      const keyframeNodePrev = renderableKeyframeNodes[keyframeNodeIndexPrev];
-      const keyframePrev = keyframeNodePrev.keyframe;
+      const keyframeNodePrev = renderableKeyframeNodes[indexPrev];
 
-      let keyframeNodeNext;
-      if (
+      const indexNext =
         targetKeyframeNext === targetKeyframePrev ||
-        targetKeyframePrev < keyframePrev
-      ) {
-        keyframeNodeNext = keyframeNodePrev;
-      } else {
-        const keyframeNodeIndexNext = Math.min(
-          keyframeNodeIndexPrev + 1,
-          renderableKeyframeNodes.length - 1
-        );
-        keyframeNodeNext = renderableKeyframeNodes[keyframeNodeIndexNext];
-      }
-      const keyframeNext = keyframeNodeNext.keyframe;
-
-      const keyframeDistancePrev = targetKeyframePrev - keyframePrev;
-      const keyframeDistanceNext = keyframeNext - targetKeyframeNext;
-      const levelDistance = startLevel - spatialNode.level;
-
-      // Balance temporal and visual quality
-      const levelWeight = Math.exp(levelDistance * 4.0);
-      const normalKeyframeWeight = 1.0;
-      const reverseKeyframeWeight = 200.0; // Keyframes on the opposite of the desired direction are deprioritized.
-      const distancePrev =
-        levelDistance * levelWeight +
-        (keyframeDistancePrev >= 0
-          ? keyframeDistancePrev * normalKeyframeWeight
-          : -keyframeDistancePrev * reverseKeyframeWeight);
-      const distanceNext =
-        levelDistance * levelWeight +
-        (keyframeDistanceNext >= 0
-          ? keyframeDistanceNext * normalKeyframeWeight
-          : -keyframeDistanceNext * reverseKeyframeWeight);
-
-      if (distancePrev < minimumDistancePrev) {
-        minimumDistancePrev = distancePrev;
+        targetKeyframePrev < keyframeNodePrev.keyframe
+          ? indexPrev
+          : Math.min(indexPrev + 1, renderableKeyframeNodes.length - 1);
+      const keyframeNodeNext = renderableKeyframeNodes[indexNext];
+
+      const distancePrev = targetKeyframePrev - keyframeNodePrev.keyframe;
+      const weightedDistancePrev = getWeightedKeyframeDistance(
+        startLevel - spatialNode.level,
+        distancePrev
+      );
+      if (weightedDistancePrev < minimumDistancePrev) {
+        minimumDistancePrev = weightedDistancePrev;
         bestKeyframeNodePrev = keyframeNodePrev;
       }
-      if (distanceNext < minimumDistanceNext) {
-        minimumDistanceNext = distanceNext;
+
+      const distanceNext = keyframeNodeNext.keyframe - targetKeyframeNext;
+      const weightedDistanceNext = getWeightedKeyframeDistance(
+        startLevel - spatialNode.level,
+        distanceNext
+      );
+      if (weightedDistanceNext < minimumDistanceNext) {
+        minimumDistanceNext = weightedDistanceNext;
         bestKeyframeNodeNext = keyframeNodeNext;
       }
-      if (keyframeDistancePrev === 0 && keyframeDistanceNext === 0) {
+
+      if (distancePrev === 0 && distanceNext === 0) {
         // Nothing higher up will be better, so break early.
         break;
       }
@@ -243,31 +241,49 @@ SpatialNode.prototype.computeSurroundingRenderableKeyframeNodes = function (
 
   this.renderableKeyframeNodePrevious = bestKeyframeNodePrev;
   this.renderableKeyframeNodeNext = bestKeyframeNodeNext;
-  if (defined(bestKeyframeNodePrev) && defined(bestKeyframeNodeNext)) {
-    const bestKeyframePrev = bestKeyframeNodePrev.keyframe;
-    const bestKeyframeNext = bestKeyframeNodeNext.keyframe;
-    this.renderableKeyframeNodeLerp =
-      bestKeyframePrev === bestKeyframeNext
-        ? 0.0
-        : CesiumMath.clamp(
-            (keyframeLocation - bestKeyframePrev) /
-              (bestKeyframeNext - bestKeyframePrev),
-            0.0,
-            1.0
-          );
+
+  if (!defined(bestKeyframeNodePrev) || !defined(bestKeyframeNodeNext)) {
+    return;
   }
+
+  const bestKeyframePrev = bestKeyframeNodePrev.keyframe;
+  const bestKeyframeNext = bestKeyframeNodeNext.keyframe;
+  this.renderableKeyframeNodeLerp =
+    bestKeyframePrev === bestKeyframeNext
+      ? 0.0
+      : CesiumMath.clamp(
+          (keyframeLocation - bestKeyframePrev) /
+            (bestKeyframeNext - bestKeyframePrev),
+          0.0,
+          1.0
+        );
 };
 
+function getKeyframeIndexPrev(targetKeyframe, keyframeNodes) {
+  const keyframeIndex = findKeyframeIndex(targetKeyframe, keyframeNodes);
+  return keyframeIndex < 0
+    ? CesiumMath.clamp(~keyframeIndex - 1, 0, keyframeNodes.length - 1)
+    : keyframeIndex;
+}
+
+function getWeightedKeyframeDistance(levelDistance, keyframeDistance) {
+  // Balance quality between visual (levelDistance) and temporal (keyframeDistance)
+  const levelWeight = Math.exp(levelDistance * 4.0);
+  // Keyframes on the opposite of the desired direction are deprioritized.
+  const keyframeWeight = keyframeDistance >= 0 ? 1.0 : -200.0;
+  return levelDistance * levelWeight + keyframeDistance * keyframeWeight;
+}
+
 /**
- * @param {Number} frameNumber
- * @returns {Boolean}
+ * @param {number} frameNumber
+ * @returns {boolean}
  */
 SpatialNode.prototype.isVisited = function (frameNumber) {
   return this.visitedFrameNumber === frameNumber;
 };
 
 /**
- * @param {Number} keyframe
+ * @param {number} keyframe
  */
 SpatialNode.prototype.createKeyframeNode = function (keyframe) {
   let index = findKeyframeIndex(keyframe, this.keyframeNodes);
@@ -355,8 +371,8 @@ SpatialNode.prototype.addKeyframeNodeToMegatextures = function (
 };
 
 /**
- * @param {Number} frameNumber
- * @returns Boolean
+ * @param {number} frameNumber
+ * @returns {boolean}
  */
 SpatialNode.prototype.isRenderable = function (frameNumber) {
   const previousNode = this.renderableKeyframeNodePrevious;

package/Source/Scene/SphereEmitter.js

@@ -10,7 +10,7 @@ import CesiumMath from "../Core/Math.js";
  * @alias SphereEmitter
  * @constructor
  *
- * @param {Number} [radius=1.0] The radius of the sphere in meters.
+ * @param {number} [radius=1.0] The radius of the sphere in meters.
  */
 function SphereEmitter(radius) {
   radius = defaultValue(radius, 1.0);
@@ -26,7 +26,7 @@ Object.defineProperties(SphereEmitter.prototype, {
   /**
    * The radius of the sphere in meters.
    * @memberof SphereEmitter.prototype
-   * @type {Number}
+   * @type {number}
    * @default 1.0
    */
   radius: {

package/Source/Scene/SplitDirection.js

@@ -1,7 +1,7 @@
 /**
  * The direction to display a primitive or ImageryLayer relative to the {@link Scene#splitPosition}.
  *
- * @enum {Number}
+ * @enum {number}
  *
  * @see ImageryLayer#splitDirection
  * @see Cesium3DTileset#splitDirection
@@ -10,7 +10,7 @@ const SplitDirection = {
   /**
    * Display the primitive or ImageryLayer to the left of the {@link Scene#splitPosition}.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   LEFT: -1.0,
@@ -18,7 +18,7 @@ const SplitDirection = {
   /**
    *  Always display the primitive or ImageryLayer.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   NONE: 0.0,
@@ -26,7 +26,7 @@ const SplitDirection = {
   /**
    * Display the primitive or ImageryLayer to the right of the {@link Scene#splitPosition}.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   RIGHT: 1.0,

package/Source/Scene/Splitter.js

@@ -36,8 +36,8 @@ const Splitter = {
   /**
    * Add `czm_splitDirection` to the given uniform map.
    *
-   * @param {Object} object The object on which the `splitDirection` property may be found.
-   * @param {Object} uniformMap The uniform map.
+   * @param {object} object The object on which the `splitDirection` property may be found.
+   * @param {object} uniformMap The uniform map.
    */
   addUniforms: function addUniforms(object, uniformMap) {
     uniformMap.czm_splitDirection = function () {

package/Source/Scene/StencilFunction.js

@@ -3,13 +3,13 @@ import WebGLConstants from "../Core/WebGLConstants.js";
 /**
  * Determines the function used to compare stencil values for the stencil test.
  *
- * @enum {Number}
+ * @enum {number}
  */
 const StencilFunction = {
   /**
    * The stencil test never passes.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   NEVER: WebGLConstants.NEVER,
@@ -17,7 +17,7 @@ const StencilFunction = {
   /**
    * The stencil test passes when the masked reference value is less than the masked stencil value.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   LESS: WebGLConstants.LESS,
@@ -25,7 +25,7 @@ const StencilFunction = {
   /**
    * The stencil test passes when the masked reference value is equal to the masked stencil value.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   EQUAL: WebGLConstants.EQUAL,
@@ -33,7 +33,7 @@ const StencilFunction = {
   /**
    * The stencil test passes when the masked reference value is less than or equal to the masked stencil value.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   LESS_OR_EQUAL: WebGLConstants.LEQUAL,
@@ -41,7 +41,7 @@ const StencilFunction = {
   /**
    * The stencil test passes when the masked reference value is greater than the masked stencil value.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   GREATER: WebGLConstants.GREATER,
@@ -49,7 +49,7 @@ const StencilFunction = {
   /**
    * The stencil test passes when the masked reference value is not equal to the masked stencil value.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   NOT_EQUAL: WebGLConstants.NOTEQUAL,
@@ -57,7 +57,7 @@ const StencilFunction = {
   /**
    * The stencil test passes when the masked reference value is greater than or equal to the masked stencil value.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   GREATER_OR_EQUAL: WebGLConstants.GEQUAL,
@@ -65,7 +65,7 @@ const StencilFunction = {
   /**
    * The stencil test always passes.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   ALWAYS: WebGLConstants.ALWAYS,

package/Source/Scene/StencilOperation.js

@@ -3,13 +3,13 @@ import WebGLConstants from "../Core/WebGLConstants.js";
 /**
  * Determines the action taken based on the result of the stencil test.
  *
- * @enum {Number}
+ * @enum {number}
  */
 const StencilOperation = {
   /**
    * Sets the stencil buffer value to zero.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   ZERO: WebGLConstants.ZERO,
@@ -17,7 +17,7 @@ const StencilOperation = {
   /**
    * Does not change the stencil buffer.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   KEEP: WebGLConstants.KEEP,
@@ -25,7 +25,7 @@ const StencilOperation = {
   /**
    * Replaces the stencil buffer value with the reference value.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   REPLACE: WebGLConstants.REPLACE,
@@ -33,7 +33,7 @@ const StencilOperation = {
   /**
    * Increments the stencil buffer value, clamping to unsigned byte.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   INCREMENT: WebGLConstants.INCR,
@@ -41,7 +41,7 @@ const StencilOperation = {
   /**
    * Decrements the stencil buffer value, clamping to zero.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   DECREMENT: WebGLConstants.DECR,
@@ -49,7 +49,7 @@ const StencilOperation = {
   /**
    * Bitwise inverts the existing stencil buffer value.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   INVERT: WebGLConstants.INVERT,
@@ -57,7 +57,7 @@ const StencilOperation = {
   /**
    * Increments the stencil buffer value, wrapping to zero when exceeding the unsigned byte range.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   INCREMENT_WRAP: WebGLConstants.INCR_WRAP,
@@ -65,7 +65,7 @@ const StencilOperation = {
   /**
    * Decrements the stencil buffer value, wrapping to the maximum unsigned byte instead of going below zero.
    *
-   * @type {Number}
+   * @type {number}
    * @constant
    */
   DECREMENT_WRAP: WebGLConstants.DECR_WRAP,