@babylonjs/core 7.48.0 → 7.48.2

package/Loading/sceneLoader.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from "../Misc/observable";
-import type { Nullable } from "../types";
+import type { DeepImmutable, Nullable } from "../types";
 import { Scene } from "../scene";
 import type { AbstractMesh } from "../Meshes/abstractMesh";
 import type { AnimationGroup } from "../Animations/animationGroup";
@@ -351,10 +351,39 @@ export interface ImportAnimationsOptions extends SceneLoaderOptions {
  * Adds a new plugin to the list of registered plugins
  * @param plugin defines the plugin to add
  */
+export declare function RegisterSceneLoaderPlugin(plugin: ISceneLoaderPlugin | ISceneLoaderPluginAsync | ISceneLoaderPluginFactory): void;
+/**
+ * Adds a new plugin to the list of registered plugins
+ * @deprecated Please use `RegisterSceneLoaderPlugin` instead.
+ * @param plugin defines the plugin to add
+ */
 export declare function registerSceneLoaderPlugin(plugin: ISceneLoaderPlugin | ISceneLoaderPluginAsync | ISceneLoaderPluginFactory): void;
+/**
+ * Gets metadata for all currently registered scene loader plugins.
+ * @returns An array where each entry has metadata for a single scene loader plugin.
+ */
+export declare function GetRegisteredSceneLoaderPluginMetadata(): DeepImmutable<Array<Pick<ISceneLoaderPluginMetadata, "name"> & {
+    /**
+     * The extensions supported by the plugin.
+     */
+    extensions: ({
+        /**
+         * The file extension.
+         */
+        extension: string;
+    } & ISceneLoaderPluginExtensions[string])[];
+}>>;
 /**
  * Load a scene
- * @experimental
+ * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
+ * @param engine is the instance of BABYLON.Engine to use to create the scene
+ * @param options an object that configures aspects of how the scene is loaded
+ * @returns The loaded scene
+ */
+export declare function LoadSceneAsync(source: SceneSource, engine: AbstractEngine, options?: LoadOptions): Promise<Scene>;
+/**
+ * Load a scene
+ * @deprecated Please use `LoadSceneAsync` instead.
  * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
  * @param engine is the instance of BABYLON.Engine to use to create the scene
  * @param options an object that configures aspects of how the scene is loaded
@@ -363,15 +392,32 @@ export declare function registerSceneLoaderPlugin(plugin: ISceneLoaderPlugin | I
 export declare function loadSceneAsync(source: SceneSource, engine: AbstractEngine, options?: LoadOptions): Promise<Scene>;
 /**
  * Append a scene
- * @experimental
  * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
  * @param scene is the instance of BABYLON.Scene to append to
  * @param options an object that configures aspects of how the scene is loaded
+ * @returns A promise that resolves when the scene is appended
+ */
+export declare function AppendSceneAsync(source: SceneSource, scene: Scene, options?: AppendOptions): Promise<void>;
+/**
+ * Append a scene
+ * @deprecated Please use `AppendSceneAsync` instead.
+ * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
+ * @param scene is the instance of BABYLON.Scene to append to
+ * @param options an object that configures aspects of how the scene is loaded
+ * @returns A promise that resolves when the scene is appended
  */
 export declare function appendSceneAsync(source: SceneSource, scene: Scene, options?: AppendOptions): Promise<void>;
 /**
  * Load a scene into an asset container
- * @experimental
+ * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
+ * @param scene is the instance of Scene to append to
+ * @param options an object that configures aspects of how the scene is loaded
+ * @returns The loaded asset container
+ */
+export declare function LoadAssetContainerAsync(source: SceneSource, scene: Scene, options?: LoadAssetContainerOptions): Promise<AssetContainer>;
+/**
+ * Load a scene into an asset container
+ * @deprecated Please use `LoadAssetContainerAsync` instead.
  * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
  * @param scene is the instance of Scene to append to
  * @param options an object that configures aspects of how the scene is loaded
@@ -380,15 +426,25 @@ export declare function appendSceneAsync(source: SceneSource, scene: Scene, opti
 export declare function loadAssetContainerAsync(source: SceneSource, scene: Scene, options?: LoadAssetContainerOptions): Promise<AssetContainer>;
 /**
  * Import animations from a file into a scene
- * @experimental
  * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
  * @param scene is the instance of BABYLON.Scene to append to
  * @param options an object that configures aspects of how the scene is loaded
+ * @returns A promise that resolves when the animations are imported
+ */
+export declare function ImportAnimationsAsync(source: SceneSource, scene: Scene, options?: ImportAnimationsOptions): Promise<void>;
+/**
+ * Import animations from a file into a scene
+ * @deprecated Please use `ImportAnimationsAsync` instead.
+ * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
+ * @param scene is the instance of BABYLON.Scene to append to
+ * @param options an object that configures aspects of how the scene is loaded
+ * @returns A promise that resolves when the animations are imported
  */
 export declare function importAnimationsAsync(source: SceneSource, scene: Scene, options?: ImportAnimationsOptions): Promise<void>;
 /**
  * Class used to load scene from various file formats using registered plugins
  * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/loadingFileTypes
+ * @deprecated The module level functions (such as LoadAssetContainerAsync) are more efficient for bundler tree shaking and allow plugin options to be passed through. Future improvements to scene loading will primarily be in the module level functions. The SceneLoader class will remain available, but it will be beneficial to prefer the module level functions.
  */
 export declare class SceneLoader {
     /**

package/Loading/sceneLoader.js

@@ -294,7 +294,7 @@ function _getFileInfo(rootUrl, sceneSource) {
  * Adds a new plugin to the list of registered plugins
  * @param plugin defines the plugin to add
  */
-export function registerSceneLoaderPlugin(plugin) {
+export function RegisterSceneLoaderPlugin(plugin) {
     if (typeof plugin.extensions === "string") {
         const extension = plugin.extensions;
         registeredPlugins[extension.toLowerCase()] = {
@@ -313,6 +313,28 @@ export function registerSceneLoaderPlugin(plugin) {
         });
     }
 }
+/**
+ * Adds a new plugin to the list of registered plugins
+ * @deprecated Please use `RegisterSceneLoaderPlugin` instead.
+ * @param plugin defines the plugin to add
+ */
+export function registerSceneLoaderPlugin(plugin) {
+    RegisterSceneLoaderPlugin(plugin);
+}
+/**
+ * Gets metadata for all currently registered scene loader plugins.
+ * @returns An array where each entry has metadata for a single scene loader plugin.
+ */
+export function GetRegisteredSceneLoaderPluginMetadata() {
+    return Array.from(Object.entries(registeredPlugins).reduce((pluginMap, [extension, extensionRegistration]) => {
+        let pluginMetadata = pluginMap.get(extensionRegistration.plugin.name);
+        if (!pluginMetadata) {
+            pluginMap.set(extensionRegistration.plugin.name, (pluginMetadata = []));
+        }
+        pluginMetadata.push({ extension, isBinary: extensionRegistration.isBinary, mimeType: extensionRegistration.mimeType });
+        return pluginMap;
+    }, new Map())).map(([name, extensions]) => ({ name, extensions }));
+}
 async function importMeshAsync(meshNames, rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
     if (!scene) {
         Logger.Error("No scene available to import mesh to");
@@ -391,51 +413,69 @@ async function importMeshAsync(meshNames, rootUrl, sceneFilename = "", scene = E
 }
 function importMeshAsyncCore(meshNames, rootUrl, sceneFilename, scene, onProgress, pluginExtension, name, pluginOptions) {
     return new Promise((resolve, reject) => {
-        importMeshAsync(meshNames, rootUrl, sceneFilename, scene, (meshes, particleSystems, skeletons, animationGroups, transformNodes, geometries, lights, spriteManagers) => {
-            resolve({
-                meshes: meshes,
-                particleSystems: particleSystems,
-                skeletons: skeletons,
-                animationGroups: animationGroups,
-                transformNodes: transformNodes,
-                geometries: geometries,
-                lights: lights,
-                spriteManagers: spriteManagers,
-            });
-        }, onProgress, (scene, message, exception) => {
-            reject(exception || new Error(message));
-        }, pluginExtension, name, pluginOptions);
+        try {
+            importMeshAsync(meshNames, rootUrl, sceneFilename, scene, (meshes, particleSystems, skeletons, animationGroups, transformNodes, geometries, lights, spriteManagers) => {
+                resolve({
+                    meshes: meshes,
+                    particleSystems: particleSystems,
+                    skeletons: skeletons,
+                    animationGroups: animationGroups,
+                    transformNodes: transformNodes,
+                    geometries: geometries,
+                    lights: lights,
+                    spriteManagers: spriteManagers,
+                });
+            }, onProgress, (scene, message, exception) => {
+                reject(exception || new Error(message));
+            }, pluginExtension, name, pluginOptions).catch(reject);
+        }
+        catch (error) {
+            reject(error);
+        }
     });
 }
-function loadScene(rootUrl, sceneFilename = "", engine = EngineStore.LastCreatedEngine, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
+// This is the core implementation of load scene
+async function loadSceneImplAsync(rootUrl, sceneFilename = "", engine = EngineStore.LastCreatedEngine, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
     if (!engine) {
         Tools.Error("No engine available");
         return;
     }
-    appendAsync(rootUrl, sceneFilename, new Scene(engine), onSuccess, onProgress, onError, pluginExtension, name, pluginOptions);
+    await appendSceneImplAsync(rootUrl, sceneFilename, new Scene(engine), onSuccess, onProgress, onError, pluginExtension, name, pluginOptions);
 }
 /**
  * Load a scene
- * @experimental
  * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
  * @param engine is the instance of BABYLON.Engine to use to create the scene
  * @param options an object that configures aspects of how the scene is loaded
  * @returns The loaded scene
  */
-export function loadSceneAsync(source, engine, options) {
+export function LoadSceneAsync(source, engine, options) {
     const { rootUrl = "", onProgress, pluginExtension, name, pluginOptions } = options ?? {};
-    return loadSceneAsyncCore(rootUrl, source, engine, onProgress, pluginExtension, name, pluginOptions);
+    return loadSceneSharedAsync(rootUrl, source, engine, onProgress, pluginExtension, name, pluginOptions);
 }
-function loadSceneAsyncCore(rootUrl, sceneFilename, engine, onProgress, pluginExtension, name, pluginOptions) {
+/**
+ * Load a scene
+ * @deprecated Please use `LoadSceneAsync` instead.
+ * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
+ * @param engine is the instance of BABYLON.Engine to use to create the scene
+ * @param options an object that configures aspects of how the scene is loaded
+ * @returns The loaded scene
+ */
+export function loadSceneAsync(source, engine, options) {
+    return LoadSceneAsync(source, engine, options);
+}
+// This function is shared between the new module level loadSceneAsync and the legacy SceneLoader.LoadAsync
+function loadSceneSharedAsync(rootUrl, sceneFilename, engine, onProgress, pluginExtension, name, pluginOptions) {
     return new Promise((resolve, reject) => {
-        loadScene(rootUrl, sceneFilename, engine, (scene) => {
+        loadSceneImplAsync(rootUrl, sceneFilename, engine, (scene) => {
             resolve(scene);
         }, onProgress, (scene, message, exception) => {
             reject(exception || new Error(message));
         }, pluginExtension, name, pluginOptions);
     });
 }
-async function appendAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
+// This is the core implementation of append scene
+async function appendSceneImplAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
     if (!scene) {
         Logger.Error("No scene available to append to");
         return null;
@@ -514,25 +554,43 @@ async function appendAsync(rootUrl, sceneFilename = "", scene = EngineStore.Last
 }
 /**
  * Append a scene
- * @experimental
  * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
  * @param scene is the instance of BABYLON.Scene to append to
  * @param options an object that configures aspects of how the scene is loaded
+ * @returns A promise that resolves when the scene is appended
  */
-export async function appendSceneAsync(source, scene, options) {
+export async function AppendSceneAsync(source, scene, options) {
     const { rootUrl = "", onProgress, pluginExtension, name, pluginOptions } = options ?? {};
-    await appendSceneAsyncCore(rootUrl, source, scene, onProgress, pluginExtension, name, pluginOptions);
+    await appendSceneSharedAsync(rootUrl, source, scene, onProgress, pluginExtension, name, pluginOptions);
+}
+/**
+ * Append a scene
+ * @deprecated Please use `AppendSceneAsync` instead.
+ * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
+ * @param scene is the instance of BABYLON.Scene to append to
+ * @param options an object that configures aspects of how the scene is loaded
+ * @returns A promise that resolves when the scene is appended
+ */
+export function appendSceneAsync(source, scene, options) {
+    return AppendSceneAsync(source, scene, options);
 }
-function appendSceneAsyncCore(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name, pluginOptions) {
+// This function is shared between the new module level appendSceneAsync and the legacy SceneLoader.AppendAsync
+function appendSceneSharedAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name, pluginOptions) {
     return new Promise((resolve, reject) => {
-        appendAsync(rootUrl, sceneFilename, scene, (scene) => {
-            resolve(scene);
-        }, onProgress, (scene, message, exception) => {
-            reject(exception || new Error(message));
-        }, pluginExtension, name, pluginOptions);
+        try {
+            appendSceneImplAsync(rootUrl, sceneFilename, scene, (scene) => {
+                resolve(scene);
+            }, onProgress, (scene, message, exception) => {
+                reject(exception || new Error(message));
+            }, pluginExtension, name, pluginOptions).catch(reject);
+        }
+        catch (error) {
+            reject(error);
+        }
     });
 }
-async function loadAssetContainerCoreAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
+// This is the core implementation of load asset container
+async function loadAssetContainerImplAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
     if (!scene) {
         Logger.Error("No scene available to load asset container to");
         return null;
@@ -609,26 +667,43 @@ async function loadAssetContainerCoreAsync(rootUrl, sceneFilename = "", scene =
 }
 /**
  * Load a scene into an asset container
- * @experimental
  * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
  * @param scene is the instance of Scene to append to
  * @param options an object that configures aspects of how the scene is loaded
  * @returns The loaded asset container
  */
-export function loadAssetContainerAsync(source, scene, options) {
+export function LoadAssetContainerAsync(source, scene, options) {
     const { rootUrl = "", onProgress, pluginExtension, name, pluginOptions } = options ?? {};
-    return internalLoadAssetContainerAsync(rootUrl, source, scene, onProgress, pluginExtension, name, pluginOptions);
+    return loadAssetContainerSharedAsync(rootUrl, source, scene, onProgress, pluginExtension, name, pluginOptions);
 }
-function internalLoadAssetContainerAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name, pluginOptions) {
+/**
+ * Load a scene into an asset container
+ * @deprecated Please use `LoadAssetContainerAsync` instead.
+ * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
+ * @param scene is the instance of Scene to append to
+ * @param options an object that configures aspects of how the scene is loaded
+ * @returns The loaded asset container
+ */
+export function loadAssetContainerAsync(source, scene, options) {
+    return LoadAssetContainerAsync(source, scene, options);
+}
+// This function is shared between the new module level loadAssetContainerAsync and the legacy SceneLoader.LoadAssetContainerAsync
+function loadAssetContainerSharedAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name, pluginOptions) {
     return new Promise((resolve, reject) => {
-        loadAssetContainerCoreAsync(rootUrl, sceneFilename, scene, (assets) => {
-            resolve(assets);
-        }, onProgress, (scene, message, exception) => {
-            reject(exception || new Error(message));
-        }, pluginExtension, name, pluginOptions);
+        try {
+            loadAssetContainerImplAsync(rootUrl, sceneFilename, scene, (assets) => {
+                resolve(assets);
+            }, onProgress, (scene, message, exception) => {
+                reject(exception || new Error(message));
+            }, pluginExtension, name, pluginOptions).catch(reject);
+        }
+        catch (error) {
+            reject(error);
+        }
     });
 }
-function importAnimations(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, overwriteAnimations = true, animationGroupLoadingMode = 0 /* SceneLoaderAnimationGroupLoadingMode.Clean */, targetConverter = null, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
+// This is the core implementation of import animations
+async function importAnimationsImplAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, overwriteAnimations = true, animationGroupLoadingMode = 0 /* SceneLoaderAnimationGroupLoadingMode.Clean */, targetConverter = null, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
     if (!scene) {
         Logger.Error("No scene available to load animations to");
         return;
@@ -684,31 +759,49 @@ function importAnimations(rootUrl, sceneFilename = "", scene = EngineStore.LastC
             onSuccess(scene);
         }
     };
-    loadAssetContainerCoreAsync(rootUrl, sceneFilename, scene, onAssetContainerLoaded, onProgress, onError, pluginExtension, name, pluginOptions);
+    await loadAssetContainerImplAsync(rootUrl, sceneFilename, scene, onAssetContainerLoaded, onProgress, onError, pluginExtension, name, pluginOptions);
 }
 /**
  * Import animations from a file into a scene
- * @experimental
  * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
  * @param scene is the instance of BABYLON.Scene to append to
  * @param options an object that configures aspects of how the scene is loaded
+ * @returns A promise that resolves when the animations are imported
  */
-export async function importAnimationsAsync(source, scene, options) {
+export async function ImportAnimationsAsync(source, scene, options) {
     const { rootUrl = "", overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name, pluginOptions } = options ?? {};
-    await importAnimationsAsyncCore(rootUrl, source, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name, pluginOptions);
+    await importAnimationsSharedAsync(rootUrl, source, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name, pluginOptions);
 }
-function importAnimationsAsyncCore(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name, pluginOptions) {
+/**
+ * Import animations from a file into a scene
+ * @deprecated Please use `ImportAnimationsAsync` instead.
+ * @param source a string that defines the name of the scene file, or starts with "data:" following by the stringified version of the scene, or a File object, or an ArrayBufferView
+ * @param scene is the instance of BABYLON.Scene to append to
+ * @param options an object that configures aspects of how the scene is loaded
+ * @returns A promise that resolves when the animations are imported
+ */
+export function importAnimationsAsync(source, scene, options) {
+    return ImportAnimationsAsync(source, scene, options);
+}
+// This function is shared between the new module level importAnimationsAsync and the legacy SceneLoader.ImportAnimationsAsync
+function importAnimationsSharedAsync(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name, pluginOptions) {
     return new Promise((resolve, reject) => {
-        importAnimations(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, (scene) => {
-            resolve(scene);
-        }, onProgress, (scene, message, exception) => {
-            reject(exception || new Error(message));
-        }, pluginExtension, name, pluginOptions);
+        try {
+            importAnimationsImplAsync(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, (scene) => {
+                resolve(scene);
+            }, onProgress, (scene, message, exception) => {
+                reject(exception || new Error(message));
+            }, pluginExtension, name, pluginOptions).catch(reject);
+        }
+        catch (error) {
+            reject(error);
+        }
     });
 }
 /**
  * Class used to load scene from various file formats using registered plugins
  * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/loadingFileTypes
+ * @deprecated The module level functions (such as LoadAssetContainerAsync) are more efficient for bundler tree shaking and allow plugin options to be passed through. Future improvements to scene loading will primarily be in the module level functions. The SceneLoader class will remain available, but it will be beneficial to prefer the module level functions.
  */
 export class SceneLoader {
     /**
@@ -779,7 +872,7 @@ export class SceneLoader {
      * @param plugin defines the plugin to add
      */
     static RegisterPlugin(plugin) {
-        registerSceneLoaderPlugin(plugin);
+        RegisterSceneLoaderPlugin(plugin);
     }
     /**
      * Import meshes into a scene
@@ -795,7 +888,7 @@ export class SceneLoader {
      * @deprecated Please use ImportMeshAsync instead
      */
     static ImportMesh(meshNames, rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name) {
-        importMeshAsync(meshNames, rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name);
+        importMeshAsync(meshNames, rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name).catch((error) => onError?.(EngineStore.LastCreatedScene, error?.message, error));
     }
     /**
      * Import meshes into a scene
@@ -824,7 +917,7 @@ export class SceneLoader {
      * @deprecated Please use LoadAsync instead
      */
     static Load(rootUrl, sceneFilename, engine, onSuccess, onProgress, onError, pluginExtension, name) {
-        loadScene(rootUrl, sceneFilename, engine, onSuccess, onProgress, onError, pluginExtension, name);
+        loadSceneImplAsync(rootUrl, sceneFilename, engine, onSuccess, onProgress, onError, pluginExtension, name).catch((error) => onError?.(EngineStore.LastCreatedScene, error?.message, error));
     }
     /**
      * Load a scene
@@ -837,7 +930,7 @@ export class SceneLoader {
      * @returns The loaded scene
      */
     static LoadAsync(rootUrl, sceneFilename, engine, onProgress, pluginExtension, name) {
-        return loadSceneAsyncCore(rootUrl, sceneFilename, engine, onProgress, pluginExtension, name);
+        return loadSceneSharedAsync(rootUrl, sceneFilename, engine, onProgress, pluginExtension, name);
     }
     /**
      * Append a scene
@@ -852,7 +945,7 @@ export class SceneLoader {
      * @deprecated Please use AppendAsync instead
      */
     static Append(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name) {
-        appendAsync(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name);
+        appendSceneImplAsync(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name).catch((error) => onError?.((scene ?? EngineStore.LastCreatedScene), error?.message, error));
     }
     /**
      * Append a scene
@@ -865,7 +958,7 @@ export class SceneLoader {
      * @returns The given scene
      */
     static AppendAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name) {
-        return appendSceneAsyncCore(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
+        return appendSceneSharedAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
     }
     /**
      * Load a scene into an asset container
@@ -880,7 +973,7 @@ export class SceneLoader {
      * @deprecated Please use LoadAssetContainerAsync instead
      */
     static LoadAssetContainer(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name) {
-        loadAssetContainerCoreAsync(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name);
+        loadAssetContainerImplAsync(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name).catch((error) => onError?.((scene ?? EngineStore.LastCreatedScene), error?.message, error));
     }
     /**
      * Load a scene into an asset container
@@ -893,7 +986,7 @@ export class SceneLoader {
      * @returns The loaded asset container
      */
     static LoadAssetContainerAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name) {
-        return internalLoadAssetContainerAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
+        return loadAssetContainerSharedAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
     }
     /**
      * Import animations from a file into a scene
@@ -911,7 +1004,7 @@ export class SceneLoader {
      * @deprecated Please use ImportAnimationsAsync instead
      */
     static ImportAnimations(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onSuccess, onProgress, onError, pluginExtension, name) {
-        importAnimations(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onSuccess, onProgress, onError, pluginExtension, name);
+        importAnimationsImplAsync(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onSuccess, onProgress, onError, pluginExtension, name).catch((error) => onError?.((scene ?? EngineStore.LastCreatedScene), error?.message, error));
     }
     /**
      * Import animations from a file into a scene
@@ -933,7 +1026,7 @@ export class SceneLoader {
     onSuccess, onProgress, 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     onError, pluginExtension, name) {
-        return importAnimationsAsyncCore(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name);
+        return importAnimationsSharedAsync(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name);
     }
 }
 /**