@cesium/engine 11.0.0 → 12.0.0

package/Source/Scene/PrimitiveCollection.js

@@ -142,7 +142,7 @@ PrimitiveCollection.prototype.add = function (primitive, index) {
       throw new DeveloperError("index must be greater than or equal to zero.");
     } else if (index > this._primitives.length) {
       throw new DeveloperError(
-        "index must be less than or equal to the number of primitives."
+        "index must be less than or equal to the number of primitives.",
       );
     }
   }

package/Source/Scene/PrimitiveLoadPlan.js

@@ -196,7 +196,7 @@ function generateOutlines(loadPlan) {
   // The outline generator creates a new attribute for the outline coordinates
   // that are used with a lookup texture.
   const outlineCoordinates = makeOutlineCoordinatesAttribute(
-    generator.outlineCoordinates
+    generator.outlineCoordinates,
   );
   const outlineCoordinatesPlan = new AttributeLoadPlan(outlineCoordinates);
   outlineCoordinatesPlan.loadBuffer = true;

package/Source/Scene/PrimitivePipeline.js

@@ -17,7 +17,7 @@ import WebMercatorProjection from "../Core/WebMercatorProjection.js";
 function transformToWorldCoordinates(
   instances,
   primitiveModelMatrix,
-  scene3DOnly
+  scene3DOnly,
 ) {
   let toWorld = !scene3DOnly;
   const length = instances.length;
@@ -45,7 +45,7 @@ function transformToWorldCoordinates(
     Matrix4.multiplyTransformation(
       primitiveModelMatrix,
       instances[0].modelMatrix,
-      primitiveModelMatrix
+      primitiveModelMatrix,
     );
   }
 }
@@ -113,7 +113,7 @@ function geometryPipeline(parameters) {
       instances[i].geometry.primitiveType !== primitiveType
     ) {
       throw new DeveloperError(
-        "All instance geometries must have the same primitiveType."
+        "All instance geometries must have the same primitiveType.",
       );
     }
   }
@@ -145,17 +145,17 @@ function geometryPipeline(parameters) {
         defined(instance.eastHemisphereGeometry)
       ) {
         GeometryPipeline.reorderForPostVertexCache(
-          instance.westHemisphereGeometry
+          instance.westHemisphereGeometry,
         );
         GeometryPipeline.reorderForPreVertexCache(
-          instance.westHemisphereGeometry
+          instance.westHemisphereGeometry,
         );
 
         GeometryPipeline.reorderForPostVertexCache(
-          instance.eastHemisphereGeometry
+          instance.eastHemisphereGeometry,
         );
         GeometryPipeline.reorderForPreVertexCache(
-          instance.eastHemisphereGeometry
+          instance.eastHemisphereGeometry,
         );
       }
     }
@@ -185,11 +185,11 @@ function geometryPipeline(parameters) {
             name,
             name3D,
             name2D,
-            projection
+            projection,
           );
           if (defined(geometry.boundingSphere) && name === "position") {
             geometry.boundingSphereCV = BoundingSphere.fromVertices(
-              geometry.attributes.position2D.values
+              geometry.attributes.position2D.values,
             );
           }
 
@@ -197,13 +197,13 @@ function geometryPipeline(parameters) {
             geometry,
             name3D,
             `${name3D}High`,
-            `${name3D}Low`
+            `${name3D}Low`,
           );
           GeometryPipeline.encodeAttribute(
             geometry,
             name2D,
             `${name2D}High`,
-            `${name2D}Low`
+            `${name2D}Low`,
           );
         }
       }
@@ -217,7 +217,7 @@ function geometryPipeline(parameters) {
             geometry,
             name,
             `${name}3DHigh`,
-            `${name}3DLow`
+            `${name}3DLow`,
           );
         }
       }
@@ -236,7 +236,7 @@ function geometryPipeline(parameters) {
     for (i = 0; i < length; ++i) {
       geometry = geometries[i];
       splitGeometries = splitGeometries.concat(
-        GeometryPipeline.fitToUnsignedShortIndices(geometry)
+        GeometryPipeline.fitToUnsignedShortIndices(geometry),
       );
     }
 
@@ -294,13 +294,13 @@ function createInstancePickOffsets(instances, geometries) {
     instances,
     "westHemisphereGeometry",
     geometries,
-    pickOffsets
+    pickOffsets,
   );
   createPickOffsets(
     instances,
     "eastHemisphereGeometry",
     geometries,
-    pickOffsets
+    pickOffsets,
   );
   return pickOffsets;
 }
@@ -326,7 +326,7 @@ PrimitivePipeline.combineGeometry = function (parameters) {
     geometries = geometryPipeline(parameters);
     if (geometries.length > 0) {
       attributeLocations = GeometryPipeline.createAttributeLocations(
-        geometries[0]
+        geometries[0],
       );
       if (parameters.createPickOffsets) {
         pickOffsets = createInstancePickOffsets(instances, geometries);
@@ -363,7 +363,7 @@ PrimitivePipeline.combineGeometry = function (parameters) {
       ) {
         boundingSpheres[i] = BoundingSphere.union(
           eastHemisphereGeometry.boundingSphere,
-          westHemisphereGeometry.boundingSphere
+          westHemisphereGeometry.boundingSphere,
         );
       }
       if (
@@ -372,7 +372,7 @@ PrimitivePipeline.combineGeometry = function (parameters) {
       ) {
         boundingSpheresCV[i] = BoundingSphere.union(
           eastHemisphereGeometry.boundingSphereCV,
-          westHemisphereGeometry.boundingSphereCV
+          westHemisphereGeometry.boundingSphereCV,
         );
       }
     }
@@ -451,7 +451,7 @@ function countCreateGeometryResults(items) {
  */
 PrimitivePipeline.packCreateGeometryResults = function (
   items,
-  transferableObjects
+  transferableObjects,
 ) {
   const packedData = new Float64Array(countCreateGeometryResults(items));
   const stringTable = [];
@@ -543,7 +543,7 @@ PrimitivePipeline.packCreateGeometryResults = function (
  * @private
  */
 PrimitivePipeline.unpackCreateGeometryResults = function (
-  createGeometryResult
+  createGeometryResult,
 ) {
   const stringTable = createGeometryResult.stringTable;
   const packedGeometry = createGeometryResult.packedData;
@@ -574,7 +574,7 @@ PrimitivePipeline.unpackCreateGeometryResults = function (
     if (validBoundingSphere) {
       boundingSphere = BoundingSphere.unpack(
         packedGeometry,
-        packedGeometryIndex
+        packedGeometryIndex,
       );
     }
 
@@ -584,7 +584,7 @@ PrimitivePipeline.unpackCreateGeometryResults = function (
     if (validBoundingSphereCV) {
       boundingSphereCV = BoundingSphere.unpack(
         packedGeometry,
-        packedGeometryIndex
+        packedGeometryIndex,
       );
     }
 
@@ -677,7 +677,7 @@ function unpackInstancesForCombine(data) {
         offset: new OffsetGeometryInstanceAttribute(
           packedInstances[i],
           packedInstances[i + 1],
-          packedInstances[i + 2]
+          packedInstances[i + 2],
         ),
       };
     }
@@ -697,7 +697,7 @@ function unpackInstancesForCombine(data) {
  */
 PrimitivePipeline.packCombineGeometryParameters = function (
   parameters,
-  transferableObjects
+  transferableObjects,
 ) {
   const createGeometryResults = parameters.createGeometryResults;
   const length = createGeometryResults.length;
@@ -710,7 +710,7 @@ PrimitivePipeline.packCombineGeometryParameters = function (
     createGeometryResults: parameters.createGeometryResults,
     packedInstances: packInstancesForCombine(
       parameters.instances,
-      transferableObjects
+      transferableObjects,
     ),
     ellipsoid: parameters.ellipsoid,
     isGeographic: parameters.projection instanceof GeographicProjection,
@@ -727,7 +727,7 @@ PrimitivePipeline.packCombineGeometryParameters = function (
  * @private
  */
 PrimitivePipeline.unpackCombineGeometryParameters = function (
-  packedParameters
+  packedParameters,
 ) {
   const instances = unpackInstancesForCombine(packedParameters.packedInstances);
   const createGeometryResults = packedParameters.createGeometryResults;
@@ -736,7 +736,7 @@ PrimitivePipeline.unpackCombineGeometryParameters = function (
 
   for (let resultIndex = 0; resultIndex < length; resultIndex++) {
     const geometries = PrimitivePipeline.unpackCreateGeometryResults(
-      createGeometryResults[resultIndex]
+      createGeometryResults[resultIndex],
     );
     const geometriesLength = geometries.length;
     for (
@@ -812,7 +812,7 @@ function unpackBoundingSpheres(buffer) {
  */
 PrimitivePipeline.packCombineGeometryResults = function (
   results,
-  transferableObjects
+  transferableObjects,
 ) {
   if (defined(results.geometries)) {
     transferGeometries(results.geometries, transferableObjects);
@@ -820,11 +820,11 @@ PrimitivePipeline.packCombineGeometryResults = function (
 
   const packedBoundingSpheres = packBoundingSpheres(results.boundingSpheres);
   const packedBoundingSpheresCV = packBoundingSpheres(
-    results.boundingSpheresCV
+    results.boundingSpheresCV,
   );
   transferableObjects.push(
     packedBoundingSpheres.buffer,
-    packedBoundingSpheresCV.buffer
+    packedBoundingSpheresCV.buffer,
   );
 
   return {

package/Source/Scene/PropertyTable.js

@@ -298,21 +298,21 @@ PropertyTable.prototype.getPropertyIds = function (index, results) {
     // concat in place to avoid unnecessary array allocation
     results.push.apply(
       results,
-      this._metadataTable.getPropertyIds(scratchResults)
+      this._metadataTable.getPropertyIds(scratchResults),
     );
   }
 
   if (defined(this._batchTableHierarchy)) {
     results.push.apply(
       results,
-      this._batchTableHierarchy.getPropertyIds(index, scratchResults)
+      this._batchTableHierarchy.getPropertyIds(index, scratchResults),
     );
   }
 
   if (defined(this._jsonMetadataTable)) {
     results.push.apply(
       results,
-      this._jsonMetadataTable.getPropertyIds(scratchResults)
+      this._jsonMetadataTable.getPropertyIds(scratchResults),
     );
   }
 
@@ -434,7 +434,7 @@ PropertyTable.prototype.getPropertyBySemantic = function (index, semantic) {
 PropertyTable.prototype.setPropertyBySemantic = function (
   index,
   semantic,
-  value
+  value,
 ) {
   if (defined(this._metadataTable)) {
     return this._metadataTable.setPropertyBySemantic(index, semantic, value);
@@ -497,7 +497,7 @@ function checkFeatureId(featureId, featuresLength) {
   if (!defined(featureId) || featureId < 0 || featureId >= featuresLength) {
     throw new DeveloperError(
       `featureId is required and must be between zero and featuresLength - 1 (${featuresLength}` -
-        +")."
+        +").",
     );
   }
 }

package/Source/Scene/PropertyTextureProperty.js

@@ -4,6 +4,7 @@ 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.
@@ -185,20 +186,48 @@ PropertyTextureProperty.prototype.isGpuCompatible = function () {
 
   if (classProperty.isArray) {
     // only support arrays of 1-4 UINT8 scalars (normalized or unnormalized)
-    return (
-      !classProperty.isVariableLengthArray &&
-      classProperty.arrayLength <= 4 &&
-      type === MetadataType.SCALAR &&
-      componentType === MetadataComponentType.UINT8
-    );
+    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) {
-    return componentType === MetadataComponentType.UINT8;
+    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;
 };