@cesium/engine 22.2.0 → 23.0.0

package/Source/Scene/GltfLoader.js

@@ -173,120 +173,115 @@ const GltfLoaderState = {
  * Implements the {@link ResourceLoader} interface.
  * </p>
  *
- * @alias GltfLoader
- * @constructor
- * @augments ResourceLoader
- *
- * @param {object} options Object with the following properties:
- * @param {Resource} options.gltfResource The {@link Resource} containing the glTF. This is often the path of the .gltf or .glb file, but may also be the path of the .b3dm, .i3dm, or .cmpt file containing the embedded glb. .cmpt resources should have a URI fragment indicating the index of the inner content to which the glb belongs in order to individually identify the glb in the cache, e.g. http://example.com/tile.cmpt#index=2.
- * @param {Resource} [options.baseResource] The {@link Resource} that paths in the glTF JSON are relative to.
- * @param {Uint8Array} [options.typedArray] The typed array containing the glTF contents, e.g. from a .b3dm, .i3dm, or .cmpt file.
- * @param {object} [options.gltfJson] A parsed glTF JSON file instead of passing it in as a typed array.
- * @param {boolean} [options.releaseGltfJson=false] When true, the glTF JSON is released once the glTF is loaded. This is especially useful for cases like 3D Tiles, where each .gltf model is unique and caching the glTF JSON is not effective.
- * @param {boolean} [options.asynchronous=true] Determines if WebGL resource creation will be spread out over several frames or block until all WebGL resources are created.
- * @param {boolean} [options.incrementallyLoadTextures=true] Determine if textures may continue to stream in after the glTF is loaded.
- * @param {Axis} [options.upAxis=Axis.Y] The up-axis of the glTF model.
- * @param {Axis} [options.forwardAxis=Axis.Z] The forward-axis of the glTF model.
- * @param {boolean} [options.loadAttributesAsTypedArray=false] Load all attributes and indices as typed arrays instead of GPU buffers. If the attributes are interleaved in the glTF they will be de-interleaved in the typed array.
- * @param {boolean} [options.loadAttributesFor2D=false] If <code>true</code>, load the positions buffer and any instanced attribute buffers as typed arrays for accurately projecting models to 2D.
- * @param {boolean} [options.enablePick=false]  If <code>true</code>, load the positions buffer, any instanced attribute buffers, and index buffer as typed arrays for CPU-enabled picking in WebGL1.
- * @param {boolean} [options.loadIndicesForWireframe=false] If <code>true</code>, load the index buffer as both a buffer and typed array. The latter is useful for creating wireframe indices in WebGL1.
- * @param {boolean} [options.loadPrimitiveOutline=true] If <code>true</code>, load outlines from the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. This can be set false to avoid post-processing geometry at load time.
- * @param {boolean} [options.loadForClassification=false] If <code>true</code> and if the model has feature IDs, load the feature IDs and indices as typed arrays. This is useful for batching features for classification.
- * @param {boolean} [options.renameBatchIdSemantic=false] If <code>true</code>, rename _BATCHID or BATCHID to _FEATURE_ID_0. This is used for .b3dm models
  * @private
  */
-function GltfLoader(options) {
-  options = options ?? Frozen.EMPTY_OBJECT;
-  const {
-    gltfResource,
-    typedArray,
-    releaseGltfJson = false,
-    asynchronous = true,
-    incrementallyLoadTextures = true,
-    upAxis = Axis.Y,
-    forwardAxis = Axis.Z,
-    loadAttributesAsTypedArray = false,
-    loadAttributesFor2D = false,
-    enablePick = false,
-    loadIndicesForWireframe = false,
-    loadPrimitiveOutline = true,
-    loadForClassification = false,
-    renameBatchIdSemantic = false,
-  } = options;
-
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("options.gltfResource", gltfResource);
-  //>>includeEnd('debug');
-
-  const { baseResource = gltfResource.clone() } = options;
-
-  this._gltfJson = options.gltfJson;
-  this._gltfResource = gltfResource;
-  this._baseResource = baseResource;
-  this._typedArray = typedArray;
-  this._releaseGltfJson = releaseGltfJson;
-  this._asynchronous = asynchronous;
-  this._incrementallyLoadTextures = incrementallyLoadTextures;
-  this._upAxis = upAxis;
-  this._forwardAxis = forwardAxis;
-  this._loadAttributesAsTypedArray = loadAttributesAsTypedArray;
-  this._loadAttributesFor2D = loadAttributesFor2D;
-  this._enablePick = enablePick;
-  this._loadIndicesForWireframe = loadIndicesForWireframe;
-  this._loadPrimitiveOutline = loadPrimitiveOutline;
-  this._loadForClassification = loadForClassification;
-  this._renameBatchIdSemantic = renameBatchIdSemantic;
-
-  // When loading EXT_feature_metadata, the feature tables and textures
-  // are now stored as arrays like the newer EXT_structural_metadata extension.
-  // This requires sorting the dictionary keys for a consistent ordering.
-  this._sortedPropertyTableIds = undefined;
-  this._sortedFeatureTextureIds = undefined;
-
-  this._gltfJsonLoader = undefined;
-  this._state = GltfLoaderState.NOT_LOADED;
-  this._textureState = GltfLoaderState.NOT_LOADED;
-  this._promise = undefined;
-  this._processError = undefined;
-  this._textureErrors = [];
-
-  // Information about whether to load primitives as typed arrays or buffers,
-  // and whether post-processing is needed after loading (e.g. for
-  // generating outlines)
-  this._primitiveLoadPlans = [];
-
-  // Loaders that need to be processed before the glTF becomes ready
-  this._loaderPromises = [];
-  this._textureLoaders = [];
-  this._texturesPromises = [];
-  this._textureCallbacks = [];
-  this._bufferViewLoaders = [];
-  this._geometryLoaders = [];
-  this._geometryCallbacks = [];
-  this._structuralMetadataLoader = undefined;
-  this._meshPrimitiveGpmLoader = undefined;
-  this._loadResourcesPromise = undefined;
-  this._resourcesLoaded = false;
-  this._texturesLoaded = false;
-
-  this._supportedImageFormats = undefined;
-
-  // In some cases where geometry post-processing is needed (like generating
-  // outlines) new attributes are added that may have GPU resources attached.
-  // The GltfLoader will own the resources and store them here.
-  this._postProcessBuffers = [];
-
-  // Loaded results
-  this._components = undefined;
-}
-
-if (defined(Object.create)) {
-  GltfLoader.prototype = Object.create(ResourceLoader.prototype);
-  GltfLoader.prototype.constructor = GltfLoader;
-}
-
-Object.defineProperties(GltfLoader.prototype, {
+class GltfLoader extends ResourceLoader {
+  /**
+   * @param {object} options Object with the following properties:
+   * @param {Resource} options.gltfResource The {@link Resource} containing the glTF. This is often the path of the .gltf or .glb file, but may also be the path of the .b3dm, .i3dm, or .cmpt file containing the embedded glb. .cmpt resources should have a URI fragment indicating the index of the inner content to which the glb belongs in order to individually identify the glb in the cache, e.g. http://example.com/tile.cmpt#index=2.
+   * @param {Resource} [options.baseResource] The {@link Resource} that paths in the glTF JSON are relative to.
+   * @param {Uint8Array} [options.typedArray] The typed array containing the glTF contents, e.g. from a .b3dm, .i3dm, or .cmpt file.
+   * @param {object} [options.gltfJson] A parsed glTF JSON file instead of passing it in as a typed array.
+   * @param {boolean} [options.releaseGltfJson=false] When true, the glTF JSON is released once the glTF is loaded. This is especially useful for cases like 3D Tiles, where each .gltf model is unique and caching the glTF JSON is not effective.
+   * @param {boolean} [options.asynchronous=true] Determines if WebGL resource creation will be spread out over several frames or block until all WebGL resources are created.
+   * @param {boolean} [options.incrementallyLoadTextures=true] Determine if textures may continue to stream in after the glTF is loaded.
+   * @param {Axis} [options.upAxis=Axis.Y] The up-axis of the glTF model.
+   * @param {Axis} [options.forwardAxis=Axis.Z] The forward-axis of the glTF model.
+   * @param {boolean} [options.loadAttributesAsTypedArray=false] Load all attributes and indices as typed arrays instead of GPU buffers. If the attributes are interleaved in the glTF they will be de-interleaved in the typed array.
+   * @param {boolean} [options.loadAttributesFor2D=false] If <code>true</code>, load the positions buffer and any instanced attribute buffers as typed arrays for accurately projecting models to 2D.
+   * @param {boolean} [options.enablePick=false]  If <code>true</code>, load the positions buffer, any instanced attribute buffers, and index buffer as typed arrays for CPU-enabled picking in WebGL1.
+   * @param {boolean} [options.loadIndicesForWireframe=false] If <code>true</code>, load the index buffer as both a buffer and typed array. The latter is useful for creating wireframe indices in WebGL1.
+   * @param {boolean} [options.loadPrimitiveOutline=true] If <code>true</code>, load outlines from the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. This can be set false to avoid post-processing geometry at load time.
+   * @param {boolean} [options.loadForClassification=false] If <code>true</code> and if the model has feature IDs, load the feature IDs and indices as typed arrays. This is useful for batching features for classification.
+   * @param {boolean} [options.renameBatchIdSemantic=false] If <code>true</code>, rename _BATCHID or BATCHID to _FEATURE_ID_0. This is used for .b3dm models
+   */
+  constructor(options) {
+    super();
+
+    options = options ?? Frozen.EMPTY_OBJECT;
+    const {
+      gltfResource,
+      typedArray,
+      releaseGltfJson = false,
+      asynchronous = true,
+      incrementallyLoadTextures = true,
+      upAxis = Axis.Y,
+      forwardAxis = Axis.Z,
+      loadAttributesAsTypedArray = false,
+      loadAttributesFor2D = false,
+      enablePick = false,
+      loadIndicesForWireframe = false,
+      loadPrimitiveOutline = true,
+      loadForClassification = false,
+      renameBatchIdSemantic = false,
+    } = options;
+
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.object("options.gltfResource", gltfResource);
+    //>>includeEnd('debug');
+
+    const { baseResource = gltfResource.clone() } = options;
+
+    this._gltfJson = options.gltfJson;
+    this._gltfResource = gltfResource;
+    this._baseResource = baseResource;
+    this._typedArray = typedArray;
+    this._releaseGltfJson = releaseGltfJson;
+    this._asynchronous = asynchronous;
+    this._incrementallyLoadTextures = incrementallyLoadTextures;
+    this._upAxis = upAxis;
+    this._forwardAxis = forwardAxis;
+    this._loadAttributesAsTypedArray = loadAttributesAsTypedArray;
+    this._loadAttributesFor2D = loadAttributesFor2D;
+    this._enablePick = enablePick;
+    this._loadIndicesForWireframe = loadIndicesForWireframe;
+    this._loadPrimitiveOutline = loadPrimitiveOutline;
+    this._loadForClassification = loadForClassification;
+    this._renameBatchIdSemantic = renameBatchIdSemantic;
+
+    // When loading EXT_feature_metadata, the feature tables and textures
+    // are now stored as arrays like the newer EXT_structural_metadata extension.
+    // This requires sorting the dictionary keys for a consistent ordering.
+    this._sortedPropertyTableIds = undefined;
+    this._sortedFeatureTextureIds = undefined;
+
+    this._gltfJsonLoader = undefined;
+    this._state = GltfLoaderState.NOT_LOADED;
+    this._textureState = GltfLoaderState.NOT_LOADED;
+    this._promise = undefined;
+    this._processError = undefined;
+    this._textureErrors = [];
+
+    // Information about whether to load primitives as typed arrays or buffers,
+    // and whether post-processing is needed after loading (e.g. for
+    // generating outlines)
+    this._primitiveLoadPlans = [];
+
+    // Loaders that need to be processed before the glTF becomes ready
+    this._loaderPromises = [];
+    this._textureLoaders = [];
+    this._texturesPromises = [];
+    this._textureCallbacks = [];
+    this._bufferViewLoaders = [];
+    this._geometryLoaders = [];
+    this._geometryCallbacks = [];
+    this._structuralMetadataLoader = undefined;
+    this._meshPrimitiveGpmLoader = undefined;
+    this._loadResourcesPromise = undefined;
+    this._resourcesLoaded = false;
+    this._texturesLoaded = false;
+
+    this._supportedImageFormats = undefined;
+
+    // In some cases where geometry post-processing is needed (like generating
+    // outlines) new attributes are added that may have GPU resources attached.
+    // The GltfLoader will own the resources and store them here.
+    this._postProcessBuffers = [];
+
+    // Loaded results
+    this._components = undefined;
+  }
+
   /**
    * The cache key of the resource.
    *
@@ -296,11 +291,10 @@ Object.defineProperties(GltfLoader.prototype, {
    * @readonly
    * @private
    */
-  cacheKey: {
-    get: function () {
-      return undefined;
-    },
-  },
+  get cacheKey() {
+    return undefined;
+  }
+
   /**
    * The loaded components.
    *
@@ -310,11 +304,10 @@ Object.defineProperties(GltfLoader.prototype, {
    * @readonly
    * @private
    */
-  components: {
-    get: function () {
-      return this._components;
-    },
-  },
+  get components() {
+    return this._components;
+  }
+
   /**
    * The loaded glTF json.
    *
@@ -324,14 +317,13 @@ Object.defineProperties(GltfLoader.prototype, {
    * @readonly
    * @private
    */
-  gltfJson: {
-    get: function () {
-      if (defined(this._gltfJsonLoader)) {
-        return this._gltfJsonLoader.gltf;
-      }
-      return this._gltfJson;
-    },
-  },
+  get gltfJson() {
+    if (defined(this._gltfJsonLoader)) {
+      return this._gltfJsonLoader.gltf;
+    }
+    return this._gltfJson;
+  }
+
   /**
    * Returns true if textures are loaded separately from the other glTF resources.
    *
@@ -341,11 +333,10 @@ Object.defineProperties(GltfLoader.prototype, {
    * @readonly
    * @private
    */
-  incrementallyLoadTextures: {
-    get: function () {
-      return this._incrementallyLoadTextures;
-    },
-  },
+  get incrementallyLoadTextures() {
+    return this._incrementallyLoadTextures;
+  }
+
   /**
    * true if textures are loaded, useful when incrementallyLoadTextures is true
    *
@@ -355,12 +346,193 @@ Object.defineProperties(GltfLoader.prototype, {
    * @readonly
    * @private
    */
-  texturesLoaded: {
-    get: function () {
-      return this._texturesLoaded;
-    },
-  },
-});
+  get texturesLoaded() {
+    return this._texturesLoaded;
+  }
+
+  /**
+   * Loads the resource.
+   * @returns {Promise.<GltfLoader>} A promise which resolves to the loader when the resource loading is completed.
+   * @exception {RuntimeError} Unsupported glTF version
+   * @exception {RuntimeError} Unsupported glTF Extension
+   * @private
+   */
+  async load() {
+    if (defined(this._promise)) {
+      return this._promise;
+    }
+
+    this._promise = loadGltfJson(this);
+    return this._promise;
+  }
+
+  /**
+   * Process loaders other than textures
+   * @private
+   */
+  _process(frameState) {
+    if (this._state === GltfLoaderState.READY) {
+      return true;
+    }
+
+    if (this._state === GltfLoaderState.PROCESSING) {
+      processLoaders(this, frameState);
+    }
+
+    if (
+      this._resourcesLoaded &&
+      this._state === GltfLoaderState.POST_PROCESSING
+    ) {
+      postProcessGeometry(this, frameState.context);
+      this._state = GltfLoaderState.PROCESSED;
+    }
+
+    if (this._resourcesLoaded && this._state === GltfLoaderState.PROCESSED) {
+      // The buffer views can be unloaded once the data is copied.
+      unloadBufferViewLoaders(this);
+
+      // Similarly, if the glTF was loaded from a typed array, release the memory
+      this._typedArray = undefined;
+
+      this._state = GltfLoaderState.READY;
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Process textures other than textures
+   * @private
+   */
+  _processTextures(frameState) {
+    if (this._textureState === GltfLoaderState.READY) {
+      return true;
+    }
+
+    if (this._textureState !== GltfLoaderState.PROCESSING) {
+      return false;
+    }
+
+    let ready = true;
+    const textureLoaders = this._textureLoaders;
+    for (let i = 0; i < textureLoaders.length; ++i) {
+      const textureReady = textureLoaders[i].process(frameState);
+      if (textureReady && defined(this._textureCallbacks[i])) {
+        this._textureCallbacks[i]();
+        this._textureCallbacks[i] = undefined;
+      }
+
+      ready = ready && textureReady;
+    }
+
+    if (!ready) {
+      return false;
+    }
+
+    this._textureState = GltfLoaderState.READY;
+    this._texturesLoaded = true;
+    return true;
+  }
+
+  /**
+   * Processes the resource until it becomes ready.
+   *
+   * @param {FrameState} frameState The frame state.
+   * @private
+   */
+  process(frameState) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.object("frameState", frameState);
+    //>>includeEnd('debug');
+
+    if (
+      this._state === GltfLoaderState.LOADED &&
+      !defined(this._loadResourcesPromise)
+    ) {
+      this._loadResourcesPromise = loadResources(this, frameState)
+        .then(() => {
+          this._resourcesLoaded = true;
+        })
+        .catch((error) => {
+          this._processError = error;
+        });
+    }
+
+    if (defined(this._processError)) {
+      this._state = GltfLoaderState.FAILED;
+      const error = this._processError;
+      this._processError = undefined;
+      handleError(this, error);
+    }
+
+    // Pop the next error of the list in case there are multiple
+    const textureError = this._textureErrors.pop();
+    if (defined(textureError)) {
+      // There shouldn't be the need to completely unload in this case. Just throw the error.
+      const error = this.getError("Failed to load glTF texture", textureError);
+      error.name = "TextureError";
+      throw error;
+    }
+
+    if (this._state === GltfLoaderState.FAILED) {
+      return false;
+    }
+
+    let ready = false;
+    try {
+      ready = this._process(frameState);
+    } catch (error) {
+      this._state = GltfLoaderState.FAILED;
+      handleError(this, error);
+    }
+
+    // Since textures can be loaded independently and are handled through a separate promise, they are processed in their own function
+    let texturesReady = false;
+    try {
+      texturesReady = this._processTextures(frameState);
+    } catch (error) {
+      this._textureState = GltfLoaderState.FAILED;
+      handleError(this, error);
+    }
+
+    if (this._incrementallyLoadTextures) {
+      return ready;
+    }
+
+    return ready && texturesReady;
+  }
+
+  /**
+   * Returns whether the resource has been unloaded.
+   * @private
+   */
+  isUnloaded() {
+    return this._state === GltfLoaderState.UNLOADED;
+  }
+
+  /**
+   * Unloads the resource.
+   * @private
+   */
+  unload() {
+    if (defined(this._gltfJsonLoader) && !this._gltfJsonLoader.isDestroyed()) {
+      ResourceCache.unload(this._gltfJsonLoader);
+    }
+    this._gltfJsonLoader = undefined;
+
+    unloadTextures(this);
+    unloadBufferViewLoaders(this);
+    unloadGeometry(this);
+    unloadGeneratedAttributes(this);
+    unloadStructuralMetadata(this);
+    unloadMeshPrimitiveGpm(this);
+
+    this._components = undefined;
+    this._typedArray = undefined;
+    this._state = GltfLoaderState.UNLOADED;
+  }
+}
 
 /**
  * Loads the gltf object
@@ -433,22 +605,6 @@ async function loadResources(loader, frameState) {
   return promise;
 }
 
-/**
- * Loads the resource.
- * @returns {Promise.<GltfLoader>} A promise which resolves to the loader when the resource loading is completed.
- * @exception {RuntimeError} Unsupported glTF version
- * @exception {RuntimeError} Unsupported glTF Extension
- * @private
- */
-GltfLoader.prototype.load = async function () {
-  if (defined(this._promise)) {
-    return this._promise;
-  }
-
-  this._promise = loadGltfJson(this);
-  return this._promise;
-};
-
 function handleError(gltfLoader, error) {
   gltfLoader.unload();
   const errorMessage = "Failed to load glTF";
@@ -545,143 +701,6 @@ function gatherPostProcessBuffers(loader, primitiveLoadPlan) {
   }
 }
 
-/**
- * Process loaders other than textures
- * @private
- */
-GltfLoader.prototype._process = function (frameState) {
-  if (this._state === GltfLoaderState.READY) {
-    return true;
-  }
-
-  if (this._state === GltfLoaderState.PROCESSING) {
-    processLoaders(this, frameState);
-  }
-
-  if (
-    this._resourcesLoaded &&
-    this._state === GltfLoaderState.POST_PROCESSING
-  ) {
-    postProcessGeometry(this, frameState.context);
-    this._state = GltfLoaderState.PROCESSED;
-  }
-
-  if (this._resourcesLoaded && this._state === GltfLoaderState.PROCESSED) {
-    // The buffer views can be unloaded once the data is copied.
-    unloadBufferViewLoaders(this);
-
-    // Similarly, if the glTF was loaded from a typed array, release the memory
-    this._typedArray = undefined;
-
-    this._state = GltfLoaderState.READY;
-    return true;
-  }
-
-  return false;
-};
-
-/**
- * Process textures other than textures
- * @private
- */
-GltfLoader.prototype._processTextures = function (frameState) {
-  if (this._textureState === GltfLoaderState.READY) {
-    return true;
-  }
-
-  if (this._textureState !== GltfLoaderState.PROCESSING) {
-    return false;
-  }
-
-  let ready = true;
-  const textureLoaders = this._textureLoaders;
-  for (let i = 0; i < textureLoaders.length; ++i) {
-    const textureReady = textureLoaders[i].process(frameState);
-    if (textureReady && defined(this._textureCallbacks[i])) {
-      this._textureCallbacks[i]();
-      this._textureCallbacks[i] = undefined;
-    }
-
-    ready = ready && textureReady;
-  }
-
-  if (!ready) {
-    return false;
-  }
-
-  this._textureState = GltfLoaderState.READY;
-  this._texturesLoaded = true;
-  return true;
-};
-
-/**
- * Processes the resource until it becomes ready.
- *
- * @param {FrameState} frameState The frame state.
- * @private
- */
-GltfLoader.prototype.process = function (frameState) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("frameState", frameState);
-  //>>includeEnd('debug');
-
-  if (
-    this._state === GltfLoaderState.LOADED &&
-    !defined(this._loadResourcesPromise)
-  ) {
-    this._loadResourcesPromise = loadResources(this, frameState)
-      .then(() => {
-        this._resourcesLoaded = true;
-      })
-      .catch((error) => {
-        this._processError = error;
-      });
-  }
-
-  if (defined(this._processError)) {
-    this._state = GltfLoaderState.FAILED;
-    const error = this._processError;
-    this._processError = undefined;
-    handleError(this, error);
-  }
-
-  // Pop the next error of the list in case there are multiple
-  const textureError = this._textureErrors.pop();
-  if (defined(textureError)) {
-    // There shouldn't be the need to completely unload in this case. Just throw the error.
-    const error = this.getError("Failed to load glTF texture", textureError);
-    error.name = "TextureError";
-    throw error;
-  }
-
-  if (this._state === GltfLoaderState.FAILED) {
-    return false;
-  }
-
-  let ready = false;
-  try {
-    ready = this._process(frameState);
-  } catch (error) {
-    this._state = GltfLoaderState.FAILED;
-    handleError(this, error);
-  }
-
-  // Since textures can be loaded independently and are handled through a separate promise, they are processed in their own function
-  let texturesReady = false;
-  try {
-    texturesReady = this._processTextures(frameState);
-  } catch (error) {
-    this._textureState = GltfLoaderState.FAILED;
-    handleError(this, error);
-  }
-
-  if (this._incrementallyLoadTextures) {
-    return ready;
-  }
-
-  return ready && texturesReady;
-};
-
 function getVertexBufferLoader(
   loader,
   accessorId,
@@ -1811,6 +1830,16 @@ function loadMaterial(loader, gltfMaterial, frameState) {
   material.alphaCutoff = gltfMaterial.alphaCutoff;
   material.doubleSided = gltfMaterial.doubleSided;
 
+  // BENTLEY_materials_point_style extension
+  const pointStyleExtension = extensions.BENTLEY_materials_point_style;
+  if (defined(pointStyleExtension) && defined(pointStyleExtension.diameter)) {
+    const diameter = pointStyleExtension.diameter;
+    // The spec requires a positive integer, but we floor non-integers as a best effort.
+    if (diameter >= 1) {
+      material.pointDiameter = Math.floor(diameter);
+    }
+  }
+
   return material;
 }
 
@@ -2956,34 +2985,4 @@ function unloadMeshPrimitiveGpm(loader) {
   }
 }
 
-/**
- * Returns whether the resource has been unloaded.
- * @private
- */
-GltfLoader.prototype.isUnloaded = function () {
-  return this._state === GltfLoaderState.UNLOADED;
-};
-
-/**
- * Unloads the resource.
- * @private
- */
-GltfLoader.prototype.unload = function () {
-  if (defined(this._gltfJsonLoader) && !this._gltfJsonLoader.isDestroyed()) {
-    ResourceCache.unload(this._gltfJsonLoader);
-  }
-  this._gltfJsonLoader = undefined;
-
-  unloadTextures(this);
-  unloadBufferViewLoaders(this);
-  unloadGeometry(this);
-  unloadGeneratedAttributes(this);
-  unloadStructuralMetadata(this);
-  unloadMeshPrimitiveGpm(this);
-
-  this._components = undefined;
-  this._typedArray = undefined;
-  this._state = GltfLoaderState.UNLOADED;
-};
-
 export default GltfLoader;