@mavonengine/core 0.0.2

package/dist/cjs/Types/Asset.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Asset_exports = {};
+module.exports = __toCommonJS(Asset_exports);

package/dist/cjs/Types/Events.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Events_exports = {};
+module.exports = __toCommonJS(Events_exports);

package/dist/cjs/Types/IEditor.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var IEditor_exports = {};
+module.exports = __toCommonJS(IEditor_exports);

package/dist/cjs/Utils/Debug.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Debug_exports = {};
+__export(Debug_exports, {
+  default: () => Debug
+});
+module.exports = __toCommonJS(Debug_exports);
+var EssentialsPlugin = __toESM(require("@tweakpane/plugin-essentials"), 1);
+var import_tweakpane = require("tweakpane");
+var import_EventEmitter = __toESM(require("./EventEmitter"), 1);
+class Debug extends import_EventEmitter.default {
+  constructor() {
+    super();
+    this.active = window.location.hash === "#debug";
+    if (this.active) {
+      this.ui = new import_tweakpane.Pane();
+      this.ui.registerPlugin(EssentialsPlugin);
+      this.trigger("debug");
+    }
+  }
+}

package/dist/cjs/Utils/EventEmitter.cjs

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EventEmitter_exports = {};
+__export(EventEmitter_exports, {
+  EventEmitterMixin: () => EventEmitterMixin,
+  default: () => EventEmitter
+});
+module.exports = __toCommonJS(EventEmitter_exports);
+function EventEmitterMixin(Base) {
+  return class extends Base {
+    constructor() {
+      super(...arguments);
+      this.callbacks = {};
+    }
+    on(event, callback) {
+      if (!this.callbacks[event]) {
+        this.callbacks[event] = [callback];
+      } else {
+        this.callbacks[event].push(callback);
+      }
+    }
+    off(event, callback) {
+      if (this.callbacks[event]) {
+        this.callbacks[event] = this.callbacks[event].filter((cb) => cb !== callback);
+      }
+    }
+    trigger(name, event) {
+      if (this.callbacks[name]) {
+        this.callbacks[name].forEach((callback) => {
+          callback(event);
+        });
+      }
+    }
+  };
+}
+class EventEmitter extends EventEmitterMixin(class {
+}) {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventEmitterMixin
+});

package/dist/cjs/Utils/Helpers.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Helpers_exports = {};
+__export(Helpers_exports, {
+  xyzIterator: () => xyzIterator
+});
+module.exports = __toCommonJS(Helpers_exports);
+var import_three = require("three");
+function* xyzIterator(arr) {
+  for (let i = 0; i < arr.length; i += 3) {
+    yield new import_three.Vector3(arr[i], arr[i + 1], arr[i + 2]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  xyzIterator
+});

package/dist/cjs/Utils/LoadingScreen.cjs

@@ -0,0 +1,91 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var LoadingScreen_exports = {};
+__export(LoadingScreen_exports, {
+  default: () => LoadingScreen
+});
+module.exports = __toCommonJS(LoadingScreen_exports);
+var import_three = require("three");
+var import_Game = __toESM(require("../Game"), 1);
+var import_Fragment = __toESM(require("../Particles/Shaders/LoadingScreen/Fragment.glsl"), 1);
+var import_Vertex = __toESM(require("../Particles/Shaders/LoadingScreen/Vertex.glsl"), 1);
+var import_EventEmitter = __toESM(require("./EventEmitter"), 1);
+class LoadingScreen extends import_EventEmitter.default {
+  constructor(resources) {
+    super();
+    this.loaded = false;
+    this.progress = 0;
+    this.duration = 2;
+    this.fadeStartTime = null;
+    import_Game.default.instance().on("uiMounted", () => {
+      this.loadingBar = document.getElementById("loadingBar");
+      const overlayGeometry = new import_three.PlaneGeometry(2, 2, 1, 1);
+      const overlayMaterial = new import_three.ShaderMaterial({
+        vertexShader: import_Vertex.default,
+        fragmentShader: import_Fragment.default,
+        transparent: true,
+        uniforms: {
+          uAlpha: { value: 1 }
+        }
+      });
+      this.overlay = new import_three.Mesh(overlayGeometry, overlayMaterial);
+      import_Game.default.instance().scene.add(this.overlay);
+      resources.on("loaded", () => {
+        this.loaded = true;
+        this.fadeStartTime = 0;
+        setTimeout(() => {
+          this.loadingBar.classList.add("ended");
+          this.loadingBar.style.transform = "";
+          import_Game.default.instance().uiRoot.style.removeProperty("visibility");
+        }, 500);
+      });
+      resources.on("progress", (evt) => {
+        const event = evt;
+        const progress = event.loaded / event.total;
+        this.loadingBar.style.transform = `scaleX(${progress})`;
+      });
+    });
+  }
+  update(delta) {
+    if (!this.loaded)
+      return;
+    if (this.fadeStartTime === 0) {
+      this.fadeStartTime = 1e-4;
+    }
+    if (this.fadeStartTime !== null) {
+      this.fadeStartTime += delta;
+      const progress = Math.min(this.fadeStartTime / this.duration, 1);
+      this.progress = this.overlay.material.uniforms.uAlpha.value = 1 - progress;
+      import_Game.default.instance().uiRoot.style.opacity = `${progress}`;
+      if (progress >= 1) {
+        import_Game.default.instance().scene.remove(this.overlay);
+      }
+    }
+  }
+}

package/dist/cjs/Utils/Logger.cjs

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Logger_exports = {};
+__export(Logger_exports, {
+  default: () => Logger
+});
+module.exports = __toCommonJS(Logger_exports);
+const levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+const styles = {
+  error: "background: #f44336; color: white; padding: 2px 6px; border-radius: 3px;",
+  warn: "background: #ff9800; color: white; padding: 2px 6px; border-radius: 3px;",
+  info: "background: #2196F3; color: white; padding: 2px 6px; border-radius: 3px;",
+  debug: "background: #9E9E9E; color: white; padding: 2px 6px; border-radius: 3px;"
+};
+const labelStyle = "color: #888; font-weight: normal;";
+class Logger {
+  constructor(level = "error") {
+    this.level = levels[level];
+  }
+  error(message, ...args) {
+    if (this.level >= levels.error)
+      console.error(`%c ERROR %c ${message}`, styles.error, labelStyle, ...args);
+  }
+  warn(message, ...args) {
+    if (this.level >= levels.warn)
+      console.warn(`%c WARN %c ${message}`, styles.warn, labelStyle, ...args);
+  }
+  info(message, ...args) {
+    if (this.level >= levels.info)
+      console.info(`%c INFO %c ${message}`, styles.info, labelStyle, ...args);
+  }
+  debug(message, ...args) {
+    if (this.level >= levels.debug)
+      console.debug(`%c DEBUG %c ${message}`, styles.debug, labelStyle, ...args);
+  }
+  emerg(message, ...args) {
+    console.error(`%c EMERG %c ${message}`, styles.error, labelStyle, ...args);
+  }
+}

package/dist/cjs/Utils/Math.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Math_exports = {};
+__export(Math_exports, {
+  randRange: () => randRange,
+  randomSigned: () => randomSigned
+});
+module.exports = __toCommonJS(Math_exports);
+function randomSigned() {
+  return Math.random() * (Math.random() < 0.5 ? -1 : 1);
+}
+function randRange(min, max) {
+  return Math.random() * (max - min) + min;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randRange,
+  randomSigned
+});

package/dist/cjs/Utils/Resources.cjs

@@ -0,0 +1,101 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Resources_exports = {};
+__export(Resources_exports, {
+  default: () => Resources
+});
+module.exports = __toCommonJS(Resources_exports);
+var import_three = require("three");
+var import_DRACOLoader = require("three/addons/loaders/DRACOLoader.js");
+var import_GLTFLoader = require("three/addons/loaders/GLTFLoader.js");
+var import_Addons = require("three/examples/jsm/Addons.js");
+var import_EventEmitter = __toESM(require("./EventEmitter"), 1);
+class Resources extends import_EventEmitter.default {
+  constructor(sources) {
+    super();
+    this.sources = sources;
+    this.items = {};
+    this.toLoad = this.sources.length;
+    this.loaded = 0;
+    this.loaders = {
+      gltfLoader: new import_GLTFLoader.GLTFLoader(),
+      textureLoader: new import_three.TextureLoader(),
+      cubeTextureLoader: new import_three.CubeTextureLoader(),
+      audioLoader: new import_three.AudioLoader(),
+      svgLoader: new import_Addons.SVGLoader(),
+      fontLoader: new import_Addons.FontLoader()
+    };
+    this.loaders.gltfLoader.dracoLoader = new import_DRACOLoader.DRACOLoader();
+    this.loaders.gltfLoader.dracoLoader.setDecoderPath("/draco/");
+    this.startLoading();
+  }
+  startLoading() {
+    this.sources.forEach((source) => {
+      const { type, path } = source;
+      const loadHandler = (loader, path2) => {
+        if (Array.isArray(path2)) {
+          path2.forEach((p) => loader.load(p, (data) => this.sourceLoaded(source, data)));
+        } else {
+          loader.load(path2, (data) => this.sourceLoaded(source, data));
+        }
+      };
+      switch (type) {
+        case "gltfModel":
+          loadHandler(this.loaders.gltfLoader, path);
+          break;
+        case "texture":
+          loadHandler(this.loaders.textureLoader, path);
+          break;
+        case "sound":
+          loadHandler(this.loaders.audioLoader, path);
+          break;
+        case "svg":
+          loadHandler(this.loaders.svgLoader, path);
+          break;
+        case "font":
+          loadHandler(this.loaders.fontLoader, path);
+          break;
+        case "cubeTexture":
+          this.loaders.cubeTextureLoader.load([...path], (data) => this.sourceLoaded(source, data));
+          break;
+      }
+    });
+  }
+  sourceLoaded(source, file) {
+    this.items[source.name] = file;
+    this.loaded++;
+    this.trigger("progress", {
+      loaded: this.loaded,
+      total: this.sources.length
+    });
+    if (this.loaded === this.toLoad) {
+      this.trigger("loaded");
+    }
+  }
+}

package/dist/cjs/Utils/Sizes.cjs

@@ -0,0 +1,51 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Sizes_exports = {};
+__export(Sizes_exports, {
+  default: () => Sizes
+});
+module.exports = __toCommonJS(Sizes_exports);
+var import_EventEmitter = __toESM(require("./EventEmitter"), 1);
+class Sizes extends import_EventEmitter.default {
+  constructor() {
+    super();
+    this.width = window.innerWidth;
+    this.height = window.innerHeight;
+    this.pixelRatio = Math.min(window.devicePixelRatio, 2);
+    window.addEventListener("resize", () => {
+      this.setSize(window.innerWidth, window.innerHeight);
+    });
+  }
+  setSize(width, height) {
+    this.width = width;
+    this.height = height;
+    this.pixelRatio = Math.min(window.devicePixelRatio, 2);
+    this.trigger("resize");
+  }
+}

package/dist/cjs/Utils/SkeletonAxesHelper.cjs

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SkeletonAxesHelper_exports = {};
+__export(SkeletonAxesHelper_exports, {
+  default: () => SkeletonAxesHelper
+});
+module.exports = __toCommonJS(SkeletonAxesHelper_exports);
+var import_three = require("three");
+class SkeletonAxesHelper extends import_three.Object3D {
+  constructor(object, size = 0.05) {
+    super();
+    this.bones = [];
+    this.axesHelpers = [];
+    object.traverse((object2) => {
+      if (object2 instanceof import_three.Bone) {
+        this.bones.push(object2);
+      }
+    });
+    for (let i = 0; i < this.bones.length; i++) {
+      const axesHelper = new import_three.AxesHelper(size);
+      if (!(axesHelper.material instanceof import_three.Material)) {
+        throw new TypeError("Invalid material");
+      }
+      axesHelper.material.transparent = true;
+      axesHelper.material.depthTest = false;
+      axesHelper.matrixAutoUpdate = false;
+      this.axesHelpers.push(axesHelper);
+      this.add(axesHelper);
+    }
+  }
+  updateMatrixWorld(force) {
+    for (let i = 0; i < this.bones.length; i++) {
+      const bone = this.bones[i];
+      const axesHelper = this.axesHelpers[i];
+      axesHelper.matrix.copy(bone.matrixWorld);
+    }
+    super.updateMatrixWorld(force);
+  }
+  dispose() {
+    for (let i = 0; i < this.axesHelpers.length; i++) {
+      this.axesHelpers[i].dispose();
+    }
+  }
+}

package/dist/cjs/World/Actor.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Actor_exports = {};
+__export(Actor_exports, {
+  default: () => Actor
+});
+module.exports = __toCommonJS(Actor_exports);
+var import_State = __toESM(require("./Entity/State"), 1);
+var import_GameObject = __toESM(require("./GameObject"), 1);
+class Actor extends import_GameObject.default {
+  constructor() {
+    super(...arguments);
+    /**
+     * TODO rename to states and then have a get state() that will get the last entry
+     */
+    this.state = [];
+  }
+  update(delta) {
+    if (this.state.length) {
+      const res = this.state[this.state.length - 1].update(delta);
+      if (res instanceof import_State.default) {
+        this.state.push(res);
+      }
+    }
+  }
+  get stateHash() {
+    return btoa(JSON.stringify(this.serialize()));
+  }
+}