@skewedaspect/sage 0.7.1 → 0.8.0

package/dist/sage.es.js

@@ -1,10 +1,10 @@
-var M = Object.defineProperty;
-var k = (r, e, t) => e in r ? M(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var L = Object.defineProperty;
+var k = (r, e, t) => e in r ? L(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
 var n = (r, e, t) => k(r, typeof e != "symbol" ? e + "" : e, t);
-import { Scene as L, Vector3 as C, FreeCamera as A, HemisphericLight as I, DirectionalLight as B, PointLight as G, SpotLight as V, MeshBuilder as v, PhysicsAggregate as K, Sound as T, LoadAssetContainerAsync as U, ImportMeshAsync as R, NullEngine as z, WebGPUEngine as P, Engine as O, HavokPlugin as H } from "@babylonjs/core";
-import W from "@babylonjs/havok";
-const b = "0.7.0";
-class F {
+import { Scene as A, Vector3 as E, FreeCamera as I, HemisphericLight as B, DirectionalLight as G, PointLight as V, SpotLight as K, MeshBuilder as v, PhysicsAggregate as T, Sound as U, LoadAssetContainerAsync as R, ImportMeshAsync as z, NullEngine as P, WebGPUEngine as H, Engine as W, HavokPlugin as O } from "@babylonjs/core";
+import F from "@babylonjs/havok";
+const m = "0.7.1";
+class N {
   /**
    * Creates an instance of SkewedAspectGameEngine.
    * @param canvas - The game canvas.
@@ -68,14 +68,14 @@ class F {
    * Starts the game engine.
    */
   async start() {
-    this.started ? this._log.warn("Game engine is already started. Skipping start.") : (this._log.info(`Starting SkewedAspect Game Engine (Version: ${b})...`), this._beforeStartHook && (this._log.debug("Executing beforeStart hook..."), await this._beforeStartHook(this)), await this.managers.gameManager.start(), this._log.info("Game engine started successfully"), this._onStartHook && (this._log.debug("Executing onStart hook..."), await this._onStartHook(this)), this.started = !0);
+    this.started ? this._log.warn("Game engine is already started. Skipping start.") : (this._log.info(`Starting SkewedAspect Game Engine (Version: ${m})...`), this._beforeStartHook && (this._log.debug("Executing beforeStart hook..."), await this._beforeStartHook(this)), await this.managers.gameManager.start(), this._log.info("Game engine started successfully"), this._onStartHook && (this._log.debug("Executing onStart hook..."), await this._onStartHook(this)), this.started = !0);
   }
   /**
    * Stops the game engine.
    */
   async stop() {
     if (this.started) {
-      this._log.info(`Stopping SkewedAspect Game Engine (Version: ${b})...`);
+      this._log.info(`Stopping SkewedAspect Game Engine (Version: ${m})...`);
       let e = null;
       if (this._onTeardownHook)
         try {
@@ -112,7 +112,7 @@ class F {
       this._log.warn("Game engine is not started. Skipping stop.");
   }
 }
-class N {
+class J {
   constructor() {
     n(this, "timers");
     this.timers = /* @__PURE__ */ new Map();
@@ -201,7 +201,7 @@ class N {
       console.warn(`[${e}]: Timer '${t}' does not exist`);
   }
 }
-class J {
+class Y {
   trace(e, t, ...s) {
   }
   debug(e, t, ...s) {
@@ -218,7 +218,7 @@ class J {
   }
 }
 class u {
-  constructor(e, t = "none", s = new J()) {
+  constructor(e, t = "none", s = new Y()) {
     n(this, "category");
     n(this, "backend");
     n(this, "minLevel");
@@ -273,14 +273,14 @@ class u {
     }
   }
 }
-class Y {
+class j {
   /**
    * Create a new LoggingUtility.
    *
    * @param level - The minimum logging level (defaults to INFO)
    * @param backend - The logging backend to use (defaults to ConsoleBackend)
    */
-  constructor(e = "debug", t = new N()) {
+  constructor(e = "debug", t = new J()) {
     n(this, "backend");
     n(this, "level");
     n(this, "loggers");
@@ -326,7 +326,7 @@ class Y {
     return t;
   }
 }
-class j {
+class X {
   /**
    * Creates a new GameEventBus instance
    *
@@ -430,22 +430,22 @@ class j {
     t === 0 ? this._log.debug(`No subscribers found for event: ${e.type}`) : this._log.trace(`Event ${e.type} dispatched to ${t} subscribers`);
   }
 }
-class X {
+class Z {
   constructor(e, t, s, i) {
     n(this, "_canvas");
     n(this, "_engine");
     n(this, "_physics");
     n(this, "_log");
-    this._canvas = e, this._engine = t, this._physics = s, this._log = (i == null ? void 0 : i.getLogger("SceneEngine")) || new u("SceneEngine");
+    this._canvas = e, this._engine = t, this._physics = s, this._log = i.getLogger("SceneEngine");
   }
   /**
    * Creates a new scene with physics enabled
    * @returns A new Scene instance with physics enabled
    */
   createScene() {
-    return this._log.debug("Creating new scene..."), new L(this._engine);
+    return new A(this._engine);
   }
-  enablePhysics(e, t = new C(0, -9.8, 0)) {
+  enablePhysics(e, t = new E(0, -9.8, 0)) {
     this._log.debug(
       `Enabling physics with gravity (${t.x}, ${t.y}, ${t.z})...`
     ), e.enablePhysics(t, this._physics);
@@ -460,9 +460,8 @@ class X {
    * @returns A new FreeCamera instance
    */
   createFreeCamera(e, t, s, i) {
-    this._log.debug(`Creating free camera: ${e}`);
-    const o = new A(e, t, s);
-    return o.setTarget(C.Zero()), i = i ?? this._canvas, i && o.attachControl(i, !0), o;
+    const o = new I(e, t, s);
+    return o.setTarget(E.Zero()), i = i ?? this._canvas, i && o.attachControl(i, !0), o;
   }
   // Lighting Utilities
   /**
@@ -474,8 +473,7 @@ class X {
    * @returns A new HemisphericLight instance
    */
   createHemisphericLight(e, t, s, i = 0.7) {
-    this._log.debug(`Creating hemispheric light: ${e}`);
-    const o = new I(e, t, s);
+    const o = new B(e, t, s);
     return o.intensity = i, o;
   }
   /**
@@ -487,8 +485,7 @@ class X {
    * @returns A new DirectionalLight instance
    */
   createDirectionalLight(e, t, s, i = 1) {
-    this._log.debug(`Creating directional light: ${e}`);
-    const o = new B(e, t, s);
+    const o = new G(e, t, s);
     return o.intensity = i, o;
   }
   /**
@@ -500,12 +497,11 @@ class X {
    * @returns A new PointLight instance
    */
   createPointLight(e, t, s, i = 1) {
-    this._log.debug(`Creating point light: ${e}`);
-    const o = new G(e, t, s);
+    const o = new V(e, t, s);
     return o.intensity = i, o;
   }
   /**
-   * Creates a spot light (flashlight-like lighting)
+   * Creates a spotlight (flashlight-like lighting)
    * @param name - The name for the light
    * @param position - The position of the light
    * @param direction - The direction of the light
@@ -516,8 +512,7 @@ class X {
    * @returns A new SpotLight instance
    */
   createSpotLight(e, t, s, i, o, c, a = 1) {
-    this._log.debug(`Creating spot light: ${e}`);
-    const h = new V(e, t, s, i, o, c);
+    const h = new K(e, t, s, i, o, c);
     return h.intensity = a, h;
   }
   // Mesh Creation Utilities
@@ -529,7 +524,6 @@ class X {
    * @returns A new sphere Mesh instance
    */
   createSphere(e, t = {}, s) {
-    this._log.debug(`Creating sphere: ${e}`);
     const i = { diameter: 1, segments: 32 };
     return v.CreateSphere(e, { ...i, ...t }, s);
   }
@@ -541,7 +535,6 @@ class X {
    * @returns A new box Mesh instance
    */
   createBox(e, t = {}, s) {
-    this._log.debug(`Creating box: ${e}`);
     const i = { size: 1 };
     return v.CreateBox(e, { ...i, ...t }, s);
   }
@@ -553,7 +546,6 @@ class X {
    * @returns A new ground Mesh instance
    */
   createGround(e, t = {}, s) {
-    this._log.debug(`Creating ground: ${e}`);
     const i = { width: 6, height: 6, subdivisions: 2 };
     return v.CreateGround(e, { ...i, ...t }, s);
   }
@@ -565,7 +557,6 @@ class X {
    * @returns A new cylinder Mesh instance
    */
   createCylinder(e, t = {}, s) {
-    this._log.debug(`Creating cylinder: ${e}`);
     const i = { height: 2, diameterTop: 1, diameterBottom: 1 };
     return v.CreateCylinder(e, { ...i, ...t }, s);
   }
@@ -579,9 +570,8 @@ class X {
    * @returns A new PhysicsAggregate instance
    */
   addPhysics(e, t, s = {}, i) {
-    this._log.debug(`Adding physics to mesh: ${e.name}`);
     const o = { mass: 1, restitution: 0.75, friction: 0.5 };
-    return new K(e, t, { ...o, ...s }, i);
+    return new T(e, t, { ...o, ...s }, i);
   }
   // Audio Utilities
   /**
@@ -593,9 +583,8 @@ class X {
    * @returns A new Sound instance
    */
   createSound(e, t, s, i = {}) {
-    this._log.debug(`Creating sound: ${e}`);
     const c = { ...{ loop: !1, autoplay: !1, volume: 1, playbackRate: 1 }, ...i };
-    return new T(
+    return new U(
       e,
       t,
       s,
@@ -607,35 +596,34 @@ class X {
   // Model Loading Utilities
   /**
    * Loads a 3D model/asset from a file
-   * @param rootUrl - The root URL where the file is located
    * @param sceneFilename - The filename of the scene file
    * @param scene - The scene to load the model into
    * @returns Promise that resolves with the loaded AssetContainer
    */
-  async loadModel(e, t, s) {
-    this._log.debug(`Loading model: ${e}${t}`);
+  async loadModel(e, t) {
+    this._log.debug(`Loading model: ${e}`);
     try {
-      const i = await U(`${e}${t}`, s);
-      return this._log.debug(`Model loaded successfully: ${t}`), i;
-    } catch (i) {
-      throw this._log.error(`Failed to load model: ${t}`, i), i;
+      const s = await R(`${e}`, t);
+      return this._log.debug(`Model loaded successfully: ${e}`), s;
+    } catch (s) {
+      throw this._log.error(`Failed to load model: ${e}`, s), s;
     }
   }
   /**
    * Imports meshes from a file
    * @param meshNames - Array of mesh names to import (empty array imports all)
-   * @param rootUrl - The root URL where the file is located
    * @param sceneFilename - The filename of the scene file
    * @param scene - The scene to import the meshes into
+   *
    * @returns Promise that resolves with the import result
    */
-  async importMeshes(e, t, s, i) {
-    this._log.debug(`Importing meshes from: ${t}${s}`);
+  async importMeshes(e, t, s) {
+    this._log.debug(`Importing meshes from: ${t}`);
     try {
-      const o = await R(`${t}${s}`, i, { meshNames: e });
-      return this._log.debug(`Meshes imported successfully: ${e.length > 0 ? e.join(", ") : "all"}`), o;
-    } catch (o) {
-      throw this._log.error(`Failed to import meshes from: ${s}`, o), o;
+      const i = await z(`${t}`, s, { meshNames: e });
+      return this._log.debug(`Meshes imported successfully: ${e.length > 0 ? e.join(", ") : "all"}`), i;
+    } catch (i) {
+      throw this._log.error(`Failed to import meshes from: ${t}`, i), i;
     }
   }
   /**
@@ -645,12 +633,12 @@ class X {
     return this._log.info("Tearing down SceneEngine"), this._log.info("SceneEngine torn down successfully"), Promise.resolve();
   }
 }
-const Z = [
+const q = [
   "trigger",
   "toggle",
   "value"
 ];
-class q {
+class Q {
   //------------------------------------------------------------------------------------------------------------------
   /**
    * Create a new trigger binding
@@ -751,7 +739,7 @@ class q {
     };
   }
 }
-class Q {
+class ee {
   //------------------------------------------------------------------------------------------------------------------
   /**
    * Create a new toggle binding
@@ -880,7 +868,7 @@ class Q {
     };
   }
 }
-class ee {
+class te {
   //------------------------------------------------------------------------------------------------------------------
   /**
    * Create a new value binding
@@ -1196,7 +1184,7 @@ class x {
     };
   }
 }
-class te {
+class se {
   /**
    * Creates an instance of BindingManager.
    *
@@ -1277,7 +1265,7 @@ class te {
     const { deviceID: s, ...i } = e.input;
     switch (e.type) {
       case "trigger":
-        return new q(
+        return new Q(
           t,
           s,
           this._createInputSourceFromDefinition(i),
@@ -1287,7 +1275,7 @@ class te {
           }
         );
       case "toggle":
-        return new Q(
+        return new ee(
           t,
           s,
           this._createInputSourceFromDefinition(i),
@@ -1297,7 +1285,7 @@ class te {
           }
         );
       case "value":
-        return new ee(
+        return new te(
           t,
           s,
           this._createInputSourceFromDefinition(i),
@@ -1464,7 +1452,7 @@ class te {
    */
   $registerBinding(e) {
     var t;
-    if (!Z.includes(e.type))
+    if (!q.includes(e.type))
       throw new Error(`Invalid binding type: ${e.type}`);
     e.context && !this._contexts.has(e.context) && this.registerContext(e.context), this._bindings.has(e.deviceID) || this._bindings.set(e.deviceID, []), (t = this._bindings.get(e.deviceID)) == null || t.push(e), this._log.debug(`Registered ${e.type} binding for "${e.action.name}" in context "${e.context || null}"`);
   }
@@ -1570,10 +1558,10 @@ class te {
 function w() {
   return typeof window < "u" && typeof window.document < "u";
 }
-function E() {
+function C() {
   return w() && !!window.navigator.gpu;
 }
-class se {
+class ie {
   //------------------------------------------------------------------------------------------------------------------
   constructor(e, t, s, i, o) {
     n(this, "_engine");
@@ -1613,7 +1601,7 @@ class se {
     this._log.info("Tearing down GameManager"), this.started && await this.stop(), w() && window.removeEventListener("resize", this._boundResizeHandler), this._log.info("GameManager torn down successfully");
   }
 }
-class fe {
+class ye {
   constructor() {
     n(this, "entity", null);
   }
@@ -1633,7 +1621,7 @@ class fe {
     this.entity = e;
   }
 }
-class ie {
+class ne {
   /**
    * Creates an instance of GameEntityBase.
    * @param type - The type of the entity.
@@ -1729,7 +1717,7 @@ class ie {
     }
   }
 }
-class ne {
+class oe {
   /**
    * Creates an instance of EntityManager.
    * @param eventBus - The event bus for the entity manager.
@@ -1815,7 +1803,7 @@ class ne {
       const a = await s.onBeforeCreate(i);
       a !== void 0 && (i = a);
     }
-    const o = new ie(
+    const o = new ne(
       s.type,
       this.eventBus,
       i,
@@ -1884,7 +1872,81 @@ class ne {
     this.entityDefinitions.clear(), this._log.info("EntityManager torn down successfully");
   }
 }
-class oe {
+class D {
+  //------------------------------------------------------------------------------------------------------------------
+  constructor(e) {
+    n(this, "name");
+    n(this, "_log");
+    n(this, "_sceneEngine");
+    n(this, "_eventBus");
+    n(this, "_scene", null);
+    this.name = e, this._log = new u(`Level:${e}`, "info");
+  }
+  /**
+   * The current scene for this level (null if not loaded)
+   */
+  get scene() {
+    return this._scene;
+  }
+  /**
+   * Whether this level has been loaded
+   */
+  get isLoaded() {
+    return this._scene !== null;
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Emit a progress event during loading
+   */
+  $emitProgress(e, t) {
+    if (!this._eventBus)
+      throw new Error("Event bus is not initialized. Call loadScene() first.");
+    this._eventBus.publish({
+      type: "level:progress",
+      levelName: this.name,
+      progress: e,
+      message: t
+    });
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Load and create the scene for this level.
+   * Progress events will be emitted during loading.
+   *
+   * @param eventBus - The game event bus for publishing events
+   * @param sceneEngine - The scene engine used to create the scene
+   *
+   * @returns Promise that resolves to the loaded scene
+   */
+  async loadScene(e, t) {
+    if (this._scene)
+      return this._log.warn(`Level ${this.name} is already loaded`), this._scene;
+    this._eventBus = e, this._sceneEngine = t, this._log.info(`Loading level: ${this.name}`), this._log.time(`level-${this.name}-load`);
+    try {
+      return this.$emitProgress(0, "Starting level load..."), this._scene = await this.buildScene(t), this.$emitProgress(100, "Level loaded successfully"), this._eventBus.publish({
+        type: "level:complete",
+        levelName: this.name,
+        message: "Level loaded successfully"
+      }), this._log.timeEnd(`level-${this.name}-load`), this._log.info(`Level ${this.name} loaded successfully`), this._scene;
+    } catch (s) {
+      throw this._log.error(`Failed to load level ${this.name}:`, s), this._eventBus.publish({
+        type: "level:error",
+        levelName: this.name,
+        message: "Failed to load level",
+        error: s
+      }), s;
+    }
+  }
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Dispose of this level's resources
+   */
+  dispose() {
+    this._scene && (this._log.info(`Disposing level: ${this.name}`), this._scene.dispose(), this._scene = null);
+  }
+}
+class ae {
+  //------------------------------------------------------------------------------------------------------------------
   constructor(e, t, s) {
     n(this, "_eventBus");
     n(this, "_sceneEngine");
@@ -1897,6 +1959,14 @@ class oe {
       i.payload && this._handleLevelEvent(i.payload);
     }), this._log.info("LevelManager initialized");
   }
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Gets the currently active level
+   */
+  get currentLevel() {
+    return this._currentLevel;
+  }
+  //------------------------------------------------------------------------------------------------------------------
   /**
    * Handles level events from the event bus
    */
@@ -1913,36 +1983,51 @@ class oe {
         break;
     }
   }
+  //------------------------------------------------------------------------------------------------------------------
+  /**
+   * Gets a loaded level by name
+   */
+  getLevel(e) {
+    return this._registeredLevels.get(e) || null;
+  }
   /**
    * Registers a level class that can be instantiated later
-   * @param name - The name to register the level under
    * @param level - The level class instance
    */
-  registerLevel(e, t) {
-    this._registeredLevels.has(e) && this._log.warn(`Level '${e}' is already registered. Overwriting.`), this._registeredLevels.set(e, t), this._log.info(`Registered level: ${e}`);
+  registerLevel(e) {
+    this._registeredLevels.has(e.name) && this._log.warn(`Level '${e.name}' is already registered. Overwriting.`), this._registeredLevels.set(e.name, e), this._log.info(`Registered level: ${e.name}`);
   }
   /**
-   * Loads and activates a level by name
-   * @param levelName - The name of the level to load
+   * Loads a level. If a name is passed, the level must already be registered. If a `Level` instance is passed, it
+   * will be registered automatically.
+   *
+   *  @param levelOrName - The name of the level to load, or a Level instance.
+   *
    * @returns Promise that resolves when the level is loaded
    */
   async loadLevel(e) {
-    const t = this._registeredLevels.get(e);
-    if (!t)
+    let t;
+    if (e instanceof D)
+      this.registerLevel(e), t = e;
+    else if (t = this.getLevel(e), !t)
       throw new Error(`Level '${e}' is not registered.`);
-    t.isLoaded || (this._log.debug(`Loading level: ${e}`), await t.loadScene(this._eventBus, this._sceneEngine)), this._currentLevel = t, this._log.info(`Activated level: ${e}`);
-  }
-  /**
-   * Gets the currently active level
-   */
-  get currentLevel() {
-    return this._currentLevel;
+    t.isLoaded || (this._log.debug(`Loading level: ${t.name}`), await t.loadScene(this._eventBus, this._sceneEngine));
   }
   /**
-   * Gets a loaded level by name
+   * Activates a level, loading it if necessary. If a level name is provided, it must already be registered.
+   * If a `Level` instance is provided, it will be registered automatically.
+   *
+   *  @param levelOrName - The name of the level to activate, or a Level instance.
+   *
+   * @returns Promise that resolves when the level is activated.
    */
-  getLevel(e) {
-    return this._registeredLevels.get(e) || null;
+  async activateLevel(e) {
+    let t;
+    if (e instanceof D)
+      this.registerLevel(e), t = e;
+    else if (t = this.getLevel(e), !t)
+      throw new Error(`Level '${e}' is not registered.`);
+    t.isLoaded || await this.loadLevel(t), this._currentLevel = t, this._log.info(`Activated level: ${t.name}`);
   }
   /**
    * Unloads a level and disposes its resources
@@ -1964,10 +2049,10 @@ class oe {
   async $teardown() {
     for (const e of this._registeredLevels.values())
       e.dispose();
-    return this._registeredLevels.clear(), this._currentLevel = null, Promise.resolve();
+    this._registeredLevels.clear(), this._currentLevel = null;
   }
 }
-class ae {
+class re {
   //------------------------------------------------------------------------------------------------------------------
   /**
    * Create a new KeyboardResourceAccess
@@ -2078,7 +2163,7 @@ class ae {
     this._onInputChanged && this._onInputChanged(this._keyboardDevice, e);
   }
 }
-class re {
+class ce {
   //------------------------------------------------------------------------------------------------------------------
   /**
    * Create a new MouseResourceAccess
@@ -2247,7 +2332,7 @@ class re {
     this._onInputChanged && this._onInputChanged(this._mouseDevice, e);
   }
 }
-class ce {
+class he {
   //------------------------------------------------------------------------------------------------------------------
   /**
    * Create a new GamepadResourceAccess
@@ -2454,7 +2539,7 @@ class ce {
     this._onInputChanged && this._onInputChanged(e, t);
   }
 }
-class he {
+class le {
   //------------------------------------------------------------------------------------------------------------------
   /**
    * Create a new UserInputManager
@@ -2470,7 +2555,7 @@ class he {
     n(this, "_gamepadRA");
     /** Logger instance */
     n(this, "_log");
-    this._eventBus = e, this._log = (s == null ? void 0 : s.getLogger("UserInputManager")) || new u("UserInputManager"), this._log.info("Initializing UserInputManager"), this._log.debug("Initializing input resource access classes"), this._keyboardRA = new ae(), this._mouseRA = new re(t), this._gamepadRA = new ce(), this._log.debug("Registering input event callbacks"), this._keyboardRA.onDeviceConnected(this._publishDeviceConnected.bind(this)), this._keyboardRA.onInputChanged(this._publishInputChanged.bind(this)), this._mouseRA.onDeviceConnected(this._publishDeviceConnected.bind(this)), this._mouseRA.onInputChanged(this._publishInputChanged.bind(this)), this._gamepadRA.onDeviceConnected(this._publishDeviceConnected.bind(this)), this._gamepadRA.onDeviceDisconnected(this._publishDeviceDisconnected.bind(this)), this._gamepadRA.onInputChanged(this._publishInputChanged.bind(this)), this._log.info("UserInputManager initialized successfully");
+    this._eventBus = e, this._log = (s == null ? void 0 : s.getLogger("UserInputManager")) || new u("UserInputManager"), this._log.info("Initializing UserInputManager"), this._log.debug("Initializing input resource access classes"), this._keyboardRA = new re(), this._mouseRA = new ce(t), this._gamepadRA = new he(), this._log.debug("Registering input event callbacks"), this._keyboardRA.onDeviceConnected(this._publishDeviceConnected.bind(this)), this._keyboardRA.onInputChanged(this._publishInputChanged.bind(this)), this._mouseRA.onDeviceConnected(this._publishDeviceConnected.bind(this)), this._mouseRA.onInputChanged(this._publishInputChanged.bind(this)), this._gamepadRA.onDeviceConnected(this._publishDeviceConnected.bind(this)), this._gamepadRA.onDeviceDisconnected(this._publishDeviceDisconnected.bind(this)), this._gamepadRA.onInputChanged(this._publishInputChanged.bind(this)), this._log.info("UserInputManager initialized successfully");
   }
   //------------------------------------------------------------------------------------------------------------------
   // Private methods
@@ -2570,24 +2655,24 @@ class he {
     this._gamepadRA.pollGamepads();
   }
 }
-async function D(r, e) {
-  const t = new P(r, e);
+async function M(r, e) {
+  const t = new H(r, e);
   return await t.initAsync(), t;
 }
-function m(r, e) {
-  return new O(r, e.antialias, e.options, e.adaptToDeviceRatio);
+function b(r, e) {
+  return new W(r, e.antialias, e.options, e.adaptToDeviceRatio);
 }
-function le(r) {
-  return new z(r);
+function de(r) {
+  return new P(r);
 }
-async function de(r, e) {
+async function ue(r, e) {
   if (r === null)
-    return console.debug("Using Null Engine"), le(e);
+    return console.debug("Using Null Engine"), de(e);
   const t = e.engine || "auto";
   if (t === "webgpu")
-    if (E())
+    if (C())
       try {
-        return console.debug("Using forced WebGPU engine"), await D(r, e);
+        return console.debug("Using forced WebGPU engine"), await M(r, e);
       } catch (s) {
         throw console.error("Forced WebGPU initialization failed:", s), new Error(
           "Forced WebGPU failed to initialize. If WebGPU is required, check browser compatibility."
@@ -2596,22 +2681,22 @@ async function de(r, e) {
     else
       throw new Error("WebGPU was forced but is not available in this browser.");
   if (t === "webgl")
-    return console.debug("Using forced WebGL engine"), m(r, e);
-  if (E())
+    return console.debug("Using forced WebGL engine"), b(r, e);
+  if (C())
     try {
-      return console.debug("Using WebGPU"), D(r, e).catch((s) => (console.warn("WebGPU initialization failed, falling back to WebGL:", s), m(r, e)));
+      return console.debug("Using WebGPU"), M(r, e).catch((s) => (console.warn("WebGPU initialization failed, falling back to WebGL:", s), b(r, e)));
     } catch (s) {
       console.warn("WebGPU initialization failed, falling back to WebGL:", s);
     }
   else
     console.warn("WebGPU not supported, falling back to WebGL.");
-  return console.debug("Using WebGL"), m(r, e);
+  return console.debug("Using WebGL"), b(r, e);
 }
-async function ue() {
-  const r = await W();
-  return new H(!0, r);
+async function ge() {
+  const r = await F();
+  return new O(!0, r);
 }
-const ye = ["keyboard", "mouse", "gamepad"], ve = [
+const ve = ["keyboard", "mouse", "gamepad"], me = [
   "trace",
   "debug",
   "info",
@@ -2619,104 +2704,25 @@ const ye = ["keyboard", "mouse", "gamepad"], ve = [
   "error",
   "none"
 ];
-class be {
-  //------------------------------------------------------------------------------------------------------------------
-  constructor(e) {
-    n(this, "_name");
-    n(this, "_sceneEngine");
-    n(this, "_eventBus");
-    n(this, "_scene", null);
-    n(this, "_log");
-    this._name = e, this._log = new u(`Level:${e}`, "info");
-  }
-  /**
-   * The name of this level
-   */
-  get name() {
-    return this._name;
-  }
-  /**
-   * The current scene for this level (null if not loaded)
-   */
-  get scene() {
-    return this._scene;
-  }
-  /**
-   * Whether this level has been loaded
-   */
-  get isLoaded() {
-    return this._scene !== null;
-  }
-  //------------------------------------------------------------------------------------------------------------------
-  /**
-   * Emit a progress event during loading
-   */
-  _emitProgress(e, t) {
-    if (!this._eventBus)
-      throw new Error("Event bus is not initialized. Call loadScene() first.");
-    this._eventBus.publish({
-      type: "level:progress",
-      levelName: this._name,
-      progress: e,
-      message: t
-    });
-  }
-  //------------------------------------------------------------------------------------------------------------------
-  /**
-   * Load and create the scene for this level.
-   * Progress events will be emitted during loading.
-   *
-   * @param eventBus - The game event bus for publishing events
-   * @param sceneEngine - The scene engine used to create the scene
-   *
-   * @returns Promise that resolves to the loaded scene
-   */
-  async loadScene(e, t) {
-    if (this._scene)
-      return this._log.warn(`Level ${this._name} is already loaded`), this._scene;
-    this._eventBus = e, this._sceneEngine = t, this._log.info(`Loading level: ${this._name}`), this._log.time(`level-${this._name}-load`);
-    try {
-      return this._emitProgress(0, "Starting level load..."), this._scene = await this.buildScene(), this._emitProgress(100, "Level loaded successfully"), this._eventBus.publish({
-        type: "level:complete",
-        levelName: this._name,
-        message: "Level loaded successfully"
-      }), this._log.timeEnd(`level-${this._name}-load`), this._log.info(`Level ${this._name} loaded successfully`), this._scene;
-    } catch (s) {
-      throw this._log.error(`Failed to load level ${this._name}:`, s), this._eventBus.publish({
-        type: "level:error",
-        levelName: this._name,
-        message: "Failed to load level",
-        error: s
-      }), s;
-    }
-  }
-  //------------------------------------------------------------------------------------------------------------------
-  /**
-   * Dispose of this level's resources
-   */
-  dispose() {
-    this._scene && (this._log.info(`Disposing level: ${this._name}`), this._scene.dispose(), this._scene = null);
-  }
-}
-async function me(r, e, t = {}) {
-  const s = new Y(t.logLevel || "debug"), i = s.getLogger("SAGE");
-  i.info(`Initializing SAGE Game Engine v${b}...`), i.debug("Creating rendering engine...");
-  const o = await de(r, t.renderOptions || {});
+async function be(r, e, t = {}) {
+  const s = new j(t.logLevel || "debug"), i = s.getLogger("SAGE");
+  i.info(`Initializing SAGE Game Engine v${m}...`), i.debug("Creating rendering engine...");
+  const o = await ue(r, t.renderOptions || {});
   i.debug("Creating physics engine...");
-  const c = await ue();
+  const c = await ge();
   i.debug("Creating event bus...");
-  const a = new j(s);
+  const a = new X(s);
   i.debug("Creating scene engine...");
-  const h = new X(r, o, c, s);
+  const h = new Z(r, o, c, s);
   i.debug("Creating managers...");
-  const l = new he(a, r, s), _ = new te(a, s), d = new ne(a, s, _), f = new oe(a, h, s), p = new se(o, d, l, f, s);
-  i.info(`SAGE Game Engine v${b} initialized successfully.`), i.debug("Loading entities...");
+  const l = new le(a, r, s), _ = new se(a, s), d = new oe(a, s, _), f = new ae(a, h, s), p = new ie(o, d, l, f, s);
+  i.info(`SAGE Game Engine v${m} initialized successfully.`), i.debug("Loading entities...");
   for (const g of e)
     d.registerEntityDefinition(g);
   if (i.debug("Registering default input bindings..."), t.bindings)
     for (const g of t.bindings)
       _.registerBinding(g);
-  return new F(
+  return new N(
     r,
     o,
     c,
@@ -2737,19 +2743,20 @@ async function me(r, e, t = {}) {
   );
 }
 export {
-  N as ConsoleBackend,
-  ie as GameEntity,
-  fe as GameEntityBehavior,
-  j as GameEventBus,
-  be as Level,
-  ve as LogLevels,
-  Y as LoggingUtility,
-  J as NullBackend,
+  J as ConsoleBackend,
+  ne as GameEntity,
+  ye as GameEntityBehavior,
+  X as GameEventBus,
+  D as Level,
+  me as LogLevels,
+  j as LoggingUtility,
+  Y as NullBackend,
   u as SAGELogger,
-  F as SkewedAspectGameEngine,
-  b as VERSION,
-  Z as bindingTypes,
-  me as createGameEngine,
-  ye as validDeviceTypes
+  Z as SceneEngine,
+  N as SkewedAspectGameEngine,
+  m as VERSION,
+  q as bindingTypes,
+  be as createGameEngine,
+  ve as validDeviceTypes
 };
 //# sourceMappingURL=sage.es.js.map