@zylem/game-lib 0.3.15 → 0.3.17

package/dist/lib/core/utility/nodes.js

@@ -0,0 +1,27 @@
+import { BaseNode as f } from "../base-node.js";
+import { Stage as r } from "../../stage/stage.js";
+import { GameEntity as g } from "../../entities/entity.js";
+async function h(c) {
+  const { getGameDefaultConfig: a } = await import("../../game/game-default.js");
+  let s = { ...a() };
+  const o = [], e = [], i = [];
+  return Object.values(c).forEach((t) => {
+    if (t instanceof r)
+      e.push(t);
+    else if (t instanceof g)
+      i.push(t);
+    else if (t instanceof f)
+      i.push(t);
+    else if (t?.constructor?.name === "Object" && typeof t == "object") {
+      const n = Object.assign({ ...a() }, { ...t });
+      o.push(n);
+    }
+  }), o.forEach((t) => {
+    s = Object.assign(s, { ...t });
+  }), e.forEach((t) => {
+    t.addEntities(i);
+  }), e.length ? s.stages = e : s.stages[0].addEntities(i), s;
+}
+export {
+  h as convertNodes
+};

package/dist/lib/core/utility/strings.d.ts

@@ -0,0 +1,2 @@
+export declare function sortedStringify(obj: Record<string, any>): string;
+export declare function shortHash(objString: string): string;

package/dist/lib/core/utility/strings.js

@@ -0,0 +1,14 @@
+function o(r) {
+  const e = Object.keys(r).sort().reduce((t, n) => (t[n] = r[n], t), {});
+  return JSON.stringify(e);
+}
+function s(r) {
+  let e = 0;
+  for (let t = 0; t < r.length; t++)
+    e = Math.imul(31, e) + r.charCodeAt(t) | 0;
+  return e.toString(36);
+}
+export {
+  s as shortHash,
+  o as sortedStringify
+};

package/dist/lib/core/{utility.d.ts → utility/vector.d.ts}

@@ -9,7 +9,5 @@ export declare const ZylemBlue = "#0333EC";
 export declare const ZylemBlueTransparent = "#0333ECA0";
 export declare const ZylemGoldText = "#DAA420";
 export type SizeVector = Vect3 | null;
-export declare function sortedStringify(obj: Record<string, any>): string;
-export declare function shortHash(objString: string): string;
 export declare const Vec0: Vector3;
 export declare const Vec1: Vector3;

package/dist/lib/core/utility/vector.js

@@ -0,0 +1,8 @@
+import { Color as r } from "three";
+import { Vector3 as o } from "@dimforge/rapier3d-compat";
+const t = new r("#0333EC");
+new o(0, 0, 0);
+new o(1, 1, 1);
+export {
+  t as ZylemBlueColor
+};

package/dist/lib/core/vessel.d.ts

@@ -1,11 +1,13 @@
 import { BaseNode } from './base-node';
-import { SetupContext, UpdateContext, DestroyContext } from './base-node-life-cycle';
+import { SetupContext, UpdateContext, DestroyContext, LoadedContext, CleanupContext } from './base-node-life-cycle';
 export declare const VESSEL_TYPE: unique symbol;
 export declare class Vessel extends BaseNode<{}, Vessel> {
     static type: symbol;
     protected _setup(_params: SetupContext<this>): void;
+    protected _loaded(_params: LoadedContext<this>): Promise<void>;
     protected _update(_params: UpdateContext<this>): void;
     protected _destroy(_params: DestroyContext<this>): void;
+    protected _cleanup(_params: CleanupContext<this>): Promise<void>;
     create(): this;
 }
 export declare function vessel(...args: Array<BaseNode>): BaseNode<{}, Vessel>;

package/dist/lib/core/vessel.js

@@ -0,0 +1,27 @@
+import { BaseNode as t } from "./base-node.js";
+const r = Symbol("vessel");
+class n extends t {
+  static type = r;
+  _setup(s) {
+  }
+  async _loaded(s) {
+  }
+  _update(s) {
+  }
+  _destroy(s) {
+  }
+  async _cleanup(s) {
+  }
+  create() {
+    return this;
+  }
+}
+function o(...e) {
+  const s = new n();
+  return e.forEach((a) => s.add(a)), s;
+}
+export {
+  r as VESSEL_TYPE,
+  n as Vessel,
+  o as vessel
+};

package/dist/lib/debug/console/console-state.js

@@ -0,0 +1,11 @@
+import { proxy as s } from "valtio/vanilla";
+const o = s({
+  messages: []
+}), n = (t) => {
+  const e = `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] ${t}`;
+  o.messages.push(e);
+};
+export {
+  o as consoleState,
+  n as printToConsole
+};

package/dist/lib/debug/debug-state.js

@@ -0,0 +1,40 @@
+import { proxy as s } from "valtio/vanilla";
+import { printToConsole as t } from "./console/console-state.js";
+const n = {
+  NONE: "NONE",
+  SELECT: "SELECT",
+  DELETE: "DELETE"
+}, o = s({
+  on: !1,
+  paused: !1,
+  configuration: {
+    showCollisionBounds: !1,
+    showModelBounds: !1,
+    showSpriteBounds: !1
+  },
+  hovered: null,
+  selected: [],
+  tool: n.NONE
+}), r = (e = !1) => {
+  o.on = e;
+}, u = (e) => {
+  o.selected.push(e);
+}, E = () => o.tool, a = (e) => {
+  o.hovered = e;
+}, c = () => {
+  o.hovered = null;
+}, i = () => o.hovered, f = (e) => {
+  o.paused = e, t(e ? "Paused" : "Resumed");
+}, p = () => o.paused;
+export {
+  n as DebugTools,
+  o as debugState,
+  E as getDebugTool,
+  i as getHoveredEntity,
+  p as isPaused,
+  c as resetHoveredEntity,
+  r as setDebugFlag,
+  a as setHoveredEntity,
+  f as setPaused,
+  u as setSelectedEntity
+};

package/dist/lib/device/aspect-ratio.d.ts

@@ -0,0 +1,37 @@
+export declare const AspectRatio: {
+    readonly FourByThree: number;
+    readonly SixteenByNine: number;
+    readonly TwentyOneByNine: number;
+    readonly OneByOne: number;
+};
+export type AspectRatioValue = (typeof AspectRatio)[keyof typeof AspectRatio] | number;
+/**
+ * AspectRatioDelegate manages sizing a canvas to fit within a container
+ * while preserving a target aspect ratio. It notifies a consumer via
+ * onResize when the final width/height are applied so renderers/cameras
+ * can update their viewports.
+ */
+export declare class AspectRatioDelegate {
+    container: HTMLElement;
+    canvas: HTMLCanvasElement;
+    aspectRatio: number;
+    onResize?: (width: number, height: number) => void;
+    private handleResizeBound;
+    constructor(params: {
+        container: HTMLElement;
+        canvas: HTMLCanvasElement;
+        aspectRatio: AspectRatioValue;
+        onResize?: (width: number, height: number) => void;
+    });
+    /** Attach window resize listener and apply once. */
+    attach(): void;
+    /** Detach window resize listener. */
+    detach(): void;
+    /** Compute the largest size that fits container while preserving aspect. */
+    measure(): {
+        width: number;
+        height: number;
+    };
+    /** Apply measured size to canvas and notify. */
+    apply(): void;
+}

package/dist/lib/device/aspect-ratio.js

@@ -0,0 +1,44 @@
+const h = {
+  FourByThree: 1.3333333333333333,
+  SixteenByNine: 1.7777777777777777,
+  TwentyOneByNine: 2.3333333333333335,
+  OneByOne: 1
+};
+class a {
+  container;
+  canvas;
+  aspectRatio;
+  onResize;
+  handleResizeBound;
+  constructor(t) {
+    this.container = t.container, this.canvas = t.canvas, this.aspectRatio = (typeof t.aspectRatio == "number", t.aspectRatio), this.onResize = t.onResize, this.handleResizeBound = this.apply.bind(this);
+  }
+  /** Attach window resize listener and apply once. */
+  attach() {
+    window.addEventListener("resize", this.handleResizeBound), this.apply();
+  }
+  /** Detach window resize listener. */
+  detach() {
+    window.removeEventListener("resize", this.handleResizeBound);
+  }
+  /** Compute the largest size that fits container while preserving aspect. */
+  measure() {
+    const t = this.container.clientWidth || window.innerWidth, e = this.container.clientHeight || window.innerHeight;
+    if (t / e > this.aspectRatio) {
+      const i = e;
+      return { width: Math.round(i * this.aspectRatio), height: i };
+    } else {
+      const i = t, n = Math.round(i / this.aspectRatio);
+      return { width: i, height: n };
+    }
+  }
+  /** Apply measured size to canvas and notify. */
+  apply() {
+    const { width: t, height: e } = this.measure();
+    this.canvas.style.width = `${t}px`, this.canvas.style.height = `${e}px`, this.onResize?.(t, e);
+  }
+}
+export {
+  h as AspectRatio,
+  a as AspectRatioDelegate
+};

package/dist/lib/entities/actor.js

@@ -0,0 +1,125 @@
+import { ColliderDesc as l, ActiveCollisionTypes as m } from "@dimforge/rapier3d-compat";
+import { Vector3 as r, Group as d, SkinnedMesh as u } from "three";
+import { GameEntity as p } from "./entity.js";
+import { createEntity as g } from "./create.js";
+import { EntityAssetLoader as y } from "../core/entity-asset-loader.js";
+import { AnimationDelegate as f } from "./delegates/animation.js";
+import { EntityCollisionBuilder as b, EntityBuilder as _ } from "./builder.js";
+const c = {
+  position: { x: 0, y: 0, z: 0 },
+  collision: {
+    static: !1,
+    size: new r(0.5, 0.5, 0.5),
+    position: new r(0, 0, 0)
+  },
+  material: {
+    shader: "standard"
+  },
+  animations: [],
+  models: []
+};
+class j extends b {
+  height = 1;
+  objectModel = null;
+  constructor(t) {
+    super(), this.objectModel = t.objectModel;
+  }
+  createColliderFromObjectModel(t) {
+    if (!t)
+      return l.capsule(1, 1);
+    const e = t.children.find((s) => s instanceof u).geometry;
+    if (e && (e.computeBoundingBox(), e.boundingBox)) {
+      const s = e.boundingBox.max.y, h = e.boundingBox.min.y;
+      this.height = s - h;
+    }
+    this.height = 1;
+    let o = l.capsule(this.height / 2, 1);
+    return o.setSensor(!1), o.setTranslation(0, this.height + 0.5, 0), o.activeCollisionTypes = m.DEFAULT, o;
+  }
+  collider(t) {
+    return this.createColliderFromObjectModel(this.objectModel);
+  }
+}
+class C extends _ {
+  createEntity(t) {
+    return new a(t);
+  }
+}
+const D = Symbol("Actor");
+class a extends p {
+  static type = D;
+  _object = null;
+  _animationDelegate = null;
+  _modelFileNames = [];
+  _assetLoader = new y();
+  controlledRotation = !1;
+  constructor(t) {
+    super(), this.options = { ...c, ...t }, this.lifeCycleDelegate = {
+      update: [this.actorUpdate.bind(this)]
+    }, this.controlledRotation = !0;
+  }
+  async load() {
+    this._modelFileNames = this.options.models || [], await this.loadModels(), this._object && (this._animationDelegate = new f(this._object), await this._animationDelegate.loadAnimations(this.options.animations || []));
+  }
+  async data() {
+    return {
+      animations: this._animationDelegate?.animations,
+      objectModel: this._object
+    };
+  }
+  async actorUpdate(t) {
+    this._animationDelegate?.update(t.delta);
+  }
+  async loadModels() {
+    if (this._modelFileNames.length === 0)
+      return;
+    const t = this._modelFileNames.map((e) => this._assetLoader.loadFile(e)), i = await Promise.all(t);
+    i[0]?.object && (this._object = i[0].object), this._object && (this.group = new d(), this.group.attach(this._object), this.group.scale.set(this.options.scale?.x || 1, this.options.scale?.y || 1, this.options.scale?.z || 1));
+  }
+  playAnimation(t) {
+    this._animationDelegate?.playAnimation(t);
+  }
+  get object() {
+    return this._object;
+  }
+  /**
+   * Provide custom debug information for the actor
+   * This will be merged with the default debug information
+   */
+  getDebugInfo() {
+    const t = {
+      type: "Actor",
+      models: this._modelFileNames.length > 0 ? this._modelFileNames : "none",
+      modelLoaded: !!this._object,
+      scale: this.options.scale ? `${this.options.scale.x}, ${this.options.scale.y}, ${this.options.scale.z}` : "1, 1, 1"
+    };
+    if (this._animationDelegate && (t.currentAnimation = this._animationDelegate.currentAnimationKey || "none", t.animationsCount = this.options.animations?.length || 0), this._object) {
+      let i = 0, e = 0;
+      this._object.traverse((o) => {
+        if (o.isMesh) {
+          i++;
+          const s = o.geometry;
+          s && s.attributes.position && (e += s.attributes.position.count);
+        }
+      }), t.meshCount = i, t.vertexCount = e;
+    }
+    return t;
+  }
+}
+async function T(...n) {
+  return await g({
+    args: n,
+    defaultConfig: c,
+    EntityClass: a,
+    BuilderClass: C,
+    CollisionBuilderClass: j,
+    entityType: a.type
+  });
+}
+export {
+  D as ACTOR_TYPE,
+  C as ActorBuilder,
+  j as ActorCollisionBuilder,
+  a as ZylemActor,
+  T as actor
+};

package/dist/lib/entities/box.js

@@ -0,0 +1,68 @@
+import { ColliderDesc as a } from "@dimforge/rapier3d-compat";
+import { Color as d, Vector3 as n, BoxGeometry as u } from "three";
+import { GameEntity as y } from "./entity.js";
+import { EntityCollisionBuilder as f, EntityBuilder as x, EntityMeshBuilder as m } from "./builder.js";
+import { DebugDelegate as p } from "./delegates/debug.js";
+import { createEntity as z } from "./create.js";
+const l = {
+  size: new n(1, 1, 1),
+  position: new n(0, 0, 0),
+  collision: {
+    static: !1
+  },
+  material: {
+    color: new d("#ffffff"),
+    shader: "standard"
+  }
+};
+class B extends f {
+  collider(t) {
+    const e = t.size || new n(1, 1, 1), s = { x: e.x / 2, y: e.y / 2, z: e.z / 2 };
+    return a.cuboid(s.x, s.y, s.z);
+  }
+}
+class b extends m {
+  build(t) {
+    const e = t.size ?? new n(1, 1, 1);
+    return new u(e.x, e.y, e.z);
+  }
+}
+class C extends x {
+  createEntity(t) {
+    return new i(t);
+  }
+}
+const h = Symbol("Box");
+class i extends y {
+  static type = h;
+  constructor(t) {
+    super(), this.options = { ...l, ...t };
+  }
+  buildInfo() {
+    const e = new p(this).buildDebugInfo(), { x: s, y: r, z: c } = this.options.size ?? { x: 1, y: 1, z: 1 };
+    return {
+      ...e,
+      type: String(i.type),
+      size: `${s}, ${r}, ${c}`
+    };
+  }
+}
+async function $(...o) {
+  return z({
+    args: o,
+    defaultConfig: l,
+    EntityClass: i,
+    BuilderClass: C,
+    MeshBuilderClass: b,
+    CollisionBuilderClass: B,
+    entityType: i.type
+  });
+}
+export {
+  h as BOX_TYPE,
+  C as BoxBuilder,
+  B as BoxCollisionBuilder,
+  b as BoxMeshBuilder,
+  i as ZylemBox,
+  $ as box
+};

package/dist/lib/entities/builder.js

@@ -0,0 +1,79 @@
+import { Mesh as l, Color as n, BufferGeometry as u } from "three";
+import { CollisionBuilder as h } from "../collision/collision-builder.js";
+import { MeshBuilder as m } from "../graphics/mesh.js";
+import { MaterialBuilder as d } from "../graphics/material.js";
+class y extends h {
+}
+class b extends m {
+  build(i) {
+    return new u();
+  }
+  postBuild() {
+  }
+}
+class M {
+  meshBuilder;
+  collisionBuilder;
+  materialBuilder;
+  options;
+  entity;
+  constructor(i, s, t, e) {
+    this.options = i, this.entity = s, this.meshBuilder = t, this.collisionBuilder = e, this.materialBuilder = new d();
+    const o = {
+      meshBuilder: this.meshBuilder,
+      collisionBuilder: this.collisionBuilder,
+      materialBuilder: this.materialBuilder
+    };
+    this.options._builders = o;
+  }
+  withPosition(i) {
+    return this.options.position = i, this;
+  }
+  async withMaterial(i, s) {
+    return this.materialBuilder && await this.materialBuilder.build(i, s), this;
+  }
+  applyMaterialToGroup(i, s) {
+    i.traverse((t) => {
+      t instanceof l && t.type === "SkinnedMesh" && s[0] && !t.material.map && (t.material = s[0]), t.castShadow = !0, t.receiveShadow = !0;
+    });
+  }
+  async build() {
+    const i = this.entity;
+    if (this.materialBuilder && (i.materials = this.materialBuilder.materials), this.meshBuilder && i.materials) {
+      const s = this.meshBuilder.build(this.options);
+      i.mesh = this.meshBuilder._build(this.options, s, i.materials), this.meshBuilder.postBuild();
+    }
+    if (i.group && i.materials && this.applyMaterialToGroup(i.group, i.materials), this.collisionBuilder) {
+      this.collisionBuilder.withCollision(this.options?.collision || {});
+      const [s, t] = this.collisionBuilder.build(this.options);
+      i.bodyDesc = s, i.colliderDesc = t;
+      const { x: e, y: o, z: a } = this.options.position || { x: 0, y: 0, z: 0 };
+      i.bodyDesc.setTranslation(e, o, a);
+    }
+    if (this.options.collisionType && (i.collisionType = this.options.collisionType), this.options.color instanceof n) {
+      const s = (t) => {
+        const e = t;
+        e && e.color && e.color.set && e.color.set(this.options.color);
+      };
+      if (i.materials?.length)
+        for (const t of i.materials)
+          s(t);
+      if (i.mesh && i.mesh.material) {
+        const t = i.mesh.material;
+        Array.isArray(t) ? t.forEach(s) : s(t);
+      }
+      i.group && i.group.traverse((t) => {
+        if (t instanceof l && t.material) {
+          const e = t.material;
+          Array.isArray(e) ? e.forEach(s) : s(e);
+        }
+      });
+    }
+    return i;
+  }
+}
+export {
+  M as EntityBuilder,
+  y as EntityCollisionBuilder,
+  b as EntityMeshBuilder
+};

package/dist/lib/entities/create.js

@@ -0,0 +1,31 @@
+import { BaseNode as s } from "../core/base-node.js";
+import { isLoadable as p, EntityLoader as C } from "./delegates/loader.js";
+async function E(w) {
+  const { args: n, defaultConfig: l, EntityClass: g, BuilderClass: y, entityType: c, MeshBuilderClass: f, CollisionBuilderClass: d } = w;
+  let e = null, r;
+  const u = n.findIndex((i) => !(i instanceof s));
+  u !== -1 && (r = n.splice(u, 1).find((t) => !(t instanceof s)));
+  const m = r ? { ...l, ...r } : l;
+  n.push(m);
+  for (const i of n) {
+    if (i instanceof s)
+      continue;
+    let t = null;
+    const a = new g(i);
+    try {
+      if (p(a)) {
+        const o = new C(a);
+        await o.load(), t = await o.data();
+      }
+    } catch (o) {
+      console.error("Error creating entity with loader:", o);
+    }
+    e = new y(i, a, f ? new f(t) : null, d ? new d(t) : null), i.material && await e.withMaterial(i.material, c);
+  }
+  if (!e)
+    throw new Error(`missing options for ${String(c)}, builder is not initialized.`);
+  return await e.build();
+}
+export {
+  E as createEntity
+};

package/dist/lib/entities/delegates/animation.js

@@ -0,0 +1,58 @@
+import { AnimationMixer as u, LoopOnce as c, LoopRepeat as h } from "three";
+import { EntityAssetLoader as _ } from "../../core/entity-asset-loader.js";
+class d {
+  target;
+  _mixer = null;
+  _actions = {};
+  _animations = [];
+  _currentAction = null;
+  _pauseAtPercentage = 0;
+  _isPaused = !1;
+  _queuedKey = null;
+  _fadeDuration = 0.5;
+  _currentKey = "";
+  _assetLoader = new _();
+  constructor(e) {
+    this.target = e;
+  }
+  async loadAnimations(e) {
+    if (!e.length)
+      return;
+    const i = await Promise.all(e.map((t) => this._assetLoader.loadFile(t.path)));
+    this._animations = i.filter((t) => !!t.animation).map((t) => t.animation), this._animations.length && (this._mixer = new u(this.target), this._animations.forEach((t, n) => {
+      const a = e[n].key || n.toString();
+      this._actions[a] = this._mixer.clipAction(t);
+    }), this.playAnimation({ key: Object.keys(this._actions)[0] }));
+  }
+  update(e) {
+    if (!this._mixer || !this._currentAction)
+      return;
+    this._mixer.update(e);
+    const i = this._currentAction.getClip().duration * (this._pauseAtPercentage / 100);
+    if (!this._isPaused && this._pauseAtPercentage > 0 && this._currentAction.time >= i && (this._currentAction.time = i, this._currentAction.paused = !0, this._isPaused = !0, this._queuedKey !== null)) {
+      const t = this._actions[this._queuedKey];
+      t.reset().play(), this._currentAction.crossFadeTo(t, this._fadeDuration, !1), this._currentAction = t, this._currentKey = this._queuedKey, this._queuedKey = null;
+    }
+  }
+  playAnimation(e) {
+    if (!this._mixer)
+      return;
+    const { key: i, pauseAtPercentage: t = 0, pauseAtEnd: n = !1, fadeToKey: a, fadeDuration: o = 0.5 } = e;
+    if (i === this._currentKey)
+      return;
+    this._queuedKey = a || null, this._fadeDuration = o, this._pauseAtPercentage = n ? 100 : t, this._isPaused = !1;
+    const r = this._currentAction;
+    r && r.stop();
+    const s = this._actions[i];
+    s && (this._pauseAtPercentage > 0 ? (s.setLoop(c, 1 / 0), s.clampWhenFinished = !0) : (s.setLoop(h, 1 / 0), s.clampWhenFinished = !1), r && r.crossFadeTo(s, o, !1), s.reset().play(), this._currentAction = s, this._currentKey = i);
+  }
+  get currentAnimationKey() {
+    return this._currentKey;
+  }
+  get animations() {
+    return this._animations;
+  }
+}
+export {
+  d as AnimationDelegate
+};

package/dist/lib/entities/delegates/debug.js

@@ -0,0 +1,72 @@
+import { MeshStandardMaterial as c, MeshBasicMaterial as u, MeshPhongMaterial as f } from "three";
+function g(o) {
+  return o && typeof o.getDebugInfo == "function";
+}
+class d {
+  entity;
+  constructor(t) {
+    this.entity = t;
+  }
+  /**
+   * Get formatted position string
+   */
+  getPositionString() {
+    if (this.entity.mesh) {
+      const { x: n, y: s, z: r } = this.entity.mesh.position;
+      return `${n.toFixed(2)}, ${s.toFixed(2)}, ${r.toFixed(2)}`;
+    }
+    const { x: t, y: i, z: e } = this.entity.options.position || { x: 0, y: 0, z: 0 };
+    return `${t.toFixed(2)}, ${i.toFixed(2)}, ${e.toFixed(2)}`;
+  }
+  /**
+   * Get formatted rotation string (in degrees)
+   */
+  getRotationString() {
+    if (this.entity.mesh) {
+      const { x: s, y: r, z: y } = this.entity.mesh.rotation, a = (h) => (h * 180 / Math.PI).toFixed(1);
+      return `${a(s)}°, ${a(r)}°, ${a(y)}°`;
+    }
+    const { x: t, y: i, z: e } = this.entity.options.rotation || { x: 0, y: 0, z: 0 }, n = (s) => (s * 180 / Math.PI).toFixed(1);
+    return `${n(t)}°, ${n(i)}°, ${n(e)}°`;
+  }
+  /**
+   * Get material information
+   */
+  getMaterialInfo() {
+    if (!this.entity.mesh || !this.entity.mesh.material)
+      return { type: "none" };
+    const t = Array.isArray(this.entity.mesh.material) ? this.entity.mesh.material[0] : this.entity.mesh.material, i = {
+      type: t.type
+    };
+    return (t instanceof c || t instanceof u || t instanceof f) && (i.color = `#${t.color.getHexString()}`, i.opacity = t.opacity, i.transparent = t.transparent), "roughness" in t && (i.roughness = t.roughness), "metalness" in t && (i.metalness = t.metalness), i;
+  }
+  getPhysicsInfo() {
+    if (!this.entity.body)
+      return null;
+    const t = {
+      type: this.entity.body.bodyType(),
+      mass: this.entity.body.mass(),
+      isEnabled: this.entity.body.isEnabled(),
+      isSleeping: this.entity.body.isSleeping()
+    }, i = this.entity.body.linvel();
+    return t.velocity = `${i.x.toFixed(2)}, ${i.y.toFixed(2)}, ${i.z.toFixed(2)}`, t;
+  }
+  buildDebugInfo() {
+    const t = {
+      name: this.entity.name || this.entity.uuid,
+      uuid: this.entity.uuid,
+      position: this.getPositionString(),
+      rotation: this.getRotationString(),
+      material: this.getMaterialInfo()
+    }, i = this.getPhysicsInfo();
+    if (i && (t.physics = i), this.entity.behaviors.length > 0 && (t.behaviors = this.entity.behaviors.map((e) => e.constructor.name)), g(this.entity)) {
+      const e = this.entity.getDebugInfo();
+      return { ...t, ...e };
+    }
+    return t;
+  }
+}
+export {
+  d as DebugDelegate,
+  g as hasDebugInfo
+};