@cesium/engine 11.0.0 → 12.0.0

package/Source/Scene/View.js

@@ -28,6 +28,13 @@ function CommandExtent() {
 }
 
 /**
+ * @alias View
+ * @constructor
+ *
+ * @param {Scene} scene
+ * @param {Camera} camera
+ * @param {BoundingRectangle} viewport
+ *
  * @private
  */
 function View(scene, camera, viewport) {
@@ -60,8 +67,11 @@ function View(scene, camera, viewport) {
   this.globeTranslucencyFramebuffer = new GlobeTranslucencyFramebuffer();
   this.oit = oit;
   this.translucentTileClassification = new TranslucentTileClassification(
-    context
+    context,
   );
+  /**
+   * @type {PickDepth[]}
+   */
   this.pickDepths = [];
   this.frustumCommandsList = [];
   this.debugFrustumStatistics = undefined;
@@ -73,16 +83,26 @@ function View(scene, camera, viewport) {
 
 const scratchPosition0 = new Cartesian3();
 const scratchPosition1 = new Cartesian3();
-function maxComponent(a, b) {
-  const x = Math.max(Math.abs(a.x), Math.abs(b.x));
-  const y = Math.max(Math.abs(a.y), Math.abs(b.y));
-  const z = Math.max(Math.abs(a.z), Math.abs(b.z));
-  return Math.max(Math.max(x, y), z);
-}
-
+/**
+ * Check if two cameras have the same view.
+ *
+ * @param {Camera} camera0 The first camera for comparison.
+ * @param {Camera} camera1 The second camera for comparison.
+ * @param {number} epsilon The epsilon tolerance to use for equality testing.
+ * @returns {boolean} <code>true</code> if the cameras are equal.
+ *
+ * @private
+ */
 function cameraEqual(camera0, camera1, epsilon) {
-  const scalar =
-    1 / Math.max(1, maxComponent(camera0.position, camera1.position));
+  const maximumPositionComponent = Math.max(
+    Cartesian3.maximumComponent(
+      Cartesian3.abs(camera0.position, scratchPosition0),
+    ),
+    Cartesian3.maximumComponent(
+      Cartesian3.abs(camera1.position, scratchPosition1),
+    ),
+  );
+  const scalar = 1 / Math.max(1, maximumPositionComponent);
   Cartesian3.multiplyByScalar(camera0.position, scalar, scratchPosition0);
   Cartesian3.multiplyByScalar(camera1.position, scalar, scratchPosition1);
   return (
@@ -95,6 +115,14 @@ function cameraEqual(camera0, camera1, epsilon) {
   );
 }
 
+/**
+ * Check if the camera position or direction has changed.
+ *
+ * @param {Scene} scene
+ * @returns {boolean} <code>true</code> if the camera has been updated
+ *
+ * @private
+ */
 View.prototype.checkForCameraUpdates = function (scene) {
   const camera = this.camera;
   const cameraClone = this._cameraClone;
@@ -120,10 +148,22 @@ View.prototype.checkForCameraUpdates = function (scene) {
   return false;
 };
 
+/**
+ * Split the depth range of the scene into multiple frustums, and initialize
+ * a list of {@link FrustumCommands} with the distances to the near and far
+ * planes for each frustum.
+ *
+ * @param {View} view The view to which the frustum commands list is attached.
+ * @param {Scene} scene The scene to be rendered.
+ * @param {number} near The distance to the nearest object in the scene.
+ * @param {number} far The distance to the farthest object in the scene.
+ *
+ * @private
+ */
 function updateFrustums(view, scene, near, far) {
-  const frameState = scene.frameState;
-  const camera = frameState.camera;
-  const farToNearRatio = frameState.useLogDepth
+  const { frameState } = scene;
+  const { camera, useLogDepth } = frameState;
+  const farToNearRatio = useLogDepth
     ? scene.logarithmicDepthFarToNearRatio
     : scene.farToNearRatio;
   const is2D = scene.mode === SceneMode.SCENE2D;
@@ -146,14 +186,14 @@ function updateFrustums(view, scene, near, far) {
     far = Math.min(far, camera.position.z + scene.nearToFarDistance2D);
     near = Math.min(near, far);
     numFrustums = Math.ceil(
-      Math.max(1.0, far - near) / scene.nearToFarDistance2D
+      Math.max(1.0, far - near) / scene.nearToFarDistance2D,
     );
   } else {
     // The multifrustum for 3D/CV is non-uniformly distributed.
     numFrustums = Math.ceil(Math.log(far / near) / Math.log(farToNearRatio));
   }
 
-  const frustumCommandsList = view.frustumCommandsList;
+  const { frustumCommandsList } = view;
   frustumCommandsList.length = numFrustums;
   for (let m = 0; m < numFrustums; ++m) {
     let curNear;
@@ -162,7 +202,7 @@ function updateFrustums(view, scene, near, far) {
     if (is2D) {
       curNear = Math.min(
         far - nearToFarDistance2D,
-        near + m * nearToFarDistance2D
+        near + m * nearToFarDistance2D,
       );
       curFar = Math.min(far, curNear + nearToFarDistance2D);
     } else {
@@ -173,7 +213,7 @@ function updateFrustums(view, scene, near, far) {
     if (!defined(frustumCommands)) {
       frustumCommands = frustumCommandsList[m] = new FrustumCommands(
         curNear,
-        curFar
+        curFar,
       );
     } else {
       frustumCommands.near = curNear;
@@ -182,24 +222,33 @@ function updateFrustums(view, scene, near, far) {
   }
 }
 
-function insertIntoBin(view, scene, command, commandNear, commandFar) {
+/**
+ * Insert a command into the appropriate {@link FrustumCommands} based on the
+ * range of depths covered by its bounding volume.
+ *
+ * @param {View} view
+ * @param {Scene} scene
+ * @param {CommandExtent} commandExtent
+ *
+ * @private
+ */
+function insertIntoBin(view, scene, commandExtent) {
+  const { command, near, far } = commandExtent;
+
   if (scene.debugShowFrustums) {
     command.debugOverlappingFrustums = 0;
   }
 
-  const frustumCommandsList = view.frustumCommandsList;
-  const length = frustumCommandsList.length;
+  const { frustumCommandsList } = view;
 
-  for (let i = 0; i < length; ++i) {
+  for (let i = 0; i < frustumCommandsList.length; ++i) {
     const frustumCommands = frustumCommandsList[i];
-    const curNear = frustumCommands.near;
-    const curFar = frustumCommands.far;
 
-    if (commandNear > curFar) {
+    if (near > frustumCommands.far) {
       continue;
     }
 
-    if (commandFar < curNear) {
+    if (far < frustumCommands.near) {
       break;
     }
 
@@ -217,13 +266,13 @@ function insertIntoBin(view, scene, command, commandNear, commandFar) {
   }
 
   if (scene.debugShowFrustums) {
-    const cf = view.debugFrustumStatistics.commandsInFrustums;
-    cf[command.debugOverlappingFrustums] = defined(
-      cf[command.debugOverlappingFrustums]
-    )
-      ? cf[command.debugOverlappingFrustums] + 1
+    const { debugFrustumStatistics } = view;
+    const { debugOverlappingFrustums } = command;
+    const cf = debugFrustumStatistics.commandsInFrustums;
+    cf[debugOverlappingFrustums] = defined(cf[debugOverlappingFrustums])
+      ? cf[debugOverlappingFrustums] + 1
       : 1;
-    ++view.debugFrustumStatistics.totalCommands;
+    ++debugFrustumStatistics.totalCommands;
   }
 
   scene.updateDerivedCommands(command);
@@ -233,14 +282,12 @@ const scratchCullingVolume = new CullingVolume();
 const scratchNearFarInterval = new Interval();
 
 View.prototype.createPotentiallyVisibleSet = function (scene) {
-  const frameState = scene.frameState;
-  const camera = frameState.camera;
-  const direction = camera.directionWC;
-  const position = camera.positionWC;
+  const { frameState } = scene;
+  const { camera, commandList, shadowState } = frameState;
+  const { positionWC, directionWC, frustum } = camera;
 
   const computeList = scene._computeCommandList;
   const overlayList = scene._overlayCommandList;
-  const commandList = frameState.commandList;
 
   if (scene.debugShowFrustums) {
     this.debugFrustumStatistics = {
@@ -250,10 +297,8 @@ View.prototype.createPotentiallyVisibleSet = function (scene) {
   }
 
   const frustumCommandsList = this.frustumCommandsList;
-  const numberOfFrustums = frustumCommandsList.length;
-  const numberOfPasses = Pass.NUMBER_OF_PASSES;
-  for (let n = 0; n < numberOfFrustums; ++n) {
-    for (let p = 0; p < numberOfPasses; ++p) {
+  for (let n = 0; n < frustumCommandsList.length; ++n) {
+    for (let p = 0; p < Pass.NUMBER_OF_PASSES; ++p) {
       frustumCommandsList[n].indices[p] = 0;
     }
   }
@@ -268,26 +313,25 @@ View.prototype.createPotentiallyVisibleSet = function (scene) {
   let near = +Number.MAX_VALUE;
   let far = -Number.MAX_VALUE;
 
-  const shadowsEnabled = frameState.shadowState.shadowsEnabled;
+  const { shadowsEnabled } = shadowState;
   let shadowNear = +Number.MAX_VALUE;
   let shadowFar = -Number.MAX_VALUE;
   let shadowClosestObjectSize = Number.MAX_VALUE;
 
   const occluder =
     frameState.mode === SceneMode.SCENE3D ? frameState.occluder : undefined;
-  let cullingVolume = frameState.cullingVolume;
 
   // get user culling volume minus the far plane.
+  let { cullingVolume } = frameState;
   const planes = scratchCullingVolume.planes;
   for (let k = 0; k < 5; ++k) {
     planes[k] = cullingVolume.planes[k];
   }
   cullingVolume = scratchCullingVolume;
 
-  const length = commandList.length;
-  for (let i = 0; i < length; ++i) {
+  for (let i = 0; i < commandList.length; ++i) {
     const command = commandList[i];
-    const pass = command.pass;
+    const { pass, boundingVolume } = command;
 
     if (pass === Pass.COMPUTE) {
       computeList.push(command);
@@ -297,16 +341,15 @@ View.prototype.createPotentiallyVisibleSet = function (scene) {
       let commandNear;
       let commandFar;
 
-      const boundingVolume = command.boundingVolume;
       if (defined(boundingVolume)) {
-        if (!scene.isVisible(command, cullingVolume, occluder)) {
+        if (!scene.isVisible(cullingVolume, command, occluder)) {
           continue;
         }
 
         const nearFarInterval = boundingVolume.computePlaneDistances(
-          position,
-          direction,
-          scratchNearFarInterval
+          positionWC,
+          directionWC,
+          scratchNearFarInterval,
         );
         commandNear = nearFarInterval.start;
         commandFar = nearFarInterval.stop;
@@ -334,13 +377,13 @@ View.prototype.createPotentiallyVisibleSet = function (scene) {
         }
       } else if (command instanceof ClearCommand) {
         // Clear commands don't need a bounding volume - just add the clear to all frustums.
-        commandNear = camera.frustum.near;
-        commandFar = camera.frustum.far;
+        commandNear = frustum.near;
+        commandFar = frustum.far;
       } else {
         // If command has no bounding volume we need to use the camera's
         // worst-case near and far planes to avoid clipping something important.
-        commandNear = camera.frustum.near;
-        commandFar = camera.frustum.far;
+        commandNear = frustum.near;
+        commandFar = frustum.far;
         near = Math.min(near, commandNear);
         far = Math.max(far, commandFar);
       }
@@ -357,46 +400,36 @@ View.prototype.createPotentiallyVisibleSet = function (scene) {
   }
 
   if (shadowsEnabled) {
-    shadowNear = Math.min(
-      Math.max(shadowNear, camera.frustum.near),
-      camera.frustum.far
-    );
-    shadowFar = Math.max(Math.min(shadowFar, camera.frustum.far), shadowNear);
-  }
-
-  // Use the computed near and far for shadows
-  if (shadowsEnabled) {
-    frameState.shadowState.nearPlane = shadowNear;
-    frameState.shadowState.farPlane = shadowFar;
-    frameState.shadowState.closestObjectSize = shadowClosestObjectSize;
+    shadowNear = Math.min(Math.max(shadowNear, frustum.near), frustum.far);
+    shadowFar = Math.max(Math.min(shadowFar, frustum.far), shadowNear);
+    // Use the computed near and far for shadows
+    shadowState.nearPlane = shadowNear;
+    shadowState.farPlane = shadowFar;
+    shadowState.closestObjectSize = shadowClosestObjectSize;
   }
 
   updateFrustums(this, scene, near, far);
 
-  let c;
-  let ce;
-
-  for (c = 0; c < commandExtentCount; c++) {
-    ce = commandExtents[c];
-    insertIntoBin(this, scene, ce.command, ce.near, ce.far);
+  for (let c = 0; c < commandExtentCount; c++) {
+    insertIntoBin(this, scene, commandExtents[c]);
   }
 
   // Dereference old commands
   if (commandExtentCount < commandExtentCapacity) {
-    for (c = commandExtentCount; c < commandExtentCapacity; c++) {
-      ce = commandExtents[c];
-      if (!defined(ce.command)) {
+    for (let c = commandExtentCount; c < commandExtentCapacity; c++) {
+      const commandExtent = commandExtents[c];
+      if (!defined(commandExtent.command)) {
         // If the command is undefined, it's assumed that all
         // subsequent commmands were set to undefined as well,
         // so no need to loop over them all
         break;
       }
-      ce.command = undefined;
+      commandExtent.command = undefined;
     }
   }
 
   const numFrustums = frustumCommandsList.length;
-  const frustumSplits = frameState.frustumSplits;
+  const { frustumSplits } = frameState;
   frustumSplits.length = numFrustums + 1;
   for (let j = 0; j < numFrustums; ++j) {
     frustumSplits[j] = frustumCommandsList[j].near;
@@ -421,10 +454,8 @@ View.prototype.destroy = function () {
     this.globeTranslucencyFramebuffer &&
     this.globeTranslucencyFramebuffer.destroy();
 
-  let i;
   const pickDepths = this.pickDepths;
-  const length = pickDepths.length;
-  for (i = 0; i < length; ++i) {
+  for (let i = 0; i < pickDepths.length; ++i) {
     pickDepths[i].destroy();
   }
 };

package/Source/Scene/VoxelBoxShape.js

@@ -59,7 +59,7 @@ function VoxelBoxShape() {
    */
   this._minBounds = Cartesian3.clone(
     VoxelBoxShape.DefaultMinBounds,
-    new Cartesian3()
+    new Cartesian3(),
   );
 
   /**
@@ -68,7 +68,7 @@ function VoxelBoxShape() {
    */
   this._maxBounds = Cartesian3.clone(
     VoxelBoxShape.DefaultMaxBounds,
-    new Cartesian3()
+    new Cartesian3(),
   );
 
   /**
@@ -110,7 +110,7 @@ const scratchRenderMaxBounds = new Cartesian3();
 const transformLocalToUv = Matrix4.fromRotationTranslation(
   Matrix3.fromUniformScale(0.5, new Matrix3()),
   new Cartesian3(0.5, 0.5, 0.5),
-  new Matrix4()
+  new Matrix4(),
 );
 
 /**
@@ -128,7 +128,7 @@ VoxelBoxShape.prototype.update = function (
   minBounds,
   maxBounds,
   clipMinBounds,
-  clipMaxBounds
+  clipMaxBounds,
 ) {
   clipMinBounds = defaultValue(clipMinBounds, VoxelBoxShape.DefaultMinBounds);
   clipMaxBounds = defaultValue(clipMaxBounds, VoxelBoxShape.DefaultMaxBounds);
@@ -145,42 +145,42 @@ VoxelBoxShape.prototype.update = function (
     minBounds,
     defaultMinBounds,
     defaultMaxBounds,
-    this._minBounds
+    this._minBounds,
   );
 
   maxBounds = this._maxBounds = Cartesian3.clamp(
     maxBounds,
     defaultMinBounds,
     defaultMaxBounds,
-    this._maxBounds
+    this._maxBounds,
   );
 
   clipMinBounds = Cartesian3.clamp(
     clipMinBounds,
     defaultMinBounds,
     defaultMaxBounds,
-    scratchClipMinBounds
+    scratchClipMinBounds,
   );
 
   clipMaxBounds = Cartesian3.clamp(
     clipMaxBounds,
     defaultMinBounds,
     defaultMaxBounds,
-    scratchClipMaxBounds
+    scratchClipMaxBounds,
   );
 
   const renderMinBounds = Cartesian3.clamp(
     minBounds,
     clipMinBounds,
     clipMaxBounds,
-    scratchRenderMinBounds
+    scratchRenderMinBounds,
   );
 
   const renderMaxBounds = Cartesian3.clamp(
     maxBounds,
     clipMinBounds,
     clipMaxBounds,
-    scratchRenderMaxBounds
+    scratchRenderMaxBounds,
   );
 
   const scale = Matrix4.getScale(modelMatrix, scratchScale);
@@ -214,7 +214,7 @@ VoxelBoxShape.prototype.update = function (
     renderMinBounds,
     renderMaxBounds,
     this.shapeTransform,
-    this.orientedBoundingBox
+    this.orientedBoundingBox,
   );
 
   // All of the box bounds go from -1 to +1, so the model matrix scale can be
@@ -222,12 +222,12 @@ VoxelBoxShape.prototype.update = function (
   this.boundTransform = Matrix4.fromRotationTranslation(
     this.orientedBoundingBox.halfAxes,
     this.orientedBoundingBox.center,
-    this.boundTransform
+    this.boundTransform,
   );
 
   this.boundingSphere = BoundingSphere.fromOrientedBoundingBox(
     this.orientedBoundingBox,
-    this.boundingSphere
+    this.boundingSphere,
   );
 
   const { shaderUniforms, shaderDefines } = this;
@@ -252,12 +252,12 @@ VoxelBoxShape.prototype.update = function (
   shaderUniforms.renderMinBounds = Matrix4.multiplyByPoint(
     transformLocalToUv,
     renderMinBounds,
-    shaderUniforms.renderMinBounds
+    shaderUniforms.renderMinBounds,
   );
   shaderUniforms.renderMaxBounds = Matrix4.multiplyByPoint(
     transformLocalToUv,
     renderMaxBounds,
-    shaderUniforms.renderMaxBounds
+    shaderUniforms.renderMaxBounds,
   );
 
   if (hasShapeBounds) {
@@ -280,14 +280,14 @@ VoxelBoxShape.prototype.update = function (
       2.0 / (min.x === max.x ? 1.0 : max.x - min.x),
       2.0 / (min.y === max.y ? 1.0 : max.y - min.y),
       2.0 / (min.z === max.z ? 1.0 : max.z - min.z),
-      shaderUniforms.boxUvToShapeUvScale
+      shaderUniforms.boxUvToShapeUvScale,
     );
 
     shaderUniforms.boxUvToShapeUvTranslate = Cartesian3.fromElements(
       -shaderUniforms.boxUvToShapeUvScale.x * (min.x * 0.5 + 0.5),
       -shaderUniforms.boxUvToShapeUvScale.y * (min.y * 0.5 + 0.5),
       -shaderUniforms.boxUvToShapeUvScale.z * (min.z * 0.5 + 0.5),
-      shaderUniforms.boxUvToShapeUvTranslate
+      shaderUniforms.boxUvToShapeUvTranslate,
     );
   }
 
@@ -315,7 +315,7 @@ VoxelBoxShape.prototype.computeOrientedBoundingBoxForTile = function (
   tileX,
   tileY,
   tileZ,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.number("tileLevel", tileLevel);
@@ -333,21 +333,21 @@ VoxelBoxShape.prototype.computeOrientedBoundingBoxForTile = function (
     CesiumMath.lerp(minBounds.x, maxBounds.x, sizeAtLevel * tileX),
     CesiumMath.lerp(minBounds.y, maxBounds.y, sizeAtLevel * tileY),
     CesiumMath.lerp(minBounds.z, maxBounds.z, sizeAtLevel * tileZ),
-    scratchTileMinBounds
+    scratchTileMinBounds,
   );
 
   const tileMaxBounds = Cartesian3.fromElements(
     CesiumMath.lerp(minBounds.x, maxBounds.x, sizeAtLevel * (tileX + 1)),
     CesiumMath.lerp(minBounds.y, maxBounds.y, sizeAtLevel * (tileY + 1)),
     CesiumMath.lerp(minBounds.z, maxBounds.z, sizeAtLevel * (tileZ + 1)),
-    scratchTileMaxBounds
+    scratchTileMaxBounds,
   );
 
   return getBoxChunkObb(
     tileMinBounds,
     tileMaxBounds,
     this.shapeTransform,
-    result
+    result,
   );
 };
 
@@ -367,7 +367,7 @@ VoxelBoxShape.prototype.computeOrientedBoundingBoxForSample = function (
   spatialNode,
   tileDimensions,
   tileUv,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("spatialNode", spatialNode);
@@ -380,12 +380,12 @@ VoxelBoxShape.prototype.computeOrientedBoundingBoxForSample = function (
   const sampleSize = Cartesian3.divideComponents(
     Cartesian3.ONE,
     tileDimensions,
-    sampleSizeScratch
+    sampleSizeScratch,
   );
   const sampleSizeAtLevel = Cartesian3.multiplyByScalar(
     sampleSize,
     tileSizeAtLevel,
-    sampleSizeScratch
+    sampleSizeScratch,
   );
 
   const minLerp = Cartesian3.multiplyByScalar(
@@ -393,15 +393,15 @@ VoxelBoxShape.prototype.computeOrientedBoundingBoxForSample = function (
       spatialNode.x + tileUv.x,
       spatialNode.y + tileUv.y,
       spatialNode.z + tileUv.z,
-      scratchTileMinBounds
+      scratchTileMinBounds,
     ),
     tileSizeAtLevel,
-    scratchTileMinBounds
+    scratchTileMinBounds,
   );
   const maxLerp = Cartesian3.add(
     minLerp,
     sampleSizeAtLevel,
-    scratchTileMaxBounds
+    scratchTileMaxBounds,
   );
 
   const minBounds = this._minBounds;
@@ -410,20 +410,20 @@ VoxelBoxShape.prototype.computeOrientedBoundingBoxForSample = function (
     CesiumMath.lerp(minBounds.x, maxBounds.x, minLerp.x),
     CesiumMath.lerp(minBounds.y, maxBounds.y, minLerp.y),
     CesiumMath.lerp(minBounds.z, maxBounds.z, minLerp.z),
-    scratchTileMinBounds
+    scratchTileMinBounds,
   );
   const sampleMaxBounds = Cartesian3.fromElements(
     CesiumMath.lerp(minBounds.x, maxBounds.x, maxLerp.x),
     CesiumMath.lerp(minBounds.y, maxBounds.y, maxLerp.y),
     CesiumMath.lerp(minBounds.z, maxBounds.z, maxLerp.z),
-    scratchTileMaxBounds
+    scratchTileMaxBounds,
   );
 
   return getBoxChunkObb(
     sampleMinBounds,
     sampleMaxBounds,
     this.shapeTransform,
-    result
+    result,
   );
 };
 
@@ -435,7 +435,7 @@ VoxelBoxShape.prototype.computeOrientedBoundingBoxForSample = function (
  * @readonly
  */
 VoxelBoxShape.DefaultMinBounds = Object.freeze(
-  new Cartesian3(-1.0, -1.0, -1.0)
+  new Cartesian3(-1.0, -1.0, -1.0),
 );
 
 /**
@@ -446,7 +446,7 @@ VoxelBoxShape.DefaultMinBounds = Object.freeze(
  * @readonly
  */
 VoxelBoxShape.DefaultMaxBounds = Object.freeze(
-  new Cartesian3(+1.0, +1.0, +1.0)
+  new Cartesian3(+1.0, +1.0, +1.0),
 );
 
 /**
@@ -478,14 +478,14 @@ function getBoxChunkObb(minimumBounds, maximumBounds, matrix, result) {
     const localCenter = Cartesian3.midpoint(
       minimumBounds,
       maximumBounds,
-      scratchCenter
+      scratchCenter,
     );
     result.center = Matrix4.multiplyByPoint(matrix, localCenter, result.center);
     scale = Cartesian3.fromElements(
       scale.x * 0.5 * (maximumBounds.x - minimumBounds.x),
       scale.y * 0.5 * (maximumBounds.y - minimumBounds.y),
       scale.z * 0.5 * (maximumBounds.z - minimumBounds.z),
-      scratchScale
+      scratchScale,
     );
     const rotation = Matrix4.getRotation(matrix, scratchRotation);
     result.halfAxes = Matrix3.setScale(rotation, scale, result.halfAxes);

package/Source/Scene/VoxelCell.js

@@ -61,7 +61,7 @@ VoxelCell.fromKeyframeNode = function (
   primitive,
   tileIndex,
   sampleIndex,
-  keyframeNode
+  keyframeNode,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("primitive", primitive);
@@ -77,7 +77,7 @@ VoxelCell.fromKeyframeNode = function (
     primitive,
     spatialNode,
     sampleIndex,
-    voxelCell._orientedBoundingBox
+    voxelCell._orientedBoundingBox,
   );
   return voxelCell;
 };
@@ -100,7 +100,7 @@ function getMetadataForSample(primitive, metadata, sampleIndex) {
     const componentCount = MetadataType.getComponentCount(types[i]);
     const samples = metadata[i].slice(
       sampleIndex * componentCount,
-      (sampleIndex + 1) * componentCount
+      (sampleIndex + 1) * componentCount,
     );
     metadataMap[name] = samples;
   }
@@ -130,7 +130,7 @@ function getOrientedBoundingBox(primitive, spatialNode, sampleIndex, result) {
     xIndex,
     yIndex,
     zIndex,
-    tileCoordinateScratch
+    tileCoordinateScratch,
   );
 
   // Remove padding, and convert to a fraction in [0, 1], where the limits are
@@ -139,10 +139,10 @@ function getOrientedBoundingBox(primitive, spatialNode, sampleIndex, result) {
     Cartesian3.subtract(
       tileCoordinate,
       primitive._paddingBefore,
-      tileCoordinateScratch
+      tileCoordinateScratch,
     ),
     primitive.dimensions,
-    tileUvScratch
+    tileUvScratch,
   );
 
   const shape = primitive._shape;
@@ -150,7 +150,7 @@ function getOrientedBoundingBox(primitive, spatialNode, sampleIndex, result) {
     spatialNode,
     primitive.dimensions,
     tileUv,
-    result
+    result,
   );
 }