@zylem/game-lib 0.6.4 → 0.8.0

package/dist/vector-CiSHbivc.d.ts

@@ -0,0 +1,133 @@
+import { EntityHandle, Simulation } from '@zylem/behaviors/core';
+import { Vector3, Vector2 } from 'three';
+
+interface PhysicsVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+interface PhysicsQuaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+interface PhysicsPose {
+    position: PhysicsVector3;
+    rotation: PhysicsQuaternion;
+}
+interface PhysicsPoseHistory {
+    previous: PhysicsPose;
+    current: PhysicsPose;
+}
+interface PhysicsRenderPoseProvider {
+    getPoseHistory(): PhysicsPoseHistory;
+    getRenderPose(alpha: number): PhysicsPose;
+}
+
+/** Shared step counter owned by the world; lets bodies know a step has run. */
+interface SimulationStepClock {
+    steps: number;
+}
+declare class SimulationBody implements PhysicsRenderPoseProvider {
+    private readonly simulation;
+    readonly handle: EntityHandle;
+    private readonly clock;
+    private readonly poseScratch;
+    private readonly renderScratch;
+    private readonly previousScratch;
+    constructor(simulation: Simulation, handle: EntityHandle, clock: SimulationStepClock);
+    translation(): PhysicsVector3;
+    rotation(): PhysicsQuaternion;
+    linvel(): PhysicsVector3;
+    angvel(): PhysicsVector3;
+    setTranslation(translation: PhysicsVector3, _wakeUp?: boolean): void;
+    setRotation(rotation: PhysicsQuaternion, _wakeUp?: boolean): void;
+    setLinvel(velocity: PhysicsVector3, _wakeUp?: boolean): void;
+    setAngvel(velocity: PhysicsVector3, _wakeUp?: boolean): void;
+    applyImpulse(impulse: PhysicsVector3, _wakeUp?: boolean): void;
+    /**
+     * Damping is fixed at body-creation time in the wasm runtime; there is no
+     * live setter FFI yet, so this is accepted (for `MoveableBodyLike`
+     * compatibility) but has no effect.
+     */
+    setLinearDamping(_damping: number): void;
+    /**
+     * Gravity scale is fixed at body-creation time in the wasm runtime; there is
+     * no live setter FFI yet, so this is accepted for Rapier compat but has no
+     * effect. Prefer `gravityScale` on the body definition at spawn time when
+     * possible.
+     */
+    setGravityScale(_scale: number, _wakeUp?: boolean): void;
+    private bodyInfo;
+    bodyType(): number;
+    mass(): number;
+    isSleeping(): boolean;
+    isEnabled(): boolean;
+    private livePose;
+    private static slotToPose;
+    getPoseHistory(): PhysicsPoseHistory;
+    getRenderPose(alpha: number): PhysicsPose;
+    /**
+     * True when the latest render buffer marks this body as sleeping.
+     * Used by instancing to skip matrix writes for settled piles.
+     */
+    isRenderSleeping(): boolean;
+    /**
+     * Zero-allocation render-pose read for hot paths (instanced rendering of
+     * thousands of bodies). Interpolates the previous → current fixed-step
+     * poses straight from the shared render buffer into the provided
+     * out-parameters — no intermediate pose objects.
+     */
+    writeRenderPose(alpha: number, outPosition: {
+        x: number;
+        y: number;
+        z: number;
+    }, outRotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): void;
+    private writeLivePose;
+}
+
+type Vec2 = Vector2;
+type Vec3 = Vector3 | Vec3Components;
+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;
+
+export { type SimulationStepClock as S, type Vec2 as V, type Vec2Components as a, type Vec2Input as b, type Vec3 as c, type Vec3Components as d, type Vec3Input as e, VEC2_ONE as f, VEC2_ZERO as g, VEC3_ONE as h, VEC3_ZERO as i, normalizeVec3 as j, toThreeVector3 as k, SimulationBody as l, normalizeVec2 as n, toThreeVector2 as t };

package/dist/web-components.d.ts

@@ -0,0 +1,70 @@
+import { G as Game, D as DeviceProfile } from './game-C1FHVqXl.js';
+import { D as DebugTools } from './debug-state-BPT6jEog.js';
+import './base-node-life-cycle-D2NuN1VB.js';
+import 'three';
+import './stage-transition-CmGpV4tc.js';
+import './game-interfaces-mchNYSZE.js';
+import './entity-BdSI8CL3.js';
+import '@zylem/behaviors/core';
+import './vector-CiSHbivc.js';
+import './material-9vJ6SZaI.js';
+import 'three/webgpu';
+import './collision-builder-jF-toPIl.js';
+import './events.js';
+import 'mitt';
+import './entity-type-map-Bd69SpAS.js';
+import './entity-DZbFQ1Wg.js';
+import '@zylem/behaviors/particle-emitter';
+import 'three/addons/lines/webgpu/Line2.js';
+import './zylem-camera-C3bn6BTI.js';
+import './default-controls-0-vCnli7.js';
+
+/**
+ * State interface for editor-to-game communication
+ */
+interface ZylemGameState {
+    gameState?: {
+        debugFlag?: boolean;
+        [key: string]: unknown;
+    };
+    toolbarState?: {
+        tool?: DebugTools;
+        paused?: boolean;
+    };
+    [key: string]: unknown;
+}
+declare class ZylemGameElement extends HTMLElement {
+    private _game;
+    private _state;
+    private container;
+    private resizeObserver;
+    private _viewportProfile;
+    private static readonly HOST_CONFIG_MARKER;
+    constructor();
+    /**
+     * Focus the game container for keyboard input
+     */
+    focus(): void;
+    connectedCallback(): void;
+    set game(game: Game<any>);
+    get game(): Game<any> | null;
+    set state(value: ZylemGameState);
+    get state(): ZylemGameState;
+    set viewportProfile(value: DeviceProfile);
+    get viewportProfile(): DeviceProfile;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
+    /**
+     * Sync the web component's state with the game-lib's internal debug state
+     */
+    private syncDebugState;
+    /**
+     * Sync toolbar state with game-lib's debug state
+     */
+    private syncToolbarState;
+    disconnectedCallback(): void;
+    private attachHostContainer;
+    private syncDisplayRuntime;
+}
+
+export { ZylemGameElement, type ZylemGameState };

package/dist/web-components.js

@@ -0,0 +1 @@
+import{a}from"./chunk-TAUWDQZF.js";import"./chunk-JQKS42G4.js";export{a as ZylemGameElement};