@mavonengine/core 0.0.2

package/dist/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/Utils/EventEmitter.d.ts

@@ -0,0 +1,25 @@
+export declare function EventEmitterMixin<TBase extends new (...args: any[]) => object>(Base: TBase): {
+    new (...args: any[]): {
+        callbacks: {
+            [key: string]: ((event?: any) => void)[];
+        };
+        on(event: string, callback: (event?: any) => void): void;
+        off(event: string, callback: (event?: any) => void): void;
+        trigger(name: string, event?: any): void;
+    };
+} & TBase;
+declare const EventEmitter_base: {
+    new (...args: any[]): {
+        callbacks: {
+            [key: string]: ((event?: any) => void)[];
+        };
+        on(event: string, callback: (event?: any) => void): void;
+        off(event: string, callback: (event?: any) => void): void;
+        trigger(name: string, event?: any): void;
+    };
+} & {
+    new (): {};
+};
+export default class EventEmitter extends EventEmitter_base {
+}
+export {};

package/dist/Utils/EventEmitter.js

@@ -0,0 +1,31 @@
+export 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);
+                });
+            }
+        }
+    };
+}
+export default class EventEmitter extends EventEmitterMixin(class {
+}) {
+}

package/dist/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/Utils/Helpers.d.ts

@@ -0,0 +1,6 @@
+import { Vector3 } from 'three';
+/**
+ * An easy way to iterate through a Float32Array
+ * and get xyz values out
+ */
+export declare function xyzIterator(arr: Float32Array): Generator<Vector3, void, unknown>;

package/dist/Utils/Helpers.js

@@ -0,0 +1,10 @@
+import { Vector3 } from 'three';
+/**
+ * An easy way to iterate through a Float32Array
+ * and get xyz values out
+ */
+export function* xyzIterator(arr) {
+    for (let i = 0; i < arr.length; i += 3) {
+        yield new Vector3(arr[i], arr[i + 1], arr[i + 2]);
+    }
+}

package/dist/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/Utils/LoadingScreen.d.ts

@@ -0,0 +1,12 @@
+import type Resources from './Resources';
+import EventEmitter from './EventEmitter';
+export default class LoadingScreen extends EventEmitter {
+    private overlay;
+    loaded: boolean;
+    progress: number;
+    duration: number;
+    private fadeStartTime;
+    loadingBar: HTMLDivElement | undefined;
+    constructor(resources: Resources);
+    update(delta: number): void;
+}

package/dist/Utils/LoadingScreen.js

@@ -0,0 +1,59 @@
+import { Mesh, PlaneGeometry, ShaderMaterial } from 'three';
+import Game from '../Game';
+import FragmentShader from '../Particles/Shaders/LoadingScreen/Fragment.glsl';
+import VertextShader from '../Particles/Shaders/LoadingScreen/Vertex.glsl';
+import EventEmitter from './EventEmitter';
+export default class LoadingScreen extends EventEmitter {
+    constructor(resources) {
+        super();
+        this.loaded = false;
+        this.progress = 0;
+        this.duration = 2;
+        this.fadeStartTime = null;
+        Game.instance().on('uiMounted', () => {
+            this.loadingBar = document.getElementById('loadingBar');
+            const overlayGeometry = new PlaneGeometry(2, 2, 1, 1);
+            const overlayMaterial = new ShaderMaterial({
+                vertexShader: VertextShader,
+                fragmentShader: FragmentShader,
+                transparent: true,
+                uniforms: {
+                    uAlpha: { value: 1.0 },
+                },
+            });
+            this.overlay = new Mesh(overlayGeometry, overlayMaterial);
+            Game.instance().scene.add(this.overlay);
+            resources.on('loaded', () => {
+                this.loaded = true;
+                this.fadeStartTime = 0;
+                setTimeout(() => {
+                    this.loadingBar.classList.add('ended');
+                    this.loadingBar.style.transform = '';
+                    Game.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 = 0.0001; // ensure it's initialized and starts fading
+        }
+        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;
+            Game.instance().uiRoot.style.opacity = `${progress}`;
+            // Optional: remove overlay from scene after fade completes
+            if (progress >= 1) {
+                Game.instance().scene.remove(this.overlay);
+            }
+        }
+    }
+}

package/dist/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/Utils/Logger.d.ts

@@ -0,0 +1,11 @@
+type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+export default class Logger {
+    private level;
+    constructor(level?: LogLevel);
+    error(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
+    emerg(message: string, ...args: unknown[]): void;
+}
+export {};

package/dist/Utils/Logger.js

@@ -0,0 +1,39 @@
+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;';
+export default 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)
+            // eslint-disable-next-line no-console
+            console.info(`%c INFO %c ${message}`, styles.info, labelStyle, ...args);
+    }
+    debug(message, ...args) {
+        if (this.level >= levels.debug)
+            // eslint-disable-next-line no-console
+            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/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/Utils/Math.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generates a random floating-point number between -1 and 1.
+ *
+ * The function multiplies a random number between 0 and 1 by either -1 or 1,
+ * randomly choosing the sign with equal probability.
+ *
+ * @returns {number} A random number in the range [-1, 1).
+ */
+export declare function randomSigned(): number;
+export declare function randRange(min: number, max: number): number;

package/dist/Utils/Math.js

@@ -0,0 +1,14 @@
+/**
+ * Generates a random floating-point number between -1 and 1.
+ *
+ * The function multiplies a random number between 0 and 1 by either -1 or 1,
+ * randomly choosing the sign with equal probability.
+ *
+ * @returns {number} A random number in the range [-1, 1).
+ */
+export function randomSigned() {
+    return Math.random() * (Math.random() < 0.5 ? -1 : 1);
+}
+export function randRange(min, max) {
+    return Math.random() * (max - min) + min;
+}

package/dist/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/Utils/Resources.d.ts

@@ -0,0 +1,29 @@
+import type { CubeTexture, Texture } from 'three';
+import type { GLTF } from 'three/addons/loaders/GLTFLoader.js';
+import type { Font, SVGResult } from 'three/examples/jsm/Addons.js';
+import type { Asset } from '../Types/Asset';
+import { AudioLoader, CubeTextureLoader, TextureLoader } from 'three';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { FontLoader, SVGLoader } from 'three/examples/jsm/Addons.js';
+import EventEmitter from './EventEmitter';
+type AssetType = GLTF | Texture | CubeTexture | AudioBuffer | SVGResult | Font;
+export default class Resources extends EventEmitter {
+    sources: Asset[];
+    loaded: number;
+    toLoad: number;
+    items: {
+        [key: string]: AssetType;
+    };
+    loaders: {
+        gltfLoader: GLTFLoader;
+        textureLoader: TextureLoader;
+        cubeTextureLoader: CubeTextureLoader;
+        audioLoader: AudioLoader;
+        svgLoader: SVGLoader;
+        fontLoader: FontLoader;
+    };
+    constructor(sources: Asset[]);
+    startLoading(): void;
+    private sourceLoaded;
+}
+export {};