@mavonengine/core 0.0.2

package/dist/Renderer/PhysicsRenderer.cjs

@@ -0,0 +1,84 @@
+"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 PhysicsRenderer_exports = {};
+__export(PhysicsRenderer_exports, {
+  RapierDebugRenderer: () => RapierDebugRenderer
+});
+module.exports = __toCommonJS(PhysicsRenderer_exports);
+var import_three = require("three");
+var import_Game = __toESM(require("../Game"), 1);
+class RapierDebugRenderer {
+  constructor(scene, world, enabled = false) {
+    this.stats = {
+      bodies: 0,
+      colliders: 0,
+      active: 0
+    };
+    this.world = world;
+    this.mesh = new import_three.LineSegments(new import_three.BufferGeometry(), new import_three.LineBasicMaterial({ color: 16777215, vertexColors: true }));
+    this.mesh.frustumCulled = false;
+    this.enabled = enabled;
+    scene.add(this.mesh);
+    const physicsPane = import_Game.default.instance().debug.ui?.addFolder({
+      title: "Physics"
+    });
+    if (physicsPane) {
+      physicsPane.addBinding(this.stats, "bodies", { label: "Bodies", readonly: true });
+      physicsPane.addBinding(this.stats, "colliders", { label: "Colliders", readonly: true });
+      physicsPane.addBinding(this.stats, "active", { label: "Active", readonly: true });
+      this.toggleVisible(true);
+    }
+  }
+  toggleVisible(visible) {
+    this.enabled = visible;
+  }
+  update() {
+    if (this.enabled) {
+      const { vertices, colors } = this.world.debugRender();
+      this.mesh.geometry.setAttribute("position", new import_three.BufferAttribute(vertices, 3));
+      this.mesh.geometry.setAttribute("color", new import_three.BufferAttribute(colors, 4));
+      this.mesh.visible = true;
+      this.stats.bodies = 0;
+      this.stats.active = 0;
+      this.stats.colliders = this.world.colliders.len();
+      this.world.bodies.forEach((body) => {
+        this.stats.bodies++;
+        if (!body.isSleeping() && body.isEnabled()) {
+          this.stats.active++;
+        }
+      });
+    } else {
+      this.mesh.visible = false;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RapierDebugRenderer
+});

package/dist/Renderer/PhysicsRenderer.d.ts

@@ -0,0 +1,16 @@
+import type RAPIER from '@dimforge/rapier3d-compat';
+import type { Scene } from 'three';
+import { BufferGeometry, LineBasicMaterial, LineSegments } from 'three';
+export declare class RapierDebugRenderer {
+    mesh: LineSegments<BufferGeometry<import("three").NormalBufferAttributes>, LineBasicMaterial, import("three").Object3DEventMap>;
+    world: RAPIER.World;
+    enabled: boolean;
+    stats: {
+        bodies: number;
+        colliders: number;
+        active: number;
+    };
+    constructor(scene: Scene, world: RAPIER.World, enabled?: boolean);
+    toggleVisible(visible: boolean): void;
+    update(): void;
+}

package/dist/Renderer/PhysicsRenderer.js

@@ -0,0 +1,48 @@
+import { BufferAttribute, BufferGeometry, LineBasicMaterial, LineSegments } from 'three';
+import Game from '../Game';
+export class RapierDebugRenderer {
+    constructor(scene, world, enabled = false) {
+        this.stats = {
+            bodies: 0,
+            colliders: 0,
+            active: 0,
+        };
+        this.world = world;
+        this.mesh = new LineSegments(new BufferGeometry(), new LineBasicMaterial({ color: 0xFFFFFF, vertexColors: true }));
+        this.mesh.frustumCulled = false;
+        this.enabled = enabled;
+        scene.add(this.mesh);
+        const physicsPane = Game.instance().debug.ui?.addFolder({
+            title: 'Physics',
+        });
+        if (physicsPane) {
+            physicsPane.addBinding(this.stats, 'bodies', { label: 'Bodies', readonly: true });
+            physicsPane.addBinding(this.stats, 'colliders', { label: 'Colliders', readonly: true });
+            physicsPane.addBinding(this.stats, 'active', { label: 'Active', readonly: true });
+            this.toggleVisible(true);
+        }
+    }
+    toggleVisible(visible) {
+        this.enabled = visible;
+    }
+    update() {
+        if (this.enabled) {
+            const { vertices, colors } = this.world.debugRender();
+            this.mesh.geometry.setAttribute('position', new BufferAttribute(vertices, 3));
+            this.mesh.geometry.setAttribute('color', new BufferAttribute(colors, 4));
+            this.mesh.visible = true;
+            this.stats.bodies = 0;
+            this.stats.active = 0;
+            this.stats.colliders = this.world.colliders.len();
+            this.world.bodies.forEach((body) => {
+                this.stats.bodies++;
+                if (!body.isSleeping() && body.isEnabled()) {
+                    this.stats.active++;
+                }
+            });
+        }
+        else {
+            this.mesh.visible = false;
+        }
+    }
+}

package/dist/Renderer.cjs

@@ -0,0 +1,135 @@
+"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 Renderer_exports = {};
+__export(Renderer_exports, {
+  default: () => Renderer
+});
+module.exports = __toCommonJS(Renderer_exports);
+var import_three = require("three");
+var import_three_perf = require("three-perf");
+var import_Addons = require("three/examples/jsm/Addons.js");
+var import_Game = __toESM(require("./Game"), 1);
+var import_SkeletonAxesHelper = __toESM(require("./Utils/SkeletonAxesHelper"), 1);
+class Renderer {
+  constructor(parameters) {
+    this.options = {
+      wireframe: false,
+      perf: false,
+      armature: false
+    };
+    this.armatureHelpers = [];
+    this.fps = 0;
+    this._fpsFrameCount = 0;
+    this._fpsElapsed = 0;
+    this.instance = new import_three.WebGLRenderer(parameters);
+    this.composer = new import_Addons.EffectComposer(this.instance);
+    this.composer.addPass(
+      new import_Addons.RenderPass(
+        import_Game.default.instance().scene,
+        import_Game.default.instance().camera.instance
+      )
+    );
+    this.composer.addPass(new import_Addons.OutputPass());
+    this.instance.shadowMap.enabled = true;
+    this.instance.shadowMap.type = import_three.PCFSoftShadowMap;
+    this.instance.setSize(
+      import_Game.default.instance().sizes.width,
+      import_Game.default.instance().sizes.height
+    );
+    this.instance.setClearColor("#181818");
+    this.instance.setPixelRatio(import_Game.default.instance().sizes.pixelRatio);
+    this.composer.setPixelRatio(import_Game.default.instance().sizes.pixelRatio);
+    this.composer.setSize(
+      import_Game.default.instance().sizes.width,
+      import_Game.default.instance().sizes.height
+    );
+    const renderDebug = import_Game.default.instance().debug.ui?.addFolder({ title: "Render" });
+    if (renderDebug) {
+      this.perf = new import_three_perf.ThreePerf({
+        anchorX: "right",
+        anchorY: "bottom",
+        memory: true,
+        guiVisible: false,
+        domElement: document.body,
+        renderer: this.instance
+      });
+      renderDebug.addBinding(this.options, "wireframe").on("change", () => {
+        import_Game.default.instance().scene.traverse((object) => {
+          if (object instanceof import_three.Mesh && object.material) {
+            object.material.wireframe = this.options.wireframe;
+          }
+        });
+      });
+      renderDebug.addBinding(this.options, "armature").on("change", () => {
+        if (this.options.armature) {
+          import_Game.default.instance().scene.traverse((object) => {
+            if (object instanceof import_three.SkinnedMesh) {
+              const skeletonHelper = new import_three.SkeletonHelper(object.skeleton.bones[0]);
+              const axesHelper = new import_SkeletonAxesHelper.default(object.skeleton.bones[0]);
+              import_Game.default.instance().scene.add(skeletonHelper, axesHelper);
+              this.armatureHelpers.push(skeletonHelper, axesHelper);
+            }
+          });
+        } else {
+          for (const helper of this.armatureHelpers) {
+            import_Game.default.instance().scene.remove(helper);
+            if (helper instanceof import_SkeletonAxesHelper.default) {
+              helper.dispose();
+            }
+          }
+          this.armatureHelpers = [];
+        }
+      });
+    }
+  }
+  resize() {
+    this.instance.setSize(
+      import_Game.default.instance().sizes.width,
+      import_Game.default.instance().sizes.height
+    );
+    this.instance.setPixelRatio(import_Game.default.instance().sizes.pixelRatio);
+    this.composer.setPixelRatio(import_Game.default.instance().sizes.pixelRatio);
+    this.composer.setSize(
+      import_Game.default.instance().sizes.width,
+      import_Game.default.instance().sizes.height
+    );
+  }
+  update(delta) {
+    this.perf?.begin();
+    this.composer.render(delta);
+    this.perf?.end();
+    this._fpsFrameCount++;
+    this._fpsElapsed += delta;
+    if (this._fpsElapsed >= 0.5) {
+      this.fps = Math.round(this._fpsFrameCount / this._fpsElapsed);
+      this._fpsFrameCount = 0;
+      this._fpsElapsed = 0;
+    }
+  }
+}

package/dist/Renderer.d.ts

@@ -0,0 +1,23 @@
+import type { FpsGraphBladeApi } from '@tweakpane/plugin-essentials';
+import type { Object3D, WebGLRendererParameters } from 'three';
+import { WebGLRenderer } from 'three';
+import { ThreePerf } from 'three-perf';
+import { EffectComposer } from 'three/examples/jsm/Addons.js';
+export default class Renderer {
+    instance: WebGLRenderer;
+    composer: EffectComposer;
+    fpsGraph: FpsGraphBladeApi | undefined;
+    options: {
+        wireframe: boolean;
+        perf: boolean;
+        armature: boolean;
+    };
+    perf?: ThreePerf;
+    armatureHelpers: Object3D[];
+    fps: number;
+    private _fpsFrameCount;
+    private _fpsElapsed;
+    constructor(parameters?: WebGLRendererParameters);
+    resize(): void;
+    update(delta: number): void;
+}

package/dist/Renderer.js

@@ -0,0 +1,86 @@
+import { Mesh, PCFSoftShadowMap, SkeletonHelper, SkinnedMesh, WebGLRenderer } from 'three';
+import { ThreePerf } from 'three-perf';
+import { EffectComposer, OutputPass, RenderPass } from 'three/examples/jsm/Addons.js';
+import Game from './Game';
+import SkeletonAxesHelper from './Utils/SkeletonAxesHelper';
+export default class Renderer {
+    constructor(parameters) {
+        this.options = {
+            wireframe: false,
+            perf: false,
+            armature: false,
+        };
+        this.armatureHelpers = [];
+        this.fps = 0;
+        this._fpsFrameCount = 0;
+        this._fpsElapsed = 0;
+        this.instance = new WebGLRenderer(parameters);
+        this.composer = new EffectComposer(this.instance);
+        this.composer.addPass(new RenderPass(Game.instance().scene, Game.instance().camera.instance));
+        this.composer.addPass(new OutputPass());
+        this.instance.shadowMap.enabled = true;
+        this.instance.shadowMap.type = PCFSoftShadowMap;
+        this.instance.setSize(Game.instance().sizes.width, Game.instance().sizes.height);
+        this.instance.setClearColor('#181818');
+        this.instance.setPixelRatio(Game.instance().sizes.pixelRatio);
+        this.composer.setPixelRatio(Game.instance().sizes.pixelRatio);
+        this.composer.setSize(Game.instance().sizes.width, Game.instance().sizes.height);
+        const renderDebug = Game.instance().debug.ui?.addFolder({ title: 'Render' });
+        if (renderDebug) {
+            this.perf = new ThreePerf({
+                anchorX: 'right',
+                anchorY: 'bottom',
+                memory: true,
+                guiVisible: false,
+                domElement: document.body,
+                renderer: this.instance,
+            });
+            renderDebug.addBinding(this.options, 'wireframe').on('change', () => {
+                Game.instance().scene.traverse((object) => {
+                    if (object instanceof Mesh && object.material) {
+                        object.material.wireframe = this.options.wireframe;
+                    }
+                });
+            });
+            renderDebug.addBinding(this.options, 'armature').on('change', () => {
+                if (this.options.armature) {
+                    Game.instance().scene.traverse((object) => {
+                        if (object instanceof SkinnedMesh) {
+                            const skeletonHelper = new SkeletonHelper(object.skeleton.bones[0]);
+                            const axesHelper = new SkeletonAxesHelper(object.skeleton.bones[0]);
+                            Game.instance().scene.add(skeletonHelper, axesHelper);
+                            this.armatureHelpers.push(skeletonHelper, axesHelper);
+                        }
+                    });
+                }
+                else {
+                    for (const helper of this.armatureHelpers) {
+                        Game.instance().scene.remove(helper);
+                        if (helper instanceof SkeletonAxesHelper) {
+                            helper.dispose();
+                        }
+                    }
+                    this.armatureHelpers = [];
+                }
+            });
+        }
+    }
+    resize() {
+        this.instance.setSize(Game.instance().sizes.width, Game.instance().sizes.height);
+        this.instance.setPixelRatio(Game.instance().sizes.pixelRatio);
+        this.composer.setPixelRatio(Game.instance().sizes.pixelRatio);
+        this.composer.setSize(Game.instance().sizes.width, Game.instance().sizes.height);
+    }
+    update(delta) {
+        this.perf?.begin();
+        this.composer.render(delta);
+        this.perf?.end();
+        this._fpsFrameCount++;
+        this._fpsElapsed += delta;
+        if (this._fpsElapsed >= 0.5) {
+            this.fps = Math.round(this._fpsFrameCount / this._fpsElapsed);
+            this._fpsFrameCount = 0;
+            this._fpsElapsed = 0;
+        }
+    }
+}

package/dist/Shaders/Vertex/ClassicPerlin3DNoise.glsl

@@ -0,0 +1,84 @@
+// Classic Perlin 3D Noise 
+// by Stefan Gustavson
+//
+vec4 permute(vec4 x)
+{
+    return mod(((x*34.0)+1.0)*x, 289.0);
+}
+vec4 taylorInvSqrt(vec4 r)
+{
+    return 1.79284291400159 - 0.85373472095314 * r;
+}
+vec3 fade(vec3 t)
+{
+    return t*t*t*(t*(t*6.0-15.0)+10.0);
+}
+
+float cnoise(vec3 P)
+{
+    vec3 Pi0 = floor(P); // Integer part for indexing
+    vec3 Pi1 = Pi0 + vec3(1.0); // Integer part + 1
+    Pi0 = mod(Pi0, 289.0);
+    Pi1 = mod(Pi1, 289.0);
+    vec3 Pf0 = fract(P); // Fractional part for interpolation
+    vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0
+    vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+    vec4 iy = vec4(Pi0.yy, Pi1.yy);
+    vec4 iz0 = Pi0.zzzz;
+    vec4 iz1 = Pi1.zzzz;
+
+    vec4 ixy = permute(permute(ix) + iy);
+    vec4 ixy0 = permute(ixy + iz0);
+    vec4 ixy1 = permute(ixy + iz1);
+
+    vec4 gx0 = ixy0 / 7.0;
+    vec4 gy0 = fract(floor(gx0) / 7.0) - 0.5;
+    gx0 = fract(gx0);
+    vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);
+    vec4 sz0 = step(gz0, vec4(0.0));
+    gx0 -= sz0 * (step(0.0, gx0) - 0.5);
+    gy0 -= sz0 * (step(0.0, gy0) - 0.5);
+
+    vec4 gx1 = ixy1 / 7.0;
+    vec4 gy1 = fract(floor(gx1) / 7.0) - 0.5;
+    gx1 = fract(gx1);
+    vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);
+    vec4 sz1 = step(gz1, vec4(0.0));
+    gx1 -= sz1 * (step(0.0, gx1) - 0.5);
+    gy1 -= sz1 * (step(0.0, gy1) - 0.5);
+
+    vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);
+    vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);
+    vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);
+    vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);
+    vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);
+    vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);
+    vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);
+    vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);
+
+    vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+    g000 *= norm0.x;
+    g010 *= norm0.y;
+    g100 *= norm0.z;
+    g110 *= norm0.w;
+    vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+    g001 *= norm1.x;
+    g011 *= norm1.y;
+    g101 *= norm1.z;
+    g111 *= norm1.w;
+
+    float n000 = dot(g000, Pf0);
+    float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));
+    float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
+    float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));
+    float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));
+    float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
+    float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));
+    float n111 = dot(g111, Pf1);
+
+    vec3 fade_xyz = fade(Pf0);
+    vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);
+    vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);
+    float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
+    return 2.2 * n_xyz;
+}

package/dist/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/Types/Asset.d.ts

@@ -0,0 +1,6 @@
+export type AssetType = 'cubeTexture' | 'texture' | 'gltfModel' | 'sound' | 'svg' | 'font';
+export interface Asset {
+    name: string;
+    type: AssetType;
+    path: string[] | string;
+}

package/dist/Types/Asset.js

@@ -0,0 +1 @@
+export {};

package/dist/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/Types/Events.d.ts

@@ -0,0 +1,4 @@
+export interface ResourceLoadingProgress {
+    loaded: number;
+    total: number;
+}

package/dist/Types/Events.js

@@ -0,0 +1 @@
+export {};

package/dist/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/Types/IEditor.d.ts

@@ -0,0 +1,21 @@
+import type { Object3D } from 'three';
+import type EditorHelper from '../Editor/EditorHelper';
+/**
+ * Minimal interface that core code requires from an editor implementation.
+ * The full Editor class (in @mavonengine/editor) must satisfy this interface.
+ */
+export default interface IEditor {
+    update(delta: number): void;
+    addHelper(helper: EditorHelper): void;
+    removeHelper(helper: EditorHelper): void;
+    selectObject(obj: Object3D): void;
+    addLightHelper(helper: Object3D): void;
+    removeLightHelper(helper: Object3D): void;
+    setShowHelpers(visible: boolean): void;
+    on(event: string, callback: (event?: any) => void): void;
+    off(event: string, callback: (event?: any) => void): void;
+    trigger(name: string, event?: any): void;
+    availableAssetCategories: string[];
+    activeAssetCategory: 'Object' | '_texture' | 'CubeTexture' | 'AudioBuffer' | 'Font';
+    setActiveAssetCategory(value: 'Object' | '_texture' | 'CubeTexture' | 'AudioBuffer' | 'Font'): void;
+}

package/dist/Types/IEditor.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,7 @@
+import { Pane } from 'tweakpane';
+import EventEmitter from './EventEmitter';
+export default class Debug extends EventEmitter {
+    active: boolean;
+    ui?: Pane;
+    constructor();
+}

package/dist/Utils/Debug.js

@@ -0,0 +1,14 @@
+import * as EssentialsPlugin from '@tweakpane/plugin-essentials';
+import { Pane } from 'tweakpane';
+import EventEmitter from './EventEmitter';
+export default class Debug extends EventEmitter {
+    constructor() {
+        super();
+        this.active = window.location.hash === '#debug';
+        if (this.active) {
+            this.ui = new Pane();
+            this.ui.registerPlugin(EssentialsPlugin);
+            this.trigger('debug');
+        }
+    }
+}