@doki-land/live2d 0.0.10 → 0.0.12

package/README.md

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

package/dist/index.d.ts

@@ -0,0 +1,326 @@
+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, 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). */
+type MotionSegmentKind = "linear" | "bezier" | "stepped" | "inverseStepped";
+type MotionCurveTarget = "Parameter" | "PartOpacity" | "Model";
+interface MotionPoint {
+    readonly time: number;
+    readonly value: number;
+}
+interface MotionSegment {
+    readonly kind: MotionSegmentKind;
+    /** Segment start (inclusive). */
+    readonly p0: MotionPoint;
+    /** Bezier controls (bezier only). */
+    readonly p1?: MotionPoint;
+    readonly p2?: MotionPoint;
+    /** Segment end. */
+    readonly p3: MotionPoint;
+}
+interface MotionCurve {
+    readonly target: MotionCurveTarget;
+    readonly id: string;
+    readonly fadeInTime?: number;
+    readonly fadeOutTime?: number;
+    readonly segments: readonly MotionSegment[];
+}
+interface MotionUserData {
+    readonly time: number;
+    readonly value: string;
+}
+interface Motion3Clip {
+    readonly version: number;
+    readonly duration: number;
+    readonly fps: number;
+    readonly loop: boolean;
+    readonly areBeziersRestricted: boolean;
+    readonly fadeInTime: number;
+    readonly fadeOutTime: number;
+    readonly curves: readonly MotionCurve[];
+    readonly userData: readonly MotionUserData[];
+}
+/** Cubism-style priority: higher wins; equal may replace. */
+declare const MotionPriority: {
+    readonly none: 0;
+    readonly idle: 1;
+    readonly normal: 2;
+    readonly force: 3;
+};
+type MotionPriorityLevel = (typeof MotionPriority)[keyof typeof MotionPriority];
+interface PlayMotionOptions {
+    /** Default {@link MotionPriority.normal}. */
+    priority?: MotionPriorityLevel;
+    /**
+     * Parallel layer id. Default `priority:{n}` so different priorities
+     * can play together; same slot replaces or queues.
+     */
+    slot?: string;
+    /**
+     * When the slot is busy, enqueue instead of replacing / rejecting.
+     * Default false.
+     */
+    queue?: boolean;
+    /** Override clip Meta.Loop. */
+    loop?: boolean;
+    /** Override fade-in seconds (clip / definition). */
+    fadeInTime?: number;
+    /** Override fade-out seconds. */
+    fadeOutTime?: number;
+}
+interface MotionApplySample {
+    readonly target: MotionCurveTarget;
+    readonly id: string;
+    readonly value: number;
+    /** 0..1 fade weight for this frame. */
+    readonly weight: number;
+}
+
+/**
+ * Sample all curves of a clip at `timeSeconds` (clamped to [0, duration]
+ * unless looping — caller should wrap time for loops).
+ */
+declare function evaluateMotion3(clip: Motion3Clip, timeSeconds: number): Array<{
+    target: MotionCurve["target"];
+    id: string;
+    value: number;
+}>;
+declare function evaluateCurve(curve: MotionCurve, timeSeconds: number, areBeziersRestricted: boolean): number;
+
+interface MotionPlayerHandlers {
+    onStart?: (info: {
+        group: string;
+        index: number;
+        slot: string;
+    }) => void;
+    onFinish?: (info: {
+        group: string;
+        index: number;
+        slot: string;
+    }) => void;
+    onEvent?: (info: {
+        group: string;
+        index: number;
+        slot: string;
+        time: number;
+        value: string;
+    }) => void;
+}
+/**
+ * Multi-slot motion player with per-slot queue.
+ *
+ * Default slot is `priority:{n}` so idle (1) and normal (2) can run together.
+ * Same slot replaces (with fade-out) unless `queue: true`.
+ */
+declare class MotionPlayer {
+    #private;
+    constructor(handlers?: MotionPlayerHandlers);
+    get isPlaying(): boolean;
+    listPlaying(): ReadonlyArray<{
+        slot: string;
+        group: string;
+        index: number;
+        time: number;
+        priority: MotionPriorityLevel;
+    }>;
+    /** @deprecated Prefer {@link listPlaying}; returns highest-priority slot. */
+    get current(): {
+        group: string;
+        index: number;
+        time: number;
+        priority: MotionPriorityLevel;
+    } | null;
+    /**
+     * Start a clip on a slot. Returns false if rejected by priority
+     * (and not queued).
+     */
+    start(group: string, index: number, clip: Motion3Clip, options?: PlayMotionOptions): boolean;
+    /** Fade out (default) or hard-stop; `slot` omits → all slots. */
+    stop(fade?: boolean, slot?: string): void;
+    clear(): void;
+    /**
+     * Advance all slots and return blended samples (weight baked in; apply as absolute).
+     */
+    update(deltaTimeSeconds: number): MotionApplySample[];
+}
+/** Blend layers low→high priority; later layers lerp over earlier by their weight. */
+declare function blendMotionLayers(layers: ReadonlyArray<{
+    priority: number;
+    samples: readonly MotionApplySample[];
+}>): MotionApplySample[];
+
+/**
+ * Parse Cubism `motion3.json` (FileFormats/motion3.json.md).
+ */
+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[];
+    renderer?: Renderer;
+    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[];
+    hitTest(x: number, y: number): string | null;
+    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;
+    }>;
+    capturePng(opts?: {
+        mimeType?: "image/png";
+        quality?: number;
+    }): Promise<Blob>;
+}
+
+/** Wire moc backends and a renderer into one single-actor session. */
+declare function createLive2D(options?: CreateLive2DOptions): Live2DRuntime;
+
+/**
+ * Map canvas focus (-1..1, Y-up) onto standard Cubism drag parameters.
+ *
+ * Matches the Cubism sample / community widget weights:
+ * ANGLE_X/Y full range, ANGLE_Z = -dragX*dragY, BODY_ANGLE_X, EYE_BALL_*.
+ * Missing ids on a given model are skipped.
+ */
+declare function focusParameterUpdates(parameters: readonly ParameterBinding[], dragX: number, dragY: number): Array<{
+    id: string;
+    value: number;
+}>;
+
+/**
+ * `@doki-land/live2d` — public facade.
+ *
+ * ```ts
+ * import { createLive2D } from "@doki-land/live2d";
+ * ```
+ */
+
+declare const LIVE2D_VERSION: "0.0.0";
+
+export { type CreateLive2DOptions, type CreateLive2dStageFullOptions, LIVE2D_VERSION, type Live2DRuntime, type Motion3Clip, type MotionApplySample, MotionPlayer, MotionPriority, type PlayMotionOptions, blendMotionLayers, createLive2D, createLive2dStage, evaluateCurve, evaluateMotion3, focusParameterUpdates, parseMotion3 };