@cesium/engine 10.1.0 → 11.1.0

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,
   );
 }
 

package/Source/Scene/VoxelContent.js

@@ -54,7 +54,7 @@ VoxelContent.fromJson = async function (
   resource,
   json,
   binary,
-  metadataSchema
+  metadataSchema,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("resource", resource);

package/Source/Scene/VoxelCylinderShape.js

@@ -155,15 +155,15 @@ VoxelCylinderShape.prototype.update = function (
   minBounds,
   maxBounds,
   clipMinBounds,
-  clipMaxBounds
+  clipMaxBounds,
 ) {
   clipMinBounds = defaultValue(
     clipMinBounds,
-    VoxelCylinderShape.DefaultMinBounds
+    VoxelCylinderShape.DefaultMinBounds,
   );
   clipMaxBounds = defaultValue(
     clipMaxBounds,
-    VoxelCylinderShape.DefaultMaxBounds
+    VoxelCylinderShape.DefaultMaxBounds,
   );
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("modelMatrix", modelMatrix);
@@ -188,22 +188,22 @@ VoxelCylinderShape.prototype.update = function (
   const shapeMinRadius = CesiumMath.clamp(
     minBounds.x,
     defaultMinRadius,
-    defaultMaxRadius
+    defaultMaxRadius,
   );
   const shapeMaxRadius = CesiumMath.clamp(
     maxBounds.x,
     defaultMinRadius,
-    defaultMaxRadius
+    defaultMaxRadius,
   );
   const clipMinRadius = CesiumMath.clamp(
     clipMinBounds.x,
     defaultMinRadius,
-    defaultMaxRadius
+    defaultMaxRadius,
   );
   const clipMaxRadius = CesiumMath.clamp(
     clipMaxBounds.x,
     defaultMinRadius,
-    defaultMaxRadius
+    defaultMaxRadius,
   );
   const renderMinRadius = Math.max(shapeMinRadius, clipMinRadius);
   const renderMaxRadius = Math.min(shapeMaxRadius, clipMaxRadius);
@@ -212,22 +212,22 @@ VoxelCylinderShape.prototype.update = function (
   const shapeMinHeight = CesiumMath.clamp(
     minBounds.y,
     defaultMinHeight,
-    defaultMaxHeight
+    defaultMaxHeight,
   );
   const shapeMaxHeight = CesiumMath.clamp(
     maxBounds.y,
     defaultMinHeight,
-    defaultMaxHeight
+    defaultMaxHeight,
   );
   const clipMinHeight = CesiumMath.clamp(
     clipMinBounds.y,
     defaultMinHeight,
-    defaultMaxHeight
+    defaultMaxHeight,
   );
   const clipMaxHeight = CesiumMath.clamp(
     clipMaxBounds.y,
     defaultMinHeight,
-    defaultMaxHeight
+    defaultMaxHeight,
   );
   const renderMinHeight = Math.max(shapeMinHeight, clipMinHeight);
   const renderMaxHeight = Math.min(shapeMaxHeight, clipMaxHeight);
@@ -278,18 +278,18 @@ VoxelCylinderShape.prototype.update = function (
     renderMinAngle,
     renderMaxAngle,
     this.shapeTransform,
-    this.orientedBoundingBox
+    this.orientedBoundingBox,
   );
 
   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 shapeIsDefaultMaxRadius = shapeMaxRadius === defaultMaxRadius;
@@ -315,13 +315,13 @@ VoxelCylinderShape.prototype.update = function (
     shapeMinAngle,
     defaultMinAngle,
     undefined,
-    epsilonAngleDiscontinuity
+    epsilonAngleDiscontinuity,
   );
   const shapeIsMaxAngleDiscontinuity = CesiumMath.equalsEpsilon(
     shapeMaxAngle,
     defaultMaxAngle,
     undefined,
-    epsilonAngleDiscontinuity
+    epsilonAngleDiscontinuity,
   );
 
   const renderIsDefaultMinRadius = renderMinRadius === defaultMinRadius;
@@ -361,7 +361,7 @@ VoxelCylinderShape.prototype.update = function (
   shaderUniforms.cylinderRenderRadiusMinMax = Cartesian2.fromElements(
     renderMinRadius,
     renderMaxRadius,
-    shaderUniforms.cylinderRenderRadiusMinMax
+    shaderUniforms.cylinderRenderRadiusMinMax,
   );
 
   if (renderMinRadius === renderMaxRadius) {
@@ -386,7 +386,7 @@ VoxelCylinderShape.prototype.update = function (
     shaderUniforms.cylinderUvToShapeUvRadius = Cartesian2.fromElements(
       scale,
       offset,
-      shaderUniforms.cylinderUvToShapeUvRadius
+      shaderUniforms.cylinderUvToShapeUvRadius,
     );
   }
 
@@ -414,13 +414,13 @@ VoxelCylinderShape.prototype.update = function (
     shaderUniforms.cylinderUvToShapeUvHeight = Cartesian2.fromElements(
       scale,
       offset,
-      shaderUniforms.cylinderUvToShapeUvHeight
+      shaderUniforms.cylinderUvToShapeUvHeight,
     );
   }
   shaderUniforms.cylinderRenderHeightMinMax = Cartesian2.fromElements(
     renderMinHeight,
     renderMaxHeight,
-    shaderUniforms.cylinderRenderHeightMinMax
+    shaderUniforms.cylinderRenderHeightMinMax,
   );
 
   if (shapeIsAngleReversed) {
@@ -445,7 +445,7 @@ VoxelCylinderShape.prototype.update = function (
     shaderUniforms.cylinderRenderAngleMinMax = Cartesian2.fromElements(
       renderMinAngle,
       renderMaxAngle,
-      shaderUniforms.cylinderRenderAngleMinMax
+      shaderUniforms.cylinderRenderAngleMinMax,
     );
   }
 
@@ -465,7 +465,7 @@ VoxelCylinderShape.prototype.update = function (
     shaderUniforms.cylinderShapeUvAngleMinMax = Cartesian2.fromElements(
       uvMinAngle,
       uvMaxAngle,
-      shaderUniforms.cylinderShapeUvAngleMinMax
+      shaderUniforms.cylinderShapeUvAngleMinMax,
     );
     shaderUniforms.cylinderShapeUvAngleRangeZeroMid =
       (uvMaxAngle + 0.5 * uvAngleRangeZero) % 1.0;
@@ -483,7 +483,7 @@ VoxelCylinderShape.prototype.update = function (
       shaderUniforms.cylinderUvToShapeUvAngle = Cartesian2.fromElements(
         0.0,
         1.0,
-        shaderUniforms.cylinderUvToShapeUvAngle
+        shaderUniforms.cylinderUvToShapeUvAngle,
       );
     } else {
       const scale = defaultAngleRange / shapeAngleRange;
@@ -491,7 +491,7 @@ VoxelCylinderShape.prototype.update = function (
       shaderUniforms.cylinderUvToShapeUvAngle = Cartesian2.fromElements(
         scale,
         offset,
-        shaderUniforms.cylinderUvToShapeUvAngle
+        shaderUniforms.cylinderUvToShapeUvAngle,
       );
     }
   }
@@ -517,7 +517,7 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForTile = function (
   tileX,
   tileY,
   tileZ,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.number("tileLevel", tileLevel);
@@ -539,32 +539,32 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForTile = function (
   const radiusStart = CesiumMath.lerp(
     minimumRadius,
     maximumRadius,
-    tileX * sizeAtLevel
+    tileX * sizeAtLevel,
   );
   const radiusEnd = CesiumMath.lerp(
     minimumRadius,
     maximumRadius,
-    (tileX + 1) * sizeAtLevel
+    (tileX + 1) * sizeAtLevel,
   );
   const heightStart = CesiumMath.lerp(
     minimumHeight,
     maximumHeight,
-    tileY * sizeAtLevel
+    tileY * sizeAtLevel,
   );
   const heightEnd = CesiumMath.lerp(
     minimumHeight,
     maximumHeight,
-    (tileY + 1) * sizeAtLevel
+    (tileY + 1) * sizeAtLevel,
   );
   const angleStart = CesiumMath.lerp(
     minimumAngle,
     maximumAngle,
-    tileZ * sizeAtLevel
+    tileZ * sizeAtLevel,
   );
   const angleEnd = CesiumMath.lerp(
     minimumAngle,
     maximumAngle,
-    (tileZ + 1) * sizeAtLevel
+    (tileZ + 1) * sizeAtLevel,
   );
 
   return getCylinderChunkObb(
@@ -575,7 +575,7 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForTile = function (
     angleStart,
     angleEnd,
     this.shapeTransform,
-    result
+    result,
   );
 };
 
@@ -597,7 +597,7 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForSample = function (
   spatialNode,
   tileDimensions,
   tileUv,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("spatialNode", spatialNode);
@@ -610,12 +610,12 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForSample = function (
   const sampleSize = Cartesian3.divideComponents(
     Cartesian3.ONE,
     tileDimensions,
-    sampleSizeScratch
+    sampleSizeScratch,
   );
   const sampleSizeAtLevel = Cartesian3.multiplyByScalar(
     sampleSize,
     tileSizeAtLevel,
-    sampleSizeScratch
+    sampleSizeScratch,
   );
 
   const minLerp = Cartesian3.multiplyByScalar(
@@ -623,15 +623,15 @@ VoxelCylinderShape.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 minimumRadius = this._minimumRadius;
@@ -656,7 +656,7 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForSample = function (
     angleStart,
     angleEnd,
     this.shapeTransform,
-    result
+    result,
   );
 };
 
@@ -670,7 +670,7 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForSample = function (
  * @private
  */
 VoxelCylinderShape.DefaultMinBounds = Object.freeze(
-  new Cartesian3(0.0, -1.0, -CesiumMath.PI)
+  new Cartesian3(0.0, -1.0, -CesiumMath.PI),
 );
 
 /**
@@ -683,7 +683,7 @@ VoxelCylinderShape.DefaultMinBounds = Object.freeze(
  * @private
  */
 VoxelCylinderShape.DefaultMaxBounds = Object.freeze(
-  new Cartesian3(1.0, +1.0, +CesiumMath.PI)
+  new Cartesian3(1.0, +1.0, +CesiumMath.PI),
 );
 
 const maxTestAngles = 5;
@@ -762,7 +762,7 @@ function getCylinderChunkObb(
   angleStart,
   angleEnd,
   matrix,
-  result
+  result,
 ) {
   const defaultMinBounds = VoxelCylinderShape.DefaultMinBounds;
   const defaultMaxBounds = VoxelCylinderShape.DefaultMaxBounds;
@@ -845,7 +845,7 @@ function getCylinderChunkObb(
     centerX,
     centerY,
     centerZ,
-    scratchTranslation
+    scratchTranslation,
   );
 
   const rotation = Matrix3.fromRotationZ(angleMid, scratchRotation);
@@ -854,14 +854,14 @@ function getCylinderChunkObb(
     extentX,
     extentY,
     extentZ,
-    scratchScale
+    scratchScale,
   );
 
   const scaleMatrix = Matrix4.fromScale(scale, scratchScaleMatrix);
   const rotationMatrix = Matrix4.fromRotation(rotation, scratchRotationMatrix);
   const translationMatrix = Matrix4.fromTranslation(
     translation,
-    scratchTranslationMatrix
+    scratchTranslationMatrix,
   );
 
   // Shape space matrix = R * T * S
@@ -870,15 +870,15 @@ function getCylinderChunkObb(
     Matrix4.multiplyTransformation(
       translationMatrix,
       scaleMatrix,
-      scratchMatrix
+      scratchMatrix,
     ),
-    scratchMatrix
+    scratchMatrix,
   );
 
   const globalMatrix = Matrix4.multiplyTransformation(
     matrix,
     localMatrix,
-    scratchMatrix
+    scratchMatrix,
   );
 
   if (!isValidOrientedBoundingBoxTransformation(globalMatrix)) {