@cesium/engine 2.0.0 → 2.1.0

package/Source/Scene/VoxelTraversal.js

@@ -28,8 +28,8 @@ import TextureMinificationFilter from "../Renderer/TextureMinificationFilter.js"
  * @param {Cartesian3} dimensions
  * @param {MetadataType[]} types
  * @param {MetadataComponentType[]} componentTypes
- * @param {Number} keyframeCount
- * @param {Number} [maximumTextureMemoryByteLength]
+ * @param {number} keyframeCount
+ * @param {number} [maximumTextureMemoryByteLength]
  *
  * @private
  */
@@ -75,43 +75,30 @@ function VoxelTraversal(
   const maximumTileCount = this.megatextures[0].maximumTileCount;
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._simultaneousRequestCount = 0;
 
   /**
-   * @type {Boolean}
+   * @type {boolean}
    * @private
    */
   this._debugPrint = false;
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._frameNumber = 0;
 
   const shape = primitive._shape;
-  const rootLevel = 0;
-  const rootX = 0;
-  const rootY = 0;
-  const rootZ = 0;
-  const rootParent = undefined;
 
   /**
    * @type {SpatialNode}
    * @readonly
    */
-  this.rootNode = new SpatialNode(
-    rootLevel,
-    rootX,
-    rootY,
-    rootZ,
-    rootParent,
-    shape,
-    dimensions
-  );
+  this.rootNode = new SpatialNode(0, 0, 0, 0, undefined, shape, dimensions);
 
   /**
    * @type {DoubleEndedPriorityQueue}
@@ -135,39 +122,29 @@ function VoxelTraversal(
   this._keyframeNodesInMegatexture = new Array(maximumTileCount);
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._keyframeCount = keyframeCount;
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._sampleCount = undefined;
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._keyframeLocation = 0;
 
   /**
-   * @type {Number[]}
+   * @type {number[]}
    * @private
    */
   this._binaryTreeKeyframeWeighting = new Array(keyframeCount);
 
-  function binaryTreeWeightingRecursive(arr, start, end, depth) {
-    if (start > end) {
-      return;
-    }
-    const mid = Math.floor((start + end) / 2);
-    arr[mid] = depth;
-    binaryTreeWeightingRecursive(arr, start, mid - 1, depth + 1);
-    binaryTreeWeightingRecursive(arr, mid + 1, end, depth + 1);
-  }
-
   const binaryTreeKeyframeWeighting = this._binaryTreeKeyframeWeighting;
   binaryTreeKeyframeWeighting[0] = 0;
   binaryTreeKeyframeWeighting[keyframeCount - 1] = 0;
@@ -205,7 +182,7 @@ function VoxelTraversal(
   });
 
   /**
-   * @type {Number}
+   * @type {number}
    * @readonly
    */
   this.internalNodeTilesPerRow = internalNodeTilesPerRow;
@@ -228,7 +205,7 @@ function VoxelTraversal(
 
   /**
    * Only generated when there are two or more samples.
-   * @type {Number}
+   * @type {number}
    * @readonly
    */
   this.leafNodeTilesPerRow = undefined;
@@ -241,13 +218,23 @@ function VoxelTraversal(
   this.leafNodeTexelSizeUv = new Cartesian2();
 }
 
+function binaryTreeWeightingRecursive(arr, start, end, depth) {
+  if (start > end) {
+    return;
+  }
+  const mid = Math.floor((start + end) / 2);
+  arr[mid] = depth;
+  binaryTreeWeightingRecursive(arr, start, mid - 1, depth + 1);
+  binaryTreeWeightingRecursive(arr, mid + 1, end, depth + 1);
+}
+
 VoxelTraversal.simultaneousRequestCountMaximum = 50;
 
 /**
  * @param {FrameState} frameState
- * @param {Number} keyframeLocation
- * @param {Boolean} recomputeBoundingVolumes
- * @param {Boolean} pauseUpdate
+ * @param {number} keyframeLocation
+ * @param {boolean} recomputeBoundingVolumes
+ * @param {boolean} pauseUpdate
  */
 VoxelTraversal.prototype.update = function (
   frameState,
@@ -336,7 +323,7 @@ VoxelTraversal.prototype.update = function (
 /**
  * Check if a node is renderable.
  * @param {SpatialNode} tile
- * @returns {Boolean}
+ * @returns {boolean}
  */
 VoxelTraversal.prototype.isRenderable = function (tile) {
   return tile.isRenderable(this._frameNumber);
@@ -348,7 +335,7 @@ VoxelTraversal.prototype.isRenderable = function (tile) {
  * 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 VoxelTraversal#destroy
  */
@@ -425,12 +412,6 @@ function requestData(that, keyframeNode) {
 
   const primitive = that._primitive;
   const provider = primitive._provider;
-  const keyframe = keyframeNode.keyframe;
-  const spatialNode = keyframeNode.spatialNode;
-  const tileLevel = spatialNode.level;
-  const tileX = spatialNode.x;
-  const tileY = spatialNode.y;
-  const tileZ = spatialNode.z;
 
   function postRequestSuccess(result) {
     that._simultaneousRequestCount--;
@@ -469,11 +450,12 @@ function requestData(that, keyframeNode) {
     keyframeNode.state = KeyframeNode.LoadState.FAILED;
   }
 
+  const { keyframe, spatialNode } = keyframeNode;
   const promise = provider.requestData({
-    tileLevel: tileLevel,
-    tileX: tileX,
-    tileY: tileY,
-    tileZ: tileZ,
+    tileLevel: spatialNode.level,
+    tileX: spatialNode.x,
+    tileY: spatialNode.y,
+    tileZ: spatialNode.z,
     keyframe: keyframe,
   });
 
@@ -489,8 +471,8 @@ function requestData(that, keyframeNode) {
 /**
  * @function
  *
- * @param {Number} x
- * @returns {Number}
+ * @param {number} x
+ * @returns {number}
  *
  * @private
  */
@@ -510,29 +492,49 @@ function loadAndUnload(that, frameState) {
   const frameNumber = that._frameNumber;
   const primitive = that._primitive;
   const shape = primitive._shape;
-  const voxelDimensions = primitive._provider.dimensions;
-  const targetScreenSpaceError = primitive._screenSpaceError;
+  const { dimensions } = primitive;
+  const targetScreenSpaceError = primitive.screenSpaceError;
   const priorityQueue = that._priorityQueue;
   const keyframeLocation = that._keyframeLocation;
   const keyframeCount = that._keyframeCount;
   const rootNode = that.rootNode;
 
-  const cameraPosition = frameState.camera.positionWC;
-  const screenSpaceErrorDenominator = frameState.camera.frustum.sseDenominator;
-  const screenHeight =
-    frameState.context.drawingBufferHeight / frameState.pixelRatio;
-  const screenSpaceErrorMultiplier = screenHeight / screenSpaceErrorDenominator;
+  const { camera, context, pixelRatio } = frameState;
+  const { positionWC, frustum } = camera;
+  const screenHeight = context.drawingBufferHeight / pixelRatio;
+  const screenSpaceErrorMultiplier = screenHeight / frustum.sseDenominator;
+
+  function keyframePriority(previousKeyframe, keyframe, nextKeyframe) {
+    const keyframeDifference = Math.min(
+      Math.abs(keyframe - previousKeyframe),
+      Math.abs(keyframe - nextKeyframe)
+    );
+    const maxKeyframeDifference = Math.max(
+      previousKeyframe,
+      keyframeCount - nextKeyframe - 1,
+      1
+    );
+    const keyframeFactor = Math.pow(
+      1.0 - keyframeDifference / maxKeyframeDifference,
+      4.0
+    );
+    const binaryTreeFactor = Math.exp(
+      -that._binaryTreeKeyframeWeighting[keyframe]
+    );
+    return CesiumMath.lerp(
+      binaryTreeFactor,
+      keyframeFactor,
+      0.15 + 0.85 * keyframeFactor
+    );
+  }
 
   /**
    * @ignore
    * @param {SpatialNode} spatialNode
-   * @param {Number} visibilityPlaneMask
+   * @param {number} visibilityPlaneMask
    */
   function addToQueueRecursive(spatialNode, visibilityPlaneMask) {
-    spatialNode.computeScreenSpaceError(
-      cameraPosition,
-      screenSpaceErrorMultiplier
-    );
+    spatialNode.computeScreenSpaceError(positionWC, screenSpaceErrorMultiplier);
 
     visibilityPlaneMask = spatialNode.visibility(
       frameState,
@@ -565,31 +567,10 @@ function loadAndUnload(that, frameState) {
     const keyframeNodes = spatialNode.keyframeNodes;
     for (let i = 0; i < keyframeNodes.length; i++) {
       const keyframeNode = keyframeNodes[i];
-      const keyframe = keyframeNode.keyframe;
 
-      // Balanced prioritization
-      const keyframeDifference = Math.min(
-        Math.abs(keyframe - previousKeyframe),
-        Math.abs(keyframe - nextKeyframe)
-      );
-      const maxKeyframeDifference = Math.max(
-        previousKeyframe,
-        keyframeCount - nextKeyframe - 1,
-        1
-      );
-      const keyframeFactor = Math.pow(
-        1.0 - keyframeDifference / maxKeyframeDifference,
-        4.0
-      );
-      const binaryTreeFactor = Math.exp(
-        -that._binaryTreeKeyframeWeighting[keyframe]
-      );
-      keyframeNode.priority = 10.0 * ssePriority;
-      keyframeNode.priority += CesiumMath.lerp(
-        binaryTreeFactor,
-        keyframeFactor,
-        0.15 + 0.85 * keyframeFactor
-      );
+      keyframeNode.priority =
+        10.0 * ssePriority +
+        keyframePriority(previousKeyframe, keyframeNode.keyframe, nextKeyframe);
 
       if (
         keyframeNode.state !== KeyframeNode.LoadState.UNAVAILABLE &&
@@ -612,19 +593,7 @@ function loadAndUnload(that, frameState) {
     }
 
     if (!defined(spatialNode.children)) {
-      const childCoords = getChildCoords(spatialNode);
-      const childLevel = spatialNode.level + 1;
-      spatialNode.children = childCoords.map(([x, y, z]) => {
-        return new SpatialNode(
-          childLevel,
-          x,
-          y,
-          z,
-          spatialNode,
-          shape,
-          voxelDimensions
-        );
-      });
+      spatialNode.constructChildNodes(shape, dimensions);
     }
     for (let childIndex = 0; childIndex < 8; childIndex++) {
       const child = spatialNode.children[childIndex];
@@ -706,33 +675,6 @@ function loadAndUnload(that, frameState) {
   }
 }
 
-/**
- * Compute the X, Y, Z coordinates of the children of a node
- * @param {SpatialNode} spatialNode The parent node
- * @returns {Array[]} Child coordinate arrays
- * @private
- */
-function getChildCoords(spatialNode) {
-  const { x, y, z } = spatialNode;
-  const xMin = x * 2;
-  const yMin = y * 2;
-  const zMin = z * 2;
-  const yMax = yMin + 1;
-  const xMax = xMin + 1;
-  const zMax = zMin + 1;
-
-  return [
-    [xMin, yMin, zMin],
-    [xMax, yMin, zMin],
-    [xMin, yMax, zMin],
-    [xMax, yMax, zMin],
-    [xMin, yMin, zMax],
-    [xMax, yMin, zMax],
-    [xMin, yMax, zMax],
-    [xMax, yMax, zMax],
-  ];
-}
-
 /**
  * @function
  *
@@ -863,8 +805,8 @@ const GpuOctreeFlag = {
  *
  * @param {VoxelTraversal} that
  * @param {FrameState} frameState
- * @param {Number} sampleCount
- * @param {Number} levelBlendFactor
+ * @param {number} sampleCount
+ * @param {number} levelBlendFactor
  * @private
  */
 function generateOctree(that, sampleCount, levelBlendFactor) {
@@ -881,10 +823,10 @@ function generateOctree(that, sampleCount, levelBlendFactor) {
   /**
    * @ignore
    * @param {SpatialNode} node
-   * @param {Number} childOctreeIndex
-   * @param {Number} childEntryIndex
-   * @param {Number} parentOctreeIndex
-   * @param {Number} parentEntryIndex
+   * @param {number} childOctreeIndex
+   * @param {number} childEntryIndex
+   * @param {number} parentOctreeIndex
+   * @param {number} parentEntryIndex
    */
   function buildOctree(
     node,
@@ -992,9 +934,9 @@ function generateOctree(that, sampleCount, levelBlendFactor) {
 /**
  * Compute an interpolation factor between a node and its parent
  * @param {SpatialNode} node
- * @param {Number} targetSse
- * @param {Number} levelBlendFactor
- * @returns {Number}
+ * @param {number} targetSse
+ * @param {number} levelBlendFactor
+ * @returns {number}
  * @private
  */
 function getLodLerp(node, targetSse, levelBlendFactor) {
@@ -1011,9 +953,9 @@ function getLodLerp(node, targetSse, levelBlendFactor) {
 
 /**
  *
- * @param {Number[]} data
- * @param {Number} texelsPerTile
- * @param {Number} tilesPerRow
+ * @param {number[]} data
+ * @param {number} texelsPerTile
+ * @param {number} tilesPerRow
  * @param {Texture} texture
  * @private
  */
@@ -1052,9 +994,9 @@ function copyToInternalNodeTexture(data, texelsPerTile, tilesPerRow, texture) {
 
 /**
  *
- * @param {Number[]} data
- * @param {Number} texelsPerTile
- * @param {Number} tilesPerRow
+ * @param {number[]} data
+ * @param {number} texelsPerTile
+ * @param {number} tilesPerRow
  * @param {Texture} texture
  * @private
  */
@@ -1111,7 +1053,7 @@ function copyToLeafNodeTexture(data, texelsPerTile, tilesPerRow, texture) {
 }
 
 /**
- * @param {Number} tileCount
+ * @param {number} tileCount
  * @param {Cartesian3} dimensions
  * @param {MetadataType[]} types
  * @param {MetadataComponentType[]} componentTypes