From b971f4e5d7511d28817c5f2a17cd0517a311a1ce Mon Sep 17 00:00:00 2001
From: "jerome.fayot" <jerome.fayot@gmail.com>
Date: Thu, 29 Aug 2024 15:49:39 +0200
Subject: [PATCH 1/5] added CallbackPositionProperty

---
 .../gallery/Callback Position Property.html   | 217 ++++++++++++++++++
 .../gallery/Callback Position Property.jpg    | Bin 0 -> 17551 bytes
 CHANGES.md                                    |   1 +
 CONTRIBUTORS.md                               |   3 +-
 .../DataSources/CallbackPositionProperty.js   | 173 ++++++++++++++
 .../Source/DataSources/PathVisualizer.js      |  64 ++++++
 .../Source/DataSources/PositionProperty.js    |   1 +
 .../CallbackPositionPropertySpec.js           | 196 ++++++++++++++++
 .../ConstantPositionPropertySpec.js           |   2 +-
 9 files changed, 655 insertions(+), 2 deletions(-)
 create mode 100644 Apps/Sandcastle/gallery/Callback Position Property.html
 create mode 100644 Apps/Sandcastle/gallery/Callback Position Property.jpg
 create mode 100644 packages/engine/Source/DataSources/CallbackPositionProperty.js
 create mode 100644 packages/engine/Specs/DataSources/CallbackPositionPropertySpec.js
diff --git a/Apps/Sandcastle/gallery/Callback Position Property.html b/Apps/Sandcastle/gallery/Callback Position Property.html
new file mode 100644
index 00000000000..e95cd9e82db
--- /dev/null
+++ b/Apps/Sandcastle/gallery/Callback Position Property.html	
@@ -0,0 +1,217 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no"
+    />
+    <meta
+      name="description"
+      content="Use Viewer to start building new applications or easily embed Cesium into existing applications."
+    />
+    <meta name="cesium-sandcastle-labels" content="Beginner, Showcases" />
+    <title>Cesium Demo</title>
+    <script type="text/javascript" src="../Sandcastle-header.js"></script>
+    <script
+      type="text/javascript"
+      src="../../../Build/CesiumUnminified/Cesium.js"
+      nomodule
+    ></script>
+    <script type="module" src="../load-cesium-es6.js"></script>
+  </head>
+  <body
+    class="sandcastle-loading"
+    data-sandcastle-bucket="bucket-requirejs.html"
+  >
+    <style>
+      @import url(../templates/bucket.css);
+    </style>
+    <div id="cesiumContainer" class="fullSize"></div>
+    <div id="loadingOverlay"><h1>Loading...</h1></div>
+    <div id="toolbar"></div>
+    <script id="cesium_sandcastle_script">
+      window.startup = async function (Cesium) {
+        "use strict";
+        //Sandcastle_Begin
+        // This example illustrates a Callback Position Property, a position property whose
+        // value is lazily evaluated by a callback function.
+        // Use a CallbackPositionProperty when your data can't be pre-computed
+        // or needs to be derived from other properties at runtime.
+        const viewer = new Cesium.Viewer("cesiumContainer", {
+          terrain: Cesium.Terrain.fromWorldTerrain(),
+        });
+
+        // Enable lighting based on the sun position.
+        viewer.scene.globe.enableLighting = true;
+
+        // Enable depth testing so things behind the terrain disappear.
+        viewer.scene.globe.depthTestAgainstTerrain = true;
+
+        // Set bounds of our simulation time.
+        const start = Cesium.JulianDate.fromDate(new Date(2015, 2, 25, 16));
+        const duration = 8;
+        const stop = Cesium.JulianDate.addSeconds(
+          start,
+          duration,
+          new Cesium.JulianDate()
+        );
+
+        // Make sure viewer is at the desired time.
+        viewer.clock.startTime = start.clone();
+        viewer.clock.stopTime = stop.clone();
+        viewer.clock.currentTime = start.clone();
+        viewer.clock.multiplier = 1.0;
+        viewer.clock.clockRange = Cesium.ClockRange.LOOP_STOP;
+        viewer.clock.shouldAnimate = true;
+
+        // Set timeline to simulation bounds.
+        viewer.timeline.zoomTo(start, stop);
+
+        // Prepare time samples.
+        const times = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
+        const firstTime = times[0];
+        const lastTime = times[times.length - 1];
+        const delta = lastTime - firstTime;
+
+        // Prepare point samples. Before and after points are used to
+        // calculate the first and last tangents for the spline.
+        const before = Cesium.Cartesian3.fromDegrees(
+          -112.87962,
+          36.27375,
+          620.01
+        );
+        const points = [
+          Cesium.Cartesian3.fromDegrees(-112.87709, 36.27782, 620.01),
+          Cesium.Cartesian3.fromDegrees(-112.87351, 36.27992, 617.9),
+          Cesium.Cartesian3.fromDegrees(-112.87081, 36.2816, 617.6),
+          Cesium.Cartesian3.fromDegrees(-112.86539, 36.28239, 625.36),
+          Cesium.Cartesian3.fromDegrees(-112.86108, 36.28137, 627.82),
+          Cesium.Cartesian3.fromDegrees(-112.85551, 36.27967, 625.54),
+          Cesium.Cartesian3.fromDegrees(-112.848, 36.27732, 628.9),
+          Cesium.Cartesian3.fromDegrees(-112.84086, 36.27739, 638.81),
+          Cesium.Cartesian3.fromDegrees(-112.83682, 36.27995, 643.31),
+        ];
+        const after = Cesium.Cartesian3.fromDegrees(
+          -112.83506,
+          36.2822,
+          643.31
+        );
+
+        // Calculate first and last tangents.
+        const firstTangent = Cesium.Cartesian3.subtract(
+          points[0],
+          before,
+          new Cesium.Cartesian3()
+        );
+        const lastTangent = Cesium.Cartesian3.subtract(
+          after,
+          points[8],
+          new Cesium.Cartesian3()
+        );
+
+        // Create the position spline.
+        const positionSpline = new Cesium.CatmullRomSpline({
+          times: times,
+          points: points,
+          firstTangent: firstTangent,
+          lastTangent: lastTangent,
+        });
+
+        // Create the callback position property and make it return spline evaluations.
+        const position = new Cesium.CallbackPositionProperty(function (
+          time,
+          result
+        ) {
+          const splineTime =
+            (delta * Cesium.JulianDate.secondsDifference(time, start)) /
+            duration;
+          if (splineTime < firstTime || splineTime > lastTime) {
+            return undefined;
+          }
+          return positionSpline.evaluate(splineTime, result);
+        },
+        false);
+
+        const orientation = new Cesium.VelocityOrientationProperty(position);
+
+        // Add a waypoints.
+        for (let i = 0; i < points.length; ++i) {
+          viewer.entities.add({
+            position: points[i],
+            point: {
+              pixelSize: 8,
+              color: Cesium.Color.TRANSPARENT,
+              outlineColor: Cesium.Color.YELLOW,
+              outlineWidth: 3,
+            },
+          });
+        }
+
+        // Create the entity and bind its position to the callback position property
+        viewer.entities.add({
+          availability: new Cesium.TimeIntervalCollection([
+            new Cesium.TimeInterval({
+              start: start,
+              stop: stop,
+            }),
+          ]),
+          position: position,
+          orientation: orientation,
+          model: {
+            uri: "../../SampleData/models/CesiumDrone/CesiumDrone.glb",
+            minimumPixelSize: 64,
+            maximumScale: 20000,
+          },
+          path: {
+            material: new Cesium.PolylineGlowMaterialProperty({
+              glowPower: 0.1,
+              color: Cesium.Color.YELLOW,
+            }),
+            width: 10,
+            resolution: 0.01,
+            leadTime: 1,
+            trailTime: 0.1,
+          },
+        });
+
+        const camera = viewer.camera;
+
+        const scratchPosition = new Cesium.Cartesian3();
+        const scratchOrientation = new Cesium.Quaternion();
+        const scratchTransform = new Cesium.Matrix4();
+        const offset = new Cesium.Cartesian3(-100, 0, 10);
+
+        // Update camera to follow entity's position and orientation
+        viewer.clock.onTick.addEventListener(function (clock) {
+          const time = clock.currentTime;
+          const entityPosition = position.getValue(time, scratchPosition);
+          const entityOrientation = orientation.getValue(
+            time,
+            scratchOrientation
+          );
+          if (entityPosition === undefined || entityOrientation === undefined) {
+            return;
+          }
+          const transform = Cesium.Matrix4.fromTranslationQuaternionRotationScale(
+            entityPosition,
+            entityOrientation,
+            Cesium.Cartesian3.ONE,
+            scratchTransform
+          );
+          camera.lookAtTransform(transform, offset);
+        });
+        //Sandcastle_End
+      };
+      if (typeof Cesium !== "undefined") {
+        window.startupCalled = true;
+        window.startup(Cesium).catch((error) => {
+          "use strict";
+          console.error(error);
+        });
+        Sandcastle.finishedLoading();
+      }
+    </script>
+  </body>
+</html>
diff --git a/Apps/Sandcastle/gallery/Callback Position Property.jpg b/Apps/Sandcastle/gallery/Callback Position Property.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..3a4c588906fa96714f81866f942709e0d50ec5cd
GIT binary patch
literal 17551
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
Q>sZM`Z|xpvthclO3$aA&I{*Lx

literal 0
HcmV?d00001

diff --git a/CHANGES.md b/CHANGES.md
index 3a5a5ce448f..ca4dd030145 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -9,6 +9,7 @@
 - Enable MSAA by default with 4 samples. To turn MSAA off set `scene.msaaSamples = 1` [#12158](https://github.com/CesiumGS/cesium/pull/12158)
 - Made the `time` parameter optional for `Property`, using `JulianDate.now()` as default. [#12099](https://github.com/CesiumGS/cesium/pull/12099)
 - Exposes `ScreenSpaceCameraController.zoomFactor` to allow adjusting the zoom factor (speed). [#9145](https://github.com/CesiumGS/cesium/pull/9145)
+- Added `CallbackPositionProperty` to allow lazy entity position evaluation.
 
 ##### Fixes :wrench:
 
diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 5ffba76b8eb..bbdc1f9c8ac 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -404,4 +404,5 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to Cesiu
 - [Vladislav Yunev](https://github.com/YunVlad)
 - [Levi Montgomery](https://github.com/Levi-Montgomery)
 - [Brandon Berisford](https://github.com/BeyondBelief96)
-- [Adam Wirth](https://https://github.com/adamwirth)
+- [Adam Wirth](https://github.com/adamwirth)
+- [Jérôme Fayot](https://github.com/jfayot)
diff --git a/packages/engine/Source/DataSources/CallbackPositionProperty.js b/packages/engine/Source/DataSources/CallbackPositionProperty.js
new file mode 100644
index 00000000000..61909f99566
--- /dev/null
+++ b/packages/engine/Source/DataSources/CallbackPositionProperty.js
@@ -0,0 +1,173 @@
+import defaultValue from "../Core/defaultValue.js";
+import defined from "../Core/defined.js";
+import DeveloperError from "../Core/DeveloperError.js";
+import Event from "../Core/Event.js";
+import JulianDate from "../Core/JulianDate.js";
+import ReferenceFrame from "../Core/ReferenceFrame.js";
+import PositionProperty from "./PositionProperty.js";
+
+/**
+ * A {@link PositionProperty} whose value is lazily evaluated by a callback function.
+ *
+ * @alias CallbackPositionProperty
+ * @constructor
+ *
+ * @param {CallbackPositionProperty.Callback} callback The function to be called when the position property is evaluated.
+ * @param {boolean} isConstant <code>true</code> when the callback function returns the same value every time, <code>false</code> if the value will change.
+ * @param {ReferenceFrame} [referenceFrame=ReferenceFrame.FIXED] The reference frame in which the position is defined.
+ *
+ * @demo {@link https://sandcastle.cesium.com/index.html?src=Callback%20Position%20Property.html|Cesium Sandcastle Callback Position Property Demo}
+ */
+function CallbackPositionProperty(callback, isConstant, referenceFrame) {
+  this._callback = undefined;
+  this._isConstant = undefined;
+  this._referenceFrame = defaultValue(referenceFrame, ReferenceFrame.FIXED);
+  this._definitionChanged = new Event();
+  this.setCallback(callback, isConstant);
+}
+
+Object.defineProperties(CallbackPositionProperty.prototype, {
+  /**
+   * Gets a value indicating if this property is constant.
+   * @memberof CallbackPositionProperty.prototype
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  isConstant: {
+    get: function () {
+      return this._isConstant;
+    },
+  },
+  /**
+   * Gets the event that is raised whenever the definition of this property changes.
+   * The definition is considered to have changed if a call to getValue would return
+   * a different result for the same time.
+   * @memberof CallbackPositionProperty.prototype
+   *
+   * @type {Event}
+   * @readonly
+   */
+  definitionChanged: {
+    get: function () {
+      return this._definitionChanged;
+    },
+  },
+  /**
+   * Gets the reference frame in which the position is defined.
+   * @memberof CallbackPositionProperty.prototype
+   * @type {ReferenceFrame}
+   * @default ReferenceFrame.FIXED;
+   */
+  referenceFrame: {
+    get: function () {
+      return this._referenceFrame;
+    },
+  },
+});
+
+const timeScratch = new JulianDate();
+
+/**
+ * Gets the value of the property at the provided time in the fixed frame.
+ *
+ * @param {JulianDate} [time=JulianDate.now()] The time for which to retrieve the value. If omitted, the current system time is used.
+ * @param {Cartesian3} [result] The object to store the value into, if omitted, a new instance is created and returned.
+ * @returns {Cartesian3 | undefined} The modified result parameter or a new instance if the result parameter was not supplied.
+ */
+CallbackPositionProperty.prototype.getValue = function (time, result) {
+  if (!defined(time)) {
+    time = JulianDate.now(timeScratch);
+  }
+  return this.getValueInReferenceFrame(time, ReferenceFrame.FIXED, result);
+};
+
+/**
+ * Sets the callback to be used.
+ *
+ * @param {CallbackPositionProperty.Callback} callback The function to be called when the property is evaluated.
+ * @param {boolean} isConstant <code>true</code> when the callback function returns the same value every time, <code>false</code> if the value will change.
+ */
+CallbackPositionProperty.prototype.setCallback = function (
+  callback,
+  isConstant
+) {
+  //>>includeStart('debug', pragmas.debug);
+  if (!defined(callback)) {
+    throw new DeveloperError("callback is required.");
+  }
+  if (!defined(isConstant)) {
+    throw new DeveloperError("isConstant is required.");
+  }
+  //>>includeEnd('debug');
+
+  const changed =
+    this._callback !== callback || this._isConstant !== isConstant;
+
+  this._callback = callback;
+  this._isConstant = isConstant;
+
+  if (changed) {
+    this._definitionChanged.raiseEvent(this);
+  }
+};
+
+/**
+ * Gets the value of the property at the provided time and in the provided reference frame.
+ *
+ * @param {JulianDate} time The time for which to retrieve the value.
+ * @param {ReferenceFrame} referenceFrame The desired referenceFrame of the result.
+ * @param {Cartesian3} [result] The object to store the value into, if omitted, a new instance is created and returned.
+ * @returns {Cartesian3 | undefined} The modified result parameter or a new instance if the result parameter was not supplied.
+ */
+CallbackPositionProperty.prototype.getValueInReferenceFrame = function (
+  time,
+  referenceFrame,
+  result
+) {
+  //>>includeStart('debug', pragmas.debug);
+  if (!defined(time)) {
+    throw new DeveloperError("time is required.");
+  }
+  if (!defined(referenceFrame)) {
+    throw new DeveloperError("referenceFrame is required.");
+  }
+  //>>includeEnd('debug');
+
+  const value = this._callback(time, result);
+
+  return PositionProperty.convertToReferenceFrame(
+    time,
+    value,
+    this._referenceFrame,
+    referenceFrame,
+    result
+  );
+};
+
+/**
+ * Compares this property to the provided property and returns
+ * <code>true</code> if they are equal, <code>false</code> otherwise.
+ *
+ * @param {Property} [other] The other property.
+ * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+ */
+CallbackPositionProperty.prototype.equals = function (other) {
+  return (
+    this === other ||
+    (other instanceof CallbackPositionProperty &&
+      this._callback === other._callback &&
+      this._isConstant === other._isConstant &&
+      this._referenceFrame === other._referenceFrame)
+  );
+};
+
+/**
+ * A function that returns the value of the position property.
+ * @callback CallbackPositionProperty.Callback
+ *
+ * @param {JulianDate} [time=JulianDate.now()] The time for which to retrieve the value. If omitted, the current system time is used.
+ * @param {Cartesian3} [result] The object to store the value into. If omitted, the function must create and return a new instance.
+ * @returns {Cartesian3 | undefined} The modified result parameter, or a new instance if the result parameter was not supplied or is unsupported.
+ */
+export default CallbackPositionProperty;
diff --git a/packages/engine/Source/DataSources/PathVisualizer.js b/packages/engine/Source/DataSources/PathVisualizer.js
index 8ae9a415fff..6c99fc36815 100644
--- a/packages/engine/Source/DataSources/PathVisualizer.js
+++ b/packages/engine/Source/DataSources/PathVisualizer.js
@@ -11,6 +11,7 @@ import TimeInterval from "../Core/TimeInterval.js";
 import Transforms from "../Core/Transforms.js";
 import PolylineCollection from "../Scene/PolylineCollection.js";
 import SceneMode from "../Scene/SceneMode.js";
+import CallbackPositionProperty from "./CallbackPositionProperty.js";
 import CompositePositionProperty from "./CompositePositionProperty.js";
 import ConstantPositionProperty from "./ConstantPositionProperty.js";
 import MaterialProperty from "./MaterialProperty.js";
@@ -135,6 +136,58 @@ function subSampleSampledProperty(
   return r;
 }
 
+function subSampleCallbackPositionProperty(
+  property,
+  start,
+  stop,
+  updateTime,
+  referenceFrame,
+  maximumStep,
+  startingIndex,
+  result
+) {
+  let tmp;
+  let i = 0;
+  let index = startingIndex;
+  let time = start;
+  let steppedOnNow =
+    !defined(updateTime) ||
+    JulianDate.lessThanOrEquals(updateTime, start) ||
+    JulianDate.greaterThanOrEquals(updateTime, stop);
+  while (JulianDate.lessThan(time, stop)) {
+    if (!steppedOnNow && JulianDate.greaterThanOrEquals(time, updateTime)) {
+      steppedOnNow = true;
+      tmp = property.getValueInReferenceFrame(
+        updateTime,
+        referenceFrame,
+        result[index]
+      );
+      if (defined(tmp)) {
+        result[index] = tmp;
+        index++;
+      }
+    }
+    tmp = property.getValueInReferenceFrame(
+      time,
+      referenceFrame,
+      result[index]
+    );
+    if (defined(tmp)) {
+      result[index] = tmp;
+      index++;
+    }
+    i++;
+    time = JulianDate.addSeconds(start, maximumStep * i, new JulianDate());
+  }
+  //Always sample stop.
+  tmp = property.getValueInReferenceFrame(stop, referenceFrame, result[index]);
+  if (defined(tmp)) {
+    result[index] = tmp;
+    index++;
+  }
+  return index;
+}
+
 function subSampleGenericProperty(
   property,
   start,
@@ -339,6 +392,17 @@ function reallySubSample(
       index,
       result
     );
+  } else if (property instanceof CallbackPositionProperty) {
+    index = subSampleCallbackPositionProperty(
+      property,
+      start,
+      stop,
+      updateTime,
+      referenceFrame,
+      maximumStep,
+      index,
+      result
+    );
   } else if (property instanceof CompositePositionProperty) {
     index = subSampleCompositeProperty(
       property,
diff --git a/packages/engine/Source/DataSources/PositionProperty.js b/packages/engine/Source/DataSources/PositionProperty.js
index 66a9c384b67..17bce66ed19 100644
--- a/packages/engine/Source/DataSources/PositionProperty.js
+++ b/packages/engine/Source/DataSources/PositionProperty.js
@@ -14,6 +14,7 @@ import Transforms from "../Core/Transforms.js";
  * @constructor
  * @abstract
  *
+ * @see CallbackPositionProperty
  * @see CompositePositionProperty
  * @see ConstantPositionProperty
  * @see SampledPositionProperty
diff --git a/packages/engine/Specs/DataSources/CallbackPositionPropertySpec.js b/packages/engine/Specs/DataSources/CallbackPositionPropertySpec.js
new file mode 100644
index 00000000000..c9c2470f89a
--- /dev/null
+++ b/packages/engine/Specs/DataSources/CallbackPositionPropertySpec.js
@@ -0,0 +1,196 @@
+import {
+  JulianDate,
+  CallbackPositionProperty,
+  Cartesian3,
+  PositionProperty,
+  ReferenceFrame,
+} from "../../index.js";
+
+describe("DataSources/CallbackPositionProperty", function () {
+  const time = JulianDate.now();
+
+  it("constructor throws with undefined isConstant", function () {
+    expect(function () {
+      return new CallbackPositionProperty(function () {}, undefined);
+    }).toThrowDeveloperError();
+  });
+
+  it("constructor throws with undefined callback", function () {
+    expect(function () {
+      return new CallbackPositionProperty(undefined, true);
+    }).toThrowDeveloperError();
+  });
+
+  it("constructor sets expected defaults", function () {
+    const callback = jasmine.createSpy("callback");
+    let property = new CallbackPositionProperty(callback, true);
+    expect(property.referenceFrame).toBe(ReferenceFrame.FIXED);
+
+    property = new CallbackPositionProperty(
+      callback,
+      true,
+      ReferenceFrame.INERTIAL
+    );
+    expect(property.referenceFrame).toBe(ReferenceFrame.INERTIAL);
+  });
+
+  it("callback received proper parameters", function () {
+    const result = {};
+    const callback = jasmine.createSpy("callback");
+    const property = new CallbackPositionProperty(callback, true);
+    property.getValue(time, result);
+    expect(callback).toHaveBeenCalledWith(time, result);
+  });
+
+  it("getValue returns callback result", function () {
+    const value = new Cartesian3(1, 2, 3);
+    const callback = function (_time, result) {
+      return value.clone(result);
+    };
+    const property = new CallbackPositionProperty(callback, true);
+    const result = property.getValue(time);
+    expect(result).not.toBe(value);
+    expect(result).toEqual(value);
+
+    const value2 = new Cartesian3();
+    expect(property.getValue(time, value2)).toBe(value2);
+  });
+
+  it("getValue returns in fixed frame", function () {
+    const valueInertial = new Cartesian3(1, 2, 3);
+    const valueFixed = PositionProperty.convertToReferenceFrame(
+      time,
+      valueInertial,
+      ReferenceFrame.INERTIAL,
+      ReferenceFrame.FIXED
+    );
+    const callback = function (_time, result) {
+      return valueInertial.clone(result);
+    };
+    const property = new CallbackPositionProperty(
+      callback,
+      true,
+      ReferenceFrame.INERTIAL
+    );
+
+    const result = property.getValue(time);
+    expect(result).toEqual(valueFixed);
+  });
+
+  it("getValue uses JulianDate.now() if time parameter is undefined", function () {
+    spyOn(JulianDate, "now").and.callThrough();
+
+    const value = new Cartesian3(1, 2, 3);
+    const callback = function (_time, result) {
+      return value.clone(result);
+    };
+    const property = new CallbackPositionProperty(callback, true);
+    const actualResult = property.getValue();
+    expect(JulianDate.now).toHaveBeenCalled();
+    expect(actualResult).toEqual(value);
+  });
+
+  it("getValueInReferenceFrame works without a result parameter", function () {
+    const value = new Cartesian3(1, 2, 3);
+    const callback = function (_time, result) {
+      return value.clone(result);
+    };
+    const property = new CallbackPositionProperty(callback, true);
+
+    const result = property.getValueInReferenceFrame(
+      time,
+      ReferenceFrame.INERTIAL
+    );
+    expect(result).not.toBe(value);
+    expect(result).toEqual(
+      PositionProperty.convertToReferenceFrame(
+        time,
+        value,
+        ReferenceFrame.FIXED,
+        ReferenceFrame.INERTIAL
+      )
+    );
+  });
+
+  it("getValueInReferenceFrame works with a result parameter", function () {
+    const value = new Cartesian3(1, 2, 3);
+    const callback = function (_time, result) {
+      return value.clone(result);
+    };
+    const property = new CallbackPositionProperty(
+      callback,
+      true,
+      ReferenceFrame.INERTIAL
+    );
+
+    const expected = new Cartesian3();
+    const result = property.getValueInReferenceFrame(
+      time,
+      ReferenceFrame.FIXED,
+      expected
+    );
+    expect(result).toBe(expected);
+    expect(expected).toEqual(
+      PositionProperty.convertToReferenceFrame(
+        time,
+        value,
+        ReferenceFrame.INERTIAL,
+        ReferenceFrame.FIXED
+      )
+    );
+  });
+
+  it("getValueInReferenceFrame throws with undefined time", function () {
+    const property = new CallbackPositionProperty(function () {}, true);
+
+    expect(function () {
+      property.getValueInReferenceFrame(undefined, ReferenceFrame.FIXED);
+    }).toThrowDeveloperError();
+  });
+
+  it("getValueInReferenceFrame throws with undefined reference frame", function () {
+    const property = new CallbackPositionProperty(function () {}, true);
+
+    expect(function () {
+      property.getValueInReferenceFrame(time, undefined);
+    }).toThrowDeveloperError();
+  });
+
+  it("isConstant returns correct value", function () {
+    const property = new CallbackPositionProperty(function () {}, true);
+    expect(property.isConstant).toBe(true);
+    property.setCallback(function () {}, false);
+    expect(property.isConstant).toBe(false);
+  });
+
+  it("setCallback raises definitionChanged event", function () {
+    const property = new CallbackPositionProperty(function () {}, true);
+    const listener = jasmine.createSpy("listener");
+    property.definitionChanged.addEventListener(listener);
+    property.setCallback(function () {}, false);
+    expect(listener).toHaveBeenCalledWith(property);
+  });
+
+  it("equals works", function () {
+    const callback = function () {};
+    const left = new CallbackPositionProperty(callback, true);
+    let right = new CallbackPositionProperty(callback, true);
+
+    expect(left.equals(right)).toEqual(true);
+
+    right.setCallback(callback, false);
+    expect(left.equals(right)).toEqual(false);
+
+    right.setCallback(function () {
+      return undefined;
+    }, true);
+    expect(left.equals(right)).toEqual(false);
+
+    right = new CallbackPositionProperty(
+      callback,
+      true,
+      ReferenceFrame.INERTIAL
+    );
+    expect(left.equals(right)).toEqual(false);
+  });
+});
diff --git a/packages/engine/Specs/DataSources/ConstantPositionPropertySpec.js b/packages/engine/Specs/DataSources/ConstantPositionPropertySpec.js
index 7c1442cdef9..0d4c734aeef 100644
--- a/packages/engine/Specs/DataSources/ConstantPositionPropertySpec.js
+++ b/packages/engine/Specs/DataSources/ConstantPositionPropertySpec.js
@@ -61,7 +61,7 @@ describe("DataSources/ConstantPositionProperty", function () {
     expect(property.getValue(time)).toBeUndefined();
   });
 
-  it("getValue work swith undefined inertial value", function () {
+  it("getValue works with undefined inertial value", function () {
     const property = new ConstantPositionProperty(
       undefined,
       ReferenceFrame.INERTIAL

From 0477bd58bbc6ee5d1d91601bdf862ea7760d2f96 Mon Sep 17 00:00:00 2001
From: "jerome.fayot" <jerome.fayot@gmail.com>
Date: Thu, 29 Aug 2024 16:09:27 +0200
Subject: [PATCH 2/5] updated CHANGES.md

---
 CHANGES.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGES.md b/CHANGES.md
index ca4dd030145..12068d9f9d0 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -9,7 +9,7 @@
 - Enable MSAA by default with 4 samples. To turn MSAA off set `scene.msaaSamples = 1` [#12158](https://github.com/CesiumGS/cesium/pull/12158)
 - Made the `time` parameter optional for `Property`, using `JulianDate.now()` as default. [#12099](https://github.com/CesiumGS/cesium/pull/12099)
 - Exposes `ScreenSpaceCameraController.zoomFactor` to allow adjusting the zoom factor (speed). [#9145](https://github.com/CesiumGS/cesium/pull/9145)
-- Added `CallbackPositionProperty` to allow lazy entity position evaluation.
+- Added `CallbackPositionProperty` to allow lazy entity position evaluation. [#12170](https://github.com/CesiumGS/cesium/pull/12170)
 
 ##### Fixes :wrench:
 

From 0fa1e9dcb7deb42c0f538b54ce2a1cfe2ee0b1d6 Mon Sep 17 00:00:00 2001
From: "jerome.fayot" <jerome.fayot@gmail.com>
Date: Thu, 29 Aug 2024 16:56:30 +0200
Subject: [PATCH 3/5] fixed crash on sandcastle demo while morphing

---
 .../gallery/Callback Position Property.html          | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/Apps/Sandcastle/gallery/Callback Position Property.html b/Apps/Sandcastle/gallery/Callback Position Property.html
index e95cd9e82db..ae11190b8ac 100644
--- a/Apps/Sandcastle/gallery/Callback Position Property.html	
+++ b/Apps/Sandcastle/gallery/Callback Position Property.html	
@@ -177,14 +177,26 @@
         });
 
         const camera = viewer.camera;
+        const scene = viewer.scene;
 
         const scratchPosition = new Cesium.Cartesian3();
         const scratchOrientation = new Cesium.Quaternion();
         const scratchTransform = new Cesium.Matrix4();
         const offset = new Cesium.Cartesian3(-100, 0, 10);
 
+        let morphing = false;
+        scene.morphStart.addEventListener(function () {
+          morphing = true;
+        });
+        scene.morphComplete.addEventListener(function () {
+          morphing = false;
+        });
+
         // Update camera to follow entity's position and orientation
         viewer.clock.onTick.addEventListener(function (clock) {
+          if (morphing) {
+            return;
+          }
           const time = clock.currentTime;
           const entityPosition = position.getValue(time, scratchPosition);
           const entityOrientation = orientation.getValue(

From 533f2a2267c01a10634b8047f8e0d30fde5490a8 Mon Sep 17 00:00:00 2001
From: "jerome.fayot" <jerome.fayot@gmail.com>
Date: Thu, 29 Aug 2024 17:38:56 +0200
Subject: [PATCH 4/5] added PathVizualizer test case for callback position
 property

---
 .../Specs/DataSources/PathVisualizerSpec.js   | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/packages/engine/Specs/DataSources/PathVisualizerSpec.js b/packages/engine/Specs/DataSources/PathVisualizerSpec.js
index c34f20ce89d..ce9ecfff278 100644
--- a/packages/engine/Specs/DataSources/PathVisualizerSpec.js
+++ b/packages/engine/Specs/DataSources/PathVisualizerSpec.js
@@ -16,6 +16,8 @@ import {
   PolylineOutlineMaterialProperty,
   ReferenceProperty,
   SampledPositionProperty,
+  CallbackPositionProperty,
+  LinearSpline,
   ScaledPositionProperty,
   TimeIntervalCollectionPositionProperty,
   SceneMode,
@@ -733,6 +735,58 @@ describe(
       expect(result).toEqual([new Cartesian3(0, 0, 3)]);
     });
 
+    it("subSample works for callback position properties", function () {
+      const t1 = new JulianDate(0, 0);
+      const t2 = new JulianDate(2, 0);
+      const updateTime = new JulianDate(1, 1);
+      const duration = JulianDate.secondsDifference(t2, t1);
+      const spline = new LinearSpline({
+        times: [0, 1],
+        points: [new Cartesian3(0, 0, 0), new Cartesian3(0, 0, 1)],
+      });
+      const callback = function (time, result) {
+        if (JulianDate.lessThan(time, t1) || JulianDate.greaterThan(time, t2)) {
+          return undefined;
+        }
+        if (result === undefined) {
+          result = new Cartesian3();
+        }
+        const delta = JulianDate.secondsDifference(time, t1);
+        return spline.evaluate(delta / duration, result);
+      };
+
+      const property = new CallbackPositionProperty(callback, false);
+
+      const referenceFrame = ReferenceFrame.FIXED;
+      const maximumStep = 43200;
+      const result = [];
+      PathVisualizer._subSample(
+        property,
+        t1,
+        t2,
+        updateTime,
+        referenceFrame,
+        maximumStep,
+        result
+      );
+      expect(result).toEqual([
+        property.getValue(t1),
+        property.getValue(
+          JulianDate.addSeconds(t1, maximumStep, new JulianDate())
+        ),
+        property.getValue(
+          JulianDate.addSeconds(t1, maximumStep * 2, new JulianDate())
+        ),
+        property.getValue(updateTime),
+        property.getValue(
+          JulianDate.addSeconds(t1, maximumStep * 3, new JulianDate())
+        ),
+        property.getValue(
+          JulianDate.addSeconds(t1, maximumStep * 4, new JulianDate())
+        ),
+      ]);
+    });
+
     function CustomPositionProperty(innerProperty) {
       this.SampledProperty = innerProperty;
       this.isConstant = innerProperty.isConstant;

From 82381cda56cbf9f203b2ef3abd886067ee3355ab Mon Sep 17 00:00:00 2001
From: "jerome.fayot" <jerome.fayot@gmail.com>
Date: Tue, 10 Sep 2024 21:08:27 +0200
Subject: [PATCH 5/5] fix: changes following review

---
 .../gallery/Callback Position Property.html          | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/Apps/Sandcastle/gallery/Callback Position Property.html b/Apps/Sandcastle/gallery/Callback Position Property.html
index ae11190b8ac..19dab3dadca 100644
--- a/Apps/Sandcastle/gallery/Callback Position Property.html	
+++ b/Apps/Sandcastle/gallery/Callback Position Property.html	
@@ -9,7 +9,7 @@
     />
     <meta
       name="description"
-      content="Use Viewer to start building new applications or easily embed Cesium into existing applications."
+      content="Use a CallbackPositionProperty when your data can't be pre-computed or needs to be derived from other properties at runtime."
     />
     <meta name="cesium-sandcastle-labels" content="Beginner, Showcases" />
     <title>Cesium Demo</title>
@@ -184,17 +184,9 @@
         const scratchTransform = new Cesium.Matrix4();
         const offset = new Cesium.Cartesian3(-100, 0, 10);
 
-        let morphing = false;
-        scene.morphStart.addEventListener(function () {
-          morphing = true;
-        });
-        scene.morphComplete.addEventListener(function () {
-          morphing = false;
-        });
-
         // Update camera to follow entity's position and orientation
         viewer.clock.onTick.addEventListener(function (clock) {
-          if (morphing) {
+          if (scene.mode === Cesium.Scene.MORPHING) {
             return;
           }
           const time = clock.currentTime;
