@cesium/engine 10.1.0 → 11.1.0

package/Source/Scene/ParticleSystem.js

@@ -95,70 +95,70 @@ function ParticleSystem(options) {
   this._bursts = options.bursts;
 
   this._modelMatrix = Matrix4.clone(
-    defaultValue(options.modelMatrix, Matrix4.IDENTITY)
+    defaultValue(options.modelMatrix, Matrix4.IDENTITY),
   );
   this._emitterModelMatrix = Matrix4.clone(
-    defaultValue(options.emitterModelMatrix, Matrix4.IDENTITY)
+    defaultValue(options.emitterModelMatrix, Matrix4.IDENTITY),
   );
   this._matrixDirty = true;
   this._combinedMatrix = new Matrix4();
 
   this._startColor = Color.clone(
-    defaultValue(options.color, defaultValue(options.startColor, Color.WHITE))
+    defaultValue(options.color, defaultValue(options.startColor, Color.WHITE)),
   );
   this._endColor = Color.clone(
-    defaultValue(options.color, defaultValue(options.endColor, Color.WHITE))
+    defaultValue(options.color, defaultValue(options.endColor, Color.WHITE)),
   );
 
   this._startScale = defaultValue(
     options.scale,
-    defaultValue(options.startScale, 1.0)
+    defaultValue(options.startScale, 1.0),
   );
   this._endScale = defaultValue(
     options.scale,
-    defaultValue(options.endScale, 1.0)
+    defaultValue(options.endScale, 1.0),
   );
 
   this._emissionRate = defaultValue(options.emissionRate, 5.0);
 
   this._minimumSpeed = defaultValue(
     options.speed,
-    defaultValue(options.minimumSpeed, 1.0)
+    defaultValue(options.minimumSpeed, 1.0),
   );
   this._maximumSpeed = defaultValue(
     options.speed,
-    defaultValue(options.maximumSpeed, 1.0)
+    defaultValue(options.maximumSpeed, 1.0),
   );
 
   this._minimumParticleLife = defaultValue(
     options.particleLife,
-    defaultValue(options.minimumParticleLife, 5.0)
+    defaultValue(options.minimumParticleLife, 5.0),
   );
   this._maximumParticleLife = defaultValue(
     options.particleLife,
-    defaultValue(options.maximumParticleLife, 5.0)
+    defaultValue(options.maximumParticleLife, 5.0),
   );
 
   this._minimumMass = defaultValue(
     options.mass,
-    defaultValue(options.minimumMass, 1.0)
+    defaultValue(options.minimumMass, 1.0),
   );
   this._maximumMass = defaultValue(
     options.mass,
-    defaultValue(options.maximumMass, 1.0)
+    defaultValue(options.maximumMass, 1.0),
   );
 
   this._minimumImageSize = Cartesian2.clone(
     defaultValue(
       options.imageSize,
-      defaultValue(options.minimumImageSize, defaultImageSize)
-    )
+      defaultValue(options.minimumImageSize, defaultImageSize),
+    ),
   );
   this._maximumImageSize = Cartesian2.clone(
     defaultValue(
       options.imageSize,
-      defaultValue(options.maximumImageSize, defaultImageSize)
-    )
+      defaultValue(options.maximumImageSize, defaultImageSize),
+    ),
   );
 
   this._sizeInMeters = defaultValue(options.sizeInMeters, false);
@@ -557,7 +557,7 @@ function updateParticlePool(system) {
   const particlePool = system._particlePool;
   const numToAdd = Math.max(
     particleEstimate - particles.length - particlePool.length,
-    0
+    0,
   );
 
   for (let j = 0; j < numToAdd; ++j) {
@@ -630,22 +630,22 @@ function updateBillboard(system, particle) {
   const r = CesiumMath.lerp(
     particle.startColor.red,
     particle.endColor.red,
-    particle.normalizedAge
+    particle.normalizedAge,
   );
   const g = CesiumMath.lerp(
     particle.startColor.green,
     particle.endColor.green,
-    particle.normalizedAge
+    particle.normalizedAge,
   );
   const b = CesiumMath.lerp(
     particle.startColor.blue,
     particle.endColor.blue,
-    particle.normalizedAge
+    particle.normalizedAge,
   );
   const a = CesiumMath.lerp(
     particle.startColor.alpha,
     particle.endColor.alpha,
-    particle.normalizedAge
+    particle.normalizedAge,
   );
   billboard.color = new Color(r, g, b, a);
 
@@ -653,7 +653,7 @@ function updateBillboard(system, particle) {
   billboard.scale = CesiumMath.lerp(
     particle.startScale,
     particle.endScale,
-    particle.normalizedAge
+    particle.normalizedAge,
   );
 }
 
@@ -665,19 +665,19 @@ function addParticle(system, particle) {
   particle.image = system.image;
   particle.life = CesiumMath.randomBetween(
     system._minimumParticleLife,
-    system._maximumParticleLife
+    system._maximumParticleLife,
   );
   particle.mass = CesiumMath.randomBetween(
     system._minimumMass,
-    system._maximumMass
+    system._maximumMass,
   );
   particle.imageSize.x = CesiumMath.randomBetween(
     system._minimumImageSize.x,
-    system._maximumImageSize.x
+    system._maximumImageSize.x,
   );
   particle.imageSize.y = CesiumMath.randomBetween(
     system._minimumImageSize.y,
-    system._maximumImageSize.y
+    system._maximumImageSize.y,
   );
 
   // Reset the normalizedAge and age in case the particle was reused.
@@ -686,7 +686,7 @@ function addParticle(system, particle) {
 
   const speed = CesiumMath.randomBetween(
     system._minimumSpeed,
-    system._maximumSpeed
+    system._maximumSpeed,
   );
   Cartesian3.multiplyByScalar(particle.velocity, speed, particle.velocity);
 
@@ -787,7 +787,7 @@ ParticleSystem.prototype.update = function (frameState) {
       this._combinedMatrix = Matrix4.multiply(
         this.modelMatrix,
         this.emitterModelMatrix,
-        this._combinedMatrix
+        this._combinedMatrix,
       );
       this._matrixDirty = false;
     }
@@ -805,26 +805,26 @@ ParticleSystem.prototype.update = function (frameState) {
       Cartesian3.add(
         particle.position,
         particle.velocity,
-        rotatedVelocityScratch
+        rotatedVelocityScratch,
       );
       Matrix4.multiplyByPoint(
         combinedMatrix,
         rotatedVelocityScratch,
-        rotatedVelocityScratch
+        rotatedVelocityScratch,
       );
 
       // Change the position to be in world coordinates
       particle.position = Matrix4.multiplyByPoint(
         combinedMatrix,
         particle.position,
-        particle.position
+        particle.position,
       );
 
       // Orient the velocity in world space as well.
       Cartesian3.subtract(
         rotatedVelocityScratch,
         particle.position,
-        particle.velocity
+        particle.velocity,
       );
       Cartesian3.normalize(particle.velocity, particle.velocity);
 

package/Source/Scene/PerInstanceColorAppearance.js

@@ -108,7 +108,7 @@ function PerInstanceColorAppearance(options) {
   this._renderState = Appearance.getDefaultRenderState(
     translucent,
     closed,
-    options.renderState
+    options.renderState,
   );
   this._closed = closed;
 

package/Source/Scene/PickDepth.js

@@ -5,6 +5,9 @@ import FramebufferManager from "../Renderer/FramebufferManager.js";
 import RenderState from "../Renderer/RenderState.js";
 
 /**
+ * @alias PickDepth
+ * @constructor
+ *
  * @private
  */
 function PickDepth() {
@@ -23,8 +26,7 @@ Object.defineProperties(PickDepth.prototype, {
 });
 
 function updateFramebuffers(pickDepth, context, depthTexture) {
-  const width = depthTexture.width;
-  const height = depthTexture.height;
+  const { width, height } = depthTexture;
   pickDepth._framebuffer.update(context, width, height);
 }
 
@@ -52,7 +54,7 @@ void main()
           },
         },
         owner: pickDepth,
-      }
+      },
     );
   }
 
@@ -70,9 +72,19 @@ const packedDepthScale = new Cartesian4(
   1.0,
   1.0 / 255.0,
   1.0 / 65025.0,
-  1.0 / 16581375.0
+  1.0 / 16581375.0,
 );
 
+/**
+ * Read the depth from the framebuffer at the given coordinate.
+ *
+ * @param {Context} context
+ * @param {number} x The x-coordinate at which to read the depth.
+ * @param {number} y The y-coordinate at which to read the depth.
+ * @returns {number} The depth read from the framebuffer.
+ *
+ * @private
+ */
 PickDepth.prototype.getDepth = function (context, x, y) {
   // If this function is called before the framebuffer is created, the depth is undefined.
   if (!defined(this.framebuffer)) {

package/Source/Scene/PickDepthFramebuffer.js

@@ -46,7 +46,7 @@ function createResources(pickDepth, context) {
 PickDepthFramebuffer.prototype.update = function (
   context,
   drawingBufferPosition,
-  viewport
+  viewport,
 ) {
   const width = viewport.width;
   const height = viewport.height;

package/Source/Scene/PickFramebuffer.js

@@ -34,7 +34,7 @@ PickFramebuffer.prototype.begin = function (screenSpaceRectangle, viewport) {
 
   BoundingRectangle.clone(
     screenSpaceRectangle,
-    this._passState.scissorTest.rectangle
+    this._passState.scissorTest.rectangle,
   );
 
   // Create or recreate renderbuffers and framebuffer used for picking
@@ -49,7 +49,7 @@ PickFramebuffer.prototype.begin = function (screenSpaceRectangle, viewport) {
   return this._passState;
 };
 
-const colorScratch = new Color();
+const colorScratchForPickFramebuffer = new Color();
 
 /**
  * Return the picked object rendered within a given rectangle.
@@ -94,12 +94,20 @@ PickFramebuffer.prototype.end = function (screenSpaceRectangle) {
     ) {
       const index = 4 * ((halfHeight - y) * width + x + halfWidth);
 
-      colorScratch.red = Color.byteToFloat(pixels[index]);
-      colorScratch.green = Color.byteToFloat(pixels[index + 1]);
-      colorScratch.blue = Color.byteToFloat(pixels[index + 2]);
-      colorScratch.alpha = Color.byteToFloat(pixels[index + 3]);
-
-      const object = context.getObjectByPickColor(colorScratch);
+      colorScratchForPickFramebuffer.red = Color.byteToFloat(pixels[index]);
+      colorScratchForPickFramebuffer.green = Color.byteToFloat(
+        pixels[index + 1],
+      );
+      colorScratchForPickFramebuffer.blue = Color.byteToFloat(
+        pixels[index + 2],
+      );
+      colorScratchForPickFramebuffer.alpha = Color.byteToFloat(
+        pixels[index + 3],
+      );
+
+      const object = context.getObjectByPickColor(
+        colorScratchForPickFramebuffer,
+      );
       if (defined(object)) {
         return object;
       }
@@ -121,13 +129,17 @@ PickFramebuffer.prototype.end = function (screenSpaceRectangle) {
 };
 
 /**
- * Return voxel tile and sample information as rendered by a pickVoxel pass,
- * within a given rectangle.
+ * Return a typed array containing the RGBA (byte) components of the
+ * pixel that is at the center of the given rectangle.
+ *
+ * This may, for example, be voxel tile and sample information as rendered
+ * by a pickVoxel pass, within a given rectangle. Or it may be the result
+ * of a metadata picking rendering pass.
  *
  * @param {BoundingRectangle} screenSpaceRectangle
- * @returns {TypedArray}
+ * @returns {Uint8Array} The RGBA components
  */
-PickFramebuffer.prototype.readVoxelInfo = function (screenSpaceRectangle) {
+PickFramebuffer.prototype.readCenterPixel = function (screenSpaceRectangle) {
   const width = defaultValue(screenSpaceRectangle.width, 1.0);
   const height = defaultValue(screenSpaceRectangle.height, 1.0);
 

package/Source/Scene/PickedMetadataInfo.js

@@ -0,0 +1,39 @@
+/**
+ * Information about metadata that is supposed to be picked.
+ *
+ * This is initialized in the `Scene.pickMetadata` function, and passed to
+ * the `FrameState`. It is used to configure the draw commands that render
+ * the metadata values of an object into the picking frame buffer. The
+ * raw values are read from that buffer, and are then translated back into
+ * proper metadata values in `Picking.pickMetadata`, using the structural
+ * information about the metadata `classProperty` that is stored here.
+ *
+ * @private
+ */
+function PickedMetadataInfo(schemaId, className, propertyName, classProperty) {
+  /**
+   * The optional ID of the metadata schema
+   *
+   * @type {string|undefined}
+   */
+  this.schemaId = schemaId;
+  /**
+   * The name of the metadata class
+   *
+   * @type {string}
+   */
+  this.className = className;
+  /**
+   * The name of the metadata property
+   *
+   * @type {string}
+   */
+  this.propertyName = propertyName;
+  /**
+   * The optional ID of the metadata schema
+   *
+   * @type {MetadataClassProperty}
+   */
+  this.classProperty = classProperty;
+}
+export default PickedMetadataInfo;