@cesium/engine 22.3.0 → 23.0.0

package/Source/Scene/Model/PntsLoader.js

@@ -37,50 +37,45 @@ const MetallicRoughness = ModelComponents.MetallicRoughness;
 /**
  * Loads a .pnts point cloud and transcodes it into a {@link ModelComponents}
  *
- * @alias PntsLoader
- * @constructor
- * @augments ResourceLoader
  * @private
- *
- * @param {object} options An object containing the following properties
- * @param {ArrayBuffer} options.arrayBuffer The array buffer of the pnts contents
- * @param {number} [options.byteOffset] The byte offset to the beginning of the pnts contents in the array buffer
- * @param {boolean} [options.loadAttributesFor2D=false] If true, load the positions buffer as a typed array for accurately projecting models to 2D.
  */
-function PntsLoader(options) {
-  options = options ?? Frozen.EMPTY_OBJECT;
+class PntsLoader extends ResourceLoader {
+  /**
+   * @param {object} options An object containing the following properties
+   * @param {ArrayBuffer} options.arrayBuffer The array buffer of the pnts contents
+   * @param {number} [options.byteOffset] The byte offset to the beginning of the pnts contents in the array buffer
+   * @param {boolean} [options.loadAttributesFor2D=false] If true, load the positions buffer as a typed array for accurately projecting models to 2D.
+   */
+  constructor(options) {
+    super();
 
-  const arrayBuffer = options.arrayBuffer;
-  const byteOffset = options.byteOffset ?? 0;
+    options = options ?? Frozen.EMPTY_OBJECT;
 
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("options.arrayBuffer", arrayBuffer);
-  //>>includeEnd('debug');
+    const arrayBuffer = options.arrayBuffer;
+    const byteOffset = options.byteOffset ?? 0;
 
-  this._arrayBuffer = arrayBuffer;
-  this._byteOffset = byteOffset;
-  this._loadAttributesFor2D = options.loadAttributesFor2D ?? false;
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.object("options.arrayBuffer", arrayBuffer);
+    //>>includeEnd('debug');
 
-  this._parsedContent = undefined;
-  this._decodePromise = undefined;
-  this._decodedAttributes = undefined;
+    this._arrayBuffer = arrayBuffer;
+    this._byteOffset = byteOffset;
+    this._loadAttributesFor2D = options.loadAttributesFor2D ?? false;
 
-  this._promise = undefined;
-  this._error = undefined;
-  this._state = ResourceLoaderState.UNLOADED;
-  this._buffers = [];
+    this._parsedContent = undefined;
+    this._decodePromise = undefined;
+    this._decodedAttributes = undefined;
 
-  // The batch table object contains a json and a binary component access using keys of the same name.
-  this._components = undefined;
-  this._transform = Matrix4.IDENTITY;
-}
+    this._promise = undefined;
+    this._error = undefined;
+    this._state = ResourceLoaderState.UNLOADED;
+    this._buffers = [];
 
-if (defined(Object.create)) {
-  PntsLoader.prototype = Object.create(ResourceLoader.prototype);
-  PntsLoader.prototype.constructor = PntsLoader;
-}
+    // The batch table object contains a json and a binary component access using keys of the same name.
+    this._components = undefined;
+    this._transform = Matrix4.IDENTITY;
+  }
 
-Object.defineProperties(PntsLoader.prototype, {
   /**
    * The cache key of the resource
    *
@@ -90,11 +85,9 @@ Object.defineProperties(PntsLoader.prototype, {
    * @readonly
    * @private
    */
-  cacheKey: {
-    get: function () {
-      return undefined;
-    },
-  },
+  get cacheKey() {
+    return undefined;
+  }
 
   /**
    * The loaded components.
@@ -105,11 +98,9 @@ Object.defineProperties(PntsLoader.prototype, {
    * @readonly
    * @private
    */
-  components: {
-    get: function () {
-      return this._components;
-    },
-  },
+  get components() {
+    return this._components;
+  }
 
   /**
    * A world-space transform to apply to the primitives.
@@ -121,50 +112,60 @@ Object.defineProperties(PntsLoader.prototype, {
    * @readonly
    * @private
    */
-  transform: {
-    get: function () {
-      return this._transform;
-    },
-  },
-});
-
-/**
- * Loads the resource.
- * @returns {Promise<PntsLoader>} A promise which resolves to the loader when the resource loading is completed.
- * @private
- */
-PntsLoader.prototype.load = function () {
-  if (defined(this._promise)) {
-    return this._promise;
+  get transform() {
+    return this._transform;
   }
 
-  this._parsedContent = PntsParser.parse(this._arrayBuffer, this._byteOffset);
-  this._state = ResourceLoaderState.PROCESSING;
+  /**
+   * Loads the resource.
+   * @returns {Promise<PntsLoader>} A promise which resolves to the loader when the resource loading is completed.
+   * @private
+   */
+  load() {
+    if (defined(this._promise)) {
+      return this._promise;
+    }
 
-  this._promise = Promise.resolve(this);
-};
+    this._parsedContent = PntsParser.parse(this._arrayBuffer, this._byteOffset);
+    this._state = ResourceLoaderState.PROCESSING;
 
-PntsLoader.prototype.process = function (frameState) {
-  if (defined(this._error)) {
-    const error = this._error;
-    this._error = undefined;
-    throw error;
+    this._promise = Promise.resolve(this);
   }
 
-  if (this._state === ResourceLoaderState.READY) {
-    return true;
-  }
+  process(frameState) {
+    if (defined(this._error)) {
+      const error = this._error;
+      this._error = undefined;
+      throw error;
+    }
+
+    if (this._state === ResourceLoaderState.READY) {
+      return true;
+    }
+
+    if (this._state === ResourceLoaderState.PROCESSING) {
+      if (defined(this._decodePromise)) {
+        return false;
+      }
 
-  if (this._state === ResourceLoaderState.PROCESSING) {
-    if (defined(this._decodePromise)) {
-      return false;
+      this._decodePromise = decodeDraco(this, frameState.context);
     }
 
-    this._decodePromise = decodeDraco(this, frameState.context);
+    return false;
   }
 
-  return false;
-};
+  unload() {
+    const buffers = this._buffers;
+    for (let i = 0; i < buffers.length; i++) {
+      buffers[i].destroy();
+    }
+    buffers.length = 0;
+
+    this._components = undefined;
+    this._parsedContent = undefined;
+    this._arrayBuffer = undefined;
+  }
+}
 
 function decodeDraco(loader, context) {
   const parsedContent = loader._parsedContent;
@@ -701,16 +702,4 @@ function addPropertyAttributesToPrimitive(
   primitive.propertyAttributeIds = [0];
 }
 
-PntsLoader.prototype.unload = function () {
-  const buffers = this._buffers;
-  for (let i = 0; i < buffers.length; i++) {
-    buffers[i].destroy();
-  }
-  buffers.length = 0;
-
-  this._components = undefined;
-  this._parsedContent = undefined;
-  this._arrayBuffer = undefined;
-};
-
 export default PntsLoader;

package/Source/Scene/Panorama.js

@@ -0,0 +1,53 @@
+import DeveloperError from "../Core/DeveloperError.js";
+
+/**
+ * Displays panorama imagery in a scene. This type describes an interface and is not intended to be instantiated directly.
+ *
+ * @alias Panorama
+ * @constructor
+ * @abstract
+ *
+ * @see EquirectangularPanorama
+ * @see CubeMapPanorama
+ * @see GoogleStreetViewCubeMapPanoramaProvider
+ *
+ *
+ * @demo {@link https://sandcastle.cesium.com/index.html?id=panorama|Cesium Sandcastle Panorama}
+ */
+function Panorama() {
+  DeveloperError.throwInstantiationError();
+}
+
+Object.defineProperties(Panorama.prototype, {
+  /**
+   * Determines if the panorama will be shown.
+   * @memberof Panorama.prototype
+   * @type {boolean}
+   */
+  show: {
+    get: DeveloperError.throwInstantiationError,
+    set: DeveloperError.throwInstantiationError,
+  },
+
+  /**
+   * Gets the transform of the panorama.
+   * @memberof Panorama.prototype
+   * @type {Matrix4}
+   * @readonly
+   */
+  transform: {
+    get: DeveloperError.throwInstantiationError,
+  },
+
+  /**
+   * Gets the credits of the panorama.
+   * @memberof Panorama.prototype
+   * @type {Credit}
+   * @readonly
+   */
+  credit: {
+    get: DeveloperError.throwInstantiationError,
+  },
+});
+
+export default Panorama;

package/Source/Scene/PanoramaProvider.js

@@ -0,0 +1,43 @@
+import DeveloperError from "../Core/DeveloperError.js";
+
+/**
+ * Provides imagery to be displayed on the surface of an ellipsoid.  This type describes an
+ * interface and is not intended to be instantiated directly.
+ *
+ * @alias PanoramaProvider
+ * @constructor
+ * @abstract
+ *
+ * @see GoogleStreetViewCubeMapPanoramaProvider
+ * @see EquirectangularPanorama
+ * @see CubeMapPanorama
+ *
+ * @demo {@link https://sandcastle.cesium.com/index.html?id=panorama|Cesium Sandcastle Panorama}
+ */
+function PanoramaProvider() {
+  DeveloperError.throwInstantiationError();
+}
+
+Object.defineProperties(PanoramaProvider.prototype, {});
+
+/**
+ * Returns a panorama provider.
+ *
+ * @param {object} options Input options to create the panorama provider.
+ * @returns {PanoramaProvider} The panorama provider for loading panoramas into a scene.
+ */
+PanoramaProvider.fromUrl = function (options) {
+  DeveloperError.throwInstantiationError();
+};
+
+/**
+ * Returns a panorama primitive.
+ *
+ * @param {object} options Input options to create the panorama primitive.
+ * @returns {Panorama} The panorama primitive for displaying panoramas in a scene.
+ */
+PanoramaProvider.prototype.loadPanorama = function (options) {
+  DeveloperError.throwInstantiationError();
+};
+
+export default PanoramaProvider;

package/Source/Scene/PointPrimitiveCollection.js

@@ -24,6 +24,7 @@ import BlendingState from "./BlendingState.js";
 import BlendOption from "./BlendOption.js";
 import PointPrimitive from "./PointPrimitive.js";
 import SceneMode from "./SceneMode.js";
+import AttributeCompression from "../Core/AttributeCompression.js";
 
 const SHOW_INDEX = PointPrimitive.SHOW_INDEX;
 const POSITION_INDEX = PointPrimitive.POSITION_INDEX;
@@ -501,6 +502,7 @@ function createVAF(context, numberOfPointPrimitives, buffersUsage) {
 // instead of storing it in a vertex buffer.
 
 const writePositionScratch = new EncodedCartesian3();
+const writeColorScratch = new Color();
 
 function writePositionSizeAndOutline(
   pointPrimitiveCollection,
@@ -539,7 +541,6 @@ function writePositionSizeAndOutline(
   positionLowWriter(i, low.x, low.y, low.z, outlineWidth);
 }
 
-const LEFT_SHIFT16 = 65536.0; // 2^16
 const LEFT_SHIFT8 = 256.0; // 2^8
 
 function writeCompressedAttrib0(
@@ -551,31 +552,22 @@ function writeCompressedAttrib0(
   const i = pointPrimitive._index;
 
   const color = pointPrimitive.color;
-  const pickColor = pointPrimitive.getPickId(context).color;
   const outlineColor = pointPrimitive.outlineColor;
+  const pickColor = pointPrimitive.getPickId(context).color;
 
-  let red = Color.floatToByte(color.red);
-  let green = Color.floatToByte(color.green);
-  let blue = Color.floatToByte(color.blue);
-  const compressed0 = red * LEFT_SHIFT16 + green * LEFT_SHIFT8 + blue;
-
-  red = Color.floatToByte(outlineColor.red);
-  green = Color.floatToByte(outlineColor.green);
-  blue = Color.floatToByte(outlineColor.blue);
-  const compressed1 = red * LEFT_SHIFT16 + green * LEFT_SHIFT8 + blue;
-
-  red = Color.floatToByte(pickColor.red);
-  green = Color.floatToByte(pickColor.green);
-  blue = Color.floatToByte(pickColor.blue);
-  const compressed2 = red * LEFT_SHIFT16 + green * LEFT_SHIFT8 + blue;
-
-  const compressed3 =
-    Color.floatToByte(color.alpha) * LEFT_SHIFT16 +
-    Color.floatToByte(outlineColor.alpha) * LEFT_SHIFT8 +
-    Color.floatToByte(pickColor.alpha);
+  // Pack all three alpha channels into an RGB-encoded component.
+  writeColorScratch.red = color.alpha;
+  writeColorScratch.green = outlineColor.alpha;
+  writeColorScratch.blue = pickColor.alpha;
 
   const writer = vafWriters[attributeLocations.compressedAttribute0];
-  writer(i, compressed0, compressed1, compressed2, compressed3);
+  writer(
+    i,
+    AttributeCompression.encodeRGB8(color),
+    AttributeCompression.encodeRGB8(outlineColor),
+    AttributeCompression.encodeRGB8(pickColor),
+    AttributeCompression.encodeRGB8(writeColorScratch),
+  );
 }
 
 function writeCompressedAttrib1(

package/Source/Scene/PropertyTable.js

@@ -4,6 +4,7 @@ import DeveloperError from "../Core/DeveloperError.js";
 import defined from "../Core/defined.js";
 import JsonMetadataTable from "./JsonMetadataTable.js";
 import addAllToArray from "../Core/addAllToArray.js";
+import { destroyObject } from "@cesium/engine";
 
 /**
  * A property table for use with the <code>EXT_structural_metadata</code> extension or
@@ -53,6 +54,7 @@ function PropertyTable(options) {
   this._metadataTable = options.metadataTable;
   this._jsonMetadataTable = options.jsonMetadataTable;
   this._batchTableHierarchy = options.batchTableHierarchy;
+  this._texture = options.texture; // Property table buffer data packed into a GPU texture
 }
 
 Object.defineProperties(PropertyTable.prototype, {
@@ -113,6 +115,23 @@ Object.defineProperties(PropertyTable.prototype, {
     },
   },
 
+  /**
+   * The properties stored in this table.
+   *
+   * @memberof PropertyTable.prototype
+   * @type {Object<string, MetadataTableProperty>}
+   * @readonly
+   */
+  properties: {
+    get: function () {
+      if (defined(this._metadataTable)) {
+        return this._metadataTable.properties;
+      }
+
+      return undefined;
+    },
+  },
+
   /**
    * Extra user-defined properties.
    *
@@ -164,6 +183,20 @@ Object.defineProperties(PropertyTable.prototype, {
       return totalByteLength;
     },
   },
+
+  /**
+   * The texture containing the property table data, if any.
+   *
+   * @memberof PropertyTable.prototype
+   * @type {Texture | undefined}
+   * @readonly
+   * @private
+   */
+  texture: {
+    get: function () {
+      return this._texture;
+    },
+  },
 });
 
 /**
@@ -533,4 +566,14 @@ PropertyTable.prototype.getExactClassName = function (featureId) {
   return hierarchy.getClassName(featureId);
 };
 
+/**
+ * Destroys any resources that need cleaning up in the property table.
+ *
+ * @private
+ */
+PropertyTable.prototype.destroy = function () {
+  this._texture = this._texture && this._texture.destroy();
+  return destroyObject(this);
+};
+
 export default PropertyTable;

package/Source/Scene/PropertyTexture.js

@@ -105,7 +105,7 @@ Object.defineProperties(PropertyTexture.prototype, {
    *
    * @memberof PropertyTexture.prototype
    *
-   * @type {PropertyTextureProperty}
+   * @type {Object<string, PropertyTextureProperty>}
    * @readonly
    * @private
    */

package/Source/Scene/PropertyTextureProperty.js

@@ -2,9 +2,6 @@ import Check from "../Core/Check.js";
 import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import GltfLoaderUtil from "./GltfLoaderUtil.js";
-import MetadataType from "./MetadataType.js";
-import MetadataComponentType from "./MetadataComponentType.js";
-import oneTimeWarning from "../Core/oneTimeWarning.js";
 
 /**
  * A property in a property texture.
@@ -191,100 +188,6 @@ Object.defineProperties(PropertyTextureProperty.prototype, {
   },
 });
 
-PropertyTextureProperty.prototype.isGpuCompatible = function () {
-  const classProperty = this._classProperty;
-  const type = classProperty.type;
-  const componentType = classProperty.componentType;
-
-  if (classProperty.isArray) {
-    // only support arrays of 1-4 UINT8 scalars (normalized or unnormalized)
-    if (classProperty.isVariableLengthArray) {
-      oneTimeWarning(
-        `Property texture property ${classProperty.id} is a variable-length array, which is not supported`,
-      );
-      return false;
-    }
-    if (classProperty.arrayLength > 4) {
-      oneTimeWarning(
-        `Property texture property ${classProperty.id} is an array of length ${classProperty.arrayLength}, but may have at most a length of 4`,
-      );
-      return false;
-    }
-    if (type !== MetadataType.SCALAR) {
-      oneTimeWarning(
-        `Property texture property ${classProperty.id} is an array of type ${type}, but only SCALAR is supported`,
-      );
-      return false;
-    }
-    if (componentType !== MetadataComponentType.UINT8) {
-      oneTimeWarning(
-        `Property texture property ${classProperty.id} is an array with component type ${componentType}, but only UINT8 is supported`,
-      );
-      return false;
-    }
-    return true;
-  }
-
-  if (MetadataType.isVectorType(type) || type === MetadataType.SCALAR) {
-    if (componentType !== MetadataComponentType.UINT8) {
-      oneTimeWarning(
-        `Property texture property ${classProperty.id} has component type ${componentType}, but only UINT8 is supported`,
-      );
-      return false;
-    }
-    return true;
-  }
-
-  // For this initial implementation, only UINT8-based properties
-  // are supported.
-  oneTimeWarning(
-    `Property texture property ${classProperty.id} has an unsupported type`,
-  );
-  return false;
-};
-
-const floatTypesByComponentCount = [undefined, "float", "vec2", "vec3", "vec4"];
-const integerTypesByComponentCount = [
-  undefined,
-  "int",
-  "ivec2",
-  "ivec3",
-  "ivec4",
-];
-PropertyTextureProperty.prototype.getGlslType = function () {
-  const classProperty = this._classProperty;
-
-  let componentCount = MetadataType.getComponentCount(classProperty.type);
-  if (classProperty.isArray) {
-    // fixed-sized arrays of length 2-4 UINT8s are represented as vectors as the
-    // shader since those are more useful in GLSL.
-    componentCount = classProperty.arrayLength;
-  }
-
-  // Normalized UINT8 properties are float types in the shader
-  if (classProperty.normalized) {
-    return floatTypesByComponentCount[componentCount];
-  }
-
-  // other UINT8-based properties are represented as integer types.
-  return integerTypesByComponentCount[componentCount];
-};
-
-PropertyTextureProperty.prototype.unpackInShader = function (packedValueGlsl) {
-  const classProperty = this._classProperty;
-
-  // no unpacking needed if for normalized types
-  if (classProperty.normalized) {
-    return packedValueGlsl;
-  }
-
-  // integer types are read from the texture as normalized float values.
-  // these need to be rescaled to [0, 255] and cast to the appropriate integer
-  // type.
-  const glslType = this.getGlslType();
-  return `${glslType}(255.0 * ${packedValueGlsl})`;
-};
-
 /**
  * Reformat from an array of channel indices like <code>[0, 1]</code> to a
  * string of channels as would be used in GLSL swizzling (e.g. "rg")