@babylonjs/loaders 8.23.1 → 8.23.2

package/glTF/glTFFileLoader.d.ts

@@ -126,88 +126,102 @@ declare abstract class GLTFLoaderOptions {
      */
     abstract onParsed?: ((loaderData: IGLTFLoaderData) => void) | undefined;
     /**
-     * The coordinate system mode. Defaults to AUTO.
-     */
-    coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
-    /**
-     * The animation start mode. Defaults to FIRST.
+     * Defines if the loader should always compute the bounding boxes of meshes and not use the min/max values from the position accessor. Defaults to false.
      */
-    animationStartMode: GLTFLoaderAnimationStartMode;
+    alwaysComputeBoundingBox: boolean;
     /**
-     * Defines if the loader should load node animations. Defaults to true.
-     * NOTE: The animation of this node will still load if the node is also a joint of a skin and `loadSkins` is true.
+     * Defines if the loader should always compute the nearest common ancestor of the skeleton joints instead of using `skin.skeleton`. Defaults to false.
+     * Set this to true if loading assets with invalid `skin.skeleton` values.
      */
-    loadNodeAnimations: boolean;
+    alwaysComputeSkeletonRootNode: boolean;
     /**
-     * Defines if the loader should load skins. Defaults to true.
+     * The animation start mode. Defaults to FIRST.
      */
-    loadSkins: boolean;
+    animationStartMode: GLTFLoaderAnimationStartMode;
     /**
-     * Defines if the loader should load morph targets. Defaults to true.
+     * Defines if the loader should capture performance counters.
      */
-    loadMorphTargets: boolean;
+    abstract capturePerformanceCounters: boolean;
     /**
      * Defines if the loader should compile materials before raising the success callback. Defaults to false.
      */
     compileMaterials: boolean;
-    /**
-     * Defines if the loader should also compile materials with clip planes. Defaults to false.
-     */
-    useClipPlane: boolean;
     /**
      * Defines if the loader should compile shadow generators before raising the success callback. Defaults to false.
      */
     compileShadowGenerators: boolean;
     /**
-     * Defines if the Alpha blended materials are only applied as coverage.
-     * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
-     * If true, no extra effects are applied to transparent pixels.
-     */
-    transparencyAsCoverage: boolean;
-    /**
-     * Defines if the loader should use range requests when load binary glTF files from HTTP.
-     * Enabling will disable offline support and glTF validator.
-     * Defaults to false.
+     * The coordinate system mode. Defaults to AUTO.
      */
-    useRangeRequests: boolean;
+    coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
     /**
      * Defines if the loader should create instances when multiple glTF nodes point to the same glTF mesh. Defaults to true.
      */
     createInstances: boolean;
     /**
-     * Defines if the loader should always compute the bounding boxes of meshes and not use the min/max values from the position accessor. Defaults to false.
+     * Defines the node to use as the root of the hierarchy when loading the scene (default: undefined). If not defined, a root node will be automatically created.
+     * You can also pass null if you don't want a root node to be created.
      */
-    alwaysComputeBoundingBox: boolean;
+    customRootNode?: Nullable<TransformNode>;
+    /**
+     * Defines options for glTF extensions.
+     */
+    extensionOptions: {
+        [Extension in keyof GLTFLoaderExtensionOptions]?: {
+            [Option in keyof DefaultExtensionOptions<GLTFLoaderExtensionOptions[Extension]>]: DefaultExtensionOptions<GLTFLoaderExtensionOptions[Extension]>[Option];
+        };
+    };
     /**
      * If true, load all materials defined in the file, even if not used by any mesh. Defaults to false.
      */
     loadAllMaterials: boolean;
+    /**
+     * Defines if the loader should load morph targets. Defaults to true.
+     */
+    loadMorphTargets: boolean;
+    /**
+     * Defines if the loader should load node animations. Defaults to true.
+     * NOTE: The animation of this node will still load if the node is also a joint of a skin and `loadSkins` is true.
+     */
+    loadNodeAnimations: boolean;
     /**
      * If true, load only the materials defined in the file. Defaults to false.
      */
     loadOnlyMaterials: boolean;
     /**
-     * If true, do not load any materials defined in the file. Defaults to false.
+     * Defines if the loader should load skins. Defaults to true.
      */
-    skipMaterials: boolean;
+    loadSkins: boolean;
     /**
-     * If true, load the color (gamma encoded) textures into sRGB buffers (if supported by the GPU), which will yield more accurate results when sampling the texture. Defaults to true.
+     * If true, enable logging for the loader. Defaults to false.
      */
-    useSRGBBuffers: boolean;
+    abstract loggingEnabled: boolean;
     /**
-     * When loading glTF animations, which are defined in seconds, target them to this FPS. Defaults to 60.
+     * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.
      */
-    targetFps: number;
+    abstract onCameraLoaded?: (camera: Camera) => void;
     /**
-     * Defines if the loader should always compute the nearest common ancestor of the skeleton joints instead of using `skin.skeleton`. Defaults to false.
-     * Set this to true if loading assets with invalid `skin.skeleton` values.
+     * Callback raised when the loader creates a material after parsing the glTF properties of the material.
      */
-    alwaysComputeSkeletonRootNode: boolean;
+    abstract onMaterialLoaded?: (material: Material) => void;
     /**
-     * If true, the loader will derive the name for Babylon textures from the glTF texture name, image name, or image url. Defaults to false.
-     * Note that it is possible for multiple Babylon textures to share the same name when the Babylon textures load from the same glTF texture or image.
+     * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
+     * Note that the callback is called as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)
      */
-    useGltfTextureNames: boolean;
+    abstract onMeshLoaded?: (mesh: AbstractMesh) => void;
+    /**
+     * Callback raised when the loader creates a skin after parsing the glTF properties of the skin node.
+     * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/glTF/glTFSkinning#ignoring-the-transform-of-the-skinned-mesh
+     */
+    abstract onSkinLoaded?: (node: TransformNode, skinnedNode: TransformNode) => void;
+    /**
+     * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.
+     */
+    abstract onTextureLoaded?: (texture: BaseTexture) => void;
+    /**
+     * Callback raised after the asset is validated.
+     */
+    abstract onValidated?: (results: GLTF2.IGLTFValidationResults) => void;
     /**
      * Function called before loading a url referenced by the asset.
      * @param url url referenced by the asset
@@ -215,40 +229,42 @@ declare abstract class GLTFLoaderOptions {
      */
     preprocessUrlAsync: (url: string) => Promise<string>;
     /**
-     * Defines the node to use as the root of the hierarchy when loading the scene (default: undefined). If not defined, a root node will be automatically created.
-     * You can also pass null if you don't want a root node to be created.
+     * If true, do not load any materials defined in the file. Defaults to false.
      */
-    customRootNode?: Nullable<TransformNode>;
+    skipMaterials: boolean;
     /**
-     * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
-     * Note that the callback is called as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)
+     * When loading glTF animations, which are defined in seconds, target them to this FPS. Defaults to 60.
      */
-    abstract onMeshLoaded?: ((mesh: AbstractMesh) => void) | undefined;
+    targetFps: number;
     /**
-     * Callback raised when the loader creates a skin after parsing the glTF properties of the skin node.
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/glTF/glTFSkinning#ignoring-the-transform-of-the-skinned-mesh
+     * Defines if the Alpha blended materials are only applied as coverage.
+     * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
+     * If true, no extra effects are applied to transparent pixels.
      */
-    abstract onSkinLoaded?: ((node: TransformNode, skinnedNode: TransformNode) => void) | undefined;
+    transparencyAsCoverage: boolean;
     /**
-     * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.
+     * Defines if the loader should also compile materials with clip planes. Defaults to false.
      */
-    abstract onTextureLoaded?: ((texture: BaseTexture) => void) | undefined;
+    useClipPlane: boolean;
     /**
-     * Callback raised when the loader creates a material after parsing the glTF properties of the material.
+     * If true, the loader will derive the name for Babylon textures from the glTF texture name, image name, or image url. Defaults to false.
+     * Note that it is possible for multiple Babylon textures to share the same name when the Babylon textures load from the same glTF texture or image.
      */
-    abstract onMaterialLoaded?: ((material: Material) => void) | undefined;
+    useGltfTextureNames: boolean;
     /**
-     * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.
+     * Defines if the loader should use range requests when load binary glTF files from HTTP.
+     * Enabling will disable offline support and glTF validator.
+     * Defaults to false.
      */
-    abstract onCameraLoaded?: ((camera: Camera) => void) | undefined;
+    useRangeRequests: boolean;
     /**
-     * Defines options for glTF extensions.
+     * If true, load the color (gamma encoded) textures into sRGB buffers (if supported by the GPU), which will yield more accurate results when sampling the texture. Defaults to true.
      */
-    extensionOptions: {
-        [Extension in keyof GLTFLoaderExtensionOptions]?: {
-            [Option in keyof DefaultExtensionOptions<GLTFLoaderExtensionOptions[Extension]>]: DefaultExtensionOptions<GLTFLoaderExtensionOptions[Extension]>[Option];
-        };
-    };
+    useSRGBBuffers: boolean;
+    /**
+     * Defines if the loader should validate the asset.
+     */
+    validate: boolean;
 }
 /**
  * File loader for loading glTF files into a scene.
@@ -390,17 +406,13 @@ export declare class GLTFFileLoader extends GLTFLoaderOptions implements IDispos
      */
     get capturePerformanceCounters(): boolean;
     set capturePerformanceCounters(value: boolean);
-    /**
-     * Defines if the loader should validate the asset.
-     */
-    validate: boolean;
     /**
      * Observable raised after validation when validate is set to true. The event data is the result of the validation.
      */
     readonly onValidatedObservable: Observable<GLTF2.IGLTFValidationResults>;
     private _onValidatedObserver;
     /**
-     * Callback raised after a loader extension is created.
+     * Callback raised after the asset is validated.
      */
     set onValidated(callback: (results: GLTF2.IGLTFValidationResults) => void);
     private _loader;

package/glTF/glTFFileLoader.js

@@ -86,130 +86,138 @@ class GLTFLoaderOptions {
         // V2 options
         // ----------
         /**
-         * The coordinate system mode. Defaults to AUTO.
-         */
-        this.coordinateSystemMode = GLTFLoaderCoordinateSystemMode.AUTO;
-        /**
-         * The animation start mode. Defaults to FIRST.
-         */
-        this.animationStartMode = GLTFLoaderAnimationStartMode.FIRST;
-        /**
-         * Defines if the loader should load node animations. Defaults to true.
-         * NOTE: The animation of this node will still load if the node is also a joint of a skin and `loadSkins` is true.
+         * Defines if the loader should always compute the bounding boxes of meshes and not use the min/max values from the position accessor. Defaults to false.
          */
-        this.loadNodeAnimations = true;
+        this.alwaysComputeBoundingBox = false;
         /**
-         * Defines if the loader should load skins. Defaults to true.
+         * Defines if the loader should always compute the nearest common ancestor of the skeleton joints instead of using `skin.skeleton`. Defaults to false.
+         * Set this to true if loading assets with invalid `skin.skeleton` values.
          */
-        this.loadSkins = true;
+        this.alwaysComputeSkeletonRootNode = false;
         /**
-         * Defines if the loader should load morph targets. Defaults to true.
+         * The animation start mode. Defaults to FIRST.
          */
-        this.loadMorphTargets = true;
+        this.animationStartMode = GLTFLoaderAnimationStartMode.FIRST;
         /**
          * Defines if the loader should compile materials before raising the success callback. Defaults to false.
          */
         this.compileMaterials = false;
-        /**
-         * Defines if the loader should also compile materials with clip planes. Defaults to false.
-         */
-        this.useClipPlane = false;
         /**
          * Defines if the loader should compile shadow generators before raising the success callback. Defaults to false.
          */
         this.compileShadowGenerators = false;
         /**
-         * Defines if the Alpha blended materials are only applied as coverage.
-         * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
-         * If true, no extra effects are applied to transparent pixels.
-         */
-        this.transparencyAsCoverage = false;
-        /**
-         * Defines if the loader should use range requests when load binary glTF files from HTTP.
-         * Enabling will disable offline support and glTF validator.
-         * Defaults to false.
+         * The coordinate system mode. Defaults to AUTO.
          */
-        this.useRangeRequests = false;
+        this.coordinateSystemMode = GLTFLoaderCoordinateSystemMode.AUTO;
         /**
          * Defines if the loader should create instances when multiple glTF nodes point to the same glTF mesh. Defaults to true.
          */
         this.createInstances = true;
         /**
-         * Defines if the loader should always compute the bounding boxes of meshes and not use the min/max values from the position accessor. Defaults to false.
+         * Defines options for glTF extensions.
          */
-        this.alwaysComputeBoundingBox = false;
+        this.extensionOptions = {};
         /**
          * If true, load all materials defined in the file, even if not used by any mesh. Defaults to false.
          */
         this.loadAllMaterials = false;
+        /**
+         * Defines if the loader should load morph targets. Defaults to true.
+         */
+        this.loadMorphTargets = true;
+        /**
+         * Defines if the loader should load node animations. Defaults to true.
+         * NOTE: The animation of this node will still load if the node is also a joint of a skin and `loadSkins` is true.
+         */
+        this.loadNodeAnimations = true;
         /**
          * If true, load only the materials defined in the file. Defaults to false.
          */
         this.loadOnlyMaterials = false;
         /**
-         * If true, do not load any materials defined in the file. Defaults to false.
+         * Defines if the loader should load skins. Defaults to true.
          */
-        this.skipMaterials = false;
+        this.loadSkins = true;
         /**
-         * If true, load the color (gamma encoded) textures into sRGB buffers (if supported by the GPU), which will yield more accurate results when sampling the texture. Defaults to true.
+         * Function called before loading a url referenced by the asset.
+         * @param url url referenced by the asset
+         * @returns Async url to load
          */
-        this.useSRGBBuffers = true;
+        this.preprocessUrlAsync = (url) => Promise.resolve(url);
+        /**
+         * If true, do not load any materials defined in the file. Defaults to false.
+         */
+        this.skipMaterials = false;
         /**
          * When loading glTF animations, which are defined in seconds, target them to this FPS. Defaults to 60.
          */
         this.targetFps = 60;
         /**
-         * Defines if the loader should always compute the nearest common ancestor of the skeleton joints instead of using `skin.skeleton`. Defaults to false.
-         * Set this to true if loading assets with invalid `skin.skeleton` values.
+         * Defines if the Alpha blended materials are only applied as coverage.
+         * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
+         * If true, no extra effects are applied to transparent pixels.
          */
-        this.alwaysComputeSkeletonRootNode = false;
+        this.transparencyAsCoverage = false;
+        /**
+         * Defines if the loader should also compile materials with clip planes. Defaults to false.
+         */
+        this.useClipPlane = false;
         /**
          * If true, the loader will derive the name for Babylon textures from the glTF texture name, image name, or image url. Defaults to false.
          * Note that it is possible for multiple Babylon textures to share the same name when the Babylon textures load from the same glTF texture or image.
          */
         this.useGltfTextureNames = false;
         /**
-         * Function called before loading a url referenced by the asset.
-         * @param url url referenced by the asset
-         * @returns Async url to load
+         * Defines if the loader should use range requests when load binary glTF files from HTTP.
+         * Enabling will disable offline support and glTF validator.
+         * Defaults to false.
          */
-        this.preprocessUrlAsync = (url) => Promise.resolve(url);
+        this.useRangeRequests = false;
         /**
-         * Defines options for glTF extensions.
+         * If true, load the color (gamma encoded) textures into sRGB buffers (if supported by the GPU), which will yield more accurate results when sampling the texture. Defaults to true.
          */
-        this.extensionOptions = {};
+        this.useSRGBBuffers = true;
+        /**
+         * Defines if the loader should validate the asset.
+         */
+        this.validate = false;
     }
     // eslint-disable-next-line babylonjs/available
     copyFrom(options) {
         if (options) {
-            this.onParsed = options.onParsed;
-            this.coordinateSystemMode = options.coordinateSystemMode ?? this.coordinateSystemMode;
+            this.alwaysComputeBoundingBox = options.alwaysComputeBoundingBox ?? this.alwaysComputeBoundingBox;
+            this.alwaysComputeSkeletonRootNode = options.alwaysComputeSkeletonRootNode ?? this.alwaysComputeSkeletonRootNode;
             this.animationStartMode = options.animationStartMode ?? this.animationStartMode;
-            this.loadNodeAnimations = options.loadNodeAnimations ?? this.loadNodeAnimations;
-            this.loadSkins = options.loadSkins ?? this.loadSkins;
-            this.loadMorphTargets = options.loadMorphTargets ?? this.loadMorphTargets;
+            this.capturePerformanceCounters = options.capturePerformanceCounters ?? this.capturePerformanceCounters;
             this.compileMaterials = options.compileMaterials ?? this.compileMaterials;
-            this.useClipPlane = options.useClipPlane ?? this.useClipPlane;
             this.compileShadowGenerators = options.compileShadowGenerators ?? this.compileShadowGenerators;
-            this.transparencyAsCoverage = options.transparencyAsCoverage ?? this.transparencyAsCoverage;
-            this.useRangeRequests = options.useRangeRequests ?? this.useRangeRequests;
+            this.coordinateSystemMode = options.coordinateSystemMode ?? this.coordinateSystemMode;
             this.createInstances = options.createInstances ?? this.createInstances;
-            this.alwaysComputeBoundingBox = options.alwaysComputeBoundingBox ?? this.alwaysComputeBoundingBox;
+            this.customRootNode = options.customRootNode;
+            this.extensionOptions = options.extensionOptions ?? this.extensionOptions;
             this.loadAllMaterials = options.loadAllMaterials ?? this.loadAllMaterials;
+            this.loadMorphTargets = options.loadMorphTargets ?? this.loadMorphTargets;
+            this.loadNodeAnimations = options.loadNodeAnimations ?? this.loadNodeAnimations;
             this.loadOnlyMaterials = options.loadOnlyMaterials ?? this.loadOnlyMaterials;
-            this.skipMaterials = options.skipMaterials ?? this.skipMaterials;
-            this.useSRGBBuffers = options.useSRGBBuffers ?? this.useSRGBBuffers;
-            this.targetFps = options.targetFps ?? this.targetFps;
-            this.alwaysComputeSkeletonRootNode = options.alwaysComputeSkeletonRootNode ?? this.alwaysComputeSkeletonRootNode;
-            this.useGltfTextureNames = options.useGltfTextureNames ?? this.useGltfTextureNames;
-            this.preprocessUrlAsync = options.preprocessUrlAsync ?? this.preprocessUrlAsync;
-            this.customRootNode = options.customRootNode;
+            this.loadSkins = options.loadSkins ?? this.loadSkins;
+            this.loggingEnabled = options.loggingEnabled ?? this.loggingEnabled;
+            this.onCameraLoaded = options.onCameraLoaded;
+            this.onMaterialLoaded = options.onMaterialLoaded;
             this.onMeshLoaded = options.onMeshLoaded;
+            this.onParsed = options.onParsed;
             this.onSkinLoaded = options.onSkinLoaded;
             this.onTextureLoaded = options.onTextureLoaded;
-            this.onMaterialLoaded = options.onMaterialLoaded;
-            this.onCameraLoaded = options.onCameraLoaded;
-            this.extensionOptions = options.extensionOptions ?? this.extensionOptions;
+            this.onValidated = options.onValidated;
+            this.preprocessUrlAsync = options.preprocessUrlAsync ?? this.preprocessUrlAsync;
+            this.skipMaterials = options.skipMaterials ?? this.skipMaterials;
+            this.targetFps = options.targetFps ?? this.targetFps;
+            this.transparencyAsCoverage = options.transparencyAsCoverage ?? this.transparencyAsCoverage;
+            this.useClipPlane = options.useClipPlane ?? this.useClipPlane;
+            this.useGltfTextureNames = options.useGltfTextureNames ?? this.useGltfTextureNames;
+            this.useRangeRequests = options.useRangeRequests ?? this.useRangeRequests;
+            this.useSRGBBuffers = options.useSRGBBuffers ?? this.useSRGBBuffers;
+            this.validate = options.validate ?? this.validate;
         }
     }
 }
@@ -276,10 +284,6 @@ export class GLTFFileLoader extends GLTFLoaderOptions {
          * Set additional options for a loader extension in this event.
          */
         this.onExtensionLoadedObservable = new Observable();
-        /**
-         * Defines if the loader should validate the asset.
-         */
-        this.validate = false;
         /**
          * Observable raised after validation when validate is set to true. The event data is the result of the validation.
          */
@@ -453,7 +457,7 @@ export class GLTFFileLoader extends GLTFLoaderOptions {
         }
     }
     /**
-     * Callback raised after a loader extension is created.
+     * Callback raised after the asset is validated.
      */
     set onValidated(callback) {
         if (this._onValidatedObserver) {