@zylem/game-lib 0.3.15 → 0.3.17

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

@@ -0,0 +1,19 @@
+function n(e) {
+  return typeof e?.load == "function" && typeof e?.data == "function";
+}
+class a {
+  entityReference;
+  constructor(t) {
+    this.entityReference = t;
+  }
+  async load() {
+    this.entityReference.load && await this.entityReference.load();
+  }
+  async data() {
+    return this.entityReference.data ? this.entityReference.data() : null;
+  }
+}
+export {
+  a as EntityLoader,
+  n as isLoadable
+};

package/dist/lib/entities/destroy.js

@@ -0,0 +1,15 @@
+import { getGlobalState as n } from "../game/game-state.js";
+function r(o, t, e) {
+  e({
+    me: o,
+    globals: t
+  });
+}
+function d(o, t) {
+  const e = t ?? n();
+  r(o, e, o.nodeDestroy.bind(o));
+}
+export {
+  d as destroy,
+  r as destroyEntity
+};

package/dist/lib/entities/entity.d.ts

@@ -4,7 +4,7 @@ import { Vec3 } from "../core/vector";
 import { MaterialBuilder, MaterialOptions } from "../graphics/material";
 import { CollisionOptions } from "../collision/collision";
 import { BaseNode } from "../core/base-node";
-import { DestroyContext, SetupContext, UpdateContext } from "../core/base-node-life-cycle";
+import { DestroyContext, SetupContext, UpdateContext, LoadedContext, CleanupContext } from "../core/base-node-life-cycle";
 import type { EntityMeshBuilder, EntityCollisionBuilder } from "./builder";
 export declare abstract class AbstractEntity {
     abstract uuid: string;
@@ -82,8 +82,10 @@ export declare class GameEntity<O extends GameEntityOptions> extends BaseNode<O>
     onDestroy(...callbacks: ((params: DestroyContext<this>) => void)[]): this;
     onCollision(...callbacks: ((params: CollisionContext<this, O>) => void)[]): this;
     _setup(params: SetupContext<this>): void;
+    protected _loaded(_params: LoadedContext<this>): Promise<void>;
     _update(params: UpdateContext<this>): void;
     _destroy(params: DestroyContext<this>): void;
+    protected _cleanup(_params: CleanupContext<this>): Promise<void>;
     _collision(other: GameEntity<O>, globals?: any): void;
     addBehavior(behaviorCallback: ({
         type: BehaviorCallbackType;

package/dist/lib/entities/entity.js

@@ -0,0 +1,120 @@
+import { ShaderMaterial as s } from "three";
+import { position as a, scale as o, rotation as n } from "../systems/transformable.system.js";
+import { BaseNode as c } from "../core/base-node.js";
+class f extends c {
+  group;
+  mesh;
+  materials;
+  bodyDesc = null;
+  body = null;
+  colliderDesc;
+  collider;
+  custom = {};
+  debugInfo = {};
+  debugMaterial;
+  lifeCycleDelegate = {
+    setup: [],
+    update: [],
+    destroy: []
+  };
+  collisionDelegate = {
+    collision: []
+  };
+  collisionType;
+  behaviorCallbackMap = {
+    setup: [],
+    update: [],
+    destroy: [],
+    collision: []
+  };
+  constructor() {
+    super();
+  }
+  create() {
+    const { position: e } = this.options, { x: t, y: i, z: l } = e || { x: 0, y: 0, z: 0 };
+    return this.behaviors = [
+      { component: a, values: { x: t, y: i, z: l } },
+      { component: o, values: { x: 0, y: 0, z: 0 } },
+      { component: n, values: { x: 0, y: 0, z: 0, w: 0 } }
+    ], this.name = this.options.name || "", this;
+  }
+  onSetup(...e) {
+    const t = [...this.lifeCycleDelegate.setup ?? [], ...e];
+    return this.lifeCycleDelegate = {
+      ...this.lifeCycleDelegate,
+      setup: t
+    }, this;
+  }
+  onUpdate(...e) {
+    const t = [...this.lifeCycleDelegate.update ?? [], ...e];
+    return this.lifeCycleDelegate = {
+      ...this.lifeCycleDelegate,
+      update: t
+    }, this;
+  }
+  onDestroy(...e) {
+    return this.lifeCycleDelegate = {
+      ...this.lifeCycleDelegate,
+      destroy: e.length > 0 ? e : void 0
+    }, this;
+  }
+  onCollision(...e) {
+    return this.collisionDelegate = {
+      collision: e.length > 0 ? e : void 0
+    }, this;
+  }
+  _setup(e) {
+    this.behaviorCallbackMap.setup.forEach((t) => {
+      t({ ...e, me: this });
+    }), this.lifeCycleDelegate.setup?.length && this.lifeCycleDelegate.setup.forEach((i) => {
+      i({ ...e, me: this });
+    });
+  }
+  async _loaded(e) {
+  }
+  _update(e) {
+    this.updateMaterials(e), this.lifeCycleDelegate.update?.length && this.lifeCycleDelegate.update.forEach((i) => {
+      i({ ...e, me: this });
+    }), this.behaviorCallbackMap.update.forEach((t) => {
+      t({ ...e, me: this });
+    });
+  }
+  _destroy(e) {
+    this.lifeCycleDelegate.destroy?.length && this.lifeCycleDelegate.destroy.forEach((i) => {
+      i({ ...e, me: this });
+    }), this.behaviorCallbackMap.destroy.forEach((t) => {
+      t({ ...e, me: this });
+    });
+  }
+  async _cleanup(e) {
+  }
+  _collision(e, t) {
+    this.collisionDelegate.collision?.length && this.collisionDelegate.collision.forEach((l) => {
+      l({ entity: this, other: e, globals: t });
+    }), this.behaviorCallbackMap.collision.forEach((i) => {
+      i({ entity: this, other: e, globals: t });
+    });
+  }
+  addBehavior(e) {
+    const t = e.handler;
+    return t && this.behaviorCallbackMap[e.type].push(t), this;
+  }
+  addBehaviors(e) {
+    return e.forEach((t) => {
+      const i = t.handler;
+      i && this.behaviorCallbackMap[t.type].push(i);
+    }), this;
+  }
+  updateMaterials(e) {
+    if (this.materials?.length)
+      for (const t of this.materials)
+        t instanceof s && t.uniforms && t.uniforms.iTime && (t.uniforms.iTime.value += e.delta);
+  }
+  buildInfo() {
+    const e = {};
+    return e.name = this.name, e.uuid = this.uuid, e.eid = this.eid.toString(), e;
+  }
+}
+export {
+  f as GameEntity
+};

package/dist/lib/entities/plane.js

@@ -0,0 +1,81 @@
+import { ColliderDesc as B } from "@dimforge/rapier3d-compat";
+import { Color as M, Vector3 as u, Vector2 as d, PlaneGeometry as C } from "three";
+import { GameEntity as D } from "./entity.js";
+import { EntityCollisionBuilder as E, EntityBuilder as P, EntityMeshBuilder as v } from "./builder.js";
+import { XZPlaneGeometry as z } from "../graphics/geometries/XZPlaneGeometry.js";
+import { createEntity as A } from "./create.js";
+const r = 4, p = {
+  tile: new d(10, 10),
+  repeat: new d(1, 1),
+  position: new u(0, 0, 0),
+  collision: {
+    static: !0
+  },
+  material: {
+    color: new M("#ffffff"),
+    shader: "standard"
+  },
+  subdivisions: r
+};
+class G extends E {
+  collider(e) {
+    const o = e.tile ?? new d(1, 1), s = e.subdivisions ?? r, t = new u(o.x, 1, o.y), i = e._builders?.meshBuilder?.heightData, h = new u(t.x, 1, t.z);
+    return B.heightfield(s, s, i, h);
+  }
+}
+class R extends v {
+  heightData = new Float32Array();
+  columnsRows = /* @__PURE__ */ new Map();
+  build(e) {
+    const o = e.tile ?? new d(1, 1), s = e.subdivisions ?? r, t = new u(o.x, 1, o.y), i = new z(t.x, t.z, s, s), h = new C(t.x, t.z, s, s), w = t.x / s, g = t.z / s, x = i.attributes.position.array, a = h.attributes.position.array, c = /* @__PURE__ */ new Map();
+    for (let n = 0; n < a.length; n += 3) {
+      let b = Math.floor(Math.abs(a[n] + t.x / 2) / w), m = Math.floor(Math.abs(a[n + 1] - t.z / 2) / g);
+      const y = Math.random() * 4;
+      a[n + 2] = y, x[n + 1] = y, c.get(m) || c.set(m, /* @__PURE__ */ new Map()), c.get(m).set(b, y);
+    }
+    return this.columnsRows = c, i;
+  }
+  postBuild() {
+    const e = [];
+    for (let o = 0; o <= r; ++o)
+      for (let s = 0; s <= r; ++s) {
+        const t = this.columnsRows.get(s);
+        if (!t)
+          continue;
+        const i = t.get(o);
+        e.push(i);
+      }
+    this.heightData = new Float32Array(e);
+  }
+}
+class S extends P {
+  createEntity(e) {
+    return new f(e);
+  }
+}
+const V = Symbol("Plane");
+class f extends D {
+  static type = V;
+  constructor(e) {
+    super(), this.options = { ...p, ...e };
+  }
+}
+async function U(...l) {
+  return A({
+    args: l,
+    defaultConfig: p,
+    EntityClass: f,
+    BuilderClass: S,
+    MeshBuilderClass: R,
+    CollisionBuilderClass: G,
+    entityType: f.type
+  });
+}
+export {
+  V as PLANE_TYPE,
+  S as PlaneBuilder,
+  G as PlaneCollisionBuilder,
+  R as PlaneMeshBuilder,
+  f as ZylemPlane,
+  U as plane
+};

package/dist/lib/entities/rect.js

@@ -0,0 +1,160 @@
+import { Vector2 as f, Group as D, CanvasTexture as R, LinearFilter as x, SpriteMaterial as V, Sprite as Y, ClampToEdgeWrapping as T, ShaderMaterial as y, Color as S, Mesh as z, PlaneGeometry as B, Vector3 as W } from "three";
+import { GameEntity as I } from "./entity.js";
+import { EntityBuilder as X } from "./builder.js";
+import { createEntity as q } from "./create.js";
+import { DebugDelegate as U } from "./delegates/debug.js";
+const k = {
+  position: void 0,
+  width: 120,
+  height: 48,
+  fillColor: "#FFFFFF",
+  strokeColor: null,
+  strokeWidth: 0,
+  radius: 0,
+  padding: 0,
+  stickToViewport: !0,
+  screenPosition: new f(24, 24),
+  zDistance: 1,
+  anchor: new f(0, 0)
+};
+class G extends X {
+  createEntity(t) {
+    return new _(t);
+  }
+}
+const O = Symbol("Rect");
+class _ extends I {
+  static type = O;
+  _sprite = null;
+  _mesh = null;
+  _texture = null;
+  _canvas = null;
+  _ctx = null;
+  _cameraRef = null;
+  _lastCanvasW = 0;
+  _lastCanvasH = 0;
+  constructor(t) {
+    super(), this.options = { ...k, ...t }, this.group = new D(), this.createSprite(), this.lifeCycleDelegate = {
+      setup: [this.rectSetup.bind(this)],
+      update: [this.rectUpdate.bind(this)]
+    };
+  }
+  createSprite() {
+    this._canvas = document.createElement("canvas"), this._ctx = this._canvas.getContext("2d"), this._texture = new R(this._canvas), this._texture.minFilter = x, this._texture.magFilter = x;
+    const t = new V({
+      map: this._texture,
+      transparent: !0,
+      depthTest: !1,
+      depthWrite: !1,
+      alphaTest: 0.5
+    });
+    this._sprite = new Y(t), this.group?.add(this._sprite), this.redrawRect();
+  }
+  redrawRect() {
+    if (!this._canvas || !this._ctx)
+      return;
+    const t = Math.max(2, Math.floor(this.options.width ?? 120)), e = Math.max(2, Math.floor(this.options.height ?? 48)), s = this.options.padding ?? 0, i = this.options.strokeWidth ?? 0, a = t + s * 2 + i, r = e + s * 2 + i, o = Math.max(2, a), n = Math.max(2, r), h = o !== this._lastCanvasW || n !== this._lastCanvasH;
+    this._canvas.width = o, this._canvas.height = n, this._lastCanvasW = o, this._lastCanvasH = n, this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
+    const u = Math.max(0, this.options.radius ?? 0), d = Math.floor(s + i / 2), m = Math.floor(s + i / 2), g = Math.floor(t), p = Math.floor(e);
+    if (this._ctx.beginPath(), u > 0 ? this.roundedRectPath(this._ctx, d, m, g, p, u) : this._ctx.rect(d, m, g, p), this.options.fillColor && (this._ctx.fillStyle = this.toCssColor(this.options.fillColor), this._ctx.fill()), this.options.strokeColor && i > 0 && (this._ctx.lineWidth = i, this._ctx.strokeStyle = this.toCssColor(this.options.strokeColor), this._ctx.stroke()), this._texture) {
+      if (h && (this._texture.dispose(), this._texture = new R(this._canvas), this._texture.minFilter = x, this._texture.magFilter = x, this._texture.wrapS = T, this._texture.wrapT = T, this._sprite && this._sprite.material instanceof y)) {
+        const c = this._sprite.material;
+        c.uniforms?.tDiffuse && (c.uniforms.tDiffuse.value = this._texture), c.uniforms?.iResolution && c.uniforms.iResolution.value.set(this._canvas.width, this._canvas.height, 1);
+      }
+      this._texture.image = this._canvas, this._texture.needsUpdate = !0, this._sprite && this._sprite.material && (this._sprite.material.map = this._texture, this._sprite.material.needsUpdate = !0);
+    }
+  }
+  roundedRectPath(t, e, s, i, a, r) {
+    const o = Math.min(r, Math.floor(Math.min(i, a) / 2));
+    t.moveTo(e + o, s), t.lineTo(e + i - o, s), t.quadraticCurveTo(e + i, s, e + i, s + o), t.lineTo(e + i, s + a - o), t.quadraticCurveTo(e + i, s + a, e + i - o, s + a), t.lineTo(e + o, s + a), t.quadraticCurveTo(e, s + a, e, s + a - o), t.lineTo(e, s + o), t.quadraticCurveTo(e, s, e + o, s);
+  }
+  toCssColor(t) {
+    return typeof t == "string" ? t : `#${(t instanceof S ? t : new S(t)).getHexString()}`;
+  }
+  rectSetup(t) {
+    if (this._cameraRef = t.camera, this.options.stickToViewport && this._cameraRef && this._cameraRef.camera.add(this.group), this.materials?.length && this._sprite) {
+      const e = this.materials[0];
+      e instanceof y && (e.transparent = !0, e.depthTest = !1, e.depthWrite = !1, this._texture && (e.uniforms?.tDiffuse && (e.uniforms.tDiffuse.value = this._texture), e.uniforms?.iResolution && this._canvas && e.uniforms.iResolution.value.set(this._canvas.width, this._canvas.height, 1)), this._mesh = new z(new B(1, 1), e), this.group?.add(this._mesh), this._sprite.visible = !1);
+    }
+  }
+  rectUpdate(t) {
+    if (this._sprite) {
+      if (this._cameraRef && this.options.bounds) {
+        this._cameraRef.renderer.domElement;
+        const e = this.computeScreenBoundsFromOptions(this.options.bounds);
+        if (e) {
+          const { x: s, y: i, width: a, height: r } = e, o = Math.max(2, Math.floor(a)), n = Math.max(2, Math.floor(r)), h = o !== (this.options.width ?? 0) || n !== (this.options.height ?? 0);
+          this.options.screenPosition = new f(Math.floor(s), Math.floor(i)), this.options.width = o, this.options.height = n, this.options.anchor = new f(0, 0), h && this.redrawRect();
+        }
+      }
+      this.options.stickToViewport && this._cameraRef && this.updateStickyTransform();
+    }
+  }
+  updateStickyTransform() {
+    if (!this._sprite || !this._cameraRef)
+      return;
+    const t = this._cameraRef.camera, e = this._cameraRef.renderer.domElement, s = e.clientWidth, i = e.clientHeight, a = (this.options.screenPosition ?? new f(24, 24)).x, r = (this.options.screenPosition ?? new f(24, 24)).y, o = Math.max(1e-3, this.options.zDistance ?? 1);
+    let n = 1, h = 1;
+    if (t.isPerspectiveCamera) {
+      const l = t, w = Math.tan(l.fov * Math.PI / 180 / 2) * o;
+      n = w * l.aspect, h = w;
+    } else if (t.isOrthographicCamera) {
+      const l = t;
+      n = (l.right - l.left) / 2, h = (l.top - l.bottom) / 2;
+    }
+    const u = a / s * 2 - 1, d = 1 - r / i * 2, m = u * n, g = d * h;
+    let p = 1, c = 1;
+    if (this._canvas) {
+      const w = h * 2 / i, C = this._canvas.height;
+      c = Math.max(1e-4, C * w);
+      const P = this._canvas.width / this._canvas.height;
+      p = c * P, this._sprite.scale.set(p, c, 1), this._mesh && this._mesh.scale.set(p, c, 1);
+    }
+    const M = this.options.anchor ?? new f(0, 0), H = Math.min(100, Math.max(0, M.x)) / 100, b = Math.min(100, Math.max(0, M.y)) / 100, E = (0.5 - H) * p, F = (b - 0.5) * c;
+    this.group?.position.set(m + E, g + F, -o);
+  }
+  worldToScreen(t) {
+    if (!this._cameraRef)
+      return { x: 0, y: 0 };
+    const e = this._cameraRef.camera, s = this._cameraRef.renderer.domElement, i = t.clone().project(e), a = (i.x + 1) / 2 * s.clientWidth, r = (1 - i.y) / 2 * s.clientHeight;
+    return { x: a, y: r };
+  }
+  computeScreenBoundsFromOptions(t) {
+    if (!this._cameraRef)
+      return null;
+    if (this._cameraRef.renderer.domElement, t.screen)
+      return { ...t.screen };
+    if (t.world) {
+      const { left: e, right: s, top: i, bottom: a, z: r = 0 } = t.world, o = this.worldToScreen(new W(e, i, r)), n = this.worldToScreen(new W(s, a, r)), h = Math.min(o.x, n.x), u = Math.min(o.y, n.y), d = Math.abs(n.x - o.x), m = Math.abs(n.y - o.y);
+      return { x: h, y: u, width: d, height: m };
+    }
+    return null;
+  }
+  updateRect(t) {
+    this.options = { ...this.options, ...t }, this.redrawRect(), this.options.stickToViewport && this._cameraRef && this.updateStickyTransform();
+  }
+  buildInfo() {
+    return {
+      ...new U(this).buildDebugInfo(),
+      type: String(_.type),
+      width: this.options.width ?? 0,
+      height: this.options.height ?? 0,
+      sticky: this.options.stickToViewport
+    };
+  }
+}
+async function K(...v) {
+  return q({
+    args: v,
+    defaultConfig: { ...k },
+    EntityClass: _,
+    BuilderClass: G,
+    entityType: _.type
+  });
+}
+export {
+  O as RECT_TYPE,
+  G as RectBuilder,
+  _ as ZylemRect,
+  K as rect
+};

package/dist/lib/entities/sphere.js

@@ -0,0 +1,68 @@
+import { ColliderDesc as l } from "@dimforge/rapier3d-compat";
+import { Color as n, Vector3 as a, SphereGeometry as d } from "three";
+import { GameEntity as u } from "./entity.js";
+import { EntityCollisionBuilder as c, EntityBuilder as p, EntityMeshBuilder as f } from "./builder.js";
+import { DebugDelegate as m } from "./delegates/debug.js";
+import { createEntity as y } from "./create.js";
+const o = {
+  radius: 1,
+  position: new a(0, 0, 0),
+  collision: {
+    static: !1
+  },
+  material: {
+    color: new n("#ffffff"),
+    shader: "standard"
+  }
+};
+class h extends c {
+  collider(e) {
+    const t = e.radius ?? 1;
+    return l.ball(t);
+  }
+}
+class C extends f {
+  build(e) {
+    const t = e.radius ?? 1;
+    return new d(t);
+  }
+}
+class E extends p {
+  createEntity(e) {
+    return new r(e);
+  }
+}
+const B = Symbol("Sphere");
+class r extends u {
+  static type = B;
+  constructor(e) {
+    super(), this.options = { ...o, ...e };
+  }
+  buildInfo() {
+    const t = new m(this).buildDebugInfo(), i = this.options.radius ?? 1;
+    return {
+      ...t,
+      type: String(r.type),
+      radius: i.toFixed(2)
+    };
+  }
+}
+async function I(...s) {
+  return y({
+    args: s,
+    defaultConfig: o,
+    EntityClass: r,
+    BuilderClass: E,
+    MeshBuilderClass: C,
+    CollisionBuilderClass: h,
+    entityType: r.type
+  });
+}
+export {
+  B as SPHERE_TYPE,
+  E as SphereBuilder,
+  h as SphereCollisionBuilder,
+  C as SphereMeshBuilder,
+  r as ZylemSphere,
+  I as sphere
+};

package/dist/lib/entities/sprite.js

@@ -0,0 +1,118 @@
+import { ColliderDesc as h } from "@dimforge/rapier3d-compat";
+import { Color as d, Vector3 as c, TextureLoader as f, SpriteMaterial as y, Sprite as A, Group as x, Quaternion as S, Euler as I } from "three";
+import { GameEntity as w } from "./entity.js";
+import { EntityCollisionBuilder as z, EntityBuilder as E } from "./builder.js";
+import { createEntity as g } from "./create.js";
+const l = {
+  size: new c(1, 1, 1),
+  position: new c(0, 0, 0),
+  collision: {
+    static: !1
+  },
+  material: {
+    color: new d("#ffffff"),
+    shader: "standard"
+  },
+  images: [],
+  animations: []
+};
+class C extends z {
+  collider(t) {
+    const i = t.collisionSize || t.size || new c(1, 1, 1), e = { x: i.x / 2, y: i.y / 2, z: i.z / 2 };
+    return h.cuboid(e.x, e.y, e.z);
+  }
+}
+class T extends E {
+  createEntity(t) {
+    return new p(t);
+  }
+}
+const b = Symbol("Sprite");
+class p extends w {
+  static type = b;
+  sprites = [];
+  spriteMap = /* @__PURE__ */ new Map();
+  currentSpriteIndex = 0;
+  animations = /* @__PURE__ */ new Map();
+  currentAnimation = null;
+  currentAnimationFrame = "";
+  currentAnimationIndex = 0;
+  currentAnimationTime = 0;
+  constructor(t) {
+    super(), this.options = { ...l, ...t }, this.createSpritesFromImages(t?.images || []), this.createAnimations(t?.animations || []), this.lifeCycleDelegate = {
+      update: [this.spriteUpdate.bind(this)],
+      destroy: [this.spriteDestroy.bind(this)]
+    };
+  }
+  createSpritesFromImages(t) {
+    const i = new f();
+    t.forEach((e, n) => {
+      const r = i.load(e.file), s = new y({
+        map: r,
+        transparent: !0
+      }), a = new A(s);
+      a.position.normalize(), this.sprites.push(a), this.spriteMap.set(e.name, n);
+    }), this.group = new x(), this.group.add(...this.sprites);
+  }
+  createAnimations(t) {
+    t.forEach((i) => {
+      const { name: e, frames: n, loop: r = !1, speed: s = 1 } = i, a = {
+        frames: n.map((u, m) => ({
+          key: u,
+          index: m,
+          time: (typeof s == "number" ? s : s[m]) * (m + 1),
+          duration: typeof s == "number" ? s : s[m]
+        })),
+        loop: r
+      };
+      this.animations.set(e, a);
+    });
+  }
+  setSprite(t) {
+    const e = this.spriteMap.get(t) ?? 0;
+    this.currentSpriteIndex = e, this.sprites.forEach((n, r) => {
+      n.visible = this.currentSpriteIndex === r;
+    });
+  }
+  setAnimation(t, i) {
+    const e = this.animations.get(t);
+    if (!e)
+      return;
+    const { loop: n, frames: r } = e, s = r[this.currentAnimationIndex];
+    t === this.currentAnimation ? (this.currentAnimationFrame = s.key, this.currentAnimationTime += i, this.setSprite(this.currentAnimationFrame)) : this.currentAnimation = t, this.currentAnimationTime > s.time && this.currentAnimationIndex++, this.currentAnimationIndex >= r.length && (n ? (this.currentAnimationIndex = 0, this.currentAnimationTime = 0) : this.currentAnimationTime = r[this.currentAnimationIndex].time);
+  }
+  async spriteUpdate(t) {
+    this.sprites.forEach((i) => {
+      if (i.material) {
+        const e = this.body?.rotation();
+        if (e) {
+          const n = new S(e.x, e.y, e.z, e.w), r = new I().setFromQuaternion(n, "XYZ");
+          i.material.rotation = r.z;
+        }
+        i.scale.set(this.options.size?.x ?? 1, this.options.size?.y ?? 1, this.options.size?.z ?? 1);
+      }
+    });
+  }
+  async spriteDestroy(t) {
+    this.sprites.forEach((i) => {
+      i.removeFromParent();
+    }), this.group?.remove(...this.sprites), this.group?.removeFromParent();
+  }
+}
+async function P(...o) {
+  return g({
+    args: o,
+    defaultConfig: l,
+    EntityClass: p,
+    BuilderClass: T,
+    CollisionBuilderClass: C,
+    entityType: p.type
+  });
+}
+export {
+  b as SPRITE_TYPE,
+  T as SpriteBuilder,
+  C as SpriteCollisionBuilder,
+  p as ZylemSprite,
+  P as sprite
+};