@doki-land/live2d 0.0.9 → 0.0.11

package/README.md

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

package/dist/index.d.ts

@@ -0,0 +1,231 @@
+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';
+export { DEFAULT_NPM_CDN, resolveModelSourceUrl, resolveNpmSpecifier } from '@doki-land/live2d-loader';
+import { ModelBackend, Renderer, RendererKind, ParameterBinding } 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 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[];
+}
+interface Live2DRuntime extends Live2DSession {
+    readonly renderer: Renderer;
+    readonly backends: readonly ModelBackend[];
+    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.
+     */
+    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;
+        index: number;
+        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. */
+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, LIVE2D_VERSION, type Live2DRuntime, type Motion3Clip, type MotionApplySample, MotionPlayer, MotionPriority, type PlayMotionOptions, blendMotionLayers, createLive2D, evaluateCurve, evaluateMotion3, focusParameterUpdates, parseMotion3 };