@cesium/engine 25.0.0 → 26.1.0

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

@@ -64,6 +64,7 @@ const {
   LineStyle,
   Material,
   Vector,
+  Polygon,
 } = ModelComponents;
 
 /**
@@ -533,6 +534,7 @@ class GltfLoader extends ResourceLoader {
 
 /**
  * Loads the gltf object
+ * @ignore
  */
 async function loadGltfJson(loader) {
   loader._state = GltfLoaderState.LOADING;
@@ -899,6 +901,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;
@@ -2208,6 +2242,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 +2410,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)) {

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/ImageryLayer.js

@@ -676,11 +676,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 (

package/Source/Scene/ImageryLayerCollection.js

@@ -545,7 +545,7 @@ ImageryLayerCollection.prototype.pickImageryLayerFeatures = function (
 /**
  * Updates frame state to execute any queued texture re-projections.
  *
- * @private
+ * @ignore
  *
  * @param {FrameState} frameState The frameState.
  */
@@ -561,7 +561,7 @@ ImageryLayerCollection.prototype.queueReprojectionCommands = function (
 /**
  * Cancels re-projection commands queued for the next frame.
  *
- * @private
+ * @ignore
  */
 ImageryLayerCollection.prototype.cancelReprojections = function () {
   const layers = this._layers;