@cesium/engine 23.0.0 → 24.0.0

package/Source/Core/S2Cell.js

@@ -376,7 +376,7 @@ S2Cell.prototype.getCenter = function (ellipsoid) {
   let center = getS2Center(this._cellId, this._level);
   // Normalize XYZ.
   center = Cartesian3.normalize(center, center);
-  const cartographic = new Cartographic.fromCartesian(
+  const cartographic = Cartographic.fromCartesian(
     center,
     Ellipsoid.UNIT_SPHERE,
   );
@@ -405,7 +405,7 @@ S2Cell.prototype.getVertex = function (index, ellipsoid) {
   let vertex = getS2Vertex(this._cellId, this._level, index);
   // Normalize XYZ.
   vertex = Cartesian3.normalize(vertex, vertex);
-  const cartographic = new Cartographic.fromCartesian(
+  const cartographic = Cartographic.fromCartesian(
     vertex,
     Ellipsoid.UNIT_SPHERE,
   );

package/Source/Core/TerrainMesh.js

@@ -3,6 +3,7 @@ import Cartesian3 from "./Cartesian3.js";
 import Cartographic from "./Cartographic.js";
 import defined from "./defined.js";
 import Ellipsoid from "./Ellipsoid.js";
+import CesiumMath from "./Math.js";
 import Matrix4 from "./Matrix4.js";
 import OrientedBoundingBox from "./OrientedBoundingBox.js";
 import TerrainPicker from "./TerrainPicker.js";
@@ -235,7 +236,14 @@ function computeTransform(mesh, result) {
     mesh.orientedBoundingBox,
   );
 
-  return OrientedBoundingBox.computeTransformation(obb, result);
+  OrientedBoundingBox.computeTransformation(obb, result);
+  const zScale = Matrix4.getScale(result, scratchScale).z;
+  if (zScale <= CesiumMath.EPSILON16) {
+    scratchScale.z = 1.0;
+    Matrix4.setScale(result, scratchScale, result);
+  }
+
+  return result;
 }
 
 const scratchSWCartesian = new Cartesian3();
@@ -244,6 +252,7 @@ const scratchSWCartographic = new Cartographic();
 const scratchNECartographic = new Cartographic();
 const scratchScale2D = new Cartesian3();
 const scratchCenter2D = new Cartesian3();
+const scratchScale = new Cartesian3();
 
 /**
  * Get the terrain tile's model-to-world transform matrix for 2D or Columbus View modes.

package/Source/Core/TerrainPicker.js

@@ -73,6 +73,7 @@ const incrementallyBuildTerrainPickerTaskProcessor = new TaskProcessor(
 Object.defineProperties(TerrainPicker.prototype, {
   /**
    * Indicates whether the terrain picker needs to be rebuilt due to changes in the underlying terrain mesh's vertices or indices.
+   * @memberof TerrainPicker.prototype
    * @type {boolean}
    */
   needsRebuild: {

package/Source/Core/WallGeometry.js

@@ -617,7 +617,7 @@ WallGeometry.createGeometry = function (wallGeometry) {
     attributes: attributes,
     indices: indices,
     primitiveType: PrimitiveType.TRIANGLES,
-    boundingSphere: new BoundingSphere.fromVertices(positions),
+    boundingSphere: BoundingSphere.fromVertices(positions),
   });
 };
 export default WallGeometry;

package/Source/Core/WallOutlineGeometry.js

@@ -425,7 +425,7 @@ WallOutlineGeometry.createGeometry = function (wallGeometry) {
     attributes: attributes,
     indices: indices,
     primitiveType: PrimitiveType.LINES,
-    boundingSphere: new BoundingSphere.fromVertices(positions),
+    boundingSphere: BoundingSphere.fromVertices(positions),
   });
 };
 export default WallOutlineGeometry;

package/Source/Core/assert.js

@@ -0,0 +1,27 @@
+// @ts-check
+
+import DeveloperError from "./DeveloperError.js";
+
+/**
+ * Checks that a condition is truthy, throwing a specified message if condition
+ * fails. The `asserts condition` return type allows TypeScript to narrow the
+ * types of the condition and enforce stricter types without further if/else
+ * checks or nullish coalescing.
+ *
+ * @example
+ * assert(object.optionalProperty, 'Missing .optionalProperty');
+ * object.optionalProperty.toString(); // safe; no type error.
+ *
+ * @function
+ *
+ * @param {*} condition
+ * @param {string} msg
+ * @ignore
+ */
+function assert(condition, msg) {
+  if (!condition) {
+    throw new DeveloperError(msg);
+  }
+}
+
+export default assert;

package/Source/Core/globalTypes.js

@@ -8,6 +8,10 @@
  * @typedef {Float64ArrayConstructor|Float32ArrayConstructor|Uint32ArrayConstructor|Uint16ArrayConstructor|Uint8ArrayConstructor|Int32ArrayConstructor|Int16ArrayConstructor|Int8ArrayConstructor} TypedArrayConstructor
  */
 
+/**
+ * @typedef {{destroy: Function}} Destroyable
+ */
+
 /**
  * This file is omitted from 'workspaceSourceFiles' in 'scripts/build.js', and
  * must provide type-only exports exclusively, without runtime values.

package/Source/DataSources/CzmlDataSource.js

@@ -3645,6 +3645,15 @@ function processPath(entity, packet, entityCollection, sourceUri) {
     sourceUri,
     entityCollection,
   );
+  processPacketData(
+    String,
+    path,
+    "relativeTo",
+    pathData.relativeTo,
+    interval,
+    sourceUri,
+    entityCollection,
+  );
 }
 
 function processPoint(entity, packet, entityCollection, sourceUri) {

package/Source/DataSources/PathGraphics.js

@@ -17,6 +17,7 @@ import createPropertyDescriptor from "./createPropertyDescriptor.js";
  * @property {Property | number} [resolution=60] A numeric Property specifying the maximum number of seconds to step when sampling the position.
  * @property {MaterialProperty | Color} [material=Color.WHITE] A Property specifying the material used to draw the path.
  * @property {Property | DistanceDisplayCondition} [distanceDisplayCondition] A Property specifying at what distance from the camera that this path will be displayed.
+ * @property {Property | string} [relativeTo] A Property specifying the frame in which to visualize the path. Use another entity's id to visualize the path relative to that entity, or use the string values "FIXED" or "INERTIAL" to visualize the path in those reference frames.
  */
 
 /**
@@ -43,6 +44,8 @@ function PathGraphics(options) {
   this._materialSubscription = undefined;
   this._distanceDisplayCondition = undefined;
   this._distanceDisplayConditionSubscription = undefined;
+  this._relativeTo = undefined;
+  this._relativeToSubscription = undefined;
 
   this.merge(options ?? Frozen.EMPTY_OBJECT);
 }
@@ -114,6 +117,14 @@ Object.defineProperties(PathGraphics.prototype, {
   distanceDisplayCondition: createPropertyDescriptor(
     "distanceDisplayCondition",
   ),
+
+  /**
+   * Gets or sets the frame in which to visualize the path. Use another entity's id to visualize the path relative to that entity, or use the string values "FIXED" or "INERTIAL" to visualize the path in those reference frames.
+   * @memberof PathGraphics.prototype
+   * @type {Property|undefined}
+   * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+   */
+  relativeTo: createPropertyDescriptor("relativeTo"),
 });
 
 /**
@@ -133,6 +144,7 @@ PathGraphics.prototype.clone = function (result) {
   result.resolution = this.resolution;
   result.material = this.material;
   result.distanceDisplayCondition = this.distanceDisplayCondition;
+  result.relativeTo = this.relativeTo;
   return result;
 };
 
@@ -157,5 +169,6 @@ PathGraphics.prototype.merge = function (source) {
   this.material = this.material ?? source.material;
   this.distanceDisplayCondition =
     this.distanceDisplayCondition ?? source.distanceDisplayCondition;
+  this.relativeTo = this.relativeTo ?? source.relativeTo;
 };
 export default PathGraphics;

package/Source/DataSources/PathVisualizer.js

@@ -1,8 +1,10 @@
 import AssociativeArray from "../Core/AssociativeArray.js";
 import Cartesian3 from "../Core/Cartesian3.js";
+import CesiumMath from "../Core/Math.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
+import Entity from "./Entity.js";
 import JulianDate from "../Core/JulianDate.js";
 import Matrix3 from "../Core/Matrix3.js";
 import Matrix4 from "../Core/Matrix4.js";
@@ -20,6 +22,183 @@ import ReferenceProperty from "./ReferenceProperty.js";
 import SampledPositionProperty from "./SampledPositionProperty.js";
 import ScaledPositionProperty from "./ScaledPositionProperty.js";
 import TimeIntervalCollectionPositionProperty from "./TimeIntervalCollectionPositionProperty.js";
+import Quaternion from "../Core/Quaternion.js";
+
+const update3DMatrix3Scratch1 = new Matrix3();
+const update3DMatrix3Scratch2 = new Matrix3();
+const update3DMatrix3Scratch3 = new Matrix3();
+const update3DCartesian3Scratch0 = new Cartesian3();
+const update3DCartesian3Scratch1 = new Cartesian3();
+const update3DCartesian3Scratch2 = new Cartesian3();
+const update3DCartesian3Scratch3 = new Cartesian3();
+
+const transformOrientationScratch = new Quaternion();
+const transformVvlhScratch = new Matrix4();
+const transformRotationScratch = new Matrix3();
+
+/**
+ * Transforms a path entity's position into the local frame of the reference entity.
+ * If the reference entity has an orientation, uses that orientation to define the local frame.
+ * Otherwise, falls back to a VVLH (Vehicle Velocity Local Horizontal) frame derived from the reference entity's velocity.
+ *
+ * @param {JulianDate} time The time at which to evaluate the orientation or VVLH frame.
+ * @param {Cartesian3} pathEntityPos The position of the path entity in the FIXED reference frame.
+ * @param {Cartesian3} refEntityPos The position of the reference entity in the FIXED reference frame.
+ * @param {Entity} refEntity The reference entity whose frame to transform into.
+ * @param {Cartesian3} result The object onto which to store the result.
+ * @returns {Cartesian3 | undefined} The transformed position in the reference entity's local frame, or undefined if either input position is undefined.
+ */
+function transformToEntityFrame(
+  time,
+  pathEntityPos,
+  refEntityPos,
+  refEntity,
+  result,
+) {
+  if (!defined(pathEntityPos) || !defined(refEntityPos)) {
+    return undefined;
+  }
+
+  Cartesian3.subtract(pathEntityPos, refEntityPos, result);
+  if (defined(refEntity.orientation)) {
+    if (refEntity.orientation.getValue(time, transformOrientationScratch)) {
+      Quaternion.conjugate(
+        transformOrientationScratch,
+        transformOrientationScratch,
+      );
+      Matrix3.fromQuaternion(
+        transformOrientationScratch,
+        transformRotationScratch,
+      );
+      Matrix3.multiplyByVector(transformRotationScratch, result, result);
+    }
+  } else if (
+    defined(
+      computeVvlhTransform(time, refEntity.position, transformVvlhScratch),
+    )
+  ) {
+    Matrix4.inverse(transformVvlhScratch, transformVvlhScratch);
+    Matrix4.getRotation(transformVvlhScratch, transformRotationScratch);
+    Matrix3.multiplyByVector(transformRotationScratch, result, result);
+  } else {
+    // If neither ref entity's orientation nor VVLH are defined, return undefined
+    // This could happen if, for a given position of the entity we are drawing the path for,
+    // the ref entity doesn't have a position defined
+    return undefined;
+  }
+
+  return result;
+}
+
+/**
+ * Compute the vehicle velocity, local horizontal (VVLH) transform for a position property at a given time.
+ * The VVLH axes is defined based on the motion of the provided position point as follows:
+ * - The X axis is directed toward the point's velocity vector, in the direction of motion.
+ * - The Y axis is along the angular momentum vector.
+ * - The Z axis is along the position vector.
+ *
+ * @param {JulianDate} time The time at which to compute the VVLH transform.
+ * @param {PositionProperty} positionProperty The position to compute the VVLH frame for.
+ * @param {Matrix4} result The object onto which to store the result.
+ * @returns {Matrix4} The VVLH transform.
+ */
+function computeVvlhTransform(time, positionProperty, result) {
+  const cartesian = positionProperty.getValue(time, update3DCartesian3Scratch0);
+  if (defined(cartesian)) {
+    // The time delta was determined based on how fast satellites move compared to vehicles near the surface.
+    // Slower moving vehicles will most likely default to east-north-up, while faster ones will be LVLH.
+    const deltaTime = JulianDate.addSeconds(time, 0.01, new JulianDate());
+    const deltaCartesian = positionProperty.getValue(
+      deltaTime,
+      update3DCartesian3Scratch1,
+    );
+    if (
+      defined(deltaCartesian) &&
+      !Cartesian3.equalsEpsilon(cartesian, deltaCartesian, CesiumMath.EPSILON16)
+    ) {
+      let toInertial = Transforms.computeFixedToIcrfMatrix(
+        time,
+        update3DMatrix3Scratch1,
+      );
+      let toInertialDelta = Transforms.computeFixedToIcrfMatrix(
+        deltaTime,
+        update3DMatrix3Scratch2,
+      );
+      let toFixed;
+
+      if (!defined(toInertial) || !defined(toInertialDelta)) {
+        toFixed = Transforms.computeTemeToPseudoFixedMatrix(
+          time,
+          update3DMatrix3Scratch3,
+        );
+        toInertial = Matrix3.transpose(toFixed, update3DMatrix3Scratch1);
+        toInertialDelta = Transforms.computeTemeToPseudoFixedMatrix(
+          deltaTime,
+          update3DMatrix3Scratch2,
+        );
+        Matrix3.transpose(toInertialDelta, toInertialDelta);
+      } else {
+        toFixed = Matrix3.transpose(toInertial, update3DMatrix3Scratch3);
+      }
+
+      // Z along the position
+      const zBasis = update3DCartesian3Scratch2;
+      Cartesian3.normalize(cartesian, zBasis);
+      Cartesian3.normalize(deltaCartesian, deltaCartesian);
+
+      Matrix3.multiplyByVector(toInertial, zBasis, zBasis);
+      Matrix3.multiplyByVector(toInertialDelta, deltaCartesian, deltaCartesian);
+
+      // Y is along the angular momentum vector (e.g. "orbit normal")
+      const yBasis = Cartesian3.cross(
+        zBasis,
+        deltaCartesian,
+        update3DCartesian3Scratch3,
+      );
+      if (
+        !Cartesian3.equalsEpsilon(yBasis, Cartesian3.ZERO, CesiumMath.EPSILON16)
+      ) {
+        // X is along the cross of y and z (right handed basis / in the direction of motion)
+        const xBasis = Cartesian3.cross(
+          yBasis,
+          zBasis,
+          update3DCartesian3Scratch1,
+        );
+
+        Matrix3.multiplyByVector(toFixed, xBasis, xBasis);
+        Matrix3.multiplyByVector(toFixed, yBasis, yBasis);
+        Matrix3.multiplyByVector(toFixed, zBasis, zBasis);
+
+        Cartesian3.normalize(xBasis, xBasis);
+        Cartesian3.normalize(yBasis, yBasis);
+        Cartesian3.normalize(zBasis, zBasis);
+
+        if (!defined(result)) {
+          result = new Matrix4();
+        }
+
+        result[0] = xBasis.x;
+        result[1] = xBasis.y;
+        result[2] = xBasis.z;
+        result[3] = 0.0;
+        result[4] = yBasis.x;
+        result[5] = yBasis.y;
+        result[6] = yBasis.z;
+        result[7] = 0.0;
+        result[8] = zBasis.x;
+        result[9] = zBasis.y;
+        result[10] = zBasis.z;
+        result[11] = 0.0;
+        result[12] = cartesian.x;
+        result[13] = cartesian.y;
+        result[14] = cartesian.z;
+        result[15] = 1.0;
+        return result;
+      }
+    }
+  }
+  return undefined;
+}
 
 const defaultResolution = 60.0;
 const defaultWidth = 1.0;
@@ -35,6 +214,7 @@ function EntityData(entity) {
   this.updater = undefined;
 }
 
+const sampleScratch = new Cartesian3();
 function subSampleSampledProperty(
   property,
   start,
@@ -46,12 +226,38 @@ function subSampleSampledProperty(
   startingIndex,
   result,
 ) {
+  let refEntity;
+  let refPosition;
+
+  let entityFrame = false;
+  if (referenceFrame instanceof Entity) {
+    refEntity = referenceFrame;
+    refPosition = refEntity.position;
+    referenceFrame = ReferenceFrame.FIXED;
+    entityFrame = true;
+  }
+
   let r = startingIndex;
   //Always step exactly on start (but only use it if it exists.)
   let tmp;
+  let tmp2;
   tmp = property.getValueInReferenceFrame(start, referenceFrame, result[r]);
-  if (defined(tmp)) {
-    result[r++] = tmp;
+  if (!entityFrame) {
+    if (defined(tmp)) {
+      result[r++] = tmp;
+    }
+  } else {
+    tmp2 = refPosition.getValueInReferenceFrame(
+      start,
+      referenceFrame,
+      sampleScratch,
+    );
+
+    // Transform to frame of reference - either reference entity's orientation, or VVLH
+    tmp = transformToEntityFrame(start, tmp, tmp2, refEntity, tmp);
+    if (defined(tmp)) {
+      result[r++] = tmp;
+    }
   }
 
   let steppedOnNow =
@@ -78,8 +284,22 @@ function subSampleSampledProperty(
         referenceFrame,
         result[r],
       );
-      if (defined(tmp)) {
-        result[r++] = tmp;
+      if (!entityFrame) {
+        if (defined(tmp)) {
+          result[r++] = tmp;
+        }
+      } else {
+        tmp2 = refPosition.getValueInReferenceFrame(
+          updateTime,
+          referenceFrame,
+          sampleScratch,
+        );
+        if (defined(tmp) && defined(tmp2)) {
+          tmp = transformToEntityFrame(updateTime, tmp, tmp2, refEntity, tmp);
+          if (defined(tmp)) {
+            result[r++] = tmp;
+          }
+        }
       }
       steppedOnNow = true;
     }
@@ -93,8 +313,22 @@ function subSampleSampledProperty(
         referenceFrame,
         result[r],
       );
-      if (defined(tmp)) {
-        result[r++] = tmp;
+      if (!entityFrame) {
+        if (defined(tmp)) {
+          result[r++] = tmp;
+        }
+      } else {
+        tmp2 = refPosition.getValueInReferenceFrame(
+          current,
+          referenceFrame,
+          sampleScratch,
+        );
+        if (defined(tmp) && defined(tmp2)) {
+          tmp = transformToEntityFrame(current, tmp, tmp2, refEntity, tmp);
+          if (defined(tmp)) {
+            result[r++] = tmp;
+          }
+        }
       }
     }
 
@@ -129,8 +363,22 @@ function subSampleSampledProperty(
 
   //Always step exactly on stop (but only use it if it exists.)
   tmp = property.getValueInReferenceFrame(stop, referenceFrame, result[r]);
-  if (defined(tmp)) {
-    result[r++] = tmp;
+  if (!entityFrame) {
+    if (defined(tmp)) {
+      result[r++] = tmp;
+    }
+  } else {
+    tmp2 = refPosition.getValueInReferenceFrame(
+      stop,
+      referenceFrame,
+      sampleScratch,
+    );
+    if (defined(tmp) && defined(tmp2)) {
+      tmp = transformToEntityFrame(stop, tmp, tmp2, refEntity, tmp);
+      if (defined(tmp)) {
+        result[r++] = tmp;
+      }
+    }
   }
 
   return r;
@@ -484,6 +732,8 @@ function subSample(
 }
 
 const toFixedScratch = new Matrix3();
+const updateOrientationScratch = new Quaternion();
+const updateRotationScratch = new Matrix3();
 function PolylineUpdater(scene, referenceFrame) {
   this._unusedIndexes = [];
   this._polylineCollection = new PolylineCollection();
@@ -493,16 +743,38 @@ function PolylineUpdater(scene, referenceFrame) {
 }
 
 PolylineUpdater.prototype.update = function (time) {
-  if (this._referenceFrame === ReferenceFrame.INERTIAL) {
-    const toFixed = Transforms.computeIcrfToCentralBodyFixedMatrix(
-      time,
-      toFixedScratch,
-    );
+  const frame = this._referenceFrame;
+  if (frame === ReferenceFrame.INERTIAL) {
+    let toFixed = Transforms.computeIcrfToFixedMatrix(time, toFixedScratch);
+    if (!defined(toFixed)) {
+      toFixed = Transforms.computeTemeToPseudoFixedMatrix(time, toFixedScratch);
+    }
     Matrix4.fromRotationTranslation(
       toFixed,
       Cartesian3.ZERO,
       this._polylineCollection.modelMatrix,
     );
+  } else if (frame instanceof Entity) {
+    const position = frame.position.getValue(time);
+
+    // Use the reference frame entity's orientation if it has one
+    if (defined(frame.orientation)) {
+      if (defined(frame.orientation.getValue(time, updateOrientationScratch))) {
+        // Calculate the model matrix that places the body-frame path points into the world
+        Matrix3.fromQuaternion(updateOrientationScratch, updateRotationScratch);
+        Matrix4.fromRotationTranslation(
+          updateRotationScratch,
+          position,
+          this._polylineCollection.modelMatrix,
+        );
+      }
+    } else {
+      computeVvlhTransform(
+        time,
+        frame.position,
+        this._polylineCollection.modelMatrix,
+      );
+    }
   }
 };
 
@@ -597,8 +869,7 @@ PolylineUpdater.prototype.updateObject = function (time, item) {
     defaultResolution,
   );
 
-  polyline.show = true;
-  polyline.positions = subSample(
+  const positions = subSample(
     positionProperty,
     sampleStart,
     sampleStop,
@@ -607,6 +878,16 @@ PolylineUpdater.prototype.updateObject = function (time, item) {
     resolution,
     polyline.positions.slice(),
   );
+
+  // If the path only has one point, don't show it
+  // This can happen if the position is sampled at a time when it is only defined at a single point
+  if (positions.length < 2) {
+    polyline.show = false;
+    return;
+  }
+
+  polyline.show = true;
+  polyline.positions = positions;
   polyline.material = MaterialProperty.getValue(
     time,
     pathGraphics._material,
@@ -710,15 +991,40 @@ PathVisualizer.prototype.update = function (time) {
     const item = items[i];
     const entity = item.entity;
     const positionProperty = entity._position;
+    const pathGraphics = entity._path;
 
     const lastUpdater = item.updater;
 
+    let isRelative = false;
+
     let frameToVisualize = ReferenceFrame.FIXED;
+    let frameToVisualizeKey = frameToVisualize.toString();
     if (this._scene.mode === SceneMode.SCENE3D) {
-      frameToVisualize = positionProperty.referenceFrame;
+      const relativeTo = Property.getValueOrUndefined(
+        pathGraphics.relativeTo,
+        time,
+      );
+      if (defined(relativeTo)) {
+        if (relativeTo === "FIXED") {
+          frameToVisualize = ReferenceFrame.FIXED;
+          frameToVisualizeKey = frameToVisualize.toString();
+        } else if (relativeTo === "INERTIAL") {
+          frameToVisualize = ReferenceFrame.INERTIAL;
+          frameToVisualizeKey = frameToVisualize.toString();
+        } else {
+          // Path should be relative to entity
+          // Current implementation uses VVLH, ignores entity orientation
+          isRelative = true;
+          frameToVisualize = this._entityCollection.getById(relativeTo);
+          frameToVisualizeKey = relativeTo;
+        }
+      } else {
+        frameToVisualize = positionProperty.referenceFrame;
+        frameToVisualizeKey = frameToVisualize.toString();
+      }
     }
 
-    let currentUpdater = this._updaters[frameToVisualize];
+    let currentUpdater = this._updaters[frameToVisualizeKey];
 
     if (lastUpdater === currentUpdater && defined(currentUpdater)) {
       currentUpdater.updateObject(time, item);
@@ -729,10 +1035,14 @@ PathVisualizer.prototype.update = function (time) {
       lastUpdater.removeObject(item);
     }
 
+    if (isRelative && !defined(frameToVisualize)) {
+      continue;
+    }
+
     if (!defined(currentUpdater)) {
       currentUpdater = new PolylineUpdater(this._scene, frameToVisualize);
       currentUpdater.update(time);
-      this._updaters[frameToVisualize] = currentUpdater;
+      this._updaters[frameToVisualizeKey] = currentUpdater;
     }
 
     item.updater = currentUpdater;
@@ -820,4 +1130,6 @@ PathVisualizer.prototype._onCollectionChanged = function (
 
 //for testing
 PathVisualizer._subSample = subSample;
+PathVisualizer._computeVvlhTransform = computeVvlhTransform;
+PathVisualizer._transformToEntityFrame = transformToEntityFrame;
 export default PathVisualizer;

package/Source/DataSources/StaticGeometryColorBatch.js

@@ -147,18 +147,23 @@ Batch.prototype.update = function (time) {
             this.depthFailMaterial,
           );
         }
-        depthFailAppearance = new this.depthFailAppearanceType({
+
+        const DepthFailAppearanceType = this.depthFailAppearanceType;
+
+        depthFailAppearance = new DepthFailAppearanceType({
           material: this.depthFailMaterial,
           translucent: this.translucent,
           closed: this.closed,
         });
       }
 
+      const AppearanceType = this.appearanceType;
+
       primitive = new Primitive({
         show: false,
         asynchronous: true,
         geometryInstances: geometries.slice(),
-        appearance: new this.appearanceType({
+        appearance: new AppearanceType({
           translucent: this.translucent,
           closed: this.closed,
         }),