@zylem/game-lib 0.6.2 → 0.6.3

package/dist/{stage-types-Bd-KtcYT.d.ts → stage-types-BFsm3qsZ.d.ts}

@@ -1,23 +1,56 @@
-import { S as SetupFunction, Z as ZylemShaderObject, G as GameEntity, U as UpdateFunction, D as DestroyFunction, a as SetupContext, b as UpdateContext, c as DestroyContext, d as ZylemWorld, B as BaseNode, L as LoadingEvent, e as BehaviorSystem, f as BehaviorSystemFactory, g as GameEntityOptions, h as StageEvents } from './world-C8tQ7Plj.js';
+import { J as UpdateFunction, S as SetupFunction, Z as ZylemShader, I as GameEntity, K as DestroyFunction, L as SetupContext, U as UpdateContext, M as DestroyContext, N as BaseNode, O as LoadingEvent, P as GameEntityOptions, Q as StageEvents } from './entity-BpbZqg19.js';
 import * as bitecs from 'bitecs';
 import { defineSystem, IWorld } from 'bitecs';
-import { Scene, Color, Object3D, Vector3 } from 'three';
+import { Scene, Color, Object3D, Vector3, BufferGeometry, Material } from 'three';
+import { Z as ZylemWorld } from './world-Be5m1XC1.js';
 import { E as Entity, L as LifecycleFunction, S as StageEntity } from './entity-Bq_eNEDI.js';
-import { Z as ZylemCamera, C as CameraDebugDelegate, a as CameraDebugState, b as CameraWrapper } from './camera-CeJPAgGg.js';
+import { Z as ZylemCamera, C as CameraManager, R as RendererManager, a as CameraDebugDelegate, b as CameraDebugState, c as CameraWrapper } from './camera-B5e4c78l.js';
 import { G as GameEntityInterface, B as BaseEntityInterface } from './entity-types-DAu8sGJH.js';
 import RAPIER__default from '@dimforge/rapier3d-compat';
-import { S as SPRITE_TYPE, Z as ZylemSprite, a as SPHERE_TYPE, b as ZylemSphere, R as RECT_TYPE, c as ZylemRect, T as TEXT_TYPE, d as ZylemText, B as BOX_TYPE, e as ZylemBox, P as PLANE_TYPE, f as ZylemPlane, g as ZONE_TYPE, h as ZylemZone, A as ACTOR_TYPE, i as ZylemActor } from './entities-DvByhMGU.js';
+import { S as SPRITE_TYPE, Z as ZylemSprite, a as SPHERE_TYPE, b as ZylemSphere, R as RECT_TYPE, c as ZylemRect, T as TEXT_TYPE, d as ZylemText, B as BOX_TYPE, e as ZylemBox, P as PLANE_TYPE, f as ZylemPlane, g as ZONE_TYPE, h as ZylemZone, A as ACTOR_TYPE, i as ZylemActor, C as CONE_TYPE, j as ZylemCone, k as PYRAMID_TYPE, l as ZylemPyramid, m as CYLINDER_TYPE, n as ZylemCylinder, o as PILL_TYPE, p as ZylemPill } from './entities-DC9ce_vx.js';
+import { B as BehaviorSystem, a as BehaviorSystemFactory } from './behavior-descriptor-BWNWmIjv.js';
+
+type BasicTypes = number | string | boolean;
+type BaseGlobals = Record<string, BasicTypes>;
+type KeyboardMapping = Record<string, string[]>;
+type MouseMapping = Record<string, string[]>;
+interface GameInputPlayerConfig {
+    key?: KeyboardMapping;
+    mouse?: MouseMapping;
+    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;
+}
 
 interface SceneState {
     backgroundColor: Color | string;
     backgroundImage: string | null;
-    backgroundShader?: ZylemShaderObject | null;
+    backgroundShader?: ZylemShader | null;
 }
 declare class ZylemScene implements Entity<ZylemScene> {
     type: string;
     _setup?: SetupFunction<ZylemScene>;
     scene: Scene;
+    /** @deprecated Use cameraManager instead */
     zylemCamera: ZylemCamera;
+    cameraManager: CameraManager | null;
     containerElement: HTMLElement | null;
     update: LifecycleFunction<ZylemScene>;
     _collision?: ((entity: any, other: any, globals?: any) => void) | undefined;
@@ -28,21 +61,30 @@ declare class ZylemScene implements Entity<ZylemScene> {
     constructor(id: string, camera: ZylemCamera, state: SceneState);
     /**
      * Create a large inverted box with the shader for skybox effect
-     * Uses the pos.xyww trick to ensure skybox is always at maximum depth
+     * Supports both GLSL (ShaderMaterial) and TSL (MeshBasicNodeMaterial) shaders
      */
     private setupBackgroundShader;
     setup(): void;
     destroy(): void;
     /**
-     * Setup camera with the scene
+     * Setup camera with the scene.
+     * Supports both legacy single camera and CameraManager modes.
+     */
+    setupCamera(scene: Scene, camera: ZylemCamera, rendererManager?: RendererManager): void;
+    /**
+     * Setup with a CameraManager (multi-camera support).
+     */
+    setupCameraManager(scene: Scene, cameraManager: CameraManager, rendererManager: RendererManager): Promise<void>;
+    /**
+     * Add a camera (rig or direct) to the scene graph.
      */
-    setupCamera(scene: Scene, camera: ZylemCamera): void;
+    private addCameraToScene;
     /**
      * Setup scene lighting
      */
     setupLighting(scene: Scene): void;
     /**
-     * Update renderer size - delegates to camera
+     * Update renderer size - delegates to camera manager or camera
      */
     updateRenderer(width: number, height: number): void;
     /**
@@ -63,11 +105,97 @@ declare class ZylemScene implements Entity<ZylemScene> {
      */
     debugScene(): void;
     /**
-     * Update skybox shader uniforms
+     * Update skybox shader uniforms (only applies to GLSL ShaderMaterial)
+     * TSL shaders use the time node which auto-updates
      */
     updateSkybox(delta: number): void;
 }
 
+/**
+ * Configuration for batch key generation
+ */
+interface BatchKeyConfig {
+    geometryType: string;
+    dimensions: Record<string, number>;
+    materialPath?: string | null;
+    shaderType?: 'standard' | 'custom';
+    colorHex?: number;
+}
+/**
+ * Manages instanced mesh batching for entities
+ */
+declare class InstanceManager {
+    private batches;
+    private entityToBatch;
+    private scene;
+    /** Default initial capacity for new batches */
+    static DEFAULT_CAPACITY: number;
+    /** Factor to grow batch when full */
+    static GROWTH_FACTOR: number;
+    /**
+     * Set the scene to add instanced meshes to
+     */
+    setScene(scene: Object3D): void;
+    /**
+     * Generate a batch key from configuration
+     */
+    static generateBatchKey(config: BatchKeyConfig): string;
+    /**
+     * Register an entity with the instance manager
+     * @returns The instance index, or -1 if registration failed
+     */
+    register(entity: GameEntity<any>, geometry: BufferGeometry, material: Material, batchKey: string): number;
+    /**
+     * Unregister an entity from the instance manager
+     */
+    unregister(entity: GameEntity<any>): void;
+    /**
+     * Mark an entity's transform as dirty (needs syncing)
+     */
+    markDirty(entity: GameEntity<any>): void;
+    /**
+     * Update all dirty instance transforms
+     * Call this once per frame
+     */
+    /**
+     * Update all active instance transforms
+     * Call this once per frame
+     */
+    update(): void;
+    private updateInstanceMatrix;
+    /**
+     * Get batch info for an entity
+     */
+    getBatchInfo(entity: GameEntity<any>): {
+        batchKey: string;
+        instanceId: number;
+    } | null;
+    /**
+     * Get statistics about current batching
+     */
+    getStats(): {
+        batchCount: number;
+        totalInstances: number;
+        batches: {
+            key: string;
+            count: number;
+            capacity: number;
+        }[];
+    };
+    /**
+     * Dispose all batches and release resources
+     */
+    dispose(): void;
+    /**
+     * Create a new batch group
+     */
+    private createBatch;
+    /**
+     * Grow a batch's capacity
+     */
+    private growBatch;
+}
+
 /**
  * Provides BaseNode-like lifecycle without ECS/children. Consumers implement
  * the protected hooks and may assign public setup/update/destroy callbacks.
@@ -165,6 +293,7 @@ declare class ZylemStage extends LifeCycleBase<ZylemStage> {
     gravity: Vector3;
     world: ZylemWorld | null;
     scene: ZylemScene | null;
+    instanceManager: InstanceManager | null;
     children: Array<BaseNode>;
     _childrenMap: Map<number, BaseNode>;
     _removalMap: Map<number, BaseNode>;
@@ -184,7 +313,12 @@ declare class ZylemStage extends LifeCycleBase<ZylemStage> {
     uuid: string;
     wrapperRef: Stage | null;
     camera?: CameraWrapper;
+    cameras: CameraWrapper[];
     cameraRef?: ZylemCamera | null;
+    /** Camera manager for multi-camera support */
+    cameraManagerRef: CameraManager | null;
+    /** Shared renderer manager (injected by the game) */
+    rendererManager: RendererManager | null;
     private cameraDelegate;
     private loadingDelegate;
     private entityModelDelegate;
@@ -203,7 +337,7 @@ declare class ZylemStage extends LifeCycleBase<ZylemStage> {
      * @param id DOM element id for the renderer container
      * @param camera Optional camera override
      */
-    load(id: string, camera?: ZylemCamera | null): Promise<void>;
+    load(id: string, camera?: ZylemCamera | null, rendererManager?: RendererManager | null): Promise<void>;
     /**
      * Generator that yields between entity loads for real-time progress updates.
      */
@@ -226,6 +360,11 @@ declare class ZylemStage extends LifeCycleBase<ZylemStage> {
      * Safe to call only after `load` when scene/world exist.
      */
     spawnEntity(child: BaseNode): Promise<void>;
+    /**
+     * Try to register an entity for instanced rendering.
+     * Batching is enabled by default unless explicitly disabled with batched: false.
+     */
+    private tryRegisterInstance;
     buildEntityState(child: BaseNode): Partial<BaseEntityInterface>;
     /** Add the entity to internal maps and notify listeners. */
     addEntityToStage(entity: BaseNode): void;
@@ -253,6 +392,22 @@ declare class ZylemStage extends LifeCycleBase<ZylemStage> {
     /** Get an entity by its name; returns null if not found. */
     getEntityByName(name: string): BaseNode<any, any> | null;
     logMissingEntities(): void;
+    /**
+     * Add a camera to this stage's camera manager.
+     */
+    addCamera(camera: ZylemCamera, name?: string): string | null;
+    /**
+     * Remove a camera from this stage's camera manager.
+     */
+    removeCamera(nameOrRef: string | ZylemCamera): boolean;
+    /**
+     * Set the active camera by name or reference.
+     */
+    setActiveCamera(nameOrRef: string | ZylemCamera): boolean;
+    /**
+     * Get a camera by name from the camera manager.
+     */
+    getCamera(name: string): ZylemCamera | null;
     /** Resize renderer viewport. */
     resize(width: number, height: number): void;
     /**
@@ -292,6 +447,10 @@ interface EntityTypeMap {
     [ZONE_TYPE]: ZylemZone;
     [ACTOR_TYPE]: ZylemActor;
     [DISK_TYPE]: ZylemDisk;
+    [CONE_TYPE]: ZylemCone;
+    [PYRAMID_TYPE]: ZylemPyramid;
+    [CYLINDER_TYPE]: ZylemCylinder;
+    [PILL_TYPE]: ZylemPill;
 }
 
 type NodeLike = {
@@ -308,8 +467,23 @@ declare class Stage {
     private destroyCallbacks;
     private pendingLoadingCallbacks;
     private eventDelegate;
+    /** Per-stage input configuration overrides. Merged with game-level defaults on stage load. */
+    inputConfig: GameInputConfig | null;
+    /**
+     * Callback set by the game to trigger input reconfiguration
+     * when this stage's input config changes at runtime.
+     * @internal
+     */
+    onInputConfigChanged: (() => void) | null;
     constructor(options: StageOptions);
-    load(id: string, camera?: ZylemCamera | CameraWrapper | null): Promise<void>;
+    /**
+     * Set composable input configuration for this stage.
+     * Multiple configs are deep-merged (later configs win on key conflicts).
+     * If this stage is currently active, the change takes effect immediately.
+     * @example stage.setInputConfiguration(useArrowsForAxes('p1'), useWASDForDirections('p2'));
+     */
+    setInputConfiguration(...configs: GameInputConfig[]): this;
+    load(id: string, camera?: ZylemCamera | CameraWrapper | null, rendererManager?: RendererManager | null): Promise<void>;
     private applyLifecycleCallbacks;
     addEntities(entities: BaseNode[]): Promise<void>;
     add(...inputs: Array<EntityInput>): void;
@@ -328,6 +502,24 @@ declare class Stage {
      * @example stage.getEntityByName('scoreText', TEXT_TYPE)
      */
     getEntityByName<T extends symbol | void = void>(name: string, type?: T): T extends keyof EntityTypeMap ? EntityTypeMap[T] | undefined : BaseNode | undefined;
+    /**
+     * Add a camera to this stage.
+     * @param camera The ZylemCamera or CameraWrapper to add
+     * @param name Optional name for lookup
+     */
+    addCamera(camera: ZylemCamera | CameraWrapper, name?: string): string | null;
+    /**
+     * Remove a camera from this stage by name or reference.
+     */
+    removeCamera(nameOrRef: string | ZylemCamera | CameraWrapper): boolean;
+    /**
+     * Set the active camera by name or reference.
+     */
+    setActiveCamera(nameOrRef: string | ZylemCamera | CameraWrapper): boolean;
+    /**
+     * Get a camera by name from the camera manager.
+     */
+    getCamera(name: string): ZylemCamera | null;
     /**
      * Dispatch an event from the stage.
      * Events are emitted both locally and to the global event bus.
@@ -372,4 +564,4 @@ interface StageInterface {
     state: StageStateInterface;
 }
 
-export { type StageStateInterface as S, type StageOptions as a, Stage as b, createStage as c, createDisk as d, type StageInterface as e };
+export { type BaseGlobals as B, type GameInputConfig as G, type StageStateInterface as S, type ZylemGameConfig as Z, type StageOptions as a, Stage as b, createStage as c, createDisk as d, type StageInterface as e };

package/dist/stage.d.ts

@@ -1,16 +1,19 @@
-import { S as StageStateInterface } from './stage-types-Bd-KtcYT.js';
-export { a as StageOptions, c as createStage } from './stage-types-Bd-KtcYT.js';
-export { S as StageBlueprint, e as entitySpawner } from './blueprints-Cq3Ko6_G.js';
-import './world-C8tQ7Plj.js';
+import { S as StageStateInterface } from './stage-types-BFsm3qsZ.js';
+export { a as StageOptions, c as createStage } from './stage-types-BFsm3qsZ.js';
+export { S as StageBlueprint, e as entitySpawner } from './blueprints-BWGz8fII.js';
+import './entity-BpbZqg19.js';
 import 'three';
 import '@dimforge/rapier3d-compat';
-import './entity-Bq_eNEDI.js';
 import 'bitecs';
 import 'mitt';
-import './camera-CeJPAgGg.js';
+import './behavior-descriptor-BWNWmIjv.js';
+import './world-Be5m1XC1.js';
+import './entity-Bq_eNEDI.js';
+import './camera-B5e4c78l.js';
+import 'three/webgpu';
 import 'three/examples/jsm/postprocessing/EffectComposer.js';
 import './entity-types-DAu8sGJH.js';
-import './entities-DvByhMGU.js';
+import './entities-DC9ce_vx.js';
 import '@sinclair/typebox';
 
 /**