@cesium/engine 19.0.0 → 20.0.0

package/Source/Scene/GaussianSplatPrimitive.js

@@ -31,10 +31,12 @@ import Cartesian3 from "../Core/Cartesian3.js";
 import Quaternion from "../Core/Quaternion.js";
 import SplitDirection from "./SplitDirection.js";
 import destroyObject from "../Core/destroyObject.js";
+import ContextLimits from "../Renderer/ContextLimits.js";
 
 const scratchMatrix4A = new Matrix4();
 const scratchMatrix4B = new Matrix4();
 const scratchMatrix4C = new Matrix4();
+const scratchMatrix4D = new Matrix4();
 
 const GaussianSplatSortingState = {
   IDLE: 0,
@@ -44,6 +46,25 @@ const GaussianSplatSortingState = {
   ERROR: 4,
 };
 
+function createSphericalHarmonicsTexture(context, shData) {
+  const texture = new Texture({
+    context: context,
+    source: {
+      width: shData.width,
+      height: shData.height,
+      arrayBufferView: shData.data,
+    },
+    preMultiplyAlpha: false,
+    skipColorSpaceConversion: true,
+    pixelFormat: PixelFormat.RG_INTEGER,
+    pixelDatatype: PixelDatatype.UNSIGNED_INT,
+    flipY: false,
+    sampler: Sampler.NEAREST,
+  });
+
+  return texture;
+}
+
 function createGaussianSplatTexture(context, splatTextureData) {
   return new Texture({
     context: context,
@@ -64,7 +85,7 @@ function createGaussianSplatTexture(context, splatTextureData) {
 /** A primitive that renders Gaussian splats.
  * <p>
  * This primitive is used to render Gaussian splats in a 3D Tileset.
- * It is designed to work with the KHR_spz_gaussian_splats_compression extension.
+ * It is designed to work with the KHR_gaussian_splatting and KHR_gaussian_splatting_compression_spz_2 extensions.
  * </p>
  * @alias GaussianSplatPrimitive
  * @constructor
@@ -148,6 +169,14 @@ function GaussianSplatPrimitive(options) {
    * @see {@link GaussianSplatTextureGenerator}
    */
   this.gaussianSplatTexture = undefined;
+
+  /**
+   * The texture used to store the spherical harmonics coefficients for the Gaussian splats.
+   * @type {undefined|Texture}
+   * @private
+   */
+  this.sphericalHarmonicsTexture = undefined;
+
   /**
    * The last width of the Gaussian splat texture.
    * This is used to track changes in the texture size and update the primitive accordingly.
@@ -395,7 +424,7 @@ GaussianSplatPrimitive.prototype.onTileVisible = function (tile) {};
  */
 GaussianSplatPrimitive.transformTile = function (tile) {
   const computedTransform = tile.computedTransform;
-  const splatPrimitive = tile.content.splatPrimitive;
+  const gltfPrimitive = tile.content.gltfPrimitive;
   const gaussianSplatPrimitive = tile.tileset.gaussianSplatPrimitive;
 
   const computedModelMatrix = Matrix4.multiplyTransformation(
@@ -425,17 +454,17 @@ GaussianSplatPrimitive.transformTile = function (tile) {
   const rotations = tile.content._originalRotations;
   const scales = tile.content._originalScales;
   const attributePositions = ModelUtility.getAttributeBySemantic(
-    splatPrimitive,
+    gltfPrimitive,
     VertexAttributeSemantic.POSITION,
   ).typedArray;
 
   const attributeRotations = ModelUtility.getAttributeBySemantic(
-    splatPrimitive,
+    gltfPrimitive,
     VertexAttributeSemantic.ROTATION,
   ).typedArray;
 
   const attributeScales = ModelUtility.getAttributeBySemantic(
-    splatPrimitive,
+    gltfPrimitive,
     VertexAttributeSemantic.SCALE,
   ).typedArray;
 
@@ -601,12 +630,69 @@ GaussianSplatPrimitive.buildGSplatDrawCommand = function (
     ShaderDestination.VERTEX,
   );
 
+  shaderBuilder.addUniform(
+    "float",
+    "u_sphericalHarmonicsDegree",
+    ShaderDestination.VERTEX,
+  );
+
+  shaderBuilder.addUniform("float", "u_splatScale", ShaderDestination.VERTEX);
+
+  shaderBuilder.addUniform(
+    "vec3",
+    "u_cameraPositionWC",
+    ShaderDestination.VERTEX,
+  );
+
+  shaderBuilder.addUniform(
+    "mat3",
+    "u_inverseModelRotation",
+    ShaderDestination.VERTEX,
+  );
+
   const uniformMap = renderResources.uniformMap;
 
   uniformMap.u_splatAttributeTexture = function () {
     return primitive.gaussianSplatTexture;
   };
 
+  if (primitive._sphericalHarmonicsDegree > 0) {
+    shaderBuilder.addDefine(
+      "HAS_SPHERICAL_HARMONICS",
+      "1",
+      ShaderDestination.VERTEX,
+    );
+    shaderBuilder.addUniform(
+      "highp usampler2D",
+      "u_sphericalHarmonicsTexture",
+      ShaderDestination.VERTEX,
+    );
+    uniformMap.u_sphericalHarmonicsTexture = function () {
+      return primitive.sphericalHarmonicsTexture;
+    };
+  }
+  uniformMap.u_sphericalHarmonicsDegree = function () {
+    return primitive._sphericalHarmonicsDegree;
+  };
+
+  uniformMap.u_cameraPositionWC = function () {
+    return Cartesian3.clone(frameState.camera.positionWC);
+  };
+
+  uniformMap.u_inverseModelRotation = function () {
+    const tileset = primitive._tileset;
+    const modelMatrix = Matrix4.multiply(
+      tileset.modelMatrix,
+      Matrix4.fromArray(tileset.root.transform),
+      scratchMatrix4A,
+    );
+    const inverseModelRotation = Matrix4.getRotation(
+      Matrix4.inverse(modelMatrix, scratchMatrix4C),
+      scratchMatrix4D,
+    );
+    return inverseModelRotation;
+  };
+
   uniformMap.u_splitDirection = function () {
     return primitive.splitDirection;
   };
@@ -720,7 +806,11 @@ GaussianSplatPrimitive.prototype.update = function (frameState) {
     this._rootTransform = tileset.root.computedTransform;
   }
 
-  if (this._drawCommand && tileset.show) {
+  if (!tileset.show || tileset._selectedTiles.length === 0) {
+    return;
+  }
+
+  if (this._drawCommand) {
     frameState.commandList.push(this._drawCommand);
   }
 
@@ -756,6 +846,7 @@ GaussianSplatPrimitive.prototype.update = function (frameState) {
       this._scales = undefined;
       this._colors = undefined;
       this._indexes = undefined;
+      this._shData = undefined;
       this._needsGaussianSplatTexture = true;
       this._gaussianSplatTexturePending = false;
 
@@ -771,7 +862,7 @@ GaussianSplatPrimitive.prototype.update = function (frameState) {
         let aggregate;
         let offset = 0;
         for (const tile of tiles) {
-          const primitive = tile.content.splatPrimitive;
+          const primitive = tile.content.gltfPrimitive;
           const attribute = getAttributeCallback(primitive);
           if (!defined(aggregate)) {
             aggregate = ComponentDatatype.createTypedArray(
@@ -786,42 +877,71 @@ GaussianSplatPrimitive.prototype.update = function (frameState) {
         return aggregate;
       };
 
+      const aggregateShData = () => {
+        let offset = 0;
+        for (const tile of tiles) {
+          const shData = tile.content.packedSphericalHarmonicsData;
+          if (tile.content.sphericalHarmonicsDegree > 0) {
+            if (!defined(this._shData)) {
+              let coefs;
+              switch (tile.content.sphericalHarmonicsDegree) {
+                case 1:
+                  coefs = 9;
+                  break;
+                case 2:
+                  coefs = 24;
+                  break;
+                case 3:
+                  coefs = 45;
+              }
+              this._shData = new Uint32Array(totalElements * (coefs * (2 / 3)));
+            }
+            this._shData.set(shData, offset);
+            offset += shData.length;
+          }
+        }
+      };
+
       this._positions = aggregateAttributeValues(
         ComponentDatatype.FLOAT,
-        (splatPrimitive) =>
+        (gltfPrimitive) =>
           ModelUtility.getAttributeBySemantic(
-            splatPrimitive,
+            gltfPrimitive,
             VertexAttributeSemantic.POSITION,
           ),
       );
 
       this._scales = aggregateAttributeValues(
         ComponentDatatype.FLOAT,
-        (splatPrimitive) =>
+        (gltfPrimitive) =>
           ModelUtility.getAttributeBySemantic(
-            splatPrimitive,
+            gltfPrimitive,
             VertexAttributeSemantic.SCALE,
           ),
       );
 
       this._rotations = aggregateAttributeValues(
         ComponentDatatype.FLOAT,
-        (splatPrimitive) =>
+        (gltfPrimitive) =>
           ModelUtility.getAttributeBySemantic(
-            splatPrimitive,
+            gltfPrimitive,
             VertexAttributeSemantic.ROTATION,
           ),
       );
 
       this._colors = aggregateAttributeValues(
         ComponentDatatype.UNSIGNED_BYTE,
-        (splatPrimitive) =>
+        (gltfPrimitive) =>
           ModelUtility.getAttributeBySemantic(
-            splatPrimitive,
+            gltfPrimitive,
             VertexAttributeSemantic.COLOR,
           ),
       );
 
+      aggregateShData();
+      this._sphericalHarmonicsDegree =
+        tiles[0].content.sphericalHarmonicsDegree;
+
       this._numSplats = totalElements;
       this.selectedTileLength = tileset._selectedTiles.length;
     }
@@ -833,6 +953,38 @@ GaussianSplatPrimitive.prototype.update = function (frameState) {
     if (this._needsGaussianSplatTexture) {
       if (!this._gaussianSplatTexturePending) {
         GaussianSplatPrimitive.generateSplatTexture(this, frameState);
+        if (defined(this._shData)) {
+          const oldTex = this.sphericalHarmonicsTexture;
+          const width = ContextLimits.maximumTextureSize;
+          const dims =
+            tileset._selectedTiles[0].content
+              .sphericalHarmonicsCoefficientCount / 3;
+          const splatsPerRow = Math.floor(width / dims);
+          const floatsPerRow = splatsPerRow * (dims * 2);
+          const texBuf = new Uint32Array(
+            width * Math.ceil(this._numSplats / splatsPerRow) * 2,
+          );
+
+          let dataIndex = 0;
+          for (let i = 0; dataIndex < this._shData.length; i += width * 2) {
+            texBuf.set(
+              this._shData.subarray(dataIndex, dataIndex + floatsPerRow),
+              i,
+            );
+            dataIndex += floatsPerRow;
+          }
+          this.sphericalHarmonicsTexture = createSphericalHarmonicsTexture(
+            frameState.context,
+            {
+              data: texBuf,
+              width: width,
+              height: Math.ceil(this._numSplats / splatsPerRow),
+            },
+          );
+          if (defined(oldTex)) {
+            oldTex.destroy();
+          }
+        }
       }
       return;
     }

package/Source/Scene/GltfLoader.js

@@ -33,6 +33,7 @@ import GltfGpmLoader from "./Model/Extensions/Gpm/GltfGpmLoader.js";
 import GltfMeshPrimitiveGpmLoader from "./Model/Extensions/Gpm/GltfMeshPrimitiveGpmLoader.js";
 import oneTimeWarning from "../Core/oneTimeWarning.js";
 import addAllToArray from "../Core/addAllToArray.js";
+import getMeshPrimitives from "./getMeshPrimitives.js";
 
 const {
   Attribute,
@@ -1982,6 +1983,22 @@ function loadMorphTarget(
   return morphTarget;
 }
 
+function fetchSpzExtensionFrom(extensions) {
+  const gaussianSplatting = extensions?.KHR_gaussian_splatting;
+  const gsExtensions = gaussianSplatting?.extensions;
+  const spz = gsExtensions?.KHR_gaussian_splatting_compression_spz_2;
+  if (defined(spz)) {
+    return spz;
+  }
+
+  const legacySpz = extensions?.KHR_spz_gaussian_splats_compression;
+  if (defined(legacySpz)) {
+    return legacySpz;
+  }
+
+  return undefined;
+}
+
 /**
  * Load resources associated with a mesh primitive for a glTF node
  * @param {GltfLoader} loader
@@ -2019,7 +2036,8 @@ function loadPrimitive(loader, gltfPrimitive, hasInstances, frameState) {
     );
   }
 
-  const spzExtension = extensions.KHR_spz_gaussian_splats_compression;
+  //support the latest glTF spec and the legacy extension
+  const spzExtension = fetchSpzExtensionFrom(extensions);
   if (defined(spzExtension)) {
     needsPostProcessing = true;
     primitivePlan.needsGaussianSplats = true;
@@ -2432,7 +2450,7 @@ function loadNode(loader, gltfNode, frameState) {
   const meshId = gltfNode.mesh;
   if (defined(meshId)) {
     const mesh = loader.gltfJson.meshes[meshId];
-    const primitives = mesh.primitives;
+    const primitives = getMeshPrimitives(mesh);
     for (let i = 0; i < primitives.length; ++i) {
       node.primitives.push(
         loadPrimitive(

package/Source/Scene/GltfVertexBufferLoader.js

@@ -306,6 +306,26 @@ async function loadFromSpz(vertexBufferLoader) {
   }
 }
 
+function getShAttributePrefix(attribute) {
+  const prefix = attribute.startsWith("KHR_gaussian_splatting:")
+    ? "KHR_gaussian_splatting:"
+    : "_";
+  return `${prefix}SH_DEGREE_`;
+}
+
+function extractSHDegreeAndCoef(attribute) {
+  const prefix = getShAttributePrefix(attribute);
+  const separator = "_COEF_";
+
+  const lStart = prefix.length;
+  const coefIndex = attribute.indexOf(separator, lStart);
+
+  const l = parseInt(attribute.slice(lStart, coefIndex), 10);
+  const n = parseInt(attribute.slice(coefIndex + separator.length), 10);
+
+  return { l, n };
+}
+
 function processSpz(vertexBufferLoader) {
   vertexBufferLoader._state = ResourceLoaderState.PROCESSING;
   const spzLoader = vertexBufferLoader._spzLoader;
@@ -314,9 +334,16 @@ function processSpz(vertexBufferLoader) {
 
   if (vertexBufferLoader._attributeSemantic === "POSITION") {
     vertexBufferLoader._typedArray = gcloudData.positions;
-  } else if (vertexBufferLoader._attributeSemantic === "_SCALE") {
+  } else if (
+    vertexBufferLoader._attributeSemantic === "KHR_gaussian_splatting:SCALE" ||
+    vertexBufferLoader._attributeSemantic === "_SCALE"
+  ) {
     vertexBufferLoader._typedArray = gcloudData.scales;
-  } else if (vertexBufferLoader._attributeSemantic === "_ROTATION") {
+  } else if (
+    vertexBufferLoader._attributeSemantic ===
+      "KHR_gaussian_splatting:ROTATION" ||
+    vertexBufferLoader._attributeSemantic === "_ROTATION"
+  ) {
     vertexBufferLoader._typedArray = gcloudData.rotations;
   } else if (vertexBufferLoader._attributeSemantic === "COLOR_0") {
     const colors = gcloudData.colors;
@@ -344,6 +371,33 @@ function processSpz(vertexBufferLoader) {
         255.0,
       );
     }
+  } else if (vertexBufferLoader._attributeSemantic.includes("SH_DEGREE_")) {
+    const { l, n } = extractSHDegreeAndCoef(
+      vertexBufferLoader._attributeSemantic,
+    );
+    const sphericalHarmonicDegree = gcloudData.shDegree;
+    let stride = 0;
+    const base = [0, 9, 24];
+    switch (sphericalHarmonicDegree) {
+      case 1:
+        stride = 9;
+        break;
+      case 2:
+        stride = 24;
+        break;
+      case 3:
+        stride = 45;
+        break;
+    }
+    const count = gcloudData.numPoints;
+    const sh = gcloudData.sh;
+    vertexBufferLoader._typedArray = new Float32Array(count * 3);
+    for (let i = 0; i < count; i++) {
+      const idx = i * stride + base[l - 1] + n * 3;
+      vertexBufferLoader._typedArray[i * 3] = sh[idx];
+      vertexBufferLoader._typedArray[i * 3 + 1] = sh[idx + 1];
+      vertexBufferLoader._typedArray[i * 3 + 2] = sh[idx + 2];
+    }
   }
 }
 

package/Source/Scene/ITwinData.js

@@ -7,7 +7,6 @@ import Check from "../Core/Check.js";
 import KmlDataSource from "../DataSources/KmlDataSource.js";
 import GeoJsonDataSource from "../DataSources/GeoJsonDataSource.js";
 import DeveloperError from "../Core/DeveloperError.js";
-import deprecationWarning from "../Core/deprecationWarning.js";
 
 /**
  * Methods for loading iTwin platform data into CesiumJS
@@ -45,20 +44,11 @@ const ITwinData = {};
  * @throws {RuntimeError} If all exports for the given iModel are Invalid
  * @throws {RuntimeError} If the iTwin API request is not successful
  */
-ITwinData.createTilesetFromIModelId = async function (options) {
-  let internalOptions = options;
-
-  if (typeof options === "string") {
-    // the old signature was (iModelId: string, options?: Cesium3DTileset.ConstructorOptions)
-    // grab the later arguments directly instead of in the params only for this special case
-    internalOptions = { iModelId: options, tilesetOptions: arguments[1] };
-    deprecationWarning(
-      "ITwinData.createTilesetFromIModelId",
-      "The arguments signature for ITwinData functions has changed in 1.132 in favor of a single options object. Please update your code. This fallback will be removed in 1.133",
-    );
-  }
-
-  const { iModelId, changesetId, tilesetOptions } = internalOptions;
+ITwinData.createTilesetFromIModelId = async function ({
+  iModelId,
+  changesetId,
+  tilesetOptions,
+}) {
   const { exports } = await ITwinPlatform.getExports(iModelId, changesetId);
 
   if (
@@ -100,6 +90,9 @@ ITwinData.createTilesetFromIModelId = async function (options) {
  * If the <code>type</code> or <code>rootDocument</code> are not provided this function
  * will first request the full metadata for the specified reality data to fill these values.
  *
+ * The <code>maximumScreenSpaceError</code> of the resulting tileset will default to 4,
+ * unless it is explicitly overridden with the given tileset options.
+ *
  * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
  *
  * @param {Object} options
@@ -107,30 +100,19 @@ ITwinData.createTilesetFromIModelId = async function (options) {
  * @param {string} options.realityDataId The id of the reality data to load
  * @param {ITwinPlatform.RealityDataType} [options.type] The type of this reality data
  * @param {string} [options.rootDocument] The path of the root document for this reality data
+ * @param {Cesium3DTileset.ConstructorOptions} [options.tilesetOptions] Object containing
+ * options to pass to the internally created {@link Cesium3DTileset}.
  * @returns {Promise<Cesium3DTileset>}
  *
  * @throws {RuntimeError} if the type of reality data is not supported by this function
  */
-ITwinData.createTilesetForRealityDataId = async function (options) {
-  let internalOptions = options;
-
-  if (typeof options === "string") {
-    // the old signature was (iTwinId: string, realityDataId: string, type: RealityDataType, rootDocument: string)
-    // grab the later arguments directly instead of in the params only for this special case
-    internalOptions = {
-      iTwinId: options,
-      realityDataId: arguments[1],
-      type: arguments[2],
-      rootDocument: arguments[3],
-    };
-    deprecationWarning(
-      "ITwinData.createTilesetFromIModelId",
-      "The arguments signature for ITwinData functions has changed in 1.132 in favor of a single options object. Please update your code. This fallback will be removed in 1.133",
-    );
-  }
-  const { iTwinId, realityDataId } = internalOptions;
-  let { type, rootDocument } = internalOptions;
-
+ITwinData.createTilesetForRealityDataId = async function ({
+  iTwinId,
+  realityDataId,
+  type,
+  rootDocument,
+  tilesetOptions,
+}) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.string("iTwinId", iTwinId);
   Check.typeOf.string("realityDataId", realityDataId);
@@ -168,9 +150,16 @@ ITwinData.createTilesetForRealityDataId = async function (options) {
     rootDocument,
   );
 
-  return Cesium3DTileset.fromUrl(tilesetAccessUrl, {
+  // The maximum screen space error was defined to default to 4 for
+  // reality data tilesets, because they did not show the expected
+  // amount of detail with the default value of 16. Values that are
+  // given in the tilesetOptions should still override that default.
+  const internalTilesetOptions = {
     maximumScreenSpaceError: 4,
-  });
+    ...tilesetOptions,
+  };
+
+  return Cesium3DTileset.fromUrl(tilesetAccessUrl, internalTilesetOptions);
 };
 
 /**
@@ -189,26 +178,12 @@ ITwinData.createTilesetForRealityDataId = async function (options) {
  *
  * @throws {RuntimeError} if the type of reality data is not supported by this function
  */
-ITwinData.createDataSourceForRealityDataId = async function (options) {
-  let internalOptions = options;
-
-  if (typeof options === "string") {
-    // the old signature was (iTwinId: string, realityDataId: string, type: RealityDataType, rootDocument: string)
-    // grab the later arguments directly instead of in the params only for this special case
-    internalOptions = {
-      iTwinId: options,
-      realityDataId: arguments[1],
-      type: arguments[2],
-      rootDocument: arguments[3],
-    };
-    deprecationWarning(
-      "ITwinData.createTilesetFromIModelId",
-      "The arguments signature for ITwinData functions has changed in 1.132 in favor of a single options object. Please update your code. This fallback will be removed in 1.133",
-    );
-  }
-  const { iTwinId, realityDataId } = internalOptions;
-  let { type, rootDocument } = internalOptions;
-
+ITwinData.createDataSourceForRealityDataId = async function ({
+  iTwinId,
+  realityDataId,
+  type,
+  rootDocument,
+}) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.string("iTwinId", iTwinId);
   Check.typeOf.string("realityDataId", realityDataId);
@@ -263,25 +238,11 @@ ITwinData.createDataSourceForRealityDataId = async function (options) {
  * @param {number} [options.limit=10000] number of items per page, must be between 1 and 10,000 inclusive
  * @returns {Promise<GeoJsonDataSource>}
  */
-ITwinData.loadGeospatialFeatures = async function (options) {
-  let internalOptions = options;
-
-  if (typeof options === "string") {
-    // the old signature was (iTwinId: string, collectionId: string, limit: number)
-    // grab the later arguments directly instead of in the params only for this special case
-    internalOptions = {
-      iTwinId: options,
-      collectionId: arguments[1],
-      limit: arguments[2],
-    };
-    deprecationWarning(
-      "ITwinData.createTilesetFromIModelId",
-      "The arguments signature for ITwinData functions has changed in 1.132 in favor of a single options object. Please update your code. This fallback will be removed in 1.133",
-    );
-  }
-
-  const { iTwinId, collectionId, limit } = internalOptions;
-
+ITwinData.loadGeospatialFeatures = async function ({
+  iTwinId,
+  collectionId,
+  limit,
+}) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.string("iTwinId", iTwinId);
   Check.typeOf.string("collectionId", collectionId);

package/Source/Scene/Model/Model.js

@@ -72,6 +72,9 @@ import ModelImagery from "./ModelImagery.js";
  *  {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_mesh_gpu_instancing|EXT_mesh_gpu_instancing}
  *  </li>
  *  <li>
+ *  {@link https://github.com/KhronosGroup/glTF/pull/2514|EXT_mesh_primitive_restart}
+ *  </li>
+ *  <li>
  *  {@link https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_meshopt_compression|EXT_meshopt_compression}
  *  </li>
  *  <li>

package/Source/Scene/Model/ModelClippingPolygonsPipelineStage.js

@@ -79,10 +79,16 @@ ModelClippingPolygonsPipelineStage.process = function (
 
   const uniformMap = {
     model_clippingDistance: function () {
-      return clippingPolygons.clippingTexture;
+      return (
+        // The later should never happen during a render pass, see https://github.com/CesiumGS/cesium/issues/12725
+        clippingPolygons.clippingTexture ?? frameState.context.defaultTexture
+      );
     },
     model_clippingExtents: function () {
-      return clippingPolygons.extentsTexture;
+      return (
+        // The later should never happen during a render pass, see https://github.com/CesiumGS/cesium/issues/12725
+        clippingPolygons.extentsTexture ?? frameState.context.defaultTexture
+      );
     },
   };
 

package/Source/Scene/Model/ModelUtility.js

@@ -369,6 +369,7 @@ ModelUtility.supportedExtensions = {
   KHR_texture_basisu: true,
   KHR_texture_transform: true,
   KHR_gaussian_splatting: true,
+  KHR_gaussian_splatting_compression_spz_2: true,
   KHR_spz_gaussian_splats_compression: true,
   WEB3D_quantized_attributes: true,
 };

package/Source/Scene/Model/PntsLoader.js

@@ -549,17 +549,21 @@ function makeAttributes(loader, parsedContent, context) {
 function makeStructuralMetadata(parsedContent, customAttributeOutput) {
   const batchLength = parsedContent.batchLength;
   const pointsLength = parsedContent.pointsLength;
+  const batchTableJson = parsedContent.batchTableJson;
   const batchTableBinary = parsedContent.batchTableBinary;
 
   // If there are batch IDs, parse as a property table. Otherwise, parse
   // as property attributes.
   const parseAsPropertyAttributes = !defined(parsedContent.batchIds);
-
-  if (defined(batchTableBinary) || parsedContent.hasDracoBatchTable) {
+  if (
+    defined(batchTableBinary) ||
+    defined(batchTableJson) ||
+    parsedContent.hasDracoBatchTable
+  ) {
     const count = batchLength ?? pointsLength;
     return parseBatchTable({
       count: count,
-      batchTable: parsedContent.batchTableJson,
+      batchTable: batchTableJson,
       binaryBody: batchTableBinary,
       parseAsPropertyAttributes: parseAsPropertyAttributes,
       customAttributeOutput: customAttributeOutput,