@hztxi/cesium-engine 25.0.6 → 26.2.1

package/Source/Scene/GltfBufferViewLoader.js

@@ -1,7 +1,7 @@
 import Check from "../Core/Check.js";
 import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
-import hasExtension from "./hasExtension.js";
+import findMeshoptExtension from "./findMeshoptExtension.js";
 import { MeshoptDecoder } from "meshoptimizer";
 import ResourceLoader from "./ResourceLoader.js";
 import ResourceLoaderState from "./ResourceLoaderState.js";
@@ -54,8 +54,8 @@ class GltfBufferViewLoader extends ResourceLoader {
     let meshoptMode;
     let meshoptFilter;
 
-    if (hasExtension(bufferView, "EXT_meshopt_compression")) {
-      const meshopt = bufferView.extensions.EXT_meshopt_compression;
+    const meshopt = findMeshoptExtension(bufferView);
+    if (defined(meshopt)) {
       bufferId = meshopt.buffer;
       byteOffset = meshopt.byteOffset ?? 0;
       byteLength = meshopt.byteLength;

package/Source/Scene/GltfLoader.js

@@ -61,9 +61,11 @@ const {
   Specular,
   Anisotropy,
   Clearcoat,
+  PlanarFill,
   LineStyle,
   Material,
   Vector,
+  Polygon,
 } = ModelComponents;
 
 /**
@@ -533,6 +535,7 @@ class GltfLoader extends ResourceLoader {
 
 /**
  * Loads the gltf object
+ * @ignore
  */
 async function loadGltfJson(loader) {
   loader._state = GltfLoaderState.LOADING;
@@ -899,6 +902,38 @@ function loadAccessor(loader, accessor, useQuaternion) {
   return loadDefaultAccessorValues(accessor, values);
 }
 
+function loadAccessorTypedArray(loader, accessor) {
+  const values = ComponentDatatype.createTypedArray(
+    accessor.componentType,
+    accessor.count * AttributeType.getNumberOfComponents(accessor.type),
+  );
+
+  if (!defined(accessor.bufferView)) {
+    return values;
+  }
+
+  const bufferViewLoader = getBufferViewLoader(loader, accessor.bufferView);
+
+  // Save a link to the gltfJson, which is removed after bufferViewLoader.load()
+  const { gltfJson } = loader;
+
+  const promise = bufferViewLoader.load().then(() => {
+    if (loader.isDestroyed()) {
+      return;
+    }
+    const result = getPackedTypedArray(
+      gltfJson,
+      accessor,
+      bufferViewLoader.typedArray,
+    );
+    values.set(result);
+  });
+
+  loader._loaderPromises.push(promise);
+
+  return values;
+}
+
 function fromArray(MathType, values) {
   if (!defined(values)) {
     return undefined;
@@ -1753,6 +1788,23 @@ function loadClearcoat(loader, clearcoatInfo, frameState) {
   return clearcoat;
 }
 
+/**
+ * Load properties for the BENTLEY_materials_planar_fill extension.
+ *
+ * Note: The wireframeFill property is loaded but is currently a NO-OP in the
+ * rendering pipeline. CesiumJS does not yet have a proper wireframe rendering
+ * mode, so this value is stored for completeness but has no effect on rendering.
+ * See https://github.com/CesiumGS/cesium/issues/13620 and
+ * MaterialPipelineStage.js for more details.
+ *
+ * @param {object} planarFillInfo The contents of the BENTLEY_materials_planar_fill extension in the parsed glTF JSON
+ * @returns {ModelComponents.PlanarFill}
+ * @private
+ */
+function loadPlanarFill(planarFillInfo) {
+  return new PlanarFill(planarFillInfo);
+}
+
 function loadLineStyle(lineStyleInfo) {
   if (!defined(lineStyleInfo)) {
     return undefined;
@@ -1799,6 +1851,7 @@ function loadMaterial(loader, gltfMaterial, frameState) {
   const pbrAnisotropy = extensions.KHR_materials_anisotropy;
   const pbrClearcoat = extensions.KHR_materials_clearcoat;
   const pbrMetallicRoughness = gltfMaterial.pbrMetallicRoughness;
+  const planarFill = extensions.BENTLEY_materials_planar_fill;
 
   material.unlit = defined(extensions.KHR_materials_unlit);
 
@@ -1855,6 +1908,11 @@ function loadMaterial(loader, gltfMaterial, frameState) {
   material.alphaCutoff = gltfMaterial.alphaCutoff;
   material.doubleSided = gltfMaterial.doubleSided;
 
+  // BENTLEY_materials_planar_fill extension
+  if (defined(planarFill)) {
+    material.planarFill = loadPlanarFill(planarFill);
+  }
+
   // BENTLEY_materials_point_style extension
   const pointStyleExtension = extensions.BENTLEY_materials_point_style;
   if (defined(pointStyleExtension) && defined(pointStyleExtension.diameter)) {
@@ -2122,7 +2180,7 @@ function loadEdgeVisibilityLineStrings(
       throw new RuntimeError("Edge visibility line string accessor not found!");
     }
 
-    const indices = loadAccessor(loader, accessor);
+    const indices = loadAccessorTypedArray(loader, accessor);
     const restartIndex = getLineStringPrimitiveRestartValue(
       accessor.componentType,
     );
@@ -2154,7 +2212,10 @@ function loadEdgeVisibility(loader, edgeVisibilityExtension) {
     if (!defined(visibilityAccessor)) {
       throw new RuntimeError("Edge visibility accessor not found!");
     }
-    edgeVisibility.visibility = loadAccessor(loader, visibilityAccessor);
+    edgeVisibility.visibility = loadAccessorTypedArray(
+      loader,
+      visibilityAccessor,
+    );
   }
 
   edgeVisibility.materialColor = getEdgeVisibilityMaterialColor(
@@ -2166,7 +2227,9 @@ function loadEdgeVisibility(loader, edgeVisibilityExtension) {
     const silhouetteNormalsAccessor =
       loader.gltfJson.accessors[edgeVisibilityExtension.silhouetteNormals];
     if (defined(silhouetteNormalsAccessor)) {
-      edgeVisibility.silhouetteNormals = loadAccessor(
+      // Packed typed array (x0,y0,z0, x1,y1,z1, ...), not an array of
+      // Cartesian3s. Avoids a large JS heap cost for edge-heavy tiles.
+      edgeVisibility.silhouetteNormals = loadAccessorTypedArray(
         loader,
         silhouetteNormalsAccessor,
       );
@@ -2208,6 +2271,17 @@ function loadPrimitive(loader, gltfPrimitive, hasInstances, frameState) {
   }
 
   const extensions = gltfPrimitive.extensions ?? Frozen.EMPTY_OBJECT;
+
+  const polygonExtension = extensions.EXT_mesh_polygon;
+  if (defined(polygonExtension)) {
+    primitive.polygon = loadMeshPolygonExtension(
+      loader,
+      gltfPrimitive,
+      polygonExtension,
+    );
+  }
+
+  // @deprecated CESIUM_mesh_vector to be removed after v1.142 release.
   const meshVectorExtension = extensions.CESIUM_mesh_vector;
   if (defined(meshVectorExtension)) {
     primitive.vector = loadMeshVectorExtension(loader, meshVectorExtension);
@@ -2365,12 +2439,77 @@ function loadPrimitiveOutline(loader, outlineExtension) {
   return loadAccessor(loader, accessor, useQuaternion);
 }
 
+/**
+ * @typedef {object} EXTMeshPolygonExtension
+ * @property {number} count
+ * @property {number} indicesOffsets
+ * @property {number} [loopIndices]
+ * @property {number} [loopIndicesOffsets]
+ * @property {number} [triangleIndices]
+ * @property {number} [triangleIndicesOffsets]
+ */
+
+/**
+ * Load EXT_mesh_polygon.
+ * @param {GltfLoader} loader
+ * @param {object} gltfPrimitive
+ * @param {EXTMeshPolygonExtension} polygonExtension
+ * @returns {ModelComponents.Polygon}
+ * @ignore
+ */
+function loadMeshPolygonExtension(loader, gltfPrimitive, polygonExtension) {
+  const result = new Polygon();
+  const accessors = loader.gltfJson.accessors;
+
+  result.count = polygonExtension.count;
+
+  // See ModelComponents.Polygon definition.
+  if (gltfPrimitive.mode === PrimitiveType.LINE_LOOP) {
+    result.loopIndices = loadAccessorTypedArray(
+      loader,
+      accessors[gltfPrimitive.indices],
+    );
+    result.loopIndicesOffsets = loadAccessorTypedArray(
+      loader,
+      accessors[polygonExtension.indicesOffsets],
+    );
+    result.triangleIndices = loadAccessorTypedArray(
+      loader,
+      accessors[polygonExtension.triangleIndices],
+    );
+    result.triangleIndicesOffsets = loadAccessorTypedArray(
+      loader,
+      accessors[polygonExtension.triangleIndicesOffsets],
+    );
+  } else if (gltfPrimitive.mode === PrimitiveType.TRIANGLES) {
+    result.loopIndices = loadAccessorTypedArray(
+      loader,
+      accessors[polygonExtension.loopIndices],
+    );
+    result.loopIndicesOffsets = loadAccessorTypedArray(
+      loader,
+      accessors[polygonExtension.loopIndicesOffsets],
+    );
+    result.triangleIndices = loadAccessorTypedArray(
+      loader,
+      accessors[gltfPrimitive.indices],
+    );
+    result.triangleIndicesOffsets = loadAccessorTypedArray(
+      loader,
+      accessors[polygonExtension.indicesOffsets],
+    );
+  }
+
+  return result;
+}
+
 /**
  * Load CESIUM_mesh_vector.
  * @param {GltfLoader} loader
  * @param {*} meshVectorExtension
  * @returns {ModelComponents.Vector}
  * @ignore
+ * @deprecated
  */
 function loadMeshVectorExtension(loader, meshVectorExtension) {
   if (!defined(meshVectorExtension)) {
@@ -2405,6 +2544,10 @@ function loadMeshVectorExtension(loader, meshVectorExtension) {
     meshVectorExtension.polygonIndicesOffsets,
     "polygonIndicesOffsets",
   );
+  result.polygonTileBoundaryFlags = loadVectorAccessor(
+    meshVectorExtension.polygonTileBoundaryFlags,
+    "polygonTileBoundaryFlags",
+  );
 
   return result;
 }

package/Source/Scene/GltfLoaderUtil.js

@@ -111,6 +111,22 @@ GltfLoaderUtil.createSampler = function (options) {
     }
   }
 
+  if (!TextureWrap.validate(wrapS)) {
+    wrapS = TextureWrap.REPEAT;
+  }
+
+  if (!TextureWrap.validate(wrapT)) {
+    wrapT = TextureWrap.REPEAT;
+  }
+
+  if (!TextureMinificationFilter.validate(minFilter)) {
+    minFilter = TextureMinificationFilter.LINEAR;
+  }
+
+  if (!TextureMagnificationFilter.validate(magFilter)) {
+    magFilter = TextureMagnificationFilter.LINEAR;
+  }
+
   return new Sampler({
     wrapS: wrapS,
     wrapT: wrapT,
@@ -164,10 +180,10 @@ GltfLoaderUtil.createModelTextureReader = function (options) {
 
     // prettier-ignore
     transform = new Matrix3(
-        Math.cos(rotation) * scale.x, -Math.sin(rotation) * scale.y, offset.x,
-        Math.sin(rotation) * scale.x, Math.cos(rotation) * scale.y, offset.y,
-        0.0, 0.0, 1.0
-      );
+      Math.cos(rotation) * scale.x, -Math.sin(rotation) * scale.y, offset.x,
+      Math.sin(rotation) * scale.x, Math.cos(rotation) * scale.y, offset.y,
+      0.0, 0.0, 1.0
+    );
   }
 
   const modelTextureReader = new ModelComponents.TextureReader();

package/Source/Scene/GltfPipeline/forEachTextureInMaterial.js

@@ -73,6 +73,16 @@ function forEachTextureInMaterial(material, handler) {
       }
     }
 
+    // Transmission extension
+    const transmission = extensions.KHR_materials_transmission;
+    if (defined(transmission) && defined(transmission.transmissionTexture)) {
+      const textureInfo = transmission.transmissionTexture;
+      const value = handler(textureInfo.index, textureInfo);
+      if (defined(value)) {
+        return value;
+      }
+    }
+
     // Materials common extension (may be present in models converted from glTF 1.0)
     const materialsCommon = extensions.KHR_materials_common;
     if (defined(materialsCommon) && defined(materialsCommon.values)) {

package/Source/Scene/GltfPipeline/removeUnusedElements.js

@@ -148,11 +148,16 @@ Remove.buffer = function (gltf, bufferId) {
       bufferView.buffer--;
     }
 
-    if (
-      defined(bufferView.extensions) &&
-      defined(bufferView.extensions.EXT_meshopt_compression)
-    ) {
-      bufferView.extensions.EXT_meshopt_compression.buffer--;
+    const extensions = bufferView.extensions;
+    if (defined(extensions)) {
+      const ext = extensions.EXT_meshopt_compression;
+      if (defined(ext) && ext.buffer > bufferId) {
+        ext.buffer--;
+      }
+      const khr = extensions.KHR_meshopt_compression;
+      if (defined(khr) && khr.buffer > bufferId) {
+        khr.buffer--;
+      }
     }
   });
 };
@@ -583,12 +588,17 @@ getListOfElementsIdsInUse.buffer = function (gltf) {
     if (defined(bufferView.buffer)) {
       usedBufferIds[bufferView.buffer] = true;
     }
-    if (
-      defined(bufferView.extensions) &&
-      defined(bufferView.extensions.EXT_meshopt_compression)
-    ) {
-      usedBufferIds[bufferView.extensions.EXT_meshopt_compression.buffer] =
-        true;
+
+    const extensions = bufferView.extensions;
+    if (defined(extensions)) {
+      const ext = extensions.EXT_meshopt_compression;
+      if (defined(ext)) {
+        usedBufferIds[ext.buffer] = true;
+      }
+      const khr = extensions.KHR_meshopt_compression;
+      if (defined(khr)) {
+        usedBufferIds[khr.buffer] = true;
+      }
     }
   });
 

package/Source/Scene/GltfSpzLoader.js

@@ -267,7 +267,7 @@ async function loadResources(loader) {
   try {
     const bufferViewLoader = resourceCache.getBufferViewLoader({
       gltf: loader._gltf,
-      bufferViewId: 0,
+      bufferViewId: loader._spz.bufferView,
       gltfResource: loader._gltfResource,
       baseResource: loader._baseResource,
     });

package/Source/Scene/GltfVertexBufferLoader.js

@@ -29,6 +29,7 @@ class GltfVertexBufferLoader extends ResourceLoader {
    * @param {number} [options.bufferViewId] The bufferView ID corresponding to the vertex buffer.
    * @param {object} [options.primitive] The primitive containing the Draco extension.
    * @param {object} [options.draco] The Draco extension object.
+   * @param {object} [options.spz] The SPZ extension object.
    * @param {string} [options.attributeSemantic] The attribute semantic, e.g. POSITION or NORMAL.
    * @param {number} [options.accessorId] The accessor id.
    * @param {string} [options.cacheKey] The cache key of the resource.
@@ -36,7 +37,7 @@ class GltfVertexBufferLoader extends ResourceLoader {
    * @param {boolean} [options.loadBuffer=false] Load vertex buffer as a GPU vertex buffer.
    * @param {boolean} [options.loadTypedArray=false] Load vertex buffer as a typed array.
    *
-   * @exception {DeveloperError} One of options.bufferViewId and options.draco must be defined.
+   * @exception {DeveloperError} Exactly one vertex buffer source must be effective: options.bufferViewId, options.spz, or options.draco for options.attributeSemantic.
    * @exception {DeveloperError} When options.draco is defined options.attributeSemantic must also be defined.
    * @exception {DeveloperError} When options.draco is defined options.accessorId must also be defined.
    */
@@ -76,9 +77,11 @@ class GltfVertexBufferLoader extends ResourceLoader {
     const hasAttributeSemantic = defined(attributeSemantic);
     const hasAccessorId = defined(accessorId);
     const hasSpz = defined(spz);
-    if (hasBufferViewId === (hasDraco !== hasSpz)) {
+    const sourceCount =
+      Number(hasBufferViewId) + Number(hasDraco) + Number(hasSpz);
+    if (sourceCount !== 1) {
       throw new DeveloperError(
-        "One of options.bufferViewId, options.draco, or options.spz must be defined.",
+        "Exactly one vertex buffer source must be effective: options.bufferViewId, options.spz, or options.draco for options.attributeSemantic.",
       );
     }
 

package/Source/Scene/GroundPolylinePrimitive.js

@@ -182,7 +182,7 @@ function GroundPolylinePrimitive(options) {
 
   this._retainedGeometryInstances = undefined;
 
-  /** @private Root {@link GroundPolylineGeometry} ref from the last inner {@link Primitive} build. */
+  /** Root {@link GroundPolylineGeometry} ref from the last inner {@link Primitive} build. @private */
   this._lastGroundPolylineRootGeometry = undefined;
 
   this._ready = false;
@@ -816,6 +816,7 @@ GroundPolylinePrimitive.prototype.update = function (frameState) {
       GroundPolylineGeometry.setProjectionAndEllipsoid(
         geometryInstance.geometry,
         frameState.mapProjection,
+        frameState.columbusRepeatWorlds,
       );
       geometryInstance.geometry._verticalExaggeration =
         frameState.verticalExaggeration;

package/Source/Scene/I3SDataProvider.js

@@ -408,7 +408,7 @@ I3SDataProvider.prototype.updateForPass = function (frameState, passState) {
 function buildLayerUrl(provider, layerId) {
   const dataProviderUrl = provider.resource.getUrlComponent();
 
-  let layerUrl = "";
+  let layerUrl;
   if (dataProviderUrl.match(/layers\/\d/)) {
     layerUrl = `${dataProviderUrl}`.replace(/\/+$/, "");
   } else {

package/Source/Scene/I3SLayer.js

@@ -31,7 +31,7 @@ function I3SLayer(dataProvider, layerData, parent) {
 
   const parentUrl = this._parent.resource.getUrlComponent();
 
-  let tilesetUrl = "";
+  let tilesetUrl;
   if (parentUrl.match(/layers\/\d/)) {
     tilesetUrl = `${parentUrl}`.replace(/\/+$/, "");
   } else {

package/Source/Scene/I3SNode.js

@@ -474,9 +474,9 @@ I3SNode.prototype._create3DTileDefinition = function () {
     }
   }
 
-  let boundingVolume = {};
+  let boundingVolume;
   let position;
-  let span = 0;
+  let span;
   if (defined(obb)) {
     boundingVolume = {
       box: [

package/Source/Scene/ImageryLayer.js

@@ -867,11 +867,11 @@ ImageryLayer.prototype.getImageryRectangle = function () {
  * Create skeletons for the imagery tiles that partially or completely overlap a given terrain
  * tile.
  *
- * @private
+ * @ignore
  *
  * @param {QuadtreeTile} tile The terrain tile.
  * @param {TerrainProvider|undefined} terrainProvider The terrain provider associated with the terrain tile.
- * @param {number} insertionPoint The position to insert new skeletons before in the tile's imagery list.
+ * @param {number} [insertionPoint] The position to insert new skeletons before in the tile's imagery list.
  * @returns {boolean} true if this layer overlaps any portion of the terrain tile; otherwise, false.
  */
 ImageryLayer.prototype._createTileImagerySkeletons = function (