@zylem/game-lib 0.3.14

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

@@ -0,0 +1,53 @@
+import { ColliderDesc } from '@dimforge/rapier3d-compat';
+import { Vector3 } from 'three';
+import { BaseNode } from '../core/base-node';
+import { GameEntityOptions, GameEntity } from './entity';
+import { EntityBuilder } from './builder';
+import { EntityCollisionBuilder } from './builder';
+import { CollisionHandlerDelegate } from '../collision/collision-delegate';
+export type OnHeldParams = {
+    delta: number;
+    self: ZylemZone;
+    visitor: GameEntity<any>;
+    heldTime: number;
+    globals: any;
+};
+export type OnEnterParams = Pick<OnHeldParams, 'self' | 'visitor' | 'globals'>;
+export type OnExitParams = Pick<OnHeldParams, 'self' | 'visitor' | 'globals'>;
+type ZylemZoneOptions = GameEntityOptions & {
+    size?: Vector3;
+    static?: boolean;
+    onEnter?: (params: OnEnterParams) => void;
+    onHeld?: (params: OnHeldParams) => void;
+    onExit?: (params: OnExitParams) => void;
+};
+export declare class ZoneCollisionBuilder extends EntityCollisionBuilder {
+    collider(options: ZylemZoneOptions): ColliderDesc;
+}
+export declare class ZoneBuilder extends EntityBuilder<ZylemZone, ZylemZoneOptions> {
+    protected createEntity(options: Partial<ZylemZoneOptions>): ZylemZone;
+}
+export declare const ZONE_TYPE: unique symbol;
+export declare class ZylemZone extends GameEntity<ZylemZoneOptions> implements CollisionHandlerDelegate {
+    static type: symbol;
+    private _enteredZone;
+    private _exitedZone;
+    private _zoneEntities;
+    constructor(options?: ZylemZoneOptions);
+    handlePostCollision({ delta }: {
+        delta: number;
+    }): boolean;
+    handleIntersectionEvent({ other, delta }: {
+        other: any;
+        delta: number;
+    }): void;
+    onEnter(callback: (params: OnEnterParams) => void): this;
+    onHeld(callback: (params: OnHeldParams) => void): this;
+    onExit(callback: (params: OnExitParams) => void): this;
+    entered(other: any): void;
+    exited(delta: number, key: string): void;
+    held(delta: number, other: any): void;
+}
+type ZoneOptions = BaseNode | Partial<ZylemZoneOptions>;
+export declare function zone(...args: Array<ZoneOptions>): Promise<ZylemZone>;
+export {};

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

@@ -0,0 +1,28 @@
+import { UpdateFunction } from "../core/base-node-life-cycle";
+export type BasicTypes = number | string | boolean;
+export type GlobalVariablesType = Record<string, BasicTypes>;
+export type KeyboardMapping = Record<string, string[]>;
+export type MouseMapping = Record<string, string[]>;
+export interface GameInputPlayerConfig {
+    key?: KeyboardMapping;
+    mouse?: MouseMapping;
+}
+export interface GameInputConfig {
+    p1?: GameInputPlayerConfig;
+    p2?: GameInputPlayerConfig;
+    p3?: GameInputPlayerConfig;
+    p4?: GameInputPlayerConfig;
+    p5?: GameInputPlayerConfig;
+    p6?: GameInputPlayerConfig;
+    p7?: GameInputPlayerConfig;
+    p8?: GameInputPlayerConfig;
+}
+export interface ZylemGameConfig<StageInterface, GameInterface, TGlobals extends Record<string, BasicTypes> = GlobalVariablesType> {
+    id: string;
+    globals?: TGlobals;
+    stages?: StageInterface[];
+    update?: UpdateFunction<GameInterface>;
+    debug?: boolean;
+    time?: number;
+    input?: GameInputConfig;
+}

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

@@ -0,0 +1,10 @@
+import { BasicTypes, GlobalVariablesType } from './game-interfaces';
+declare const state: {
+    id: string;
+    globals: GlobalVariablesType;
+    time: number;
+};
+export declare function setGlobalState<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType, K extends keyof TGlobals = keyof TGlobals>(key: K, value: TGlobals[K]): void;
+export declare function getGlobalState<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType>(): TGlobals;
+export declare function getGlobalState<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType, K extends keyof TGlobals = keyof TGlobals>(key: K): TGlobals[K];
+export { state };

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

@@ -0,0 +1,41 @@
+import { BaseNode } from '../core/base-node';
+import { ZylemGame } from './zylem-game';
+import { Stage } from '../stage/stage';
+import { DestroyFunction, IGame, SetupFunction, UpdateFunction } from '../core/base-node-life-cycle';
+import { GameEntityLifeCycle } from '../entities/entity';
+import { BasicTypes, GlobalVariablesType, ZylemGameConfig } from './game-interfaces';
+export declare class Game<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType> implements IGame<TGlobals> {
+    gameRef: ZylemGame<TGlobals> | null;
+    options: GameOptions<TGlobals>;
+    private pendingGlobalChangeHandlers;
+    update: UpdateFunction<ZylemGame<TGlobals>, TGlobals>;
+    setup: SetupFunction<ZylemGame<TGlobals>, TGlobals>;
+    destroy: DestroyFunction<ZylemGame<TGlobals>, TGlobals>;
+    refErrorMessage: string;
+    constructor(options: GameOptions<TGlobals>);
+    start(): Promise<this>;
+    load(): Promise<ZylemGame<TGlobals>>;
+    setOverrides(): void;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    reset(): Promise<void>;
+    nextStage(): Promise<void>;
+    previousStage(): Promise<void>;
+    goToStage(): Promise<void>;
+    end(): Promise<void>;
+    add(...inputs: Array<Stage | Promise<any> | (() => Stage | Promise<any>)>): this;
+    getGlobal<K extends keyof TGlobals>(key: K): TGlobals[K];
+    setGlobal<K extends keyof TGlobals>(key: K, value: TGlobals[K]): void;
+    onGlobalChange<K extends keyof TGlobals>(key: K, callback: (value: TGlobals[K]) => void): void;
+}
+type GameOptions<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType> = Array<ZylemGameConfig<Stage, Game<TGlobals>, TGlobals> | Stage | GameEntityLifeCycle | BaseNode>;
+/**
+ * create a new game
+ * @param options GameOptions - Array of IGameOptions, Stage, GameEntity, or BaseNode objects
+ * @param options.id Game name string (when using IGameOptions)
+ * @param options.globals Game globals object (when using IGameOptions)
+ * @param options.stages Array of stage objects (when using IGameOptions)
+ * @returns Game
+ */
+export declare function game<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType>(...options: GameOptions<TGlobals>): Game<TGlobals>;
+export {};

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

@@ -0,0 +1,44 @@
+import { Game } from './game';
+import { UpdateContext, SetupContext, DestroyContext } from '../core/base-node-life-cycle';
+import { InputManager } from '../input/input-manager';
+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';
+export declare class ZylemGame<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType> {
+    id: string;
+    initialGlobals: TGlobals;
+    customSetup: ((params: SetupContext<ZylemGame<TGlobals>, TGlobals>) => void) | null;
+    customUpdate: ((params: UpdateContext<ZylemGame<TGlobals>, TGlobals>) => void) | null;
+    customDestroy: ((params: DestroyContext<ZylemGame<TGlobals>, TGlobals>) => void) | null;
+    stages: Stage[];
+    stageMap: Map<string, Stage>;
+    currentStageId: string;
+    previousTimeStamp: number;
+    totalTime: number;
+    timer: Timer;
+    inputManager: InputManager;
+    wrapperRef: Game<TGlobals>;
+    statsRef: {
+        begin: () => void;
+        end: () => void;
+    } | null;
+    defaultCamera: ZylemCamera | null;
+    static FRAME_LIMIT: number;
+    static FRAME_DURATION: number;
+    static MAX_DELTA_SECONDS: number;
+    constructor(options: ZylemGameConfig<Stage, ZylemGame<TGlobals>, TGlobals>, wrapperRef: Game<TGlobals>);
+    loadStage(stage: Stage): Promise<void>;
+    unloadCurrentStage(): void;
+    setGlobals(options: ZylemGameConfig<Stage, ZylemGame<TGlobals>, TGlobals>): void;
+    params(): UpdateContext<ZylemGame<TGlobals>, TGlobals>;
+    start(): void;
+    loop(timestamp: number): void;
+    outOfLoop(): void;
+    getStage(id: string): Stage | undefined;
+    currentStage(): Stage | undefined;
+    getGlobal<K extends keyof TGlobals>(key: K): TGlobals[K];
+    setGlobal<K extends keyof TGlobals>(key: K, value: TGlobals[K]): void;
+    onGlobalChange<K extends keyof TGlobals>(key: K, callback: (value: TGlobals[K]) => void): void;
+}
+export default ZylemGame;

package/dist/lib/graphics/geometries/XZPlaneGeometry.d.ts

@@ -0,0 +1,7 @@
+import { BufferGeometry } from 'three';
+declare class XZPlaneGeometry extends BufferGeometry {
+    constructor(width?: number, height?: number, widthSegments?: number, heightSegments?: number);
+    copy(source: any): this;
+    static fromJSON(data: any): XZPlaneGeometry;
+}
+export { XZPlaneGeometry };

package/dist/lib/graphics/material.d.ts

@@ -0,0 +1,28 @@
+import { Color, Material, Vector2 } from 'three';
+import { shortHash } from '../core/utility';
+import { ZylemShaderType } from '../core/preset-shader';
+export interface MaterialOptions {
+    path?: string;
+    repeat?: Vector2;
+    shader?: ZylemShaderType;
+    color?: Color;
+}
+type BatchGeometryMap = Map<symbol, number>;
+interface BatchMaterialMapObject {
+    geometryMap: BatchGeometryMap;
+    material: Material;
+}
+type BatchKey = ReturnType<typeof shortHash>;
+export type TexturePath = string | null;
+export declare class MaterialBuilder {
+    static batchMaterialMap: Map<BatchKey, BatchMaterialMapObject>;
+    materials: Material[];
+    batchMaterial(options: Partial<MaterialOptions>, entityType: symbol): void;
+    build(options: Partial<MaterialOptions>, entityType: symbol): Promise<void>;
+    withColor(color: Color): this;
+    withShader(shaderType: ZylemShaderType): this;
+    setTexture(texturePath?: TexturePath, repeat?: Vector2): Promise<void>;
+    setColor(color: Color): void;
+    setShader(customShader: ZylemShaderType): void;
+}
+export {};

package/dist/lib/graphics/mesh.d.ts

@@ -0,0 +1,18 @@
+import { BufferGeometry, Material, Mesh } from 'three';
+import { GameEntityOptions } from '../entities/entity';
+/**
+ * TODO: allow for multiple materials requires geometry groups
+ * TODO: allow for instanced uniforms
+ * TODO: allow for geometry groups
+ * TODO: allow for batched meshes
+ * import { InstancedUniformsMesh } from 'three-instanced-uniforms-mesh';
+ * may not need geometry groups for shaders though
+ * setGeometry<T extends BufferGeometry>(geometry: T) {
+ *   MeshBuilder.bachedMesh = new BatchedMesh(10, 5000, 10000, material);
+ * }
+ */
+export type MeshBuilderOptions = Partial<Pick<GameEntityOptions, 'batched' | 'material'>>;
+export declare class MeshBuilder {
+    _build(meshOptions: MeshBuilderOptions, geometry: BufferGeometry, materials: Material[]): Mesh;
+    _postBuild(): void;
+}

package/dist/lib/graphics/render-pass.d.ts

@@ -0,0 +1,16 @@
+import * as THREE from 'three';
+import { WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Pass, FullScreenQuad } from 'three/addons/postprocessing/Pass.js';
+export default class RenderPass extends Pass {
+    fsQuad: FullScreenQuad;
+    resolution: THREE.Vector2;
+    scene: THREE.Scene;
+    camera: THREE.Camera;
+    rgbRenderTarget: WebGLRenderTarget;
+    normalRenderTarget: WebGLRenderTarget;
+    normalMaterial: THREE.Material;
+    constructor(resolution: THREE.Vector2, scene: THREE.Scene, camera: THREE.Camera);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget): void;
+    material(): THREE.ShaderMaterial;
+    dispose(): void;
+}

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

@@ -0,0 +1,49 @@
+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';
+interface SceneState {
+    backgroundColor: Color;
+    backgroundImage: string | null;
+}
+export declare class ZylemScene implements Entity<ZylemScene> {
+    type: string;
+    _setup?: SetupCallback;
+    scene: Scene;
+    zylemCamera: ZylemCamera;
+    containerElement: HTMLElement | null;
+    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
+     */
+    setupCamera(scene: Scene, camera: ZylemCamera): void;
+    /**
+     * Setup scene lighting
+     */
+    setupLighting(scene: Scene): void;
+    /**
+     * Update renderer size - delegates to camera
+     */
+    updateRenderer(width: number, height: number): void;
+    /**
+     * Add object to scene
+     */
+    add(object: Object3D, position?: Vector3): void;
+    /**
+     * Add game entity to scene
+     */
+    addEntity(entity: GameEntity<any>): void;
+    /**
+     * Add debug helpers to scene
+     */
+    debugScene(): void;
+}
+export {};

package/dist/lib/input/gamepad-provider.d.ts

@@ -0,0 +1,13 @@
+import { InputProvider } from './input-provider';
+import { InputGamepad } from './input';
+export declare class GamepadProvider implements InputProvider {
+    private gamepadIndex;
+    private connected;
+    private buttonStates;
+    constructor(gamepadIndex: number);
+    private handleButtonState;
+    private handleAnalogState;
+    getInput(delta: number): Partial<InputGamepad>;
+    getName(): string;
+    isConnected(): boolean;
+}

package/dist/lib/input/input-manager.d.ts

@@ -0,0 +1,14 @@
+import { InputProvider } from './input-provider';
+import { AnalogState, ButtonState, InputPlayerNumber, Inputs } from './input';
+import { GameInputConfig } from '../game/game-interfaces';
+export declare class InputManager {
+    private inputMap;
+    private currentInputs;
+    private previousInputs;
+    constructor(config?: GameInputConfig);
+    addInputProvider(playerNumber: InputPlayerNumber, provider: InputProvider): void;
+    getInputs(delta: number): Inputs;
+    mergeButtonState(a: ButtonState | undefined, b: ButtonState | undefined): ButtonState;
+    mergeAnalogState(a: AnalogState | undefined, b: AnalogState | undefined): AnalogState;
+    private mergeInputs;
+}

package/dist/lib/input/input-provider.d.ts

@@ -0,0 +1,6 @@
+import { InputGamepad } from './input';
+export interface InputProvider {
+    getInput(delta: number): Partial<InputGamepad>;
+    isConnected(): boolean;
+    getName(): string;
+}

package/dist/lib/input/input.d.ts

@@ -0,0 +1,51 @@
+/** Input
+ *
+ * Maximum number of local players is 8.
+ * All input can be mapped to a gamepad or keyboard but shares the common
+ * interface represented as a gamepad.
+ */
+export type InputPlayerNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export type InputPlayer = `p${InputPlayerNumber}`;
+export interface ButtonState {
+    pressed: boolean;
+    released: boolean;
+    held: number;
+}
+export interface AnalogState {
+    value: number;
+    held: number;
+}
+export interface InputGamepad {
+    playerNumber: InputPlayerNumber;
+    buttons: {
+        A: ButtonState;
+        B: ButtonState;
+        X: ButtonState;
+        Y: ButtonState;
+        Start: ButtonState;
+        Select: ButtonState;
+        L: ButtonState;
+        R: ButtonState;
+    };
+    directions: {
+        Up: ButtonState;
+        Down: ButtonState;
+        Left: ButtonState;
+        Right: ButtonState;
+    };
+    shoulders: {
+        LTrigger: ButtonState;
+        RTrigger: ButtonState;
+    };
+    axes: {
+        Horizontal: AnalogState;
+        Vertical: AnalogState;
+    };
+}
+export type Inputs = Record<InputPlayer, InputGamepad>;
+export type ButtonName = keyof InputGamepad['buttons'];
+export type InputHandlerCallback = () => void;
+export interface InputHandler {
+    onPress(button: ButtonName, callback: InputHandlerCallback): void;
+    update(currentInputs: Inputs): void;
+}

package/dist/lib/input/keyboard-provider.d.ts

@@ -0,0 +1,20 @@
+import { InputProvider } from './input-provider';
+import { InputGamepad } from './input';
+export declare class KeyboardProvider implements InputProvider {
+    private keyStates;
+    private keyButtonStates;
+    private mapping;
+    private includeDefaultBase;
+    constructor(mapping?: Record<string, string[]>, options?: {
+        includeDefaultBase?: boolean;
+    });
+    private isKeyPressed;
+    private handleButtonState;
+    private handleAnalogState;
+    private mergeButtonState;
+    private applyCustomMapping;
+    getInput(delta: number): Partial<InputGamepad>;
+    getName(): string;
+    private getAxisValue;
+    isConnected(): boolean;
+}

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

@@ -0,0 +1,31 @@
+import { Collider, KinematicCharacterController, RigidBody } from "@dimforge/rapier3d-compat";
+import { Group, Mesh } from "three";
+export type LifecycleFunction<T> = (params?: any) => void;
+export type CollisionOption = (entity: any, other: any, globals?: Global) => void;
+export interface Entity<T = any> {
+    setup: (entity: T) => void;
+    destroy: () => void;
+    update: LifecycleFunction<T>;
+    type: string;
+    _collision?: (entity: any, other: any, globals?: any) => void;
+    _destroy?: (globals?: any) => void;
+    name?: string;
+    tag?: Set<string>;
+}
+export interface StageEntity extends Entity {
+    uuid: string;
+    body: RigidBody;
+    group: Group;
+    mesh: Mesh;
+    instanceId: number;
+    collider: Collider;
+    controlledRotation: boolean;
+    characterController: KinematicCharacterController;
+    name: string;
+    markedForRemoval: boolean;
+}
+export type OptionalVector = {
+    x?: number;
+    y?: number;
+    z?: number;
+};

package/dist/lib/interfaces/game.d.ts

@@ -0,0 +1,19 @@
+import ZylemGame from '~/lib/game/zylem-game';
+import { ZylemScene } from '~/lib/graphics/zylem-scene';
+import { ZylemCamera } from '~/lib/camera/zylem-camera';
+import { ZylemWorld } from '~/lib/collision/world';
+export type GameRatio = '16:9' | '9:16' | '4:3' | '3:4' | '1:1';
+type Concrete<Type> = {
+    [Property in keyof Type]-?: Type[Property];
+};
+export type Conditions<T> = {
+    bindings: string[];
+    callback: (globals: Concrete<T>, game: ZylemGame) => void;
+};
+export interface SetupCallbackOptions {
+    scene: ZylemScene;
+    world?: ZylemWorld;
+    camera?: ZylemCamera;
+}
+export type SetupCallback = (options: SetupCallbackOptions) => void;
+export {};

package/dist/lib/sounds/index.d.ts

@@ -0,0 +1,2 @@
+export { ricochetSound } from "./ricochet-sound";
+export { pingPongBeep } from "./ping-pong-sound";

package/dist/lib/sounds/ping-pong-sound.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Plays a ping-pong beep sound effect.
+ */
+export declare function pingPongBeep(frequency?: number, duration?: number): void;

package/dist/lib/sounds/ricochet-sound.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Plays a ricochet sound effect when boundary collision occurs
+ */
+export declare function ricochetSound(frequency?: number, duration?: number): void;

package/dist/lib/stage/debug-entity-cursor.d.ts

@@ -0,0 +1,23 @@
+import { Color, Object3D, Scene } from 'three';
+/**
+ * Debug overlay that displays an axis-aligned bounding box around a target Object3D.
+ * Shows a semi-transparent fill plus a wireframe outline. Intended for SELECT/DELETE tools.
+ */
+export declare class DebugEntityCursor {
+    private scene;
+    private container;
+    private fillMesh;
+    private edgeLines;
+    private currentColor;
+    private bbox;
+    private size;
+    private center;
+    constructor(scene: Scene);
+    setColor(color: Color | number): void;
+    /**
+     * Update the cursor to enclose the provided Object3D using a world-space AABB.
+     */
+    updateFromObject(object: Object3D | null | undefined): void;
+    hide(): void;
+    dispose(): void;
+}

package/dist/lib/stage/entity-spawner.d.ts

@@ -0,0 +1,8 @@
+import { Vector2 } from "three";
+import { GameEntity } from "../entities";
+import { Stage } from "./stage";
+export interface EntitySpawner {
+    spawn: (stage: Stage, x: number, y: number) => Promise<GameEntity<any>>;
+    spawnRelative: (source: any, stage: Stage, offset?: Vector2) => Promise<any | void>;
+}
+export declare function entitySpawner(factory: (x: number, y: number) => Promise<any> | GameEntity<any>): EntitySpawner;

package/dist/lib/stage/stage-debug-delegate.d.ts

@@ -0,0 +1,25 @@
+import { Vector3 } from 'three';
+import { ZylemStage } from './zylem-stage';
+export type AddEntityFactory = (params: {
+    position: Vector3;
+    normal?: Vector3;
+}) => Promise<any> | any;
+export interface StageDebugDelegateOptions {
+    maxRayDistance?: number;
+    addEntityFactory?: AddEntityFactory | null;
+}
+export declare class StageDebugDelegate {
+    private stage;
+    private options;
+    private mouseNdc;
+    private raycaster;
+    private isMouseDown;
+    private disposeFns;
+    private debugCursor;
+    private debugLines;
+    constructor(stage: ZylemStage, options?: StageDebugDelegateOptions);
+    update(): void;
+    dispose(): void;
+    private handleActionOnHit;
+    private attachDomListeners;
+}

package/dist/lib/stage/stage-state.d.ts

@@ -0,0 +1,12 @@
+import { Color } from 'three';
+import { BaseEntityInterface } from '../types/entity-types';
+import { StageStateInterface } from '../types/stage-types';
+declare const stageState: StageStateInterface;
+declare const setStageState: (state: StageStateInterface) => void;
+declare const setStageBackgroundColor: (value: Color) => void;
+declare const setStageBackgroundImage: (value: string | null) => void;
+declare const setEntitiesToStage: (entities: Partial<BaseEntityInterface>[]) => void;
+declare const setStageVariable: (key: string, value: any) => void;
+declare const getStageVariable: (key: string) => any;
+declare const stageStateToString: (state: StageStateInterface) => string;
+export { stageState, setStageState, setStageBackgroundColor, setStageBackgroundImage, setEntitiesToStage, stageStateToString, setStageVariable, getStageVariable, };

package/dist/lib/stage/stage.d.ts

@@ -0,0 +1,33 @@
+import { BaseNode } from '../core/base-node';
+import { DestroyFunction, SetupContext, SetupFunction, UpdateFunction } from '../core/base-node-life-cycle';
+import { StageOptions, ZylemStage } from './zylem-stage';
+import { ZylemCamera } from '../camera/zylem-camera';
+import { CameraWrapper } from '../camera/camera';
+type NodeLike = {
+    create: Function;
+};
+type AnyNode = NodeLike | Promise<NodeLike>;
+type EntityInput = AnyNode | (() => AnyNode) | (() => Promise<any>);
+export declare class Stage {
+    stageRef: ZylemStage;
+    options: StageOptions;
+    update: UpdateFunction<ZylemStage>;
+    setup: SetupFunction<ZylemStage>;
+    destroy: DestroyFunction<ZylemStage>;
+    constructor(options: StageOptions);
+    load(id: string, camera?: ZylemCamera | CameraWrapper | null): Promise<void>;
+    addEntities(entities: BaseNode[]): Promise<void>;
+    add(...inputs: Array<EntityInput>): void;
+    start(params: SetupContext<ZylemStage>): void;
+    onUpdate(...callbacks: UpdateFunction<ZylemStage>[]): void;
+    onSetup(callback: SetupFunction<ZylemStage>): void;
+    onDestroy(callback: DestroyFunction<ZylemStage>): void;
+    setVariable(key: string, value: any): void;
+    getVariable(key: string): any;
+    watchVariable(key: string, callback: (value: any) => void): void;
+}
+/**
+ * Create a stage with optional camera
+ */
+export declare function stage(...options: StageOptions): Stage;
+export {};