@zylem/game-lib 0.6.4 → 0.7.0

package/dist/game-default-PZLLHYL7.js

@@ -0,0 +1 @@
+import{p as e}from"./chunk-QEDQDR27.js";import"./chunk-A34ZG3L4.js";import"./chunk-CDPY4VOQ.js";import"./chunk-ONWXGBWB.js";import"./chunk-DR6XXZE7.js";import"./chunk-YHEWKN7N.js";import"./chunk-QXVH6POE.js";import"./chunk-73VZQZUL.js";import"./chunk-YHKXQ2ZN.js";import"./chunk-WKHW2QO2.js";import"./chunk-4QLJUQSJ.js";import"./chunk-G2IIMSUH.js";import"./chunk-FM5TBEPO.js";import"./chunk-XRP4JJXL.js";import"./chunk-MSC2BEO5.js";import{proxy as t}from"valtio/vanilla";var s=()=>({id:"zylem",globals:{},stages:[e()],debug:!1,time:0,input:void 0}),a=t({...s()});function o(){return{id:a.id??"zylem",globals:a.globals??{},stages:a.stages??[e()],debug:a.debug,time:a.time,input:a.input}}export{o as getGameDefaultConfig};

package/dist/game-interfaces-tfpM5NBk.d.ts

@@ -0,0 +1,90 @@
+import { U as UpdateFunction } from './base-node-life-cycle-CnJ-7zX-.js';
+
+type BasicTypes = number | string | boolean;
+type BaseGlobals = Record<string, BasicTypes>;
+type KeyboardMapping = Record<string, string[]>;
+type MouseMapping = Record<string, string[]>;
+type VirtualTouchStyle = Partial<Record<string, string | number>>;
+interface VirtualTouchPosition {
+    top?: string | number;
+    right?: string | number;
+    bottom?: string | number;
+    left?: string | number;
+    transform?: string;
+}
+interface VirtualTouchButtonConfig {
+    enabled?: boolean;
+    className?: string;
+    style?: VirtualTouchStyle;
+    position?: VirtualTouchPosition;
+    size?: number;
+    label?: string;
+    /** Trusted SVG markup injected into the control. */
+    svg?: string;
+}
+interface VirtualTouchJoystickConfig {
+    enabled?: boolean;
+    className?: string;
+    style?: VirtualTouchStyle;
+    position?: VirtualTouchPosition;
+    size?: number;
+    thumbSize?: number;
+    maxDistance?: number;
+    deadzone?: number;
+    directionThreshold?: number;
+    horizontalAxis?: 'Horizontal' | 'SecondaryHorizontal';
+    verticalAxis?: 'Vertical' | 'SecondaryVertical';
+    emitDirections?: boolean;
+    svg?: {
+        base?: string;
+        thumb?: string;
+    };
+}
+type VirtualTouchButtonSlot = 'A' | 'B' | 'X' | 'Y' | 'Start' | 'Select' | 'L' | 'R' | 'LTrigger' | 'RTrigger' | 'Up' | 'Down' | 'Left' | 'Right';
+type VirtualTouchButtonsConfig = Partial<Record<VirtualTouchButtonSlot, VirtualTouchButtonConfig | false>>;
+interface VirtualTouchJoysticksConfig {
+    left?: VirtualTouchJoystickConfig | false;
+    right?: VirtualTouchJoystickConfig | false;
+}
+interface VirtualTouchConfig {
+    enabled?: boolean | 'auto';
+    className?: string;
+    style?: VirtualTouchStyle;
+    joysticks?: VirtualTouchJoysticksConfig | false;
+    buttons?: VirtualTouchButtonsConfig | false;
+}
+interface MouseConfig {
+    /** Custom mapping from mouse actions to input properties. */
+    mapping?: MouseMapping;
+    /** Whether to capture the cursor via Pointer Lock API. */
+    pointerLock?: boolean;
+    /** Sensitivity multiplier for mouse movement (default 0.002). */
+    sensitivity?: number;
+}
+interface GameInputPlayerConfig {
+    key?: KeyboardMapping;
+    mouse?: MouseConfig;
+    touch?: VirtualTouchConfig;
+    includeDefaults?: boolean;
+}
+interface GameInputConfig {
+    p1?: GameInputPlayerConfig;
+    p2?: GameInputPlayerConfig;
+    p3?: GameInputPlayerConfig;
+    p4?: GameInputPlayerConfig;
+    p5?: GameInputPlayerConfig;
+    p6?: GameInputPlayerConfig;
+    p7?: GameInputPlayerConfig;
+    p8?: GameInputPlayerConfig;
+}
+interface ZylemGameConfig<StageInterface, GameInterface, TGlobals extends BaseGlobals> {
+    id: string;
+    globals?: TGlobals;
+    stages?: StageInterface[];
+    update?: UpdateFunction<GameInterface>;
+    debug?: boolean;
+    time?: number;
+    input?: GameInputConfig;
+}
+
+export type { BaseGlobals as B, GameInputConfig as G, KeyboardMapping as K, MouseConfig as M, VirtualTouchConfig as V, ZylemGameConfig as Z, VirtualTouchButtonSlot as a, GameInputPlayerConfig as b, MouseMapping as c, VirtualTouchButtonConfig as d, VirtualTouchButtonsConfig as e, VirtualTouchJoystickConfig as f, VirtualTouchJoysticksConfig as g, VirtualTouchPosition as h, VirtualTouchStyle as i };

package/dist/globals.d.ts

@@ -0,0 +1,104 @@
+import { f as UpdateContext } from './base-node-life-cycle-CnJ-7zX-.js';
+import 'three';
+
+/**
+ * Set a global value by path.
+ * Emits a 'game:state:updated' event when the value changes.
+ * @example setGlobal('score', 100)
+ * @example setGlobal('player.health', 50)
+ */
+declare function setGlobal(path: string, value: unknown): void;
+/**
+ * Create/initialize a global with a default value.
+ * Only sets the value if it doesn't already exist.
+ * Use this to ensure globals have initial values before game starts.
+ * @example createGlobal('score', 0)
+ * @example createGlobal('player.health', 100)
+ */
+declare function createGlobal<T>(path: string, defaultValue: T): T;
+/**
+ * Get a global value by path.
+ * @example getGlobal('score') // 100
+ * @example getGlobal<number>('player.health') // 50
+ */
+declare function getGlobal<T = unknown>(path: string): T | undefined;
+/**
+ * Subscribe to changes on a global value at a specific path.
+ * Returns an unsubscribe function. Subscriptions are automatically
+ * cleaned up when the game is disposed.
+ * @example const unsub = onGlobalChange('score', (val) => console.log(val));
+ */
+declare function onGlobalChange<T = unknown>(path: string, callback: (value: T) => void): () => void;
+/**
+ * Subscribe to changes on multiple global paths.
+ * Callback fires when any of the paths change, receiving all current values.
+ * Subscriptions are automatically cleaned up when the game is disposed.
+ * @example const unsub = onGlobalChanges(['score', 'lives'], ([score, lives]) => console.log(score, lives));
+ */
+declare function onGlobalChanges<T extends unknown[] = unknown[]>(paths: string[], callback: (values: T) => void): () => void;
+/**
+ * Get the entire globals object (read-only snapshot).
+ */
+declare function getGlobals<T = Record<string, unknown>>(): T;
+/**
+ * Unsubscribe all active global subscriptions.
+ * Used internally on game dispose to prevent old callbacks from firing.
+ */
+declare function clearGlobalSubscriptions(): void;
+
+/**
+ * Set a variable on an object by path.
+ * @example setVariable(stage1, 'totalAngle', 0.5)
+ * @example setVariable(entity, 'enemy.count', 10)
+ */
+declare function setVariable(target: object, path: string, value: unknown): void;
+/**
+ * Create/initialize a variable with a default value on a target object.
+ * Only sets the value if it doesn't already exist.
+ * @example createVariable(stage1, 'totalAngle', 0)
+ * @example createVariable(entity, 'enemy.count', 10)
+ */
+declare function createVariable<T>(target: object, path: string, defaultValue: T): T;
+/**
+ * Get a variable from an object by path.
+ * @example getVariable(stage1, 'totalAngle') // 0.5
+ * @example getVariable<number>(entity, 'enemy.count') // 10
+ */
+declare function getVariable<T = unknown>(target: object, path: string): T | undefined;
+/**
+ * Subscribe to changes on a variable at a specific path for a target object.
+ * Returns an unsubscribe function.
+ * @example const unsub = onVariableChange(stage1, 'score', (val) => console.log(val));
+ */
+declare function onVariableChange<T = unknown>(target: object, path: string, callback: (value: T) => void): () => void;
+/**
+ * Subscribe to changes on multiple variable paths for a target object.
+ * Callback fires when any of the paths change, receiving all current values.
+ * Returns an unsubscribe function.
+ * @example const unsub = onVariableChanges(stage1, ['count', 'total'], ([count, total]) => console.log(count, total));
+ */
+declare function onVariableChanges<T extends unknown[] = unknown[]>(target: object, paths: string[], callback: (values: T) => void): () => void;
+
+/**
+ * Listen for a single global key change inside an onUpdate pipeline.
+ * Usage: onUpdate(globalChange('p1Score', (value) => { ... }))
+ */
+declare function globalChange<T = any>(key: string, callback: (value: T, ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
+/**
+ * Listen for multiple global key changes inside an onUpdate pipeline.
+ * Calls back when any of the provided keys changes.
+ * Usage: onUpdate(globalChanges(['p1Score','p2Score'], ([p1,p2]) => { ... }))
+ */
+declare function globalChanges<T = any>(keys: string[], callback: (values: T[], ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
+/**
+ * Listen for a single stage variable change inside an onUpdate pipeline.
+ * Usage: onUpdate(variableChange('score', (value, ctx) => { ... }))
+ */
+declare function variableChange<T = any>(key: string, callback: (value: T, ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
+/**
+ * Listen for multiple stage variable changes; fires when any changes.
+ * Usage: onUpdate(variableChanges(['a','b'], ([a,b], ctx) => { ... }))
+ */
+declare function variableChanges<T = any>(keys: string[], callback: (values: T[], ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
+
+export { clearGlobalSubscriptions, createGlobal, createVariable, getGlobal, getGlobals, getVariable, globalChange, globalChanges, onGlobalChange, onGlobalChanges, onVariableChange, onVariableChanges, setGlobal, setVariable, variableChange, variableChanges };

package/dist/globals.js

@@ -0,0 +1 @@
+import{h,i as v,j as y,k as T,l as x}from"./chunk-WKHW2QO2.js";import{e as u,f,g,h as C,i as b,j as p,m as c}from"./chunk-4QLJUQSJ.js";import"./chunk-G2IIMSUH.js";function V(t,r){let n;return a=>{let e=a.globals?.[t];n!==e&&(n===void 0&&e===void 0||r(e,a),n=e)}}function U(t,r){let n=new Array(t.length).fill(void 0);return a=>{let e=t.map(i=>a.globals?.[i]);if(e.some((i,l)=>n[l]!==i)){let i=n.every(o=>o===void 0),l=e.every(o=>o===void 0);i&&l||r(e,a),n=e}}}function m(t,r){let n;return a=>{let e=a.stage?.getVariable?.(t)??void 0;n!==e&&(n===void 0&&e===void 0||r(e,a),n=e)}}function G(t,r){let n=new Array(t.length).fill(void 0);return a=>{let e=l=>a.stage?.getVariable?.(l),d=t.map(e);if(d.some((l,o)=>n[o]!==l)){let l=n.every(s=>s===void 0),o=d.every(s=>s===void 0);l&&o||r(d,a),n=d}}}export{c as clearGlobalSubscriptions,f as createGlobal,v as createVariable,g as getGlobal,p as getGlobals,y as getVariable,V as globalChange,U as globalChanges,C as onGlobalChange,b as onGlobalChanges,T as onVariableChange,x as onVariableChanges,u as setGlobal,h as setVariable,m as variableChange,G as variableChanges};

package/dist/graphics.d.ts

@@ -0,0 +1,83 @@
+import { Z as ZylemTSLShader } from './material-Wz83vTTp.js';
+export { o as ZylemShader, m as ZylemShaderObject, r as createNodeMaterialFromTSL, q as isGLSLShader, p as isTSLShader } from './material-Wz83vTTp.js';
+export { Fn, abs, asin, atan, clamp, cos, dot, exp, float, floor, fract, length, max, min, mix, mod, normalize, positionWorld, pow, sin, smoothstep, step, time, uniform, uv, vec2, vec3, vec4 } from 'three/tsl';
+import 'three';
+import 'three/webgpu';
+import '@dimforge/rapier3d-compat';
+
+/**
+ * TSL fire shader for WebGPU.
+ */
+declare const fireTSL: ZylemTSLShader;
+
+/**
+ * TSL star shader for WebGPU.
+ */
+declare const starTSL: ZylemTSLShader;
+
+/**
+ * TSL debug wireframe shader for WebGPU.
+ */
+declare const debugTSL: ZylemTSLShader;
+
+/**
+ * Create a gradient sky shader with custom colors.
+ *
+ * @param groundColor  Color below the horizon (default: dark ground)
+ * @param horizonColor Color at the horizon line (default: warm orange)
+ * @param zenithColor  Color directly above (default: deep blue/black)
+ */
+declare function createGradientSky(groundColor?: [number, number, number], horizonColor?: [number, number, number], zenithColor?: [number, number, number]): ZylemTSLShader;
+/**
+ * Default gradient sky: dark space above, warm horizon glow, dark ground below.
+ * Suitable as a general-purpose game skybox.
+ */
+declare const gradientSkyTSL: ZylemTSLShader;
+
+/**
+ * TSL starfield skybox shader for WebGPU.
+ * Uses world-space position for proper 3D skybox rendering.
+ */
+declare const starfieldSkyTSL: ZylemTSLShader;
+
+declare const standardShader: {
+    vertex: string;
+    fragment: string;
+};
+
+declare const objectVertexShader = "\nuniform vec2 uvScale;\nvarying vec2 vUv;\n\nvoid main() {\n\tvUv = uv;\n\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n\tgl_Position = projectionMatrix * mvPosition;\n}\n";
+
+/**
+ * Convenience factory for creating background (skybox) shaders.
+ *
+ * Wraps a TSL color node into a {@link ZylemTSLShader} object suitable for
+ * passing to `stageConfig({ backgroundShader: ... })`.
+ *
+ * @example
+ * ```ts
+ * import { createBackgroundShader, Fn, positionWorld, normalize, vec4 } from '@zylem/game-lib/graphics';
+ *
+ * const myShader = createBackgroundShader(
+ *   Fn(() => {
+ *     const dir = normalize(positionWorld);
+ *     return vec4(dir.x, dir.y, dir.z, 1.0);
+ *   })()
+ * );
+ * ```
+ */
+
+/**
+ * Create a background shader from a TSL color node.
+ *
+ * The color node receives the skybox mesh geometry and should produce a
+ * `vec4` color output. For proper skybox rendering, use `positionWorld`
+ * (from `three/tsl`) to derive a view direction and compute colors in
+ * spherical coordinates.
+ *
+ * @param colorNode - A TSL node expression that evaluates to a vec4 color
+ * @param transparent - Whether the background should be transparent (default: false)
+ * @returns A ZylemTSLShader that can be used as `backgroundShader` in stage config
+ */
+declare function createBackgroundShader(colorNode: any, transparent?: boolean): ZylemTSLShader;
+
+export { ZylemTSLShader, createBackgroundShader, createGradientSky, debugTSL, fireTSL, gradientSkyTSL, objectVertexShader, standardShader, starTSL, starfieldSkyTSL };

package/dist/graphics.js

@@ -0,0 +1 @@
+import{a as tt,b as ot,f as et,g as rt,i as at,j as st,k as nt,l as mt,m as lt,n as dt,o as ct,p as ut}from"./chunk-DR6XXZE7.js";import"./chunk-QXVH6POE.js";import"./chunk-YHKXQ2ZN.js";import"./chunk-G2IIMSUH.js";import{Fn as R,uv as it,time as W,vec3 as h,vec4 as U,float as b,floor as A,fract as Z,sin as B,atan as pt,length as G,mix as p,mod as I,max as ft,pow as j}from"three/tsl";var yt=R(([e,t])=>{let a=h(1,100,1e3),s=e.mul(t),o=A(I(s,t)).mul(a),r=A(I(s.add(h(1,1,1)),t)).mul(a),n=Z(s),l=n.mul(n).mul(b(3).sub(n.mul(2))),c=U(o.x.add(o.y).add(o.z),r.x.add(o.y).add(o.z),o.x.add(r.y).add(o.z),r.x.add(r.y).add(o.z)),d=Z(B(c.mul(.1)).mul(1e3)),i=p(p(d.x,d.y,l.x),p(d.z,d.w,l.x),l.y),u=Z(B(c.add(r.z).sub(o.z).mul(.1)).mul(1e3)),f=p(p(u.x,u.y,l.x),p(u.z,u.w,l.x),l.y);return p(i,f,l.z).mul(2).sub(1)}),St=R(()=>{let e=it().sub(.5),t=b(3).sub(G(e.mul(2)).mul(3)),a=h(pt(e.x,e.y).div(6.2832).add(.5),G(e).mul(.4),.5),s=h(0,W.mul(-.05),W.mul(.01));for(let r=1;r<=7;r++){let n=Math.pow(2,r);t=t.add(b(1.5/n).mul(yt(a.add(s),b(n*16))))}let o=ft(t,0);return U(t,j(o,2).mul(.4),j(o,3).mul(.15),1)})(),xt={colorNode:St,transparent:!1};import{Fn as E,uv as bt,time as V,vec3 as S,vec4 as ht,float as Tt,fract as vt,length as q,exp as Lt,sin as gt,cos as Zt,abs as kt,pow as wt}from"three/tsl";var Nt=E(([e])=>{let t=S(.5,.5,.5),a=S(.5,.5,.5),s=S(1,1,1),o=S(.263,.416,.557);return t.add(a.mul(Zt(s.mul(e).add(o).mul(6.28318))))}),Ft=E(()=>{let e=bt().mul(2).sub(1),t=q(e),a=e,s=S(0,0,0);for(let o=0;o<4;o++){a=vt(a.mul(1.5)).sub(.5);let r=q(a).mul(Lt(t.negate())),n=Nt(t.add(o*.4).add(V.mul(.4)));r=gt(r.mul(5).add(V)).div(5),r=kt(r),r=wt(Tt(.01).div(r),1.2),s=s.add(n.mul(r))}return ht(s,1)})(),zt={colorNode:Ft,transparent:!1};import{Fn as Ct,uv as Pt,vec3 as H,vec4 as Mt,float as k,min as w,mix as Wt,smoothstep as At,fwidth as Bt}from"three/tsl";var Gt=H(.2,.2,.25),It=H(.6,.9,1),jt=1,Rt=Ct(()=>{let e=Pt(),t=w(w(e.x,k(1).sub(e.x)),w(e.y,k(1).sub(e.y))),a=Bt(t).mul(jt).max(1e-5),s=At(k(0),a,t),o=Wt(It,Gt,s);return Mt(o,1)})(),Ut={colorNode:Rt,transparent:!1};import{Fn as Vt,positionWorld as qt,vec3 as T,vec4 as Et,float as v,normalize as Ht,smoothstep as O,mix as X,clamp as N,pow as Y,asin as Ot}from"three/tsl";var Xt=Math.PI*.5;function _(e=[.15,.1,.08],t=[.45,.25,.15],a=[.02,.02,.08]){return{colorNode:Vt(()=>{let o=Ht(qt),r=Ot(N(o.y,-1,1)).div(Xt),n=O(0,1,N(r,0,1)),l=X(T(t[0],t[1],t[2]),T(a[0],a[1],a[2]),Y(n,v(1.5))),c=O(0,1,N(r.negate(),0,1)),d=X(T(t[0],t[1],t[2]),T(e[0],e[1],e[2]),Y(c,v(.8))),i=r.greaterThanEqual(v(0)).select(l,d);return Et(i,v(1))})(),transparent:!1}}var Yt=_();import{Fn as P,time as _t,positionWorld as Dt,vec2 as M,vec3 as y,vec4 as Jt,float as m,floor as D,fract as J,sin as g,dot as Kt,length as Qt,mix as C,max as F,normalize as $t,atan as to,asin as oo,clamp as eo}from"three/tsl";var ro=6.28318530718,ao=3.14159265359,so=y(1,.9,.7),no=y(.7,.85,1),mo=y(1,1,1),lo=y(.01,.01,.03),L=P(([e])=>{let t=Kt(e,M(127.1,311.7));return J(g(t).mul(43758.5453))}),z=P(([e,t,a])=>{let s=e.mul(t),o=D(s),r=J(s).sub(.5),n=L(o),l=F(m(0),n.sub(.85).mul(6.666)),c=L(o.add(1.3)).sub(.5),d=L(o.add(2.1)).sub(.5),i=M(c,d),u=r.sub(i),f=Qt(u),x=C(m(.015),m(.03),n),K=F(m(0),m(1).sub(f.div(x))),Q=F(m(0),m(1).sub(f.div(x.mul(4)))).mul(.15),$=m(.6).add(g(a.mul(m(.6).add(n)).add(n.mul(6.28))).mul(.4));return K.add(Q).mul($).mul(l)}),co=P(()=>{let e=$t(Dt),t=_t,a=to(e.z,e.x),s=oo(eo(e.y,-1,1)),o=M(a.div(ro).add(.5),s.div(ao).add(.5)),r=y(lo),n=g(o.x.mul(2).add(t.mul(.02))).mul(g(o.y.mul(1.5).sub(t.mul(.01)))).mul(.5).add(.5);r=r.add(y(.01,.005,.02).mul(n));let l=z(o,m(60),t),c=z(o.add(.37),m(120),t.mul(.8)),d=z(o.add(.71),m(240),t.mul(.6)),i=l.add(c.mul(.6)).add(d.mul(.35)),u=L(D(o.mul(60))),f=C(so,no,u),x=C(f,mo,m(.5));return r=r.add(x.mul(i)),Jt(r,m(1))})(),uo={colorNode:co,transparent:!1};import{positionWorld as Bo,normalize as Go,mix as Io,smoothstep as jo,clamp as Ro,sin as Uo,cos as Vo,atan as qo,asin as Eo,abs as Ho,exp as Oo,pow as Xo,step as Yo,max as _o,min as Do,floor as Jo,fract as Ko,dot as Qo,length as $o,vec2 as te,mod as oe}from"three/tsl";function io(e,t=!1){return{colorNode:e,transparent:t}}export{ut as Fn,Ho as abs,Eo as asin,qo as atan,Ro as clamp,Vo as cos,io as createBackgroundShader,_ as createGradientSky,at as createNodeMaterialFromTSL,Ut as debugTSL,Qo as dot,Oo as exp,xt as fireTSL,ct as float,Jo as floor,Ko as fract,Yt as gradientSkyTSL,rt as isGLSLShader,et as isTSLShader,$o as length,_o as max,Do as min,Io as mix,oe as mod,Go as normalize,tt as objectVertexShader,Bo as positionWorld,Xo as pow,Uo as sin,jo as smoothstep,ot as standardShader,zt as starTSL,uo as starfieldSkyTSL,Yo as step,mt as time,st as uniform,nt as uv,te as vec2,lt as vec3,dt as vec4};

package/dist/input-ui.d.ts

@@ -0,0 +1,34 @@
+import { T as TouchTheme, a as TouchThemeName } from './default-controls-BGc61yYl.js';
+export { D as DefaultTouchControlsOptions, J as JoystickSelection, d as defaultTouchControls, b as resolveButtonAccent, r as resolveTouchTheme, t as touchThemes } from './default-controls-BGc61yYl.js';
+import './base-node-life-cycle-CnJ-7zX-.js';
+import 'three';
+import './game-interfaces-tfpM5NBk.js';
+
+type TouchThemeInput = TouchTheme | TouchThemeName;
+interface TouchButtonSvgOptions {
+    /** Stroke + text accent color. Overrides any theme-resolved accent. */
+    accent?: string;
+    /** Theme name or full theme object (defaults to `'default'`). */
+    theme?: TouchThemeInput;
+}
+/**
+ * Stylized joystick base SVG: outer ring, subtle inner ring, and four
+ * directional tabs. Designed to scale to any size; consumes only theme
+ * color tokens so a single `theme` argument re-skins the whole control.
+ */
+declare function joystickBaseSvg(theme?: TouchThemeInput): string;
+/**
+ * Stylized joystick thumb SVG: filled disc with a subtle inner highlight ring.
+ */
+declare function joystickThumbSvg(theme?: TouchThemeInput): string;
+/**
+ * Stylized button SVG with a centered label. The accent color drives the
+ * outer stroke, the inner translucent fill, and the label text color, so
+ * each button can have its own visual identity within a shared theme.
+ *
+ * @param label   Display text (length affects font size, like the engine default).
+ * @param options `accent` overrides the theme accent; `theme` selects the palette.
+ */
+declare function touchButtonSvg(label: string, options?: TouchButtonSvgOptions): string;
+
+export { type TouchButtonSvgOptions, TouchTheme, type TouchThemeInput, TouchThemeName, joystickBaseSvg, joystickThumbSvg, touchButtonSvg };

package/dist/input-ui.js

@@ -0,0 +1 @@
+import{a as o,b as e,c as t,d as u,e as c,f as h,g as T}from"./chunk-RXDTAWI2.js";import"./chunk-MSC2BEO5.js";export{T as defaultTouchControls,u as joystickBaseSvg,c as joystickThumbSvg,t as resolveButtonAccent,e as resolveTouchTheme,h as touchButtonSvg,o as touchThemes};

package/dist/input.d.ts

@@ -0,0 +1,72 @@
+import { I as InputPlayer } from './base-node-life-cycle-CnJ-7zX-.js';
+export { A as AnalogState, c as ButtonName, B as ButtonState, b as InputGamepad, d as InputPlayerNumber, e as InputProvider, a as Inputs } from './base-node-life-cycle-CnJ-7zX-.js';
+import { G as GameInputConfig, V as VirtualTouchConfig } from './game-interfaces-tfpM5NBk.js';
+import 'three';
+
+/**
+ * Maps arrow keys to axes (Horizontal/Vertical) for the given player.
+ * @example stage.setInputConfiguration(useArrowsForAxes('p1'));
+ */
+declare function useArrowsForAxes(player: InputPlayer): GameInputConfig;
+/**
+ * Maps arrow keys to secondary axes for the given player.
+ * @example stage.setInputConfiguration(useArrowsForSecondaryAxes('p1'));
+ */
+declare function useArrowsForSecondaryAxes(player: InputPlayer): GameInputConfig;
+/**
+ * Maps arrow keys to directions (Up/Down/Left/Right) for the given player.
+ * Useful when `includeDefaults` is false and you still want arrow-key directions.
+ * @example stage.setInputConfiguration(useArrowsForDirections('p1'));
+ */
+declare function useArrowsForDirections(player: InputPlayer): GameInputConfig;
+/**
+ * Maps W/A/S/D keys to directions (Up/Down/Left/Right) for the given player.
+ * @example stage.setInputConfiguration(useWASDForDirections('p1'));
+ */
+declare function useWASDForDirections(player: InputPlayer): GameInputConfig;
+/**
+ * Maps W/A/S/D keys to axes (Horizontal/Vertical) for the given player.
+ * @example stage.setInputConfiguration(useWASDForAxes('p1'));
+ */
+declare function useWASDForAxes(player: InputPlayer): GameInputConfig;
+/**
+ * Maps I/J/K/L keys to axes (Horizontal/Vertical) for the given player.
+ * @example stage.setInputConfiguration(useIJKLForAxes('p1'));
+ */
+declare function useIJKLForAxes(player: InputPlayer): GameInputConfig;
+/**
+ * Maps I/J/K/L keys to directions (Up/Down/Left/Right) for the given player.
+ * @example stage.setInputConfiguration(useIJKLForDirections('p1'));
+ */
+declare function useIJKLForDirections(player: InputPlayer): GameInputConfig;
+/**
+ * Enables mouse-look with pointer lock for the given player.
+ * Mouse movement maps to SecondaryHorizontal/SecondaryVertical axes;
+ * left click maps to LTrigger, right click to RTrigger.
+ * @example stage.setInputConfiguration(useMouseLook('p1'));
+ */
+declare function useMouseLook(player: InputPlayer, options?: {
+    sensitivity?: number;
+}): GameInputConfig;
+/**
+ * Enables basic mouse input (no pointer lock) for the given player.
+ * @example stage.setInputConfiguration(useMouse('p1'));
+ */
+declare function useMouse(player: InputPlayer, options?: {
+    sensitivity?: number;
+}): GameInputConfig;
+/**
+ * Enables virtual touch controls for the given player.
+ * By default the provider auto-enables itself on mobile/touch devices.
+ * @example stage.setInputConfiguration(useVirtualControls('p1'));
+ */
+declare function useVirtualControls(player: InputPlayer, options?: VirtualTouchConfig): GameInputConfig;
+/**
+ * Deep-merges multiple GameInputConfig objects into one.
+ * At the player level, configs are merged (both apply).
+ * At the key level, later configs win on conflict.
+ * @example mergeInputConfigs(useArrowsForAxes('p1'), useWASDForDirections('p1'));
+ */
+declare function mergeInputConfigs(...configs: GameInputConfig[]): GameInputConfig;
+
+export { InputPlayer, mergeInputConfigs, useArrowsForAxes, useArrowsForDirections, useArrowsForSecondaryAxes, useIJKLForAxes, useIJKLForDirections, useMouse, useMouseLook, useVirtualControls, useWASDForAxes, useWASDForDirections };

package/dist/input.js

@@ -0,0 +1 @@
+import{a as e,b as o,c as r,d as s,e as t,f as u,g as n,h as i,i as p,j as a,k as A}from"./chunk-MSC2BEO5.js";export{A as mergeInputConfigs,e as useArrowsForAxes,r as useArrowsForDirections,o as useArrowsForSecondaryAxes,u as useIJKLForAxes,n as useIJKLForDirections,p as useMouse,i as useMouseLook,a as useVirtualControls,t as useWASDForAxes,s as useWASDForDirections};

package/dist/material-Wz83vTTp.d.ts

@@ -0,0 +1,151 @@
+import { Vector3, Vector2, Color, Material } from 'three';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+import { Vector3 as Vector3$1 } from '@dimforge/rapier3d-compat';
+
+type Vec2 = Vector2;
+type Vec3 = Vector3 | Vector3$1;
+type Vec2Components = {
+    x: number;
+    y: number;
+};
+type Vec3Components = {
+    x: number;
+    y: number;
+    z: number;
+};
+type Vec2Tuple = readonly [number?, number?] & {
+    x?: number;
+    y?: number;
+};
+type Vec3Tuple = readonly [number?, number?, number?] & {
+    x?: number;
+    y?: number;
+    z?: number;
+};
+type Vec2Input = Vec2 | {
+    x?: number;
+    y?: number;
+} | Vec2Tuple;
+type Vec3Input = Vec3 | {
+    x?: number;
+    y?: number;
+    z?: number;
+} | Vec3Tuple;
+declare const VEC2_ZERO: Readonly<Vec2Components>;
+declare const VEC2_ONE: Readonly<Vec2Components>;
+declare const VEC3_ZERO: Readonly<Vec3Components>;
+declare const VEC3_ONE: Readonly<Vec3Components>;
+declare function normalizeVec2(input?: Vec2Input | null, defaults?: Vec2Input | Partial<Vec2Components>): Vec2Components;
+declare function normalizeVec3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vec3Components;
+declare function toThreeVector2(input?: Vec2Input | null, defaults?: Vec2Input | Partial<Vec2Components>): Vector2;
+declare function toThreeVector3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vector3;
+declare function toRapierVector3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vector3$1;
+
+declare function shortHash(objString: string): string;
+
+/**
+ * GLSL shader object (traditional WebGL approach).
+ *
+ * @deprecated game-lib renders with WebGPU, which cannot compile raw GLSL
+ * `ShaderMaterial`. Author custom shaders as {@link ZylemTSLShader} (TSL)
+ * instead. A GLSL shader passed to a material now logs a warning and renders
+ * with a default node material.
+ */
+type ZylemShaderObject = {
+    fragment: string;
+    vertex: string;
+};
+/**
+ * TSL shader type (for WebGPU)
+ * colorNode should be a TSL node that returns the fragment color
+ */
+type ZylemTSLShader = {
+    colorNode: any;
+    transparent?: boolean;
+};
+/**
+ * Combined shader type supporting both GLSL and TSL
+ */
+type ZylemShader = ZylemShaderObject | ZylemTSLShader;
+/**
+ * Check if a shader is a TSL shader
+ */
+declare function isTSLShader(shader: ZylemShader): shader is ZylemTSLShader;
+/**
+ * Check if a shader is a GLSL shader
+ */
+declare function isGLSLShader(shader: ZylemShader): shader is ZylemShaderObject;
+interface MaterialOptions {
+    path?: string;
+    normalMap?: string;
+    repeat?: Vec2Input;
+    shader?: ZylemShader;
+    color?: Color;
+    /** Opacity from 0 (fully transparent) to 1 (fully opaque). */
+    opacity?: number;
+    /**
+     * @deprecated game-lib is WebGPU-only and always builds TSL node materials.
+     * This flag is ignored.
+     */
+    useTSL?: boolean;
+}
+type BatchGeometryMap = Map<symbol, number>;
+interface BatchMaterialMapObject {
+    geometryMap: BatchGeometryMap;
+    material: Material;
+}
+type BatchKey = ReturnType<typeof shortHash>;
+type TexturePath = string | null;
+declare class MaterialBuilder {
+    static batchMaterialMap: Map<BatchKey, BatchMaterialMapObject>;
+    /**
+     * Clear the static batch material cache.
+     * Should be called during game disposal to prevent stale material references
+     * from persisting across demo/stage switches.
+     */
+    static clearBatchCache(): void;
+    materials: Material[];
+    /**
+     * Retained for backward compatibility. game-lib is WebGPU-only and always
+     * builds TSL node materials, so this no longer changes behavior.
+     *
+     * @deprecated
+     */
+    private useTSL;
+    constructor(useTSL?: boolean);
+    batchMaterial(options: Partial<MaterialOptions>, entityType: symbol): void;
+    build(options: Partial<MaterialOptions>, entityType: symbol): void;
+    withColor(color: Color, useTSL?: boolean, opacity?: number): this;
+    withShader(shader: ZylemShaderObject, opacity?: number): this;
+    withTSLShader(shader: ZylemTSLShader, opacity?: number): this;
+    private applyOpacity;
+    /**
+     * Set texture - loads in background (deferred).
+     * Material is created immediately with null map, texture applies when loaded.
+     */
+    setTexture(texturePath?: TexturePath, repeat?: Vec2Input, _useTSL?: boolean, opacity?: number, color?: Color): void;
+    /**
+     * Set normal map for the current material
+     */
+    setNormalMap(normalMapPath: string, repeat?: Vec2Input): void;
+    setColor(color: Color, _useTSL?: boolean, opacity?: number): void;
+    /**
+     * @deprecated GLSL shaders cannot compile on the WebGPU renderer. This now
+     * logs a warning and creates a default node material so the entity still
+     * renders. Author custom shaders as {@link ZylemTSLShader} (TSL) and use
+     * {@link withTSLShader} / `material.shader` instead.
+     */
+    setShader(_customShader: ZylemShaderObject, opacity?: number): void;
+    /**
+     * Set TSL shader (WebGPU compatible)
+     */
+    setTSLShader(tslShader: ZylemTSLShader, opacity?: number): void;
+}
+/**
+ * Build a standalone WebGPU node material ({@link MeshBasicNodeMaterial}) from
+ * a {@link ZylemTSLShader}. Useful for runtime material swapping outside the
+ * entity material pipeline (e.g. demos that toggle shader "looks").
+ */
+declare function createNodeMaterialFromTSL(tslShader: ZylemTSLShader, opacity?: number): MeshBasicNodeMaterial;
+
+export { type MaterialOptions as M, type TexturePath as T, type Vec3Components as V, type ZylemTSLShader as Z, type Vec3Input as a, type Vec2Input as b, type Vec3 as c, type Vec2 as d, type Vec2Components as e, VEC2_ONE as f, VEC2_ZERO as g, VEC3_ONE as h, VEC3_ZERO as i, normalizeVec3 as j, toThreeVector2 as k, toThreeVector3 as l, type ZylemShaderObject as m, normalizeVec2 as n, type ZylemShader as o, isTSLShader as p, isGLSLShader as q, createNodeMaterialFromTSL as r, MaterialBuilder as s, toRapierVector3 as t };