@zylem/game-lib 0.3.15 → 0.3.17

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

@@ -5,6 +5,10 @@ import { Timer } from '../core/three-addons/Timer';
 import { ZylemCamera } from '~/lib/camera/zylem-camera';
 import { Stage } from '../stage/stage';
 import { BasicTypes, GlobalVariablesType, ZylemGameConfig } from './game-interfaces';
+import { GameConfig } from './game-config';
+import { AspectRatioDelegate } from '../device/aspect-ratio';
+import { GameCanvas } from './game-canvas';
+type ZylemGameOptions<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType> = ZylemGameConfig<Stage, ZylemGame<TGlobals>, TGlobals> & Partial<GameConfig>;
 export declare class ZylemGame<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType> {
     id: string;
     initialGlobals: TGlobals;
@@ -26,10 +30,17 @@ export declare class ZylemGame<TGlobals extends Record<string, BasicTypes> = Glo
         dom: HTMLElement;
     } | null;
     defaultCamera: ZylemCamera | null;
+    container: HTMLElement | null;
+    canvas: HTMLCanvasElement | null;
+    aspectRatioDelegate: AspectRatioDelegate | null;
+    resolvedConfig: GameConfig | null;
+    gameCanvas: GameCanvas | null;
     static FRAME_LIMIT: number;
     static FRAME_DURATION: number;
     static MAX_DELTA_SECONDS: number;
-    constructor(options: ZylemGameConfig<Stage, ZylemGame<TGlobals>, TGlobals>, wrapperRef: Game<TGlobals>);
+    constructor(options: ZylemGameOptions<TGlobals>, wrapperRef: Game<TGlobals>);
+    loadGameCanvas(config: GameConfig): void;
+    loadDebugOptions(options: ZylemGameOptions<TGlobals>): void;
     loadStage(stage: Stage): Promise<void>;
     unloadCurrentStage(): void;
     setGlobals(options: ZylemGameConfig<Stage, ZylemGame<TGlobals>, TGlobals>): void;

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

@@ -0,0 +1,133 @@
+import { state as o, getGlobalState as n, setGlobalState as l } from "./game-state.js";
+import { setDebugFlag as u, isPaused as m } from "../debug/debug-state.js";
+import { InputManager as c } from "../input/input-manager.js";
+import { Timer as h } from "../core/three-addons/Timer.js";
+import { resolveGameConfig as d } from "./game-config.js";
+import { GameCanvas as g } from "./game-canvas.js";
+import { subscribe as f } from "valtio/vanilla";
+import p from "stats.js";
+class r {
+  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;
+  container = null;
+  canvas = null;
+  aspectRatioDelegate = null;
+  resolvedConfig = null;
+  gameCanvas = null;
+  static FRAME_LIMIT = 120;
+  static FRAME_DURATION = 1e3 / r.FRAME_LIMIT;
+  static MAX_DELTA_SECONDS = 1 / 30;
+  constructor(t, e) {
+    this.wrapperRef = e, this.inputManager = new c(t.input), this.timer = new h(), this.timer.connect(document);
+    const a = d(t);
+    this.id = a.id, this.stages = a.stages || [], this.container = a.container, this.canvas = a.canvas ?? null, this.resolvedConfig = a, this.loadGameCanvas(a), this.loadDebugOptions(t), this.setGlobals(t);
+  }
+  loadGameCanvas(t) {
+    this.gameCanvas = new g({
+      id: t.id,
+      container: t.container,
+      containerId: t.containerId,
+      canvas: this.canvas ?? void 0,
+      bodyBackground: t.bodyBackground,
+      fullscreen: t.fullscreen,
+      aspectRatio: t.aspectRatio
+    }), this.gameCanvas.applyBodyBackground(), this.gameCanvas.mountCanvas(), this.gameCanvas.centerIfFullscreen();
+  }
+  loadDebugOptions(t) {
+    u(!!t.debug), t.debug && (this.statsRef = new p(), 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];
+    if (await t.load(this.id, e?.camera), this.stageMap.set(t.stageRef.uuid, t), this.currentStageId = t.stageRef.uuid, this.defaultCamera = t.stageRef.cameraRef, this.container && this.defaultCamera) {
+      const a = this.defaultCamera.getDomElement();
+      this.gameCanvas?.mountRenderer(a, (s, i) => this.defaultCamera?.resize(s, i));
+    }
+  }
+  unloadCurrentStage() {
+    if (!this.currentStageId)
+      return;
+    const t = this.getStage(this.currentStageId);
+    if (t) {
+      if (t?.stageRef)
+        try {
+          t.stageRef.nodeDestroy({
+            me: t.stageRef,
+            globals: o.globals
+          });
+        } catch (e) {
+          console.error("Failed to destroy previous stage", e);
+        }
+      this.stageMap.delete(this.currentStageId);
+    }
+  }
+  setGlobals(t) {
+    this.initialGlobals = { ...t.globals };
+    for (const e in this.initialGlobals) {
+      const a = this.initialGlobals[e];
+      a === void 0 && console.error(`global ${e} is undefined`), this.setGlobal(e, a);
+    }
+  }
+  params() {
+    const t = this.currentStage(), e = this.timer.getDelta(), a = this.inputManager.getInputs(e), s = t?.stageRef?.cameraRef || this.defaultCamera;
+    return {
+      delta: e,
+      inputs: a,
+      globals: o.globals,
+      me: this,
+      camera: s
+    };
+  }
+  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(), !m()) {
+      this.timer.update(t);
+      const e = this.currentStage(), a = this.params(), s = Math.min(a.delta, r.MAX_DELTA_SECONDS), i = { ...a, delta: s };
+      this.customUpdate && this.customUpdate(i), e && e.stageRef.nodeUpdate({ ...i, me: e.stageRef }), this.totalTime += i.delta, o.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 n(t);
+  }
+  setGlobal(t, e) {
+    l(t, e);
+  }
+  onGlobalChange(t, e) {
+    let a = n(t);
+    f(o, () => {
+      const s = n(t);
+      s !== a && (a = s, e(s));
+    });
+  }
+}
+export {
+  r as ZylemGame,
+  r 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.d.ts

@@ -1,5 +1,5 @@
 import { Color, Material, Vector2 } from 'three';
-import { shortHash } from '../core/utility';
+import { shortHash } from '../core/utility/strings';
 import { ZylemShaderType } from '../core/preset-shader';
 export interface MaterialOptions {
     path?: string;

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/strings.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,10 +1,10 @@
 import { Scene, Color, Object3D, Vector3 } from 'three';
-import { Entity } from '../interfaces/entity';
+import { Entity, LifecycleFunction } from '../interfaces/entity';
 import { GameEntity } from '../entities/entity';
 import { ZylemCamera } from '../camera/zylem-camera';
 import { SetupFunction } from '../core/base-node-life-cycle';
 interface SceneState {
-    backgroundColor: Color;
+    backgroundColor: Color | string;
     backgroundImage: string | null;
 }
 export declare class ZylemScene implements Entity<ZylemScene> {
@@ -13,14 +13,14 @@ export declare class ZylemScene implements Entity<ZylemScene> {
     scene: Scene;
     zylemCamera: ZylemCamera;
     containerElement: HTMLElement | null;
+    update: LifecycleFunction<ZylemScene>;
+    _collision?: ((entity: any, other: any, globals?: any) => void) | undefined;
+    _destroy?: ((globals?: any) => void) | undefined;
+    name?: string | undefined;
+    tag?: Set<string> | undefined;
     constructor(id: string, camera: ZylemCamera, state: SceneState);
-    /**
-     * Setup the container element and append camera's renderer
-     */
-    private setupContainer;
     setup(): void;
     destroy(): void;
-    update({ delta }: Partial<any>): void;
     /**
      * Setup camera with the scene
      */

package/dist/lib/graphics/zylem-scene.js

@@ -0,0 +1,75 @@
+import { Scene as d, Color as i, TextureLoader as n, AmbientLight as m, DirectionalLight as c, Vector3 as h, GridHelper as l } from "three";
+import { debugState as g } from "../debug/debug-state.js";
+import { getGlobalState as p } from "../game/game-state.js";
+class b {
+  type = "Scene";
+  _setup;
+  scene;
+  zylemCamera;
+  containerElement = null;
+  update = () => {
+  };
+  _collision;
+  _destroy;
+  name;
+  tag;
+  constructor(e, s, a) {
+    const o = new d(), t = a.backgroundColor instanceof i ? a.backgroundColor : new i(a.backgroundColor);
+    if (o.background = t, a.backgroundImage) {
+      const r = new n().load(a.backgroundImage);
+      o.background = r;
+    }
+    this.scene = o, this.zylemCamera = s, this.setupLighting(o), this.setupCamera(o, s), g.on && this.debugScene();
+  }
+  setup() {
+    this._setup && this._setup({ me: this, camera: this.zylemCamera, globals: p() });
+  }
+  destroy() {
+    this.zylemCamera && this.zylemCamera.destroy && this.zylemCamera.destroy(), this.scene && this.scene.traverse((e) => {
+      e.geometry && e.geometry.dispose?.(), e.material && (Array.isArray(e.material) ? e.material.forEach((s) => s.dispose?.()) : e.material.dispose?.());
+    });
+  }
+  /**
+   * Setup camera with the scene
+   */
+  setupCamera(e, s) {
+    e.add(s.cameraRig), s.setup(e);
+  }
+  /**
+   * Setup scene lighting
+   */
+  setupLighting(e) {
+    const s = new m(16777215, 2);
+    e.add(s);
+    const a = new c(16777215, 2);
+    a.name = "Light", a.position.set(0, 100, 0), a.castShadow = !0, a.shadow.camera.near = 0.1, a.shadow.camera.far = 2e3, a.shadow.camera.left = -100, a.shadow.camera.right = 100, a.shadow.camera.top = 100, a.shadow.camera.bottom = -100, a.shadow.mapSize.width = 2048, a.shadow.mapSize.height = 2048, e.add(a);
+  }
+  /**
+   * Update renderer size - delegates to camera
+   */
+  updateRenderer(e, s) {
+    this.zylemCamera.resize(e, s);
+  }
+  /**
+   * Add object to scene
+   */
+  add(e, s = new h(0, 0, 0)) {
+    e.position.set(s.x, s.y, s.z), this.scene.add(e);
+  }
+  /**
+   * Add game entity to scene
+   */
+  addEntity(e) {
+    e.group ? this.add(e.group, e.options.position) : e.mesh && this.add(e.mesh, e.options.position);
+  }
+  /**
+   * Add debug helpers to scene
+   */
+  debugScene() {
+    const a = new l(1e3, 100);
+    this.scene.add(a);
+  }
+}
+export {
+  b as ZylemScene
+};

package/dist/lib/input/gamepad-provider.js

@@ -0,0 +1,58 @@
+class h {
+  gamepadIndex;
+  connected = !1;
+  buttonStates = {};
+  constructor(t) {
+    this.gamepadIndex = t, window.addEventListener("gamepadconnected", (e) => {
+      e.gamepad.index === this.gamepadIndex && (this.connected = !0);
+    }), window.addEventListener("gamepaddisconnected", (e) => {
+      e.gamepad.index === this.gamepadIndex && (this.connected = !1);
+    });
+  }
+  handleButtonState(t, e, a) {
+    const s = e.buttons[t].pressed;
+    let n = this.buttonStates[t];
+    return n || (n = { pressed: !1, released: !1, held: 0 }, this.buttonStates[t] = n), s ? (n.held === 0 ? n.pressed = !0 : n.pressed = !1, n.held += a, n.released = !1) : (n.held > 0 ? (n.released = !0, n.held = 0) : n.released = !1, n.pressed = !1), n;
+  }
+  handleAnalogState(t, e, a) {
+    return { value: e.axes[t], held: a };
+  }
+  getInput(t) {
+    const e = navigator.getGamepads()[this.gamepadIndex];
+    return e ? {
+      buttons: {
+        A: this.handleButtonState(0, e, t),
+        B: this.handleButtonState(1, e, t),
+        X: this.handleButtonState(2, e, t),
+        Y: this.handleButtonState(3, e, t),
+        Start: this.handleButtonState(9, e, t),
+        Select: this.handleButtonState(8, e, t),
+        L: this.handleButtonState(4, e, t),
+        R: this.handleButtonState(5, e, t)
+      },
+      directions: {
+        Up: this.handleButtonState(12, e, t),
+        Down: this.handleButtonState(13, e, t),
+        Left: this.handleButtonState(14, e, t),
+        Right: this.handleButtonState(15, e, t)
+      },
+      axes: {
+        Horizontal: this.handleAnalogState(0, e, t),
+        Vertical: this.handleAnalogState(1, e, t)
+      },
+      shoulders: {
+        LTrigger: this.handleButtonState(6, e, t),
+        RTrigger: this.handleButtonState(7, e, t)
+      }
+    } : {};
+  }
+  getName() {
+    return `gamepad-${this.gamepadIndex + 1}`;
+  }
+  isConnected() {
+    return this.connected;
+  }
+}
+export {
+  h as GamepadProvider
+};