@cesium/engine 12.0.0 → 13.0.0

package/Source/DataSources/EntityView.js

@@ -8,8 +8,11 @@ import JulianDate from "../Core/JulianDate.js";
 import CesiumMath from "../Core/Math.js";
 import Matrix3 from "../Core/Matrix3.js";
 import Matrix4 from "../Core/Matrix4.js";
+import Quaternion from "../Core/Quaternion.js";
+import TrackingReferenceFrame from "../Core/TrackingReferenceFrame.js";
 import Transforms from "../Core/Transforms.js";
 import SceneMode from "../Scene/SceneMode.js";
+import VelocityVectorProperty from "./VelocityVectorProperty.js";
 
 const updateTransformMatrix3Scratch1 = new Matrix3();
 const updateTransformMatrix3Scratch2 = new Matrix3();
@@ -21,6 +24,9 @@ const updateTransformCartesian3Scratch3 = new Cartesian3();
 const updateTransformCartesian3Scratch4 = new Cartesian3();
 const updateTransformCartesian3Scratch5 = new Cartesian3();
 const updateTransformCartesian3Scratch6 = new Cartesian3();
+const updateTransformOrientationScratch = new Quaternion();
+const velocityScratch = new Cartesian3();
+const rotationScratch = new Matrix3();
 const deltaTime = new JulianDate();
 const northUpAxisFactor = 1.25; // times ellipsoid's maximum radius
 
@@ -30,6 +36,9 @@ function updateTransform(
   updateLookAt,
   saveCamera,
   positionProperty,
+  velocityProperty,
+  orientationProperty,
+  trackingReferenceFrame,
   time,
   ellipsoid,
 ) {
@@ -228,7 +237,44 @@ function updateTransform(
     }
 
     const transform = updateTransformMatrix4Scratch;
-    if (hasBasis) {
+
+    let orientation;
+    if (defined(orientationProperty)) {
+      orientation = orientationProperty.getValue(
+        time,
+        updateTransformOrientationScratch,
+      );
+    }
+
+    const velocity = velocityProperty.getValue(time, velocityScratch);
+
+    if (
+      trackingReferenceFrame === TrackingReferenceFrame.INERTIAL &&
+      defined(orientation)
+    ) {
+      Matrix4.fromTranslationQuaternionRotationScale(
+        cartesian,
+        orientation,
+        Cartesian3.ONE,
+        transform,
+      );
+    } else if (
+      trackingReferenceFrame === TrackingReferenceFrame.VELOCITY &&
+      defined(velocity)
+    ) {
+      const rotation = Transforms.rotationMatrixFromPositionVelocity(
+        cartesian,
+        velocity,
+        ellipsoid,
+        rotationScratch,
+      );
+      Matrix4.fromRotationTranslation(rotation, cartesian, transform);
+    } else if (
+      trackingReferenceFrame === TrackingReferenceFrame.ENU ||
+      !hasBasis
+    ) {
+      Transforms.eastNorthUpToFixedFrame(cartesian, ellipsoid, transform);
+    } else {
       transform[0] = xBasis.x;
       transform[1] = xBasis.y;
       transform[2] = xBasis.z;
@@ -245,9 +291,6 @@ function updateTransform(
       transform[13] = cartesian.y;
       transform[14] = cartesian.z;
       transform[15] = 0.0;
-    } else {
-      // Stationary or slow-moving, low-altitude objects use East-North-Up.
-      Transforms.eastNorthUpToFixedFrame(cartesian, ellipsoid, transform);
     }
 
     camera._setTransform(transform);
@@ -316,6 +359,8 @@ function EntityView(entity, scene, ellipsoid) {
   this._lastCartesian = new Cartesian3();
   this._defaultOffset3D = undefined;
 
+  this._velocityProperty = new VelocityVectorProperty(entity.position, true);
+
   this._offset3D = new Cartesian3();
 }
 
@@ -362,10 +407,13 @@ EntityView.prototype.update = function (time, boundingSphere) {
   }
 
   const entity = this.entity;
+  const trackingReferenceFrame = entity.trackingReferenceFrame;
   const positionProperty = entity.position;
   if (!defined(positionProperty)) {
     return;
   }
+  const velocityProperty = this._velocityProperty;
+  const orientationProperty = entity.orientation;
   const objectChanged = entity !== this._lastEntity;
   const sceneModeChanged = sceneMode !== this._mode;
 
@@ -419,6 +467,9 @@ EntityView.prototype.update = function (time, boundingSphere) {
     updateLookAt,
     saveCamera,
     positionProperty,
+    velocityProperty,
+    orientationProperty,
+    trackingReferenceFrame,
     time,
     ellipsoid,
   );

package/Source/DataSources/SampledProperty.js

@@ -674,6 +674,30 @@ SampledProperty.prototype.addSamples = function (
   this._definitionChanged.raiseEvent(this);
 };
 
+/**
+ * Retrieves the time of the provided sample associated with the index. A negative index accesses the list of samples in reverse order.
+ *
+ * @param {number} index The index of samples list.
+ * @returns {JulianDate | undefined} The JulianDate time of the sample, or undefined if failed.
+ */
+SampledProperty.prototype.getSample = function (index) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.number("index", index);
+  //>>includeEnd('debug');
+
+  const times = this._times;
+  const len = times.length;
+  if (!defined(len)) {
+    return undefined;
+  }
+
+  if (index < 0) {
+    index += len;
+  }
+
+  return times[index];
+};
+
 /**
  * Adds samples as a single packed array where each new sample is represented as a date,
  * followed by the packed representation of the corresponding value and derivatives.

package/Source/Renderer/ContextLimits.js

@@ -44,7 +44,7 @@ Object.defineProperties(ContextLimits, {
   },
 
   /**
-   * The approximate maximum cube mape width and height supported by this WebGL implementation.
+   * The approximate maximum cube map width and height supported by this WebGL implementation.
    * The minimum is 16, but most desktop and laptop implementations will support much larger sizes like 8,192.
    * @memberof ContextLimits
    * @type {number}

package/Source/Renderer/Texture.js

@@ -27,6 +27,7 @@ import TextureMinificationFilter from "./TextureMinificationFilter.js";
  * @property {number} [width] The pixel width of the texture. If not supplied, must be available from the source.
  * @property {number} [height] The pixel height of the texture. If not supplied, must be available from the source.
  * @property {boolean} [preMultiplyAlpha] If true, the alpha channel will be multiplied into the other channels.
+ * @property {string} [id] A unique identifier for the texture. If this is not given, then a GUID will be created.
  *
  * @private
  */
@@ -216,7 +217,7 @@ function Texture(options) {
     ? PixelFormat.compressedTextureSizeInBytes(pixelFormat, width, height)
     : PixelFormat.textureSizeInBytes(pixelFormat, pixelDatatype, width, height);
 
-  this._id = createGuid();
+  this._id = options.id ?? createGuid();
   this._context = context;
   this._textureFilterAnisotropic = context._textureFilterAnisotropic;
   this._textureTarget = gl.TEXTURE_2D;
@@ -343,7 +344,7 @@ function loadBufferSource(texture, source) {
   gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
   gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
 
-  let arrayBufferView = source.arrayBufferView;
+  let { arrayBufferView } = source;
   if (flipY) {
     arrayBufferView = PixelFormat.flipY(
       arrayBufferView,
@@ -386,6 +387,62 @@ function loadBufferSource(texture, source) {
   }
 }
 
+/**
+ * Load texel data from a buffer into part of a texture
+ *
+ * @param {Texture} texture The texture to which texel values will be loaded.
+ * @param {TypedArray} arrayBufferView The texel values to be loaded into the texture.
+ * @param {number} xOffset The texel x coordinate of the lower left corner of the subregion of the texture to be updated.
+ * @param {number} yOffset The texel y coordinate of the lower left corner of the subregion of the texture to be updated.
+ * @param {number} width The width of the source data, in pixels.
+ * @param {number} width The height of the source data, in pixels.
+ *
+ * @private
+ */
+function loadPartialBufferSource(
+  texture,
+  arrayBufferView,
+  xOffset,
+  yOffset,
+  width,
+  height,
+) {
+  const context = texture._context;
+  const gl = context._gl;
+
+  const { pixelFormat, pixelDatatype } = texture;
+
+  const unpackAlignment = PixelFormat.alignmentInBytes(
+    pixelFormat,
+    pixelDatatype,
+    width,
+  );
+  gl.pixelStorei(gl.UNPACK_ALIGNMENT, unpackAlignment);
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+
+  if (texture.flipY) {
+    arrayBufferView = PixelFormat.flipY(
+      arrayBufferView,
+      pixelFormat,
+      pixelDatatype,
+      width,
+      height,
+    );
+  }
+  gl.texSubImage2D(
+    texture._textureTarget,
+    0,
+    xOffset,
+    yOffset,
+    width,
+    height,
+    pixelFormat,
+    PixelDatatype.toWebGLConstant(pixelDatatype, context),
+    arrayBufferView,
+  );
+}
+
 /**
  * Load texel data from a framebuffer into a texture.
  *
@@ -448,6 +505,35 @@ function loadImageSource(texture, source) {
   );
 }
 
+/**
+ * Load texel data from an Image into part of a texture
+ *
+ * @param {Texture} texture The texture to which texel values will be loaded.
+ * @param {ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement} source The source for texel values to be loaded into the texture.
+ * @param {number} xOffset The texel x coordinate of the lower left corner of the subregion of the texture to be updated.
+ * @param {number} yOffset The texel y coordinate of the lower left corner of the subregion of the texture to be updated.
+ *
+ * @private
+ */
+function loadPartialImageSource(texture, source, xOffset, yOffset) {
+  const context = texture._context;
+  const gl = context._gl;
+
+  gl.pixelStorei(gl.UNPACK_ALIGNMENT, 4);
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.preMultiplyAlpha);
+  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, texture.flipY);
+
+  gl.texSubImage2D(
+    texture._textureTarget,
+    0,
+    xOffset,
+    yOffset,
+    texture.pixelFormat,
+    PixelDatatype.toWebGLConstant(texture.pixelDatatype, context),
+    source,
+  );
+}
+
 /**
  * Compute a dimension of the image for the next mip level.
  *
@@ -812,7 +898,6 @@ Texture.prototype.copyFrom = function (options) {
   gl.bindTexture(target, this._texture);
 
   let { width, height } = source;
-  const arrayBufferView = source.arrayBufferView;
 
   // Make sure we are using the element's intrinsic width and height where available
   if (defined(source.videoWidth) && defined(source.videoHeight)) {
@@ -823,25 +908,6 @@ Texture.prototype.copyFrom = function (options) {
     height = source.naturalHeight;
   }
 
-  const textureWidth = this._width;
-  const textureHeight = this._height;
-  const internalFormat = this._internalFormat;
-  const pixelFormat = this._pixelFormat;
-  const pixelDatatype = this._pixelDatatype;
-
-  const preMultiplyAlpha = this._preMultiplyAlpha;
-  const flipY = this._flipY;
-
-  let unpackAlignment = 4;
-  if (defined(arrayBufferView)) {
-    unpackAlignment = PixelFormat.alignmentInBytes(
-      pixelFormat,
-      pixelDatatype,
-      width,
-    );
-  }
-  gl.pixelStorei(gl.UNPACK_ALIGNMENT, unpackAlignment);
-
   if (skipColorSpaceConversion) {
     gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
   } else {
@@ -853,94 +919,40 @@ Texture.prototype.copyFrom = function (options) {
 
   let uploaded = false;
   if (!this._initialized) {
-    let pixels;
     if (
       xOffset === 0 &&
       yOffset === 0 &&
-      width === textureWidth &&
-      height === textureHeight
+      width === this._width &&
+      height === this._height
     ) {
       // initialize the entire texture
-      if (defined(arrayBufferView)) {
-        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
-        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-        if (flipY) {
-          pixels = PixelFormat.flipY(
-            arrayBufferView,
-            pixelFormat,
-            pixelDatatype,
-            textureWidth,
-            textureHeight,
-          );
-        } else {
-          pixels = arrayBufferView;
-        }
+      if (defined(source.arrayBufferView)) {
+        loadBufferSource(this, source);
       } else {
-        // Only valid for DOM-Element uploads
-        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, preMultiplyAlpha);
-        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);
-        pixels = source;
+        loadImageSource(this, source);
       }
       uploaded = true;
     } else {
       gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
       gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-      // initialize the entire texture to zero
-      pixels = PixelFormat.createTypedArray(
-        pixelFormat,
-        pixelDatatype,
-        textureWidth,
-        textureHeight,
-      );
+      loadNull(this);
     }
-    gl.texImage2D(
-      target,
-      0,
-      internalFormat,
-      textureWidth,
-      textureHeight,
-      0,
-      pixelFormat,
-      PixelDatatype.toWebGLConstant(pixelDatatype, context),
-      pixels,
-    );
     this._initialized = true;
   }
 
   if (!uploaded) {
-    let pixels;
-    if (defined(arrayBufferView)) {
-      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
-      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-
-      if (flipY) {
-        pixels = PixelFormat.flipY(
-          arrayBufferView,
-          pixelFormat,
-          pixelDatatype,
-          width,
-          height,
-        );
-      } else {
-        pixels = arrayBufferView;
-      }
+    if (defined(source.arrayBufferView)) {
+      loadPartialBufferSource(
+        this,
+        source.arrayBufferView,
+        xOffset,
+        yOffset,
+        width,
+        height,
+      );
     } else {
-      // Only valid for DOM-Element uploads
-      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, preMultiplyAlpha);
-      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);
-      pixels = source;
+      loadPartialImageSource(this, source, xOffset, yOffset);
     }
-    gl.texSubImage2D(
-      target,
-      0,
-      xOffset,
-      yOffset,
-      width,
-      height,
-      pixelFormat,
-      PixelDatatype.toWebGLConstant(pixelDatatype, context),
-      pixels,
-    );
   }
 
   gl.bindTexture(target, null);

package/Source/Scene/ArcGisMapService.js

@@ -4,7 +4,7 @@ import Resource from "../Core/Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "AAPTxy8BH1VEsoebNVZXo8HurEOF051kAEKlhkOhBEc9BmQpcUfxe1Yndhf82d5oKkQJ4_7VPaBQGYSISOMaRew7Sy-eTX1JQ4XwaC8v5aCvV72O6LCPs5Ss1pXXH-0uEw6bSRhTeQYHOmikutC2OMyZt6lu0VfT7FA-jVMO_UsunWNTf2cycP2O4IeDN_UV9G-VNmUu2jRvCHioi8o72ua4238s2219cYLEmcoGRJGVJTA.AT1_PjLvyih0";
+  "AAPTxy8BH1VEsoebNVZXo8HurEOF051kAEKlhkOhBEc9BmSrZYLHFXe7j_lQcsSJKc8-7rwh0IFSNWLGZErkzXRnYjMjURTz-hGiKMEeAJIZBG7uiYEn0Mt1rrwlJGIpirZQC4iO428519DlO3QC9DnRBqLXGTBhirgoU7-Z2209sy87s49kw6NOC8_Eew6nCLf-pZ883DRPRyAYH7LC8cvRLInud0EdndtUFa4y83TamrA.AT1_ahjrWDrq";
 /**
  * Default options for accessing the ArcGIS image tile service.
  *

package/Source/Scene/Cesium3DTilesetStatistics.js

@@ -1,4 +1,5 @@
 import defined from "../Core/defined.js";
+import Model3DTileContent from "./Model/Model3DTileContent.js";
 
 /**
  * @private
@@ -29,6 +30,7 @@ function Cesium3DTilesetStatistics() {
   // Memory statistics
   this.geometryByteLength = 0;
   this.texturesByteLength = 0;
+  this.texturesReferenceCounterById = {};
   this.batchTableByteLength = 0; // batch textures and any binary metadata properties not otherwise accounted for
 }
 
@@ -45,61 +47,123 @@ Cesium3DTilesetStatistics.prototype.clear = function () {
   this.numberOfTilesCulledWithChildrenUnion = 0;
 };
 
-function updatePointAndFeatureCounts(statistics, content, decrement, load) {
+/**
+ * Increment the counters for the points, triangles, and features
+ * that are currently selected for rendering.
+ *
+ * This will be called recursively for the given content and
+ * all its inner contents
+ *
+ * @param {Cesium3DTileContent} content
+ */
+Cesium3DTilesetStatistics.prototype.incrementSelectionCounts = function (
+  content,
+) {
+  this.numberOfFeaturesSelected += content.featuresLength;
+  this.numberOfPointsSelected += content.pointsLength;
+  this.numberOfTrianglesSelected += content.trianglesLength;
+
+  // Recursive calls on all inner contents
   const contents = content.innerContents;
-  const pointsLength = content.pointsLength;
-  const trianglesLength = content.trianglesLength;
-  const featuresLength = content.featuresLength;
-  const geometryByteLength = content.geometryByteLength;
-  const texturesByteLength = content.texturesByteLength;
-  const batchTableByteLength = content.batchTableByteLength;
+  if (defined(contents)) {
+    const length = contents.length;
+    for (let i = 0; i < length; ++i) {
+      this.incrementSelectionCounts(contents[i]);
+    }
+  }
+};
 
-  if (load) {
-    statistics.numberOfFeaturesLoaded += decrement
-      ? -featuresLength
-      : featuresLength;
-    statistics.numberOfPointsLoaded += decrement ? -pointsLength : pointsLength;
-    statistics.geometryByteLength += decrement
-      ? -geometryByteLength
-      : geometryByteLength;
-    statistics.texturesByteLength += decrement
-      ? -texturesByteLength
-      : texturesByteLength;
-    statistics.batchTableByteLength += decrement
-      ? -batchTableByteLength
-      : batchTableByteLength;
+/**
+ * Increment the counters for the number of features and points that
+ * are currently loaded, and the lengths (size in bytes) of the
+ * occupied memory.
+ *
+ * This will be called recursively for the given content and
+ * all its inner contents
+ *
+ * @param {Cesium3DTileContent} content
+ */
+Cesium3DTilesetStatistics.prototype.incrementLoadCounts = function (content) {
+  this.numberOfFeaturesLoaded += content.featuresLength;
+  this.numberOfPointsLoaded += content.pointsLength;
+  this.geometryByteLength += content.geometryByteLength;
+  this.batchTableByteLength += content.batchTableByteLength;
+
+  // When the content is not a `Model3DTileContent`, then its
+  // textures byte length is added directly
+  if (!(content instanceof Model3DTileContent)) {
+    this.texturesByteLength += content.texturesByteLength;
   } else {
-    statistics.numberOfFeaturesSelected += decrement
-      ? -featuresLength
-      : featuresLength;
-    statistics.numberOfPointsSelected += decrement
-      ? -pointsLength
-      : pointsLength;
-    statistics.numberOfTrianglesSelected += decrement
-      ? -trianglesLength
-      : trianglesLength;
+    // When the content is a `Model3DTileContent`, then increment the
+    // reference counter for all its textures. The byte length of any
+    // newly tracked texture to the total textures byte length
+    const textureIds = content.getTextureIds();
+    for (const textureId of textureIds) {
+      const referenceCounter =
+        this.texturesReferenceCounterById[textureId] ?? 0;
+      if (referenceCounter === 0) {
+        const textureByteLength = content.getTextureByteLengthById(textureId);
+        this.texturesByteLength += textureByteLength;
+      }
+      this.texturesReferenceCounterById[textureId] = referenceCounter + 1;
+    }
   }
 
+  // Recursive calls on all inner contents
+  const contents = content.innerContents;
   if (defined(contents)) {
     const length = contents.length;
     for (let i = 0; i < length; ++i) {
-      updatePointAndFeatureCounts(statistics, contents[i], decrement, load);
+      this.incrementLoadCounts(contents[i]);
     }
   }
-}
-
-Cesium3DTilesetStatistics.prototype.incrementSelectionCounts = function (
-  content,
-) {
-  updatePointAndFeatureCounts(this, content, false, false);
-};
-
-Cesium3DTilesetStatistics.prototype.incrementLoadCounts = function (content) {
-  updatePointAndFeatureCounts(this, content, false, true);
 };
 
+/**
+ * Decrement the counters for the number of features and points that
+ * are currently loaded, and the lengths (size in bytes) of the
+ * occupied memory.
+ *
+ * This will be called recursively for the given content and
+ * all its inner contents
+ *
+ * @param {Cesium3DTileContent} content
+ */
 Cesium3DTilesetStatistics.prototype.decrementLoadCounts = function (content) {
-  updatePointAndFeatureCounts(this, content, true, true);
+  this.numberOfFeaturesLoaded -= content.featuresLength;
+  this.numberOfPointsLoaded -= content.pointsLength;
+  this.geometryByteLength -= content.geometryByteLength;
+  this.batchTableByteLength -= content.batchTableByteLength;
+
+  // When the content is not a `Model3DTileContent`, then its
+  // textures byte length is subtracted directly
+  if (!(content instanceof Model3DTileContent)) {
+    this.texturesByteLength -= content.texturesByteLength;
+  } else {
+    // When the content is a `Model3DTileContent`, then decrement the
+    // reference counter for all its textures. The byte length of any
+    // texture that is no longer references is subtracted from the
+    // total textures byte length
+    const textureIds = content.getTextureIds();
+    for (const textureId of textureIds) {
+      const referenceCounter = this.texturesReferenceCounterById[textureId];
+      if (referenceCounter === 1) {
+        delete this.texturesReferenceCounterById[textureId];
+        const textureByteLength = content.getTextureByteLengthById(textureId);
+        this.texturesByteLength -= textureByteLength;
+      } else {
+        this.texturesReferenceCounterById[textureId] = referenceCounter - 1;
+      }
+    }
+  }
+  // Recursive calls on all inner contents
+  const contents = content.innerContents;
+  if (defined(contents)) {
+    const length = contents.length;
+    for (let i = 0; i < length; ++i) {
+      this.decrementLoadCounts(contents[i]);
+    }
+  }
 };
 
 Cesium3DTilesetStatistics.clone = function (statistics, result) {
@@ -124,6 +188,9 @@ Cesium3DTilesetStatistics.clone = function (statistics, result) {
     statistics.numberOfTilesCulledWithChildrenUnion;
   result.geometryByteLength = statistics.geometryByteLength;
   result.texturesByteLength = statistics.texturesByteLength;
+  result.texturesReferenceCounterById = {
+    ...statistics.texturesReferenceCounterById,
+  };
   result.batchTableByteLength = statistics.batchTableByteLength;
 };
 export default Cesium3DTilesetStatistics;