@doki-land/live2d 0.0.11 → 0.0.12

package/README.md

@@ -1,3 +1,3 @@
 # @doki-land/live2d
 
-live2d.ts package 0.0.11.
+live2d.ts package 0.0.12.

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { Live2DSession, MotionDefinition } from '@doki-land/live2d-core';
-export { AssetResolver, EventEmitter, FrameProfile, FrameSnapshot, InternalModel, Live2DSession, LoadProgress, LoadProgressStage, ModelFormat, ModelInstance, ModelProgram, ModelSettings, ModelSource, SessionPhase, SessionState } from '@doki-land/live2d-core';
+import * as _doki_land_live2d_core from '@doki-land/live2d-core';
+import { LoadProgress, InternalModel, ModelSource, AssetResolver, Live2dActor, CreateActorOptions, ActorTransform, ActorHit, CreateLive2dStageOptions, Live2dStage, PointerTrackingPolicy, StagePointerEvent, Live2DSession } from '@doki-land/live2d-core';
+export { ActorHit, ActorTransform, AssetResolver, CreateActorOptions, CreateLive2dStageOptions, DEFAULT_ACTOR_TRANSFORM, EventEmitter, FrameProfile, FrameSnapshot, InternalModel, Live2DSession, Live2dActor, Live2dStage, LoadProgress, LoadProgressStage, ModelFormat, ModelInstance, ModelProgram, ModelSettings, ModelSource, PointerTrackingMode, PointerTrackingPolicy, SessionPhase, SessionState, StagePointerEvent, StageUpdateMode } from '@doki-land/live2d-core';
 export { DEFAULT_NPM_CDN, resolveModelSourceUrl, resolveNpmSpecifier } from '@doki-land/live2d-loader';
-import { ModelBackend, Renderer, RendererKind, ParameterBinding } from '@doki-land/live2d-renderer';
+import { ModelBackend, Renderer, ParameterBinding, DrawableMesh, RendererKind } from '@doki-land/live2d-renderer';
 export { ModelBackend, ParameterBinding, Renderer, RendererKind, createCanvas2DRenderer, createMoc2Backend, createMoc3Backend, createQuadProgram, createRenderer, createWebGl2Renderer, createWebGpuRenderer, decodeMoc3, evaluateFrame, fingerprintSnapshot, parseCpuProgram, serializeCpuProgram } from '@doki-land/live2d-renderer';
 
 /** Cubism motion3 segment kinds (spec). */
@@ -157,36 +158,133 @@ declare function blendMotionLayers(layers: ReadonlyArray<{
  */
 declare function parseMotion3(json: unknown): Motion3Clip;
 
+interface ActorModelSlotOptions {
+    backends: readonly ModelBackend[];
+    renderer: Renderer;
+    onProgress?: (payload: LoadProgress) => void;
+    onMotionStart?: (payload: {
+        group: string;
+        index: number;
+        slot: string;
+    }) => void;
+    onMotionFinish?: (payload: {
+        group: string;
+        index: number;
+        slot: string;
+    }) => void;
+}
+/** One loaded model + draw pass owned by an actor (not a renderer). */
+declare class ActorModelSlot {
+    #private;
+    constructor(options: ActorModelSlotOptions);
+    get model(): InternalModel | null;
+    get drawPass(): ReturnType<Renderer["createModelDrawPass"]> | null;
+    ensureDrawPass(): ReturnType<Renderer["createModelDrawPass"]>;
+    load(source: ModelSource, resolver?: AssetResolver): Promise<InternalModel>;
+    setParameter(id: string, value: number): void;
+    listParameters(): readonly ParameterBinding[];
+    listMotionGroups(): Record<string, readonly _doki_land_live2d_core.MotionDefinition[]>;
+    playMotion(group: string, index?: number, options?: PlayMotionOptions): Promise<boolean>;
+    stopMotion(opts?: {
+        fade?: boolean;
+        slot?: string;
+    }): void;
+    listPlayingMotions(): ReadonlyArray<{
+        slot: string;
+        group: string;
+        index: number;
+        time: number;
+        priority: number;
+    }>;
+    update(deltaTimeSeconds: number): DrawableMesh[] | null;
+    hitTestModelCoords(modelX: number, modelY: number): string | null;
+    destroy(): void;
+}
+
+interface Live2dActorImplOptions {
+    id: string;
+    creationIndex: number;
+    backends: readonly ModelBackend[];
+    renderer: Renderer;
+}
+declare class Live2dActorImpl implements Live2dActor {
+    #private;
+    readonly id: string;
+    readonly creationIndex: number;
+    constructor(options: CreateActorOptions | undefined, shared: Live2dActorImplOptions);
+    get model(): InternalModel | null;
+    get visible(): boolean;
+    set visible(value: boolean);
+    get opacity(): number;
+    set opacity(value: number);
+    get layer(): string;
+    set layer(value: string);
+    get order(): number;
+    set order(value: number);
+    getTransform(): ActorTransform;
+    setTransform(patch: Partial<ActorTransform>): void;
+    load(source: Parameters<Live2dActor["load"]>[0], resolver?: Parameters<Live2dActor["load"]>[1]): Promise<InternalModel>;
+    setParameter(id: string, value: number): void;
+    lookAt(stageX: number, stageY: number): void;
+    /** Internal: evaluate motion/physics and cache drawables for render. */
+    update(deltaTimeSeconds: number): DrawableMesh[] | null;
+    get lastDrawables(): DrawableMesh[] | null;
+    get slot(): ActorModelSlot;
+    hitTestStage(stageX: number, stageY: number): Omit<ActorHit, "actor"> | null;
+    destroy(): void;
+}
+
+interface CreateLive2dStageFullOptions extends CreateLive2dStageOptions {
+    backends?: ModelBackend[];
+    renderer?: Renderer;
+    prefer?: RendererKind[];
+}
+type PointerListener = (event: StagePointerEvent) => void;
+declare class Live2dStageImpl implements Live2dStage {
+    #private;
+    constructor(options?: CreateLive2dStageFullOptions);
+    get actors(): readonly Live2dActor[];
+    get pointerTracking(): PointerTrackingPolicy;
+    set pointerTracking(policy: PointerTrackingPolicy);
+    get renderer(): Renderer;
+    mount(canvas: HTMLCanvasElement): Promise<void>;
+    createActor(options?: CreateActorOptions): Live2dActor;
+    removeActor(actorOrId: Live2dActor | string): void;
+    defineLayers(layers: readonly string[]): void;
+    update(deltaTimeSeconds: number): void;
+    render(): void;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    hitTest(stageX: number, stageY: number): ActorHit | null;
+    hitTestAll(stageX: number, stageY: number): readonly ActorHit[];
+    addEventListener(type: "pointerdown" | "pointermove" | "pointerup", listener: PointerListener): void;
+    removeEventListener(type: "pointerdown" | "pointermove" | "pointerup", listener: PointerListener): void;
+    destroy(): void;
+}
+declare function createLive2dStage(options?: CreateLive2dStageFullOptions): Live2dStage;
+
 interface CreateLive2DOptions {
     backends?: ModelBackend[];
-    /** Defaults to `createRenderer({ prefer })` (async fallback on initialize). */
     renderer?: Renderer;
-    /**
-     * Renderer try order when `renderer` is omitted.
-     * Default: `["webgpu", "webgl2", "canvas2d"]`.
-     */
     prefer?: RendererKind[];
+    updateMode?: "auto" | "manual";
 }
 interface Live2DRuntime extends Live2DSession {
     readonly renderer: Renderer;
     readonly backends: readonly ModelBackend[];
+    readonly stage: Live2dStageImpl;
+    readonly actor: Live2dActorImpl;
     setParameter(id: string, value: number): void;
     listParameters(): readonly ParameterBinding[];
-    /** Hit-test the current model in normalized canvas coordinates (-1..1). */
     hitTest(x: number, y: number): string | null;
-    /** Motion groups from the loaded model settings. */
-    listMotionGroups(): Record<string, readonly MotionDefinition[]>;
-    /**
-     * Load and play a motion from `settings.motionGroups[group][index]`.
-     * Returns false if priority rejects or the entry is missing.
-     */
+    listMotionGroups(): Record<string, readonly _doki_land_live2d_core.MotionDefinition[]>;
     playMotion(group: string, index?: number, options?: PlayMotionOptions): Promise<boolean>;
-    /** Fade out (default) or hard-stop. Optional slot; omit = all slots. */
     stopMotion(opts?: {
         fade?: boolean;
         slot?: string;
     }): void;
-    /** Active motion slots (idle + tap can both appear). */
     listPlayingMotions(): ReadonlyArray<{
         slot: string;
         group: string;
@@ -194,16 +292,13 @@ interface Live2DRuntime extends Live2DSession {
         time: number;
         priority: number;
     }>;
-    /**
-     * Draw one frame and encode the canvas as PNG.
-     * Works for Canvas2D and WebGL2 (`preserveDrawingBuffer`).
-     */
     capturePng(opts?: {
         mimeType?: "image/png";
         quality?: number;
     }): Promise<Blob>;
 }
-/** Wire moc backends and a renderer into one session. */
+
+/** Wire moc backends and a renderer into one single-actor session. */
 declare function createLive2D(options?: CreateLive2DOptions): Live2DRuntime;
 
 /**
@@ -228,4 +323,4 @@ declare function focusParameterUpdates(parameters: readonly ParameterBinding[],
 
 declare const LIVE2D_VERSION: "0.0.0";
 
-export { type CreateLive2DOptions, LIVE2D_VERSION, type Live2DRuntime, type Motion3Clip, type MotionApplySample, MotionPlayer, MotionPriority, type PlayMotionOptions, blendMotionLayers, createLive2D, evaluateCurve, evaluateMotion3, focusParameterUpdates, parseMotion3 };
+export { type CreateLive2DOptions, type CreateLive2dStageFullOptions, LIVE2D_VERSION, type Live2DRuntime, type Motion3Clip, type MotionApplySample, MotionPlayer, MotionPriority, type PlayMotionOptions, blendMotionLayers, createLive2D, createLive2dStage, evaluateCurve, evaluateMotion3, focusParameterUpdates, parseMotion3 };