@zylem/game-lib 0.3.14 → 0.3.16

package/dist/lib/game/game.js

@@ -0,0 +1,157 @@
+import { BaseNode as h } from "../core/base-node.js";
+import { ZylemGame as c } from "./zylem-game.js";
+import { Stage as o, stage as l } from "../stage/stage.js";
+import { setPaused as r } from "../debug/debug-state.js";
+import { GameEntity as u } from "../entities/entity.js";
+import { getGlobalState as m, setGlobalState as p } from "./game-state.js";
+const f = {
+  id: "zylem",
+  globals: {},
+  stages: [
+    l()
+  ]
+};
+function d(n) {
+  let e = { ...f };
+  const t = [], s = [], a = [];
+  return Object.values(n).forEach((i) => {
+    if (i instanceof o)
+      s.push(i);
+    else if (i instanceof u)
+      a.push(i);
+    else if (i instanceof h)
+      a.push(i);
+    else if (i.constructor.name === "Object" && typeof i == "object") {
+      const g = Object.assign(f, { ...i });
+      t.push(g);
+    }
+  }), t.forEach((i) => {
+    e = Object.assign(e, { ...i });
+  }), s.forEach((i) => {
+    i.addEntities(a);
+  }), s.length ? e.stages = s : e.stages[0].addEntities(a), e;
+}
+class R {
+  gameRef = null;
+  options;
+  pendingGlobalChangeHandlers = [];
+  update = () => {
+  };
+  setup = () => {
+  };
+  destroy = () => {
+  };
+  refErrorMessage = "lost reference to game";
+  constructor(e) {
+    this.options = e;
+  }
+  async start() {
+    const e = await this.load();
+    return this.gameRef = e, this.setOverrides(), e.start(), this;
+  }
+  async load() {
+    console.log("loading game", this.options);
+    const e = d(this.options), t = new c(e, this);
+    return await t.loadStage(e.stages[0]), t;
+  }
+  setOverrides() {
+    if (!this.gameRef) {
+      console.error(this.refErrorMessage);
+      return;
+    }
+    if (this.gameRef.customSetup = this.setup, this.gameRef.customUpdate = this.update, this.gameRef.customDestroy = this.destroy, this.pendingGlobalChangeHandlers.length) {
+      for (const { key: e, callback: t } of this.pendingGlobalChangeHandlers)
+        this.gameRef.onGlobalChange(e, t);
+      this.pendingGlobalChangeHandlers = [];
+    }
+  }
+  async pause() {
+    r(!0);
+  }
+  async resume() {
+    r(!1), this.gameRef && (this.gameRef.previousTimeStamp = 0, this.gameRef.timer.reset());
+  }
+  async reset() {
+    if (!this.gameRef) {
+      console.error(this.refErrorMessage);
+      return;
+    }
+    await this.gameRef.loadStage(this.gameRef.stages[0]);
+  }
+  async nextStage() {
+    if (!this.gameRef) {
+      console.error(this.refErrorMessage);
+      return;
+    }
+    const e = this.gameRef.currentStageId, t = this.gameRef.stages.findIndex((a) => a.stageRef.uuid === e), s = this.gameRef.stages[t + 1];
+    if (!s) {
+      console.error("next stage called on last stage");
+      return;
+    }
+    await this.gameRef.loadStage(s);
+  }
+  async previousStage() {
+    if (!this.gameRef) {
+      console.error(this.refErrorMessage);
+      return;
+    }
+    const e = this.gameRef.currentStageId, t = this.gameRef.stages.findIndex((a) => a.stageRef.uuid === e), s = this.gameRef.stages[t - 1];
+    if (!s) {
+      console.error("previous stage called on first stage");
+      return;
+    }
+    await this.gameRef.loadStage(s);
+  }
+  async goToStage() {
+  }
+  async end() {
+  }
+  add(...e) {
+    for (const t of e)
+      if (t) {
+        if (t instanceof o) {
+          this.gameRef ? (this.gameRef.stages.push(t), this.gameRef.stageMap.set(t.stageRef.uuid, t)) : this.options.push(t);
+          continue;
+        }
+        if (typeof t == "function") {
+          try {
+            const s = t();
+            s instanceof o ? this.gameRef ? (this.gameRef.stages.push(s), this.gameRef.stageMap.set(s.stageRef.uuid, s)) : this.options.push(s) : s && typeof s.then == "function" && s.then((a) => {
+              a instanceof o && (this.gameRef ? (this.gameRef.stages.push(a), this.gameRef.stageMap.set(a.stageRef.uuid, a)) : this.options.push(a));
+            }).catch((a) => console.error("Failed to add async stage", a));
+          } catch (s) {
+            console.error("Error executing stage factory", s);
+          }
+          continue;
+        }
+        t && typeof t.then == "function" && t.then((s) => {
+          s instanceof o && (this.gameRef ? (this.gameRef.stages.push(s), this.gameRef.stageMap.set(s.stageRef.uuid, s)) : this.options.push(s));
+        }).catch((s) => console.error("Failed to add async stage", s));
+      }
+    return this;
+  }
+  getGlobal(e) {
+    return this.gameRef ? this.gameRef.getGlobal(e) : m(e);
+  }
+  setGlobal(e, t) {
+    if (this.gameRef) {
+      this.gameRef.setGlobal(e, t);
+      return;
+    }
+    p(e, t);
+  }
+  onGlobalChange(e, t) {
+    if (this.gameRef) {
+      this.gameRef.onGlobalChange(e, t);
+      return;
+    }
+    this.pendingGlobalChangeHandlers.push({ key: e, callback: t });
+  }
+}
+function M(...n) {
+  return new R(n);
+}
+export {
+  R as Game,
+  M as game
+};

package/dist/lib/game/zylem-game.d.ts

@@ -22,6 +22,8 @@ export declare class ZylemGame<TGlobals extends Record<string, BasicTypes> = Glo
     statsRef: {
         begin: () => void;
         end: () => void;
+        showPanel: (panel: number) => void;
+        dom: HTMLElement;
     } | null;
     defaultCamera: ZylemCamera | null;
     static FRAME_LIMIT: number;

package/dist/lib/game/zylem-game.js

@@ -0,0 +1,107 @@
+import { state as i, getGlobalState as r, setGlobalState as n } from "./game-state.js";
+import { setDebugFlag as u, isPaused as h } from "../debug/debug-state.js";
+import { InputManager as g } from "../input/input-manager.js";
+import { Timer as c } from "../core/three-addons/Timer.js";
+import { subscribe as m } from "valtio/vanilla";
+import f from "stats.js";
+class l {
+  id;
+  initialGlobals = {};
+  customSetup = null;
+  customUpdate = null;
+  customDestroy = null;
+  stages = [];
+  stageMap = /* @__PURE__ */ new Map();
+  currentStageId = "";
+  previousTimeStamp = 0;
+  totalTime = 0;
+  timer;
+  inputManager;
+  wrapperRef;
+  statsRef = null;
+  defaultCamera = null;
+  static FRAME_LIMIT = 120;
+  static FRAME_DURATION = 1e3 / l.FRAME_LIMIT;
+  static MAX_DELTA_SECONDS = 1 / 30;
+  constructor(t, e) {
+    this.wrapperRef = e, this.inputManager = new g(t.input), this.timer = new c(), this.timer.connect(document), this.id = t.id, this.stages = t.stages || [], this.setGlobals(t), t.debug && (this.statsRef = new f(), this.statsRef.showPanel(0), this.statsRef.dom.style.position = "absolute", this.statsRef.dom.style.bottom = "0", this.statsRef.dom.style.right = "0", this.statsRef.dom.style.top = "auto", this.statsRef.dom.style.left = "auto", document.body.appendChild(this.statsRef.dom));
+  }
+  async loadStage(t) {
+    this.unloadCurrentStage();
+    const e = t.options[0];
+    await t.load(this.id, e?.camera), this.stageMap.set(t.stageRef.uuid, t), this.currentStageId = t.stageRef.uuid, this.defaultCamera = t.stageRef.cameraRef;
+  }
+  unloadCurrentStage() {
+    if (!this.currentStageId)
+      return;
+    const t = this.getStage(this.currentStageId);
+    if (t) {
+      if (t?.stageRef)
+        try {
+          t.stageRef.nodeDestroy({
+            me: t.stageRef,
+            globals: i.globals
+          });
+        } catch (e) {
+          console.error("Failed to destroy previous stage", e);
+        }
+      this.stageMap.delete(this.currentStageId);
+    }
+  }
+  setGlobals(t) {
+    u(t.debug), this.initialGlobals = { ...t.globals };
+    for (const e in this.initialGlobals) {
+      const s = this.initialGlobals[e];
+      s === void 0 && console.error(`global ${e} is undefined`), this.setGlobal(e, s);
+    }
+  }
+  params() {
+    const t = this.currentStage(), e = this.timer.getDelta(), s = this.inputManager.getInputs(e), a = t?.stageRef?.cameraRef || this.defaultCamera;
+    return {
+      delta: e,
+      inputs: s,
+      globals: i.globals,
+      me: this,
+      camera: a
+    };
+  }
+  start() {
+    const t = this.currentStage(), e = this.params();
+    t.start({ ...e, me: t.stageRef }), this.customSetup && this.customSetup(e), this.loop(0);
+  }
+  loop(t) {
+    if (this.statsRef && this.statsRef.begin(), !h()) {
+      this.timer.update(t);
+      const e = this.currentStage(), s = this.params(), a = Math.min(s.delta, l.MAX_DELTA_SECONDS), o = { ...s, delta: a };
+      this.customUpdate && this.customUpdate(o), e && e.stageRef.nodeUpdate({ ...o, me: e.stageRef }), this.totalTime += o.delta, i.time = this.totalTime, this.previousTimeStamp = t;
+    }
+    this.statsRef && this.statsRef.end(), this.outOfLoop(), requestAnimationFrame(this.loop.bind(this));
+  }
+  outOfLoop() {
+    const t = this.currentStage();
+    t && t.stageRef.outOfLoop();
+  }
+  getStage(t) {
+    return this.stageMap.get(t);
+  }
+  currentStage() {
+    return this.getStage(this.currentStageId);
+  }
+  getGlobal(t) {
+    return r(t);
+  }
+  setGlobal(t, e) {
+    n(t, e);
+  }
+  onGlobalChange(t, e) {
+    let s = r(t);
+    m(i, () => {
+      const a = r(t);
+      a !== s && (s = a, e(a));
+    });
+  }
+}
+export {
+  l as ZylemGame,
+  l as default
+};

package/dist/lib/graphics/geometries/XZPlaneGeometry.js

@@ -0,0 +1,34 @@
+import { BufferGeometry as _, Float32BufferAttribute as f } from "three";
+class b extends _ {
+  constructor(t = 1, h = 1, l = 1, a = 1) {
+    super(), this.type = "XZPlaneGeometry", this.parameters = {
+      width: t,
+      height: h,
+      widthSegments: l,
+      heightSegments: a
+    };
+    const d = t / 2, x = h / 2, n = Math.floor(l), i = Math.floor(a), r = n + 1, w = i + 1, A = t / n, v = h / i, u = [], m = [], g = [], p = [];
+    for (let s = 0; s < w; s++) {
+      const e = s * v - x;
+      for (let o = 0; o < r; o++) {
+        const c = o * A - d;
+        m.push(c, 0, e), g.push(0, 1, 0), p.push(o / n), p.push(1 - s / i);
+      }
+    }
+    for (let s = 0; s < i; s++)
+      for (let e = 0; e < n; e++) {
+        const o = e + r * s, c = e + r * (s + 1), X = e + 1 + r * (s + 1), y = e + 1 + r * s;
+        u.push(o, c, y), u.push(c, X, y);
+      }
+    this.setIndex(u), this.setAttribute("position", new f(m, 3)), this.setAttribute("normal", new f(g, 3)), this.setAttribute("uv", new f(p, 2));
+  }
+  copy(t) {
+    return super.copy(t), this.parameters = Object.assign({}, t.parameters), this;
+  }
+  static fromJSON(t) {
+    return new b(t.width, t.height, t.widthSegments, t.heightSegments);
+  }
+}
+export {
+  b as XZPlaneGeometry
+};

package/dist/lib/graphics/material.js

@@ -0,0 +1,64 @@
+import { Color as n, Vector2 as m, TextureLoader as c, RepeatWrapping as o, MeshPhongMaterial as p, MeshStandardMaterial as u, ShaderMaterial as f, Vector3 as d } from "three";
+import { shortHash as M, sortedStringify as w } from "../core/utility.js";
+import h from "../core/preset-shader.js";
+class i {
+  static batchMaterialMap = /* @__PURE__ */ new Map();
+  materials = [];
+  batchMaterial(t, a) {
+    const r = M(w(t)), e = i.batchMaterialMap.get(r);
+    if (e) {
+      const s = e.geometryMap.get(a);
+      s ? e.geometryMap.set(a, s + 1) : e.geometryMap.set(a, 1);
+    } else
+      i.batchMaterialMap.set(r, {
+        geometryMap: /* @__PURE__ */ new Map([[a, 1]]),
+        material: this.materials[0]
+      });
+  }
+  async build(t, a) {
+    const { path: r, repeat: e, color: s, shader: l } = t;
+    l && this.withShader(l), s && this.withColor(s), await this.setTexture(r ?? null, e), this.materials.length === 0 && this.setColor(new n("#ffffff")), this.batchMaterial(t, a);
+  }
+  withColor(t) {
+    return this.setColor(t), this;
+  }
+  withShader(t) {
+    return this.setShader(t), this;
+  }
+  async setTexture(t = null, a = new m(1, 1)) {
+    if (!t)
+      return;
+    const e = await new c().loadAsync(t);
+    e.repeat = a, e.wrapS = o, e.wrapT = o;
+    const s = new p({
+      map: e
+    });
+    this.materials.push(s);
+  }
+  setColor(t) {
+    const a = new u({
+      color: t,
+      emissiveIntensity: 0.5,
+      lightMapIntensity: 0.5,
+      fog: !0
+    });
+    this.materials.push(a);
+  }
+  setShader(t) {
+    const { fragment: a, vertex: r } = h.get(t) ?? h.get("standard"), e = new f({
+      uniforms: {
+        iResolution: { value: new d(1, 1, 1) },
+        iTime: { value: 0 },
+        tDiffuse: { value: null },
+        tDepth: { value: null },
+        tNormal: { value: null }
+      },
+      vertexShader: r,
+      fragmentShader: a
+    });
+    this.materials.push(e);
+  }
+}
+export {
+  i as MaterialBuilder
+};

package/dist/lib/graphics/mesh.js

@@ -0,0 +1,14 @@
+import { Mesh as n } from "three";
+class h {
+  _build(t, r, s) {
+    const { batched: i, material: a } = t;
+    i && console.warn("warning: mesh batching is not implemented");
+    const e = new n(r, s.at(-1));
+    return e.position.set(0, 0, 0), e.castShadow = !0, e.receiveShadow = !0, e;
+  }
+  _postBuild() {
+  }
+}
+export {
+  h as MeshBuilder
+};

package/dist/lib/graphics/render-pass.js

@@ -0,0 +1,56 @@
+import * as s from "three";
+import { WebGLRenderTarget as i } from "three";
+import n from "./shaders/fragment/standard.glsl.js";
+import l from "./shaders/vertex/standard.glsl.js";
+import { Pass as o, FullScreenQuad as d } from "three/addons/postprocessing/Pass.js";
+class f extends o {
+  fsQuad;
+  resolution;
+  scene;
+  camera;
+  rgbRenderTarget;
+  normalRenderTarget;
+  normalMaterial;
+  constructor(e, r, a) {
+    super(), this.resolution = e, this.fsQuad = new d(this.material()), this.scene = r, this.camera = a, this.rgbRenderTarget = new i(e.x * 4, e.y * 4), this.normalRenderTarget = new i(e.x * 4, e.y * 4), this.normalMaterial = new s.MeshNormalMaterial();
+  }
+  render(e, r) {
+    e.setRenderTarget(this.rgbRenderTarget), e.render(this.scene, this.camera);
+    const a = this.scene.overrideMaterial;
+    e.setRenderTarget(this.normalRenderTarget), this.scene.overrideMaterial = this.normalMaterial, e.render(this.scene, this.camera), this.scene.overrideMaterial = a;
+    const t = this.fsQuad.material.uniforms;
+    t.tDiffuse.value = this.rgbRenderTarget.texture, t.tDepth.value = this.rgbRenderTarget.depthTexture, t.tNormal.value = this.normalRenderTarget.texture, t.iTime.value += 0.01, this.renderToScreen ? e.setRenderTarget(null) : e.setRenderTarget(r), this.fsQuad.render(e);
+  }
+  material() {
+    return new s.ShaderMaterial({
+      uniforms: {
+        iTime: { value: 0 },
+        tDiffuse: { value: null },
+        tDepth: { value: null },
+        tNormal: { value: null },
+        resolution: {
+          value: new s.Vector4(this.resolution.x, this.resolution.y, 1 / this.resolution.x, 1 / this.resolution.y)
+        }
+      },
+      vertexShader: l,
+      fragmentShader: n
+    });
+  }
+  dispose() {
+    try {
+      this.fsQuad?.dispose?.();
+    } catch {
+    }
+    try {
+      this.rgbRenderTarget?.dispose?.(), this.normalRenderTarget?.dispose?.();
+    } catch {
+    }
+    try {
+      this.normalMaterial?.dispose?.();
+    } catch {
+    }
+  }
+}
+export {
+  f as default
+};

package/dist/lib/graphics/shaders/fragment/debug.glsl.js

@@ -0,0 +1,23 @@
+var e = `varying vec3 vBarycentric;
+uniform vec3 baseColor;
+uniform vec3 wireframeColor;
+uniform float wireframeThickness;
+
+float edgeFactor() {
+    vec3 d = fwidth(vBarycentric);
+    vec3 a3 = smoothstep(vec3(0.0), d * wireframeThickness, vBarycentric);
+    return min(min(a3.x, a3.y), a3.z);
+}
+
+void main() {
+    float edge = edgeFactor();
+
+    vec3 wireColor = wireframeColor;
+
+    vec3 finalColor = mix(wireColor, baseColor, edge);
+    
+    gl_FragColor = vec4(finalColor, 1.0);
+}`;
+export {
+  e as default
+};

package/dist/lib/graphics/shaders/fragment/fire.glsl.js

@@ -0,0 +1,52 @@
+var n = `#include <common>
+ 
+uniform vec3 iResolution;
+uniform float iTime;
+uniform vec2 iOffset;
+varying vec2 vUv;
+
+float snoise(vec3 uv, float res)
+{
+	const vec3 s = vec3(1e0, 1e2, 1e3);
+	
+	uv *= res;
+	
+	vec3 uv0 = floor(mod(uv, res))*s;
+	vec3 uv1 = floor(mod(uv+vec3(1.), res))*s;
+	
+	vec3 f = fract(uv); f = f*f*(3.0-2.0*f);
+
+	vec4 v = vec4(uv0.x+uv0.y+uv0.z, uv1.x+uv0.y+uv0.z,
+		      	  uv0.x+uv1.y+uv0.z, uv1.x+uv1.y+uv0.z);
+
+	vec4 r = fract(sin(v*1e-1)*1e3);
+	float r0 = mix(mix(r.x, r.y, f.x), mix(r.z, r.w, f.x), f.y);
+	
+	r = fract(sin((v + uv1.z - uv0.z)*1e-1)*1e3);
+	float r1 = mix(mix(r.x, r.y, f.x), mix(r.z, r.w, f.x), f.y);
+	
+	return mix(r0, r1, f.z)*2.-1.;
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
+	vec2 p = -.5 + fragCoord.xy / iResolution.xy;
+	p.x *= iResolution.x/iResolution.y;
+	
+	float color = 3.0 - (3.*length(2.*p));
+	
+	vec3 coord = vec3(atan(p.x,p.y)/6.2832+.5, length(p)*.4, .5);
+	
+	for(int i = 1; i <= 7; i++)
+	{
+		float power = pow(2.0, float(i));
+		color += (1.5 / power) * snoise(coord + vec3(0.,-iTime*.05, iTime*.01), power*16.);
+	}
+	fragColor = vec4( color, pow(max(color,0.),2.)*0.4, pow(max(color,0.),3.)*0.15 , 1.0);
+}
+
+void main() {
+  mainImage(gl_FragColor, vUv);
+}`;
+export {
+  n as default
+};

package/dist/lib/graphics/shaders/fragment/standard.glsl.js

@@ -0,0 +1,11 @@
+var e = `uniform sampler2D tDiffuse;
+varying vec2 vUv;
+
+void main() {
+	vec4 texel = texture2D( tDiffuse, vUv );
+
+	gl_FragColor = texel;
+}`;
+export {
+  e as default
+};

package/dist/lib/graphics/shaders/fragment/stars.glsl.js

@@ -0,0 +1,44 @@
+var n = `#include <common>
+
+uniform vec3 iResolution;
+uniform float iTime;
+varying vec2 vUv;
+
+vec3 palette( float t ) {
+    vec3 a = vec3(0.5, 0.5, 0.5);
+    vec3 b = vec3(0.5, 0.5, 0.5);
+    vec3 c = vec3(1.0, 1.0, 1.0);
+    vec3 d = vec3(0.263,0.416,0.557);
+
+    return a + b*cos( 6.28318*(c*t+d) );
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
+    vec2 uv = (fragCoord * 2.0 - iResolution.xy) / iResolution.y;
+    vec2 uv0 = uv;
+    vec3 finalColor = vec3(0.0);
+    
+    for (float i = 0.0; i < 4.0; i++) {
+        uv = fract(uv * 1.5) - 0.5;
+
+        float d = length(uv) * exp(-length(uv0));
+
+        vec3 col = palette(length(uv0) + i*.4 + iTime*.4);
+
+        d = sin(d*5. + iTime)/5.;
+        d = abs(d);
+
+        d = pow(0.01 / d, 1.2);
+
+        finalColor += col * d;
+    }
+        
+    fragColor = vec4(finalColor, 1.0);
+}
+ 
+void main() {
+  mainImage(gl_FragColor, vUv);
+}`;
+export {
+  n as default
+};

package/dist/lib/graphics/shaders/vertex/debug.glsl.js

@@ -0,0 +1,15 @@
+var e = `varying vec3 vBarycentric;
+
+void main() {
+    vec3 barycentric = vec3(0.0);
+    int index = gl_VertexID % 3;
+    if (index == 0) barycentric = vec3(1.0, 0.0, 0.0);
+    else if (index == 1) barycentric = vec3(0.0, 1.0, 0.0);
+    else barycentric = vec3(0.0, 0.0, 1.0);
+    vBarycentric = barycentric;
+    
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}`;
+export {
+  e as default
+};

package/dist/lib/graphics/shaders/vertex/object-shader.glsl.js

@@ -0,0 +1,11 @@
+var i = `uniform vec2 uvScale;
+varying vec2 vUv;
+
+void main() {
+	vUv = uv;
+	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
+	gl_Position = projectionMatrix * mvPosition;
+}`;
+export {
+  i as default
+};

package/dist/lib/graphics/shaders/vertex/standard.glsl.js

@@ -0,0 +1,9 @@
+var i = `varying vec2 vUv;
+
+void main() {
+	vUv = uv;
+	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+}`;
+export {
+  i as default
+};

package/dist/lib/graphics/zylem-scene.d.ts

@@ -1,15 +1,15 @@
 import { Scene, Color, Object3D, Vector3 } from 'three';
 import { Entity } from '../interfaces/entity';
-import { SetupCallback } from '~/lib/interfaces/game';
 import { GameEntity } from '../entities/entity';
 import { ZylemCamera } from '../camera/zylem-camera';
+import { SetupFunction } from '../core/base-node-life-cycle';
 interface SceneState {
     backgroundColor: Color;
     backgroundImage: string | null;
 }
 export declare class ZylemScene implements Entity<ZylemScene> {
     type: string;
-    _setup?: SetupCallback;
+    _setup?: SetupFunction<ZylemScene>;
     scene: Scene;
     zylemCamera: ZylemCamera;
     containerElement: HTMLElement | null;