@cesium/engine 23.0.1 → 25.0.0

package/Source/Scene/GetFeatureInfoFormat.js

@@ -5,17 +5,17 @@ import RuntimeError from "../Core/RuntimeError.js";
 import ImageryLayerFeatureInfo from "./ImageryLayerFeatureInfo.js";
 
 /**
- * Describes the format in which to request GetFeatureInfo from a Web Map Service (WMS) server.
+ * Describes the format in which to request GetFeatureInfo from a Web Map Service (WMS) or Web Map Tile Service (WMTS) server.
  *
  * @alias GetFeatureInfoFormat
  * @constructor
  *
  * @param {string} type The type of response to expect from a GetFeatureInfo request.  Valid
  *        values are 'json', 'xml', 'html', or 'text'.
- * @param {string} [format] The info format to request from the WMS server.  This is usually a
+ * @param {string} [format] The info format to request from the server.  This is usually a
  *        MIME type such as 'application/json' or text/xml'.  If this parameter is not specified, the provider will request 'json'
  *        using 'application/json', 'xml' using 'text/xml', 'html' using 'text/html', and 'text' using 'text/plain'.
- * @param {Function} [callback] A function to invoke with the GetFeatureInfo response from the WMS server
+ * @param {Function} [callback] A function to invoke with the GetFeatureInfo response from the server
  *        in order to produce an array of picked {@link ImageryLayerFeatureInfo} instances.  If this parameter is not specified,
  *        a default function for the type of response is used.
  */

package/Source/Scene/GltfBufferViewLoader.js

@@ -92,7 +92,6 @@ class GltfBufferViewLoader extends ResourceLoader {
   /**
    * The cache key of the resource.
    *
-   * @memberof GltfBufferViewLoader.prototype
    *
    * @type {string}
    * @readonly
@@ -105,7 +104,6 @@ class GltfBufferViewLoader extends ResourceLoader {
   /**
    * The typed array containing buffer view data.
    *
-   * @memberof GltfBufferViewLoader.prototype
    *
    * @type {Uint8Array}
    * @readonly

package/Source/Scene/GltfDracoLoader.js

@@ -66,7 +66,6 @@ class GltfDracoLoader extends ResourceLoader {
   /**
    * The cache key of the resource.
    *
-   * @memberof GltfDracoLoader.prototype
    *
    * @type {string}
    * @readonly
@@ -79,7 +78,6 @@ class GltfDracoLoader extends ResourceLoader {
   /**
    * The decoded data.
    *
-   * @memberof GltfDracoLoader.prototype
    *
    * @type {object}
    * @readonly

package/Source/Scene/GltfImageLoader.js

@@ -65,7 +65,6 @@ class GltfImageLoader extends ResourceLoader {
   /**
    * The cache key of the resource.
    *
-   * @memberof GltfImageLoader.prototype
    *
    * @type {string}
    * @readonly
@@ -78,7 +77,6 @@ class GltfImageLoader extends ResourceLoader {
   /**
    * The image.
    *
-   * @memberof GltfImageLoader.prototype
    *
    * @type {Image|ImageBitmap|CompressedTextureBuffer}
    * @readonly
@@ -91,7 +89,6 @@ class GltfImageLoader extends ResourceLoader {
   /**
    * The mip levels. Only defined for KTX2 files containing mip levels.
    *
-   * @memberof GltfImageLoader.prototype
    *
    * @type {Uint8Array[]}
    * @readonly

package/Source/Scene/GltfIndexBufferLoader.js

@@ -88,7 +88,6 @@ class GltfIndexBufferLoader extends ResourceLoader {
   /**
    * The cache key of the resource.
    *
-   * @memberof GltfIndexBufferLoader.prototype
    *
    * @type {string}
    * @readonly
@@ -101,7 +100,6 @@ class GltfIndexBufferLoader extends ResourceLoader {
   /**
    * The index buffer. This is only defined when <code>loadBuffer</code> is true.
    *
-   * @memberof GltfIndexBufferLoader.prototype
    *
    * @type {Buffer}
    * @readonly
@@ -114,7 +112,6 @@ class GltfIndexBufferLoader extends ResourceLoader {
   /**
    * The typed array containing indices. This is only defined when <code>loadTypedArray</code> is true.
    *
-   * @memberof GltfIndexBufferLoader.prototype
    *
    * @type {Uint8Array|Uint16Array|Uint32Array}
    * @readonly
@@ -127,7 +124,6 @@ class GltfIndexBufferLoader extends ResourceLoader {
   /**
    * The index datatype after decode.
    *
-   * @memberof GltfIndexBufferLoader.prototype
    *
    * @type {IndexDatatype}
    * @readonly

package/Source/Scene/GltfJsonLoader.js

@@ -67,7 +67,6 @@ class GltfJsonLoader extends ResourceLoader {
   /**
    * The cache key of the resource.
    *
-   * @memberof GltfJsonLoader.prototype
    *
    * @type {string}
    * @readonly
@@ -80,7 +79,6 @@ class GltfJsonLoader extends ResourceLoader {
   /**
    * The glTF JSON.
    *
-   * @memberof GltfJsonLoader.prototype
    *
    * @type {object}
    * @readonly

package/Source/Scene/GltfLoader.js

@@ -61,7 +61,9 @@ const {
   Specular,
   Anisotropy,
   Clearcoat,
+  LineStyle,
   Material,
+  Vector,
 } = ModelComponents;
 
 /**
@@ -285,7 +287,6 @@ class GltfLoader extends ResourceLoader {
   /**
    * The cache key of the resource.
    *
-   * @memberof GltfLoader.prototype
    *
    * @type {string}
    * @readonly
@@ -298,7 +299,6 @@ class GltfLoader extends ResourceLoader {
   /**
    * The loaded components.
    *
-   * @memberof GltfLoader.prototype
    *
    * @type {ModelComponents.Components}
    * @readonly
@@ -311,7 +311,6 @@ class GltfLoader extends ResourceLoader {
   /**
    * The loaded glTF json.
    *
-   * @memberof GltfLoader.prototype
    *
    * @type {object}
    * @readonly
@@ -327,7 +326,6 @@ class GltfLoader extends ResourceLoader {
   /**
    * Returns true if textures are loaded separately from the other glTF resources.
    *
-   * @memberof GltfLoader.prototype
    *
    * @type {boolean}
    * @readonly
@@ -340,7 +338,6 @@ class GltfLoader extends ResourceLoader {
   /**
    * true if textures are loaded, useful when incrementallyLoadTextures is true
    *
-   * @memberof GltfLoader.prototype
    *
    * @type {boolean}
    * @readonly
@@ -1756,6 +1753,34 @@ function loadClearcoat(loader, clearcoatInfo, frameState) {
   return clearcoat;
 }
 
+function loadLineStyle(lineStyleInfo) {
+  if (!defined(lineStyleInfo)) {
+    return undefined;
+  }
+
+  const lineStyle = new LineStyle();
+
+  if (defined(lineStyleInfo.width)) {
+    const width = lineStyleInfo.width;
+    if (width > 0 && Math.floor(width) === width) {
+      lineStyle.width = width;
+    }
+  }
+
+  if (defined(lineStyleInfo.pattern)) {
+    const pattern = lineStyleInfo.pattern;
+    if (pattern >= 0 && pattern <= 65535 && Math.floor(pattern) === pattern) {
+      lineStyle.pattern = pattern;
+    }
+  }
+
+  if (!defined(lineStyle.width) && !defined(lineStyle.pattern)) {
+    return undefined;
+  }
+
+  return lineStyle;
+}
+
 /**
  * Load textures and parse factors and flags for a glTF material
  *
@@ -1840,6 +1865,8 @@ function loadMaterial(loader, gltfMaterial, frameState) {
     }
   }
 
+  material.lineStyle = loadLineStyle(extensions.BENTLEY_materials_line_style);
+
   return material;
 }
 
@@ -2031,6 +2058,132 @@ function fetchSpzExtensionFrom(extensions) {
   return undefined;
 }
 
+function getEdgeVisibilityMaterialColor(loader, materialIndex) {
+  if (!defined(materialIndex)) {
+    return undefined;
+  }
+
+  const materials = loader.gltfJson.materials;
+  if (
+    !defined(materials) ||
+    materialIndex < 0 ||
+    materialIndex >= materials.length
+  ) {
+    return undefined;
+  }
+
+  const material = materials[materialIndex];
+  if (!defined(material)) {
+    return undefined;
+  }
+
+  const metallicRoughness =
+    material.pbrMetallicRoughness ?? Frozen.EMPTY_OBJECT;
+  const color = fromArray(Cartesian4, metallicRoughness.baseColorFactor);
+
+  if (defined(color)) {
+    return color;
+  }
+
+  return new Cartesian4(1.0, 1.0, 1.0, 1.0);
+}
+
+function getLineStringPrimitiveRestartValue(componentType) {
+  switch (componentType) {
+    case ComponentDatatype.UNSIGNED_BYTE:
+      return 255;
+    case ComponentDatatype.UNSIGNED_SHORT:
+      return 65535;
+    case ComponentDatatype.UNSIGNED_INT:
+      return 4294967295;
+    default:
+      throw new RuntimeError(
+        "EXT_mesh_primitive_edge_visibility line strings indices must use unsigned scalar component types.",
+      );
+  }
+}
+
+function loadEdgeVisibilityLineStrings(
+  loader,
+  lineStringDefinitions,
+  defaultMaterialIndex,
+) {
+  if (!defined(lineStringDefinitions) || lineStringDefinitions.length === 0) {
+    return undefined;
+  }
+
+  const result = new Array(lineStringDefinitions.length);
+  for (let i = 0; i < lineStringDefinitions.length; i++) {
+    const definition = lineStringDefinitions[i] ?? Frozen.EMPTY_OBJECT;
+    const accessorId = definition.indices;
+    const accessor = loader.gltfJson.accessors[accessorId];
+
+    if (!defined(accessor)) {
+      throw new RuntimeError("Edge visibility line string accessor not found!");
+    }
+
+    const indices = loadAccessor(loader, accessor);
+    const restartIndex = getLineStringPrimitiveRestartValue(
+      accessor.componentType,
+    );
+    const materialIndex = defined(definition.material)
+      ? definition.material
+      : defaultMaterialIndex;
+
+    result[i] = {
+      indices: indices,
+      restartIndex: restartIndex,
+      componentType: accessor.componentType,
+      materialColor: getEdgeVisibilityMaterialColor(loader, materialIndex),
+    };
+  }
+
+  return result;
+}
+
+function loadEdgeVisibility(loader, edgeVisibilityExtension) {
+  if (!defined(edgeVisibilityExtension)) {
+    return undefined;
+  }
+
+  const edgeVisibility = {};
+
+  const visibilityAccessorId = edgeVisibilityExtension.visibility;
+  if (defined(visibilityAccessorId)) {
+    const visibilityAccessor = loader.gltfJson.accessors[visibilityAccessorId];
+    if (!defined(visibilityAccessor)) {
+      throw new RuntimeError("Edge visibility accessor not found!");
+    }
+    edgeVisibility.visibility = loadAccessor(loader, visibilityAccessor);
+  }
+
+  edgeVisibility.materialColor = getEdgeVisibilityMaterialColor(
+    loader,
+    edgeVisibilityExtension.material,
+  );
+
+  if (defined(edgeVisibilityExtension.silhouetteNormals)) {
+    const silhouetteNormalsAccessor =
+      loader.gltfJson.accessors[edgeVisibilityExtension.silhouetteNormals];
+    if (defined(silhouetteNormalsAccessor)) {
+      edgeVisibility.silhouetteNormals = loadAccessor(
+        loader,
+        silhouetteNormalsAccessor,
+      );
+    }
+  }
+
+  if (defined(edgeVisibilityExtension.lineStrings)) {
+    edgeVisibility.lineStrings = loadEdgeVisibilityLineStrings(
+      loader,
+      edgeVisibilityExtension.lineStrings,
+      edgeVisibilityExtension.material,
+    );
+  }
+
+  return edgeVisibility;
+}
+
 /**
  * Load resources associated with a mesh primitive for a glTF node
  * @param {GltfLoader} loader
@@ -2055,6 +2208,10 @@ function loadPrimitive(loader, gltfPrimitive, hasInstances, frameState) {
   }
 
   const extensions = gltfPrimitive.extensions ?? Frozen.EMPTY_OBJECT;
+  const meshVectorExtension = extensions.CESIUM_mesh_vector;
+  if (defined(meshVectorExtension)) {
+    primitive.vector = loadMeshVectorExtension(loader, meshVectorExtension);
+  }
 
   let needsPostProcessing = false;
   const outlineExtension = extensions.CESIUM_primitive_outline;
@@ -2068,40 +2225,10 @@ function loadPrimitive(loader, gltfPrimitive, hasInstances, frameState) {
     );
   }
 
-  // Edge Visibility
-  const edgeVisibilityExtension = extensions.EXT_mesh_primitive_edge_visibility;
-  const hasEdgeVisibility = defined(edgeVisibilityExtension);
-  if (hasEdgeVisibility) {
-    const visibilityAccessor =
-      loader.gltfJson.accessors[edgeVisibilityExtension.visibility];
-    if (!defined(visibilityAccessor)) {
-      throw new RuntimeError("Edge visibility accessor not found!");
-    }
-    const visibilityValues = loadAccessor(loader, visibilityAccessor);
-    primitive.edgeVisibility = {
-      visibility: visibilityValues,
-      material: edgeVisibilityExtension.material,
-    };
-
-    // Load silhouette normals
-    if (defined(edgeVisibilityExtension.silhouetteNormals)) {
-      const silhouetteNormalsAccessor =
-        loader.gltfJson.accessors[edgeVisibilityExtension.silhouetteNormals];
-      if (defined(silhouetteNormalsAccessor)) {
-        const silhouetteNormalsValues = loadAccessor(
-          loader,
-          silhouetteNormalsAccessor,
-        );
-        primitive.edgeVisibility.silhouetteNormals = silhouetteNormalsValues;
-      }
-    }
-
-    // Load line strings
-    if (defined(edgeVisibilityExtension.lineStrings)) {
-      primitivePlan.edgeVisibility.lineStrings =
-        edgeVisibilityExtension.lineStrings;
-    }
-  }
+  primitive.edgeVisibility = loadEdgeVisibility(
+    loader,
+    extensions.EXT_mesh_primitive_edge_visibility,
+  );
 
   //support the latest glTF spec and the legacy extension
   const spzExtension = fetchSpzExtensionFrom(extensions);
@@ -2238,6 +2365,50 @@ function loadPrimitiveOutline(loader, outlineExtension) {
   return loadAccessor(loader, accessor, useQuaternion);
 }
 
+/**
+ * Load CESIUM_mesh_vector.
+ * @param {GltfLoader} loader
+ * @param {*} meshVectorExtension
+ * @returns {ModelComponents.Vector}
+ * @ignore
+ */
+function loadMeshVectorExtension(loader, meshVectorExtension) {
+  if (!defined(meshVectorExtension)) {
+    return undefined;
+  }
+
+  const result = new Vector();
+  result.vector = meshVectorExtension.vector;
+  result.count = meshVectorExtension.count;
+
+  const accessors = loader.gltfJson.accessors;
+  function loadVectorAccessor(accessorId, name) {
+    if (!defined(accessorId)) {
+      return undefined;
+    }
+    return loadAccessor(loader, accessors[accessorId]);
+  }
+
+  result.polygonAttributeOffsets = loadVectorAccessor(
+    meshVectorExtension.polygonAttributeOffsets,
+    "polygonAttributeOffsets",
+  );
+  result.polygonHoleCounts = loadVectorAccessor(
+    meshVectorExtension.polygonHoleCounts,
+    "polygonHoleCounts",
+  );
+  result.polygonHoleOffsets = loadVectorAccessor(
+    meshVectorExtension.polygonHoleOffsets,
+    "polygonHoleOffsets",
+  );
+  result.polygonIndicesOffsets = loadVectorAccessor(
+    meshVectorExtension.polygonIndicesOffsets,
+    "polygonIndicesOffsets",
+  );
+
+  return result;
+}
+
 // For EXT_mesh_features
 function loadPrimitiveFeatures(
   loader,
@@ -2512,6 +2683,7 @@ function loadNode(loader, gltfNode, frameState) {
   const nodeExtensions = gltfNode.extensions ?? Frozen.EMPTY_OBJECT;
   const instancingExtension = nodeExtensions.EXT_mesh_gpu_instancing;
   const articulationsExtension = nodeExtensions.AGI_articulations;
+  const meshVectorExtension = nodeExtensions.CESIUM_mesh_vector;
 
   if (defined(instancingExtension)) {
     if (loader._loadForClassification) {
@@ -2526,6 +2698,10 @@ function loadNode(loader, gltfNode, frameState) {
     node.articulationName = articulationsExtension.articulationName;
   }
 
+  if (defined(meshVectorExtension)) {
+    node.meshVector = meshVectorExtension;
+  }
+
   const meshId = gltfNode.mesh;
   if (defined(meshId)) {
     const mesh = loader.gltfJson.meshes[meshId];

package/Source/Scene/GltfLoaderUtil.js

@@ -178,6 +178,20 @@ GltfLoaderUtil.createModelTextureReader = function (options) {
   modelTextureReader.transform = transform;
   modelTextureReader.channels = channels;
 
+  // EXT_textureInfo_constant_lod extension
+  const constantLodExtension =
+    textureInfo.extensions?.EXT_textureInfo_constant_lod;
+  if (defined(constantLodExtension)) {
+    modelTextureReader.constantLod = {
+      repetitions: constantLodExtension.repetitions ?? 1.0,
+      offset: defined(constantLodExtension.offset)
+        ? Cartesian2.unpack(constantLodExtension.offset)
+        : Cartesian2.ZERO,
+      minClampDistance: constantLodExtension.minClampDistance ?? 1.0,
+      maxClampDistance: constantLodExtension.maxClampDistance ?? 4294967296.0,
+    };
+  }
+
   return modelTextureReader;
 };
 

package/Source/Scene/GltfSpzLoader.js

@@ -1,10 +1,88 @@
 import Check from "../Core/Check.js";
 import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
+import RuntimeError from "../Core/RuntimeError.js";
 import ResourceLoader from "./ResourceLoader.js";
 import ResourceLoaderState from "./ResourceLoaderState.js";
 import { loadSpz } from "@spz-loader/core";
 
+// Cumulative number of SH coefficient floats per splat per channel for each
+// degree. Degree 0 has no extra SH data (base color is stored separately in
+// the "colors" attribute). Degrees 1-3 follow the standard SH basis count:
+// l=1 adds 3 bands × 3 channels = 9; l=2 adds 5 × 3 = 15 (total 24);
+// l=3 adds 7 × 3 = 21 (total 45).
+const SH_FLOATS_PER_SPLAT_BY_DEGREE = [0, 9, 24, 45];
+
+// Non-SH attribute floats per splat: position(3) + scale(3) + rotation(4)
+// + opacity(1) + color(3) = 14.
+const BASE_FLOATS_PER_SPLAT = 14;
+
+// The spz-loader WASM module is compiled with a signed 32-bit address space,
+// giving a hard ceiling of 2 GB. An additional factor of ~2× is required
+// because spz-loader copies every decoded C++ vector into a JavaScript
+// TypedArray. 1.6 GB is used as a conservative pre-flight threshold.
+const WASM_MEMORY_LIMIT_BYTES = 1.6 * 1024 * 1024 * 1024;
+
+/**
+ * Derives the point count and maximum spherical harmonics degree for an SPZ
+ * primitive from the glTF JSON, without touching the compressed binary data.
+ * <p>
+ * The SPZ payload is gzip-compressed and therefore cannot be inspected
+ * directly. Instead, <code>numPoints</code> is read from the POSITION
+ * accessor's <code>count</code> field and <code>shDegree</code> is inferred
+ * from the highest-numbered <code>SH_DEGREE_n</code> attribute present in
+ * the primitive. Returns <code>undefined</code> if the required information
+ * is unavailable.
+ * </p>
+ * @param {object} gltf The glTF JSON object.
+ * @param {object} primitive The glTF primitive object.
+ * @returns {{ numPoints: number, shDegree: number }|undefined}
+ * @private
+ */
+function getSpzInfoFromGltf(gltf, primitive) {
+  const attributes = primitive?.attributes;
+  if (!defined(attributes)) {
+    return undefined;
+  }
+
+  const positionAccessorId = attributes["POSITION"];
+  if (!defined(positionAccessorId)) {
+    return undefined;
+  }
+  const accessor = gltf?.accessors?.[positionAccessorId];
+  if (!defined(accessor) || accessor.count <= 0) {
+    return undefined;
+  }
+
+  let shDegree = 0;
+  for (const semantic in attributes) {
+    if (Object.prototype.hasOwnProperty.call(attributes, semantic)) {
+      const match = /SH_DEGREE_(\d+)_COEF_/.exec(semantic);
+      if (match) {
+        shDegree = Math.max(shDegree, parseInt(match[1], 10));
+      }
+    }
+  }
+
+  return { numPoints: accessor.count, shDegree };
+}
+
+/**
+ * Estimates the peak memory consumption (in bytes) of decoding an SPZ file
+ * with the given parameters. The estimate accounts for both the WASM heap
+ * allocations and the JavaScript TypedArray copies produced by spz-loader.
+ * @param {number} numPoints Number of Gaussian splats.
+ * @param {number} shDegree Spherical harmonics degree (0–3).
+ * @returns {number} Estimated byte count.
+ * @private
+ */
+function estimateSpzMemoryBytes(numPoints, shDegree) {
+  const floatsPerPoint =
+    BASE_FLOATS_PER_SPLAT + (SH_FLOATS_PER_SPLAT_BY_DEGREE[shDegree] ?? 0);
+  // ×2 accounts for WASM heap + JS TypedArray mirror.
+  return numPoints * floatsPerPoint * Float32Array.BYTES_PER_ELEMENT * 2;
+}
+
 /**
  * Load a SPZ buffer from a glTF.
  * <p>
@@ -63,7 +141,6 @@ class GltfSpzLoader extends ResourceLoader {
 
   /**
    * The cache key of the resource.
-   * @memberof GltfSpzLoader.prototype
    * @type {string}
    * @readonly
    * @private
@@ -74,7 +151,6 @@ class GltfSpzLoader extends ResourceLoader {
 
   /**
    * The decoded SPZ data.
-   * @memberof GltfSpzLoader.prototype
    * @type {object}
    * @readonly
    * @private
@@ -128,6 +204,36 @@ class GltfSpzLoader extends ResourceLoader {
       return false;
     }
 
+    // Reject oversized SPZ payloads before invoking the WASM decoder.
+    // The spz-loader WASM module has a hard 2 GB memory ceiling; exceeding
+    // it causes an unrecoverable Aborted() call with no useful diagnostic.
+    // See: https://github.com/CesiumGS/cesium/issues/13283
+    //
+    // The SPZ binary is gzip-compressed, so its header cannot be read
+    // directly. Point count and SH degree are therefore derived from the
+    // glTF JSON, which is available at this stage.
+    const spzInfo = getSpzInfoFromGltf(this._gltf, this._primitive);
+    if (defined(spzInfo)) {
+      const estimatedBytes = estimateSpzMemoryBytes(
+        spzInfo.numPoints,
+        spzInfo.shDegree,
+      );
+      if (estimatedBytes > WASM_MEMORY_LIMIT_BYTES) {
+        const estimatedMB = Math.round(estimatedBytes / (1024 * 1024));
+        handleError(
+          this,
+          new RuntimeError(
+            `SPZ data too large to decode: ${spzInfo.numPoints.toLocaleString()} splats ` +
+              `with spherical harmonics degree ${spzInfo.shDegree} would require ` +
+              `approximately ${estimatedMB} MB, which exceeds the WASM memory limit. ` +
+              `Consider using a lower spherical harmonics degree or splitting the ` +
+              `dataset into smaller tiles.`,
+          ),
+        );
+        return false;
+      }
+    }
+
     const decodePromise = loadSpz(this._bufferViewTypedArray, {
       unpackOptions: { coordinateSystem: "UNSPECIFIED" },
     });
@@ -214,4 +320,5 @@ async function processDecode(loader, decodePromise) {
   }
 }
 
+export { estimateSpzMemoryBytes, getSpzInfoFromGltf };
 export default GltfSpzLoader;

package/Source/Scene/GltfStructuralMetadataLoader.js

@@ -82,7 +82,6 @@ class GltfStructuralMetadataLoader extends ResourceLoader {
   /**
    * The cache key of the resource.
    *
-   * @memberof GltfStructuralMetadataLoader.prototype
    *
    * @type {string}
    * @readonly
@@ -95,7 +94,6 @@ class GltfStructuralMetadataLoader extends ResourceLoader {
   /**
    * The parsed structural metadata
    *
-   * @memberof GltfStructuralMetadataLoader.prototype
    *
    * @type {StructuralMetadata}
    * @readonly

package/Source/Scene/GltfTextureLoader.js

@@ -83,7 +83,6 @@ class GltfTextureLoader extends ResourceLoader {
   /**
    * The cache key of the resource.
    *
-   * @memberof GltfTextureLoader.prototype
    *
    * @type {string}
    * @readonly
@@ -96,7 +95,6 @@ class GltfTextureLoader extends ResourceLoader {
   /**
    * The texture.
    *
-   * @memberof GltfTextureLoader.prototype
    *
    * @type {Texture}
    * @readonly