@spiffcommerce/preview 3.6.2-rc.4 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/Loading/sceneLoader.esm.js

@@ -0,0 +1,551 @@
+import { Tools as L } from "../Misc/tools.esm.js";
+import { Observable as R } from "../Misc/observable.esm.js";
+import { Scene as M } from "../scene.esm.js";
+import { Engine as x } from "../Engines/engine.esm.js";
+import { EngineStore as E } from "../Engines/engineStore.esm.js";
+import { Logger as A } from "../Misc/logger.esm.js";
+import { SceneLoaderFlags as v } from "./sceneLoaderFlags.esm.js";
+import { IsBase64DataUrl as B } from "../Misc/fileTools.esm.js";
+import { RuntimeError as k, ErrorCodes as N } from "../Misc/error.esm.js";
+var F;
+(function(C) {
+  C[C.Clean = 0] = "Clean", C[C.Stop = 1] = "Stop", C[C.Sync = 2] = "Sync", C[C.NoSync = 3] = "NoSync";
+})(F || (F = {}));
+class a {
+  /**
+   * Gets or sets a boolean indicating if entire scene must be loaded even if scene contains incremental data
+   */
+  static get ForceFullSceneLoadingForIncremental() {
+    return v.ForceFullSceneLoadingForIncremental;
+  }
+  static set ForceFullSceneLoadingForIncremental(t) {
+    v.ForceFullSceneLoadingForIncremental = t;
+  }
+  /**
+   * Gets or sets a boolean indicating if loading screen must be displayed while loading a scene
+   */
+  static get ShowLoadingScreen() {
+    return v.ShowLoadingScreen;
+  }
+  static set ShowLoadingScreen(t) {
+    v.ShowLoadingScreen = t;
+  }
+  /**
+   * Defines the current logging level (while loading the scene)
+   * @ignorenaming
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static get loggingLevel() {
+    return v.loggingLevel;
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static set loggingLevel(t) {
+    v.loggingLevel = t;
+  }
+  /**
+   * Gets or set a boolean indicating if matrix weights must be cleaned upon loading
+   */
+  static get CleanBoneMatrixWeights() {
+    return v.CleanBoneMatrixWeights;
+  }
+  static set CleanBoneMatrixWeights(t) {
+    v.CleanBoneMatrixWeights = t;
+  }
+  /**
+   * Gets the default plugin (used to load Babylon files)
+   * @returns the .babylon plugin
+   */
+  static GetDefaultPlugin() {
+    return a._RegisteredPlugins[".babylon"];
+  }
+  static _GetPluginForExtension(t) {
+    const e = a._RegisteredPlugins[t];
+    return e || (A.Warn("Unable to find a plugin to load " + t + " files. Trying to use .babylon default plugin. To load from a specific filetype (eg. gltf) see: https://doc.babylonjs.com/features/featuresDeepDive/importers/loadingFileTypes"), a.GetDefaultPlugin());
+  }
+  static _GetPluginForDirectLoad(t) {
+    for (const e in a._RegisteredPlugins) {
+      const r = a._RegisteredPlugins[e].plugin;
+      if (r.canDirectLoad && r.canDirectLoad(t))
+        return a._RegisteredPlugins[e];
+    }
+    return a.GetDefaultPlugin();
+  }
+  static _GetPluginForFilename(t) {
+    const e = t.indexOf("?");
+    e !== -1 && (t = t.substring(0, e));
+    const r = t.lastIndexOf("."), n = t.substring(r, t.length).toLowerCase();
+    return a._GetPluginForExtension(n);
+  }
+  static _GetDirectLoad(t) {
+    return t.substr(0, 5) === "data:" ? t.substr(5) : null;
+  }
+  static _FormatErrorMessage(t, e, r) {
+    let l = "Unable to load from " + (t.rawData ? "binary data" : t.url);
+    return e ? l += `: ${e}` : r && (l += `: ${r}`), l;
+  }
+  static _LoadData(t, e, r, n, l, f, g, P) {
+    const d = a._GetDirectLoad(t.url);
+    if (t.rawData && !g)
+      throw "When using ArrayBufferView to load data the file extension must be provided.";
+    const o = g ? a._GetPluginForExtension(g) : d ? a._GetPluginForDirectLoad(t.url) : a._GetPluginForFilename(t.url);
+    if (t.rawData && !o.isBinary)
+      throw "Loading from ArrayBufferView can not be used with plugins that don't support binary loading.";
+    let i;
+    if (o.plugin.createPlugin !== void 0 ? i = o.plugin.createPlugin() : i = o.plugin, !i)
+      throw "The loader plugin corresponding to the file type you are trying to load has not been found. If using es6, please import the plugin you wish to use before.";
+    if (a.OnPluginActivatedObservable.notifyObservers(i), d && (i.canDirectLoad && i.canDirectLoad(t.url) || !B(t.url))) {
+      if (i.directLoad) {
+        const m = i.directLoad(e, d);
+        m.then ? m.then((w) => {
+          r(i, w);
+        }).catch((w) => {
+          l("Error in directLoad of _loadData: " + w, w);
+        }) : r(i, m);
+      } else
+        r(i, d);
+      return i;
+    }
+    const h = o.isBinary, c = (m, w) => {
+      if (e.isDisposed) {
+        l("Scene has been disposed");
+        return;
+      }
+      r(i, m, w);
+    };
+    let y = null, u = !1;
+    const s = i.onDisposeObservable;
+    s && s.add(() => {
+      u = !0, y && (y.abort(), y = null), f();
+    });
+    const p = () => {
+      if (u)
+        return;
+      const m = (w, G) => {
+        l(w == null ? void 0 : w.statusText, G);
+      };
+      if (!i.loadFile && t.rawData)
+        throw "Plugin does not support loading ArrayBufferView.";
+      y = i.loadFile ? i.loadFile(e, t.rawData || t.file || t.url, t.rootUrl, c, n, h, m, P) : e._loadFile(t.file || t.url, c, n, !0, h, m);
+    }, b = e.getEngine();
+    let D = b.enableOfflineSupport;
+    if (D) {
+      let m = !1;
+      for (const w of e.disableOfflineSupportExceptionRules)
+        if (w.test(t.url)) {
+          m = !0;
+          break;
+        }
+      D = !m;
+    }
+    return D && x.OfflineProviderFactory ? e.offlineProvider = x.OfflineProviderFactory(t.url, p, b.disableManifestCheck) : p(), i;
+  }
+  static _GetFileInfo(t, e) {
+    let r, n, l = null, f = null;
+    if (!e)
+      r = t, n = L.GetFilename(t), t = L.GetFolderPath(t);
+    else if (e.name) {
+      const g = e;
+      r = `file:${g.name}`, n = g.name, l = g;
+    } else if (ArrayBuffer.isView(e))
+      r = "", n = "arrayBuffer", f = e;
+    else if (typeof e == "string" && e.startsWith("data:"))
+      r = e, n = "";
+    else {
+      const g = e;
+      if (g.substr(0, 1) === "/")
+        return L.Error("Wrong sceneFilename parameter"), null;
+      r = t + g, n = g;
+    }
+    return {
+      url: r,
+      rootUrl: t,
+      name: n,
+      file: l,
+      rawData: f
+    };
+  }
+  // Public functions
+  /**
+   * Gets a plugin that can load the given extension
+   * @param extension defines the extension to load
+   * @returns a plugin or null if none works
+   */
+  static GetPluginForExtension(t) {
+    return a._GetPluginForExtension(t).plugin;
+  }
+  /**
+   * Gets a boolean indicating that the given extension can be loaded
+   * @param extension defines the extension to load
+   * @returns true if the extension is supported
+   */
+  static IsPluginForExtensionAvailable(t) {
+    return !!a._RegisteredPlugins[t];
+  }
+  /**
+   * Adds a new plugin to the list of registered plugins
+   * @param plugin defines the plugin to add
+   */
+  static RegisterPlugin(t) {
+    if (typeof t.extensions == "string") {
+      const e = t.extensions;
+      a._RegisteredPlugins[e.toLowerCase()] = {
+        plugin: t,
+        isBinary: !1
+      };
+    } else {
+      const e = t.extensions;
+      Object.keys(e).forEach((r) => {
+        a._RegisteredPlugins[r.toLowerCase()] = {
+          plugin: t,
+          isBinary: e[r].isBinary
+        };
+      });
+    }
+  }
+  /**
+   * Import meshes into a scene
+   * @param meshNames an array of mesh names, a single mesh name, or empty string for all meshes that filter what meshes are imported
+   * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
+   * @param sceneFilename 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 (default: empty string)
+   * @param scene the instance of BABYLON.Scene to append to
+   * @param onSuccess a callback with a list of imported meshes, particleSystems, skeletons, and animationGroups when import succeeds
+   * @param onProgress a callback with a progress event for each file being loaded
+   * @param onError a callback with the scene, a message, and possibly an exception when import fails
+   * @param pluginExtension the extension used to determine the plugin
+   * @returns The loaded plugin
+   */
+  static ImportMesh(t, e, r = "", n = E.LastCreatedScene, l = null, f = null, g = null, P = null, d = "") {
+    if (!n)
+      return A.Error("No scene available to import mesh to"), null;
+    const o = a._GetFileInfo(e, r);
+    if (!o)
+      return null;
+    const i = {};
+    n.addPendingData(i);
+    const h = () => {
+      n.removePendingData(i);
+    }, c = (s, p) => {
+      const b = a._FormatErrorMessage(o, s, p);
+      g ? g(n, b, new k(b, N.SceneLoaderError, p)) : A.Error(b), h();
+    }, y = f ? (s) => {
+      try {
+        f(s);
+      } catch (p) {
+        c("Error in onProgress callback: " + p, p);
+      }
+    } : void 0, u = (s, p, b, D, m, w, G) => {
+      if (n.importedMeshesFiles.push(o.url), l)
+        try {
+          l(s, p, b, D, m, w, G);
+        } catch (O) {
+          c("Error in onSuccess callback: " + O, O);
+        }
+      n.removePendingData(i);
+    };
+    return a._LoadData(o, n, (s, p, b) => {
+      if (s.rewriteRootURL && (o.rootUrl = s.rewriteRootURL(o.rootUrl, b)), s.importMesh) {
+        const D = s, m = new Array(), w = new Array(), G = new Array();
+        if (!D.importMesh(t, n, p, o.rootUrl, m, w, G, c))
+          return;
+        n.loadingPluginName = s.name, u(m, w, G, [], [], [], []);
+      } else
+        s.importMeshAsync(t, n, p, o.rootUrl, y, o.name).then((m) => {
+          n.loadingPluginName = s.name, u(m.meshes, m.particleSystems, m.skeletons, m.animationGroups, m.transformNodes, m.geometries, m.lights);
+        }).catch((m) => {
+          c(m.message, m);
+        });
+    }, y, c, h, P, d);
+  }
+  /**
+   * Import meshes into a scene
+   * @param meshNames an array of mesh names, a single mesh name, or empty string for all meshes that filter what meshes are imported
+   * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
+   * @param sceneFilename 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 (default: empty string)
+   * @param scene the instance of BABYLON.Scene to append to
+   * @param onProgress a callback with a progress event for each file being loaded
+   * @param pluginExtension the extension used to determine the plugin
+   * @returns The loaded list of imported meshes, particle systems, skeletons, and animation groups
+   */
+  static ImportMeshAsync(t, e, r = "", n = E.LastCreatedScene, l = null, f = null, g = "") {
+    return new Promise((P, d) => {
+      a.ImportMesh(t, e, r, n, (o, i, h, c, y, u, s) => {
+        P({
+          meshes: o,
+          particleSystems: i,
+          skeletons: h,
+          animationGroups: c,
+          transformNodes: y,
+          geometries: u,
+          lights: s
+        });
+      }, l, (o, i, h) => {
+        d(h || new Error(i));
+      }, f, g);
+    });
+  }
+  /**
+   * Load a scene
+   * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
+   * @param sceneFilename 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 (default: empty string)
+   * @param engine is the instance of BABYLON.Engine to use to create the scene
+   * @param onSuccess a callback with the scene when import succeeds
+   * @param onProgress a callback with a progress event for each file being loaded
+   * @param onError a callback with the scene, a message, and possibly an exception when import fails
+   * @param pluginExtension the extension used to determine the plugin
+   * @returns The loaded plugin
+   */
+  static Load(t, e = "", r = E.LastCreatedEngine, n = null, l = null, f = null, g = null, P = "") {
+    return r ? a.Append(t, e, new M(r), n, l, f, g, P) : (L.Error("No engine available"), null);
+  }
+  /**
+   * Load a scene
+   * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
+   * @param sceneFilename 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 (default: empty string)
+   * @param engine is the instance of BABYLON.Engine to use to create the scene
+   * @param onProgress a callback with a progress event for each file being loaded
+   * @param pluginExtension the extension used to determine the plugin
+   * @returns The loaded scene
+   */
+  static LoadAsync(t, e = "", r = E.LastCreatedEngine, n = null, l = null, f = "") {
+    return new Promise((g, P) => {
+      a.Load(t, e, r, (d) => {
+        g(d);
+      }, n, (d, o, i) => {
+        P(i || new Error(o));
+      }, l, f);
+    });
+  }
+  /**
+   * Append a scene
+   * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
+   * @param sceneFilename 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 (default: empty string)
+   * @param scene is the instance of BABYLON.Scene to append to
+   * @param onSuccess a callback with the scene when import succeeds
+   * @param onProgress a callback with a progress event for each file being loaded
+   * @param onError a callback with the scene, a message, and possibly an exception when import fails
+   * @param pluginExtension the extension used to determine the plugin
+   * @returns The loaded plugin
+   */
+  static Append(t, e = "", r = E.LastCreatedScene, n = null, l = null, f = null, g = null, P = "") {
+    if (!r)
+      return A.Error("No scene available to append to"), null;
+    const d = a._GetFileInfo(t, e);
+    if (!d)
+      return null;
+    const o = {};
+    r.addPendingData(o);
+    const i = () => {
+      r.removePendingData(o);
+    };
+    a.ShowLoadingScreen && !this._ShowingLoadingScreen && (this._ShowingLoadingScreen = !0, r.getEngine().displayLoadingUI(), r.executeWhenReady(() => {
+      r.getEngine().hideLoadingUI(), this._ShowingLoadingScreen = !1;
+    }));
+    const h = (u, s) => {
+      const p = a._FormatErrorMessage(d, u, s);
+      f ? f(r, p, new k(p, N.SceneLoaderError, s)) : A.Error(p), i();
+    }, c = l ? (u) => {
+      try {
+        l(u);
+      } catch (s) {
+        h("Error in onProgress callback", s);
+      }
+    } : void 0, y = () => {
+      if (n)
+        try {
+          n(r);
+        } catch (u) {
+          h("Error in onSuccess callback", u);
+        }
+      r.removePendingData(o);
+    };
+    return a._LoadData(d, r, (u, s) => {
+      if (u.load) {
+        if (!u.load(r, s, d.rootUrl, h))
+          return;
+        r.loadingPluginName = u.name, y();
+      } else
+        u.loadAsync(r, s, d.rootUrl, c, d.name).then(() => {
+          r.loadingPluginName = u.name, y();
+        }).catch((b) => {
+          h(b.message, b);
+        });
+    }, c, h, i, g, P);
+  }
+  /**
+   * Append a scene
+   * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
+   * @param sceneFilename 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 (default: empty string)
+   * @param scene is the instance of BABYLON.Scene to append to
+   * @param onProgress a callback with a progress event for each file being loaded
+   * @param pluginExtension the extension used to determine the plugin
+   * @returns The given scene
+   */
+  static AppendAsync(t, e = "", r = E.LastCreatedScene, n = null, l = null, f = "") {
+    return new Promise((g, P) => {
+      a.Append(t, e, r, (d) => {
+        g(d);
+      }, n, (d, o, i) => {
+        P(i || new Error(o));
+      }, l, f);
+    });
+  }
+  /**
+   * Load a scene into an asset container
+   * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
+   * @param sceneFilename 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 (default: empty string)
+   * @param scene is the instance of BABYLON.Scene to append to (default: last created scene)
+   * @param onSuccess a callback with the scene when import succeeds
+   * @param onProgress a callback with a progress event for each file being loaded
+   * @param onError a callback with the scene, a message, and possibly an exception when import fails
+   * @param pluginExtension the extension used to determine the plugin
+   * @returns The loaded plugin
+   */
+  static LoadAssetContainer(t, e = "", r = E.LastCreatedScene, n = null, l = null, f = null, g = null, P = "") {
+    if (!r)
+      return A.Error("No scene available to load asset container to"), null;
+    const d = a._GetFileInfo(t, e);
+    if (!d)
+      return null;
+    const o = {};
+    r.addPendingData(o);
+    const i = () => {
+      r.removePendingData(o);
+    }, h = (u, s) => {
+      const p = a._FormatErrorMessage(d, u, s);
+      f ? f(r, p, new k(p, N.SceneLoaderError, s)) : A.Error(p), i();
+    }, c = l ? (u) => {
+      try {
+        l(u);
+      } catch (s) {
+        h("Error in onProgress callback", s);
+      }
+    } : void 0, y = (u) => {
+      if (n)
+        try {
+          n(u);
+        } catch (s) {
+          h("Error in onSuccess callback", s);
+        }
+      r.removePendingData(o);
+    };
+    return a._LoadData(d, r, (u, s) => {
+      if (u.loadAssetContainer) {
+        const b = u.loadAssetContainer(r, s, d.rootUrl, h);
+        if (!b)
+          return;
+        r.loadingPluginName = u.name, y(b);
+      } else
+        u.loadAssetContainerAsync ? u.loadAssetContainerAsync(r, s, d.rootUrl, c, d.name).then((b) => {
+          r.loadingPluginName = u.name, y(b);
+        }).catch((b) => {
+          h(b.message, b);
+        }) : h("LoadAssetContainer is not supported by this plugin. Plugin did not provide a loadAssetContainer or loadAssetContainerAsync method.");
+    }, c, h, i, g, P);
+  }
+  /**
+   * Load a scene into an asset container
+   * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
+   * @param sceneFilename a string that defines the name of the scene file or starts with "data:" following by the stringified version of the scene (default: empty string)
+   * @param scene is the instance of Scene to append to
+   * @param onProgress a callback with a progress event for each file being loaded
+   * @param pluginExtension the extension used to determine the plugin
+   * @returns The loaded asset container
+   */
+  static LoadAssetContainerAsync(t, e = "", r = E.LastCreatedScene, n = null, l = null) {
+    return new Promise((f, g) => {
+      a.LoadAssetContainer(t, e, r, (P) => {
+        f(P);
+      }, n, (P, d, o) => {
+        g(o || new Error(d));
+      }, l);
+    });
+  }
+  /**
+   * Import animations from a file into a scene
+   * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
+   * @param sceneFilename 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 (default: empty string)
+   * @param scene is the instance of BABYLON.Scene to append to (default: last created scene)
+   * @param overwriteAnimations when true, animations are cleaned before importing new ones. Animations are appended otherwise
+   * @param animationGroupLoadingMode defines how to handle old animations groups before importing new ones
+   * @param targetConverter defines a function used to convert animation targets from loaded scene to current scene (default: search node by name)
+   * @param onSuccess a callback with the scene when import succeeds
+   * @param onProgress a callback with a progress event for each file being loaded
+   * @param onError a callback with the scene, a message, and possibly an exception when import fails
+   * @param pluginExtension the extension used to determine the plugin
+   */
+  static ImportAnimations(t, e = "", r = E.LastCreatedScene, n = !0, l = F.Clean, f = null, g = null, P = null, d = null, o = null) {
+    if (!r) {
+      A.Error("No scene available to load animations to");
+      return;
+    }
+    if (n) {
+      for (const y of r.animatables)
+        y.reset();
+      r.stopAllAnimations(), r.animationGroups.slice().forEach((y) => {
+        y.dispose();
+      }), r.getNodes().forEach((y) => {
+        y.animations && (y.animations = []);
+      });
+    } else
+      switch (l) {
+        case F.Clean:
+          r.animationGroups.slice().forEach((c) => {
+            c.dispose();
+          });
+          break;
+        case F.Stop:
+          r.animationGroups.forEach((c) => {
+            c.stop();
+          });
+          break;
+        case F.Sync:
+          r.animationGroups.forEach((c) => {
+            c.reset(), c.restart();
+          });
+          break;
+        case F.NoSync:
+          break;
+        default:
+          A.Error("Unknown animation group loading mode value '" + l + "'");
+          return;
+      }
+    const i = r.animatables.length, h = (c) => {
+      c.mergeAnimationsTo(r, r.animatables.slice(i), f), c.dispose(), r.onAnimationFileImportedObservable.notifyObservers(r), g && g(r);
+    };
+    this.LoadAssetContainer(t, e, r, h, P, d, o);
+  }
+  /**
+   * Import animations from a file into a scene
+   * @param rootUrl a string that defines the root url for the scene and resources or the concatenation of rootURL and filename (e.g. http://example.com/test.glb)
+   * @param sceneFilename 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 (default: empty string)
+   * @param scene is the instance of BABYLON.Scene to append to (default: last created scene)
+   * @param overwriteAnimations when true, animations are cleaned before importing new ones. Animations are appended otherwise
+   * @param animationGroupLoadingMode defines how to handle old animations groups before importing new ones
+   * @param targetConverter defines a function used to convert animation targets from loaded scene to current scene (default: search node by name)
+   * @param onSuccess a callback with the scene when import succeeds
+   * @param onProgress a callback with a progress event for each file being loaded
+   * @param onError a callback with the scene, a message, and possibly an exception when import fails
+   * @param pluginExtension the extension used to determine the plugin
+   * @returns the updated scene with imported animations
+   */
+  static ImportAnimationsAsync(t, e = "", r = E.LastCreatedScene, n = !0, l = F.Clean, f = null, g = null, P = null, d = null, o = null) {
+    return new Promise((i, h) => {
+      a.ImportAnimations(t, e, r, n, l, f, (c) => {
+        i(c);
+      }, P, (c, y, u) => {
+        h(u || new Error(y));
+      }, o);
+    });
+  }
+}
+a.NO_LOGGING = 0;
+a.MINIMAL_LOGGING = 1;
+a.SUMMARY_LOGGING = 2;
+a.DETAILED_LOGGING = 3;
+a.OnPluginActivatedObservable = new R();
+a._RegisteredPlugins = {};
+a._ShowingLoadingScreen = !1;
+export {
+  a as SceneLoader,
+  F as SceneLoaderAnimationGroupLoadingMode
+};

package/dist/node_modules/@babylonjs/core/Loading/sceneLoaderFlags.esm.js

@@ -0,0 +1,48 @@
+class e {
+  /**
+   * Gets or sets a boolean indicating if entire scene must be loaded even if scene contains incremental data
+   */
+  static get ForceFullSceneLoadingForIncremental() {
+    return e._ForceFullSceneLoadingForIncremental;
+  }
+  static set ForceFullSceneLoadingForIncremental(t) {
+    e._ForceFullSceneLoadingForIncremental = t;
+  }
+  /**
+   * Gets or sets a boolean indicating if loading screen must be displayed while loading a scene
+   */
+  static get ShowLoadingScreen() {
+    return e._ShowLoadingScreen;
+  }
+  static set ShowLoadingScreen(t) {
+    e._ShowLoadingScreen = t;
+  }
+  /**
+   * Defines the current logging level (while loading the scene)
+   * @ignorenaming
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static get loggingLevel() {
+    return e._LoggingLevel;
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static set loggingLevel(t) {
+    e._LoggingLevel = t;
+  }
+  /**
+   * Gets or set a boolean indicating if matrix weights must be cleaned upon loading
+   */
+  static get CleanBoneMatrixWeights() {
+    return e._CleanBoneMatrixWeights;
+  }
+  static set CleanBoneMatrixWeights(t) {
+    e._CleanBoneMatrixWeights = t;
+  }
+}
+e._ForceFullSceneLoadingForIncremental = !1;
+e._ShowLoadingScreen = !0;
+e._CleanBoneMatrixWeights = !1;
+e._LoggingLevel = 0;
+export {
+  e as SceneLoaderFlags
+};