@doki-land/live2d 0.0.10 → 0.0.12

package/dist/reexports/core.d.ts

@@ -0,0 +1,3 @@
+export * from '@doki-land/live2d-core';
+import '@doki-land/live2d-loader';
+import '@doki-land/live2d-renderer';

package/dist/reexports/core.js

@@ -0,0 +1,2 @@
+// src/reexports/core.ts
+export * from "@doki-land/live2d-core";

package/dist/reexports/loader.d.ts

@@ -0,0 +1 @@
+export * from '@doki-land/live2d-loader';

package/dist/reexports/loader.js

@@ -0,0 +1,2 @@
+// src/reexports/loader.ts
+export * from "@doki-land/live2d-loader";

package/dist/reexports/renderer.d.ts

@@ -0,0 +1 @@
+export * from '@doki-land/live2d-renderer';

package/dist/reexports/renderer.js

@@ -0,0 +1,2 @@
+// src/reexports/renderer.ts
+export * from "@doki-land/live2d-renderer";

package/package.json

@@ -1,47 +1,65 @@
 {
-    "name": "@doki-land/live2d",
-    "version": "0.0.10",
-    "keywords": [
-        "live2d",
-        "pixi",
-        "typescript"
-    ],
-    "description": "Live2D TypeScript runtime based on pixi",
-    "author": "Aster <192608617@qq.com>",
-    "license": "LGPL-3.0-or-later",
-    "type": "module",
+  "name": "@doki-land/live2d",
+  "version": "0.0.12",
+  "description": "Live2D TypeScript library — public facade for Doki Land",
+  "type": "module",
+  "license": "MIT",
+  "author": "Doki Land",
+  "homepage": "https://github.com/doki-land/live2d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/doki-land/live2d.ts.git"
+  },
+  "keywords": [
+    "live2d",
+    "webgpu",
+    "webgl2",
+    "doki-land"
+  ],
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./core": "./src/reexports/core.ts",
+    "./loader": "./src/reexports/loader.ts",
+    "./renderer": "./src/reexports/renderer.ts"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
     "exports": {
-        ".": {
-            "types": "./src/index.ts",
-            "import": "./src/index.ts",
-            "require": "./dist/l2d.umd.js"
-        },
-        "./*": {
-            "types": "./src/*/index.ts",
-            "import": "./src/*/index.ts"
-        }
-    },
-    "files": [
-        "dist",
-        "lib",
-        "src"
-    ],
-    "publishConfig": {
-        "registry": "https://registry.npmjs.org",
-        "access": "public"
-    },
-    "scripts": {
-        "dev": "vite",
-        "build": "vite build",
-        "preview": "vite preview",
-        "prepublishOnly": "pnpm build"
-    },
-    "dependencies": {
-        "@pixi/core": "^7.4.3",
-        "@pixi/display": "^7.4.3",
-        "@pixi/ticker": "^7.4.3",
-        "minimatch": "^10.0.1",
-        "pixi-live2d-display-lipsyncpatch": "0.5.0-ls-7",
-        "pixi.js": "^7.4.3"
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      },
+      "./core": {
+        "types": "./dist/reexports/core.d.ts",
+        "import": "./dist/reexports/core.js"
+      },
+      "./loader": {
+        "types": "./dist/reexports/loader.d.ts",
+        "import": "./dist/reexports/loader.js"
+      },
+      "./renderer": {
+        "types": "./dist/reexports/renderer.d.ts",
+        "import": "./dist/reexports/renderer.js"
+      }
     }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/reexports/core.ts src/reexports/loader.ts src/reexports/renderer.ts --format esm --dts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests"
+  },
+  "dependencies": {
+    "@doki-land/live2d-core": "0.0.12",
+    "@doki-land/live2d-loader": "0.0.12",
+    "@doki-land/live2d-renderer": "0.0.12"
+  },
+  "sideEffects": false
 }

package/src/create-live2d.ts

@@ -0,0 +1,39 @@
+import {
+    createMoc2Backend,
+    createMoc3Backend,
+    createRenderer,
+} from "@doki-land/live2d-renderer";
+import { allocateActorId } from "./stage/actor.js";
+import {
+    type CreateLive2DOptions,
+    createSingleActorFacade,
+    type Live2DRuntime,
+} from "./stage/single-facade.js";
+import { createLive2dStage } from "./stage/stage.js";
+
+export type {
+    CreateLive2DOptions,
+    Live2DRuntime,
+} from "./stage/single-facade.js";
+export {
+    MotionPriority,
+    type PlayMotionOptions,
+} from "./stage/single-facade.js";
+
+/** Wire moc backends and a renderer into one single-actor session. */
+export function createLive2D(options: CreateLive2DOptions = {}): Live2DRuntime {
+    const backends = options.backends ?? [
+        createMoc2Backend(),
+        createMoc3Backend(),
+    ];
+    const stage = createLive2dStage({
+        backends,
+        renderer:
+            options.renderer ?? createRenderer({ prefer: options.prefer }),
+        updateMode: options.updateMode ?? "manual",
+    }) as import("./stage/stage.js").Live2dStageImpl;
+    const actor = stage.createActor({
+        id: allocateActorId("default"),
+    }) as import("./stage/actor.js").Live2dActorImpl;
+    return createSingleActorFacade(stage, actor, backends);
+}

package/src/focus.ts

@@ -0,0 +1,53 @@
+import type { ParameterBinding } from "@doki-land/live2d-renderer";
+
+/**
+ * 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.
+ */
+export function focusParameterUpdates(
+    parameters: readonly ParameterBinding[],
+    dragX: number,
+    dragY: number,
+): Array<{ id: string; value: number }> {
+    const byId = new Map(parameters.map((p) => [p.id, p]));
+    const x = clampUnit(dragX);
+    const y = clampUnit(dragY);
+    const out: Array<{ id: string; value: number }> = [];
+
+    const set = (id: string, normalized: number) => {
+        const binding = byId.get(id);
+        if (!binding) return;
+        out.push({ id, value: valueFromNormalized(binding, normalized) });
+    };
+
+    set("PARAM_ANGLE_X", x);
+    set("PARAM_ANGLE_Y", y);
+    set("PARAM_ANGLE_Z", clampUnit(x * y * -1));
+    // Official sample uses dragX*10 vs ANGLE's *30; BODY range is typically ±10,
+    // so full-range normalized drag still matches that relative weight.
+    set("PARAM_BODY_ANGLE_X", x);
+    set("PARAM_BODY_ANGLE_Y", y);
+    set("PARAM_EYE_BALL_X", x);
+    set("PARAM_EYE_BALL_Y", y);
+
+    return out;
+}
+
+function clampUnit(n: number): number {
+    if (n > 1) return 1;
+    if (n < -1) return -1;
+    return n;
+}
+
+function valueFromNormalized(
+    binding: ParameterBinding,
+    normalized: number,
+): number {
+    const n = clampUnit(normalized);
+    return n >= 0
+        ? binding.defaultValue + (binding.max - binding.defaultValue) * n
+        : binding.defaultValue + (binding.defaultValue - binding.min) * n;
+}

package/src/index.ts

@@ -1,190 +1,81 @@
-import '../lib/cubism2.min.js';
-import '../lib/cubism5.min.js';
-import * as PIXI from 'pixi.js';
-import {Application} from 'pixi.js';
-import {Ticker} from '@pixi/ticker';
-import {Live2DModel, MotionManager, SoundManager} from 'pixi-live2d-display-lipsyncpatch';
-import './icons/style.css';
-import {Live2dOptions} from '@doki-land/live2d/types';
-
-export {MotionManager, SoundManager, Live2DModel, PIXI};
-
-/**
- * 创建Live2D模型
- * @param options 模型配置选项
- * @returns Promise<Live2DModel> 加载完成的Live2D模型实例
- */
-export async function createLive2D(options: Live2dOptions): Promise<Live2DModel> {
-    const {
-        element_id = 'live2d-canvas',
-        models,
-        width = 300,
-        height = 300,
-        auto_fit = true,
-        auto_motion = true,
-        mouse_tracking = true
-    } = options;
-    // 创建画布
-    let element = findOrCreateCanvas(element_id, options)
-    // 初始化PIXI应用
-    const app = new Application({
-        view: element,
-        width: width,
-        height: height,
-        // resolution: 1,
-        backgroundAlpha: 0,
-        autoDensity: true,
-        antialias: true,
-        eventMode: 'static',
-        eventFeatures: {
-            move: true,
-            globalMove: true,
-            click: true,
-            wheel: true
-        }
-    });
-
-    // 加载模型
-    const model = await Live2DModel.from(models[0].model_url, {
-        ticker: Ticker.system,
-    });
-    // 添加模型到舞台
-    app.stage.addChild(model);
-
-    // 自动适应大小
-    if (auto_fit) {
-        // 修复auto_fit功能，确保模型不被截断且保持正确比例
-        const scale = Math.min(width / model.width, height / model.height);
-        model.scale.set(scale);
-
-        // 居中显示，确保模型完全可见
-        model.x = (width - model.width * scale) / 2;
-        model.y = (height - model.height * scale) / 2;
-    }
-
-    // 启用鼠标跟踪
-    if (mouse_tracking) {
-        enableMouseTracking(model, app.view);
-    }
-
-    // 自动开始动画
-    if (auto_motion) {
-        await startIdleAnimation(model);
-    }
-
-    // 创建右侧图标栏
-    // createIconPanel(model, element);
-
-    return model;
-}
-
-function findOrCreateCanvas(id: string, options: Live2dOptions): HTMLCanvasElement {
-    let canvas = document.getElementById(id) as HTMLCanvasElement;
-    if (!canvas) {
-        canvas = document.createElement('canvas');
-        canvas.id = id;
-        canvas.classList.add('live2d-canvas')
-        canvas.style.bottom = `${options.spacing_y || 0}px`;
-        canvas.style[options.position === 'left' ? 'left' : 'right'] = `${options.spacing_x || 0}px`;
-        document.body.appendChild(canvas);
-    }
-    return canvas;
-}
-
-
-/**
- * 启用鼠标跟踪功能
- * @param model Live2D模型实例
- * @param canvas 画布元素
- */
-function enableMouseTracking(model: Live2DModel, canvas: any) {
-    // 跟踪鼠标移动
-    document.addEventListener('mousemove', (event) => {
-        const rect = canvas.getBoundingClientRect();
-        const centerX = rect.left + rect.width / 2;
-        const centerY = rect.top + rect.height / 2;
-
-        // 计算鼠标位置相对于画布中心的偏移
-        const mouseX = (event.clientX - centerX) / rect.width;
-        // 修正Y轴方向，使用负值来反转方向
-        const mouseY = -(event.clientY - centerY) / rect.height;
-
-        // 更新模型的视线方向
-        if (model.internalModel) {
-            model.internalModel.focusController?.focus(mouseX, mouseY);
-        }
-    });
-
-    // 添加点击模型触发动作的交互
-    canvas.addEventListener('click', () => {
-        // 尝试播放tap_body动作，如果没有则尝试其他可用动作
-        try {
-            const motions = model.internalModel?.motionManager.definitions;
-            if (motions) {
-                if (motions.tap_body) {
-                    model.motion('tap_body');
-                } else if (motions.tap) {
-                    model.motion('tap');
-                } else {
-                    // 使用第一个可用的动作组
-                    const firstMotionGroup = Object.keys(motions)[0];
-                    if (firstMotionGroup) {
-                        model.motion(firstMotionGroup);
-                    }
-                }
-            }
-        } catch (error) {
-            console.warn('Failed to play tap animation:', error);
-        }
-    });
-}
-
-/**
- * 开始空闲动画
- * @param model Live2D模型实例
- */
-async function startIdleAnimation(model: Live2DModel) {
-    // 尝试播放内置的动作组
-    try {
-        // 获取模型支持的动作组
-        const motions = model.internalModel?.motionManager.definitions;
-
-        if (motions) {
-            // 优先使用Idle动作组
-            if (motions.idle) {
-                await model.motion('idle');
-            } else if (motions.tap_body) {
-                // 如果没有idle动作，尝试使用 tap_body 动作
-                await model.motion('tap_body');
-            } else {
-                // 使用第一个可用的动作组
-                const firstMotionGroup = Object.keys(motions)[0];
-                if (firstMotionGroup) {
-                    await model.motion(firstMotionGroup);
-                }
-            }
-        }
-    } catch (error) {
-        console.warn('Failed to start idle animation:', error);
-    }
-}
-
 /**
- * 加载Cubism SDK
- * 在使用Live2D功能前必须调用此函数
- * @param cubism2 可选的CubismCore对象，如果在非浏览器环境中使用，需要传入
- * @param cubism5
+ * `@doki-land/live2d` — public facade.
+ *
+ * ```ts
+ * import { createLive2D } from "@doki-land/live2d";
+ * ```
  */
-export async function initializeLive2D() {
-    // 首先初始化 Cubism2 SDK
-    // console.log('sdk2:', Cubism2);
-    // console.log('sdk5:', Cubism5);
-    // @ts-ignore
-    // window.Live2D = cubism2 || Cubism2;
-    // 然后初始化 Cubism5 SDK
-    // @ts-ignore
-    // window.Live2DCubismCore = cubism5 || Cubism5().Live2DCubismCore;
 
-    // 注册 InteractionManager 以支持 Live2D 模型的自动交互
-    // PIXI.extensions.add(InteractionManager);
-}
+export type {
+    ActorHit,
+    ActorTransform,
+    AssetResolver,
+    CreateActorOptions,
+    CreateLive2dStageOptions,
+    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_ACTOR_TRANSFORM, EventEmitter } from "@doki-land/live2d-core";
+export {
+    DEFAULT_NPM_CDN,
+    resolveModelSourceUrl,
+    resolveNpmSpecifier,
+} from "@doki-land/live2d-loader";
+export {
+    createCanvas2DRenderer,
+    createMoc2Backend,
+    createMoc3Backend,
+    createQuadProgram,
+    createRenderer,
+    createWebGl2Renderer,
+    createWebGpuRenderer,
+    decodeMoc3,
+    evaluateFrame,
+    fingerprintSnapshot,
+    type ModelBackend,
+    type ParameterBinding,
+    parseCpuProgram,
+    type Renderer,
+    type RendererKind,
+    serializeCpuProgram,
+} from "@doki-land/live2d-renderer";
+export {
+    type CreateLive2DOptions,
+    createLive2D,
+    type Live2DRuntime,
+    MotionPriority,
+    type PlayMotionOptions,
+} from "./create-live2d.js";
+export { focusParameterUpdates } from "./focus.js";
+export {
+    blendMotionLayers,
+    evaluateCurve,
+    evaluateMotion3,
+    type Motion3Clip,
+    type MotionApplySample,
+    MotionPlayer,
+    parseMotion3,
+} from "./motion/index.js";
+export {
+    type CreateLive2dStageFullOptions,
+    createLive2dStage,
+} from "./stage/stage.js";
+
+export const LIVE2D_VERSION = "0.0.0" as const;

package/src/load-textures.ts

@@ -0,0 +1,85 @@
+/**
+ * Fetch model texture images via AssetResolver → TextureData for draw passes.
+ */
+
+import type { AssetResolver } from "@doki-land/live2d-core";
+import type { TextureData } from "@doki-land/live2d-renderer";
+
+export interface LoadTexturesOptions {
+    onProgress?: (update: {
+        index: number;
+        total: number;
+        key: string;
+        bytesLoaded: number;
+        bytesTotal: number | null;
+    }) => void;
+}
+
+function guessMime(path: string): string {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+    if (lower.endsWith(".webp")) return "image/webp";
+    if (lower.endsWith(".gif")) return "image/gif";
+    return "image/png";
+}
+
+async function bytesToImageBitmap(
+    bytes: ArrayBuffer,
+    path: string,
+): Promise<ImageBitmap> {
+    if (typeof createImageBitmap !== "function") {
+        throw new Error(
+            "@doki-land/live2d: createImageBitmap is not available in this environment",
+        );
+    }
+    const blob = new Blob([new Uint8Array(bytes)], {
+        type: guessMime(path),
+    });
+    return createImageBitmap(blob);
+}
+
+/** Load texture paths from a resolver into GPU-uploadable TextureData. */
+export async function loadTextureData(
+    resolver: AssetResolver,
+    paths: readonly string[],
+    options: LoadTexturesOptions = {},
+): Promise<TextureData[]> {
+    const out: TextureData[] = [];
+    const total = paths.length;
+    for (let i = 0; i < paths.length; i++) {
+        const key = paths[i]!;
+        options.onProgress?.({
+            index: i,
+            total,
+            key,
+            bytesLoaded: 0,
+            bytesTotal: null,
+        });
+        const bytes = await resolver.fetchBytes(key);
+        options.onProgress?.({
+            index: i,
+            total,
+            key,
+            bytesLoaded: bytes.byteLength,
+            bytesTotal: bytes.byteLength,
+        });
+        const image = await bytesToImageBitmap(bytes, key);
+        out.push({
+            index: i,
+            image,
+            width: image.width,
+            height: image.height,
+        });
+    }
+    return out;
+}
+
+/** Close ImageBitmaps previously passed to setTextures. */
+export function releaseTextureData(textures: readonly TextureData[]): void {
+    for (const t of textures) {
+        const img = t.image;
+        if (typeof ImageBitmap !== "undefined" && img instanceof ImageBitmap) {
+            img.close();
+        }
+    }
+}