@doki-land/live2d 0.0.13 → 0.0.15

package/dist/index.js

@@ -57,74 +57,6 @@ function valueFromNormalized(binding, normalized) {
   return n >= 0 ? binding.defaultValue + (binding.max - binding.defaultValue) * n : binding.defaultValue + (binding.defaultValue - binding.min) * n;
 }
 
-// src/stage/actor-model-slot.ts
-import { modelSourceUrl } from "@doki-land/live2d-core";
-import {
-  createUrlAssetResolver,
-  fetchModelJson,
-  normalizeModelSettings,
-  resolveModelSourceUrl
-} from "@doki-land/live2d-loader";
-import { selectModelBackend } from "@doki-land/live2d-renderer";
-
-// src/load-textures.ts
-function guessMime(path) {
-  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, path) {
-  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);
-}
-async function loadTextureData(resolver, paths, options = {}) {
-  const out = [];
-  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;
-}
-function releaseTextureData(textures) {
-  for (const t of textures) {
-    const img = t.image;
-    if (typeof ImageBitmap !== "undefined" && img instanceof ImageBitmap) {
-      img.close();
-    }
-  }
-}
-
 // src/motion/evaluate-curve.ts
 function evaluateMotion3(clip, timeSeconds) {
   const t = clamp(timeSeconds, 0, clip.duration);
@@ -611,23 +543,18 @@ function optionalNum(v) {
 }
 
 // src/stage/actor-model-slot.ts
-function lerp(a, b, t) {
-  return a + (b - a) * Math.min(1, Math.max(0, t));
-}
 var ActorModelSlot = class {
-  #backends;
+  #assets;
   #renderer;
   #onProgress;
   #motionPlayer;
-  #motionCache = /* @__PURE__ */ new Map();
   #drawPass = null;
   #model = null;
   #backend = null;
-  #textures = [];
-  #resolver = null;
+  #lease = null;
   #loadGeneration = 0;
   constructor(options) {
-    this.#backends = options.backends;
+    this.#assets = options.assets;
     this.#renderer = options.renderer;
     this.#onProgress = options.onProgress;
     this.#motionPlayer = new MotionPlayer({
@@ -650,12 +577,9 @@ var ActorModelSlot = class {
   #report(payload) {
     this.#onProgress?.(payload);
   }
-  #clearTextures() {
-    if (this.#textures.length > 0) {
-      releaseTextureData(this.#textures);
-      this.#textures = [];
-    }
-    this.#drawPass?.setTextures([]);
+  #releaseLease() {
+    this.#lease?.release();
+    this.#lease = null;
   }
   #applyMotionSamples(samples) {
     if (!this.#model || !this.#backend) return;
@@ -697,138 +621,59 @@ var ActorModelSlot = class {
       detail: "prepare draw pass"
     });
     const drawPass = this.ensureDrawPass();
-    this.#report({
-      stage: "resolve",
-      progress: 0.02,
-      detail: "resolve source"
-    });
-    let json;
-    let baseUrl;
-    let settingsUrl;
-    if (typeof source === "object" && source.kind === "json") {
-      json = source.json;
-      baseUrl = source.baseUrl;
-      settingsUrl = source.baseUrl;
-      this.#report({
-        stage: "settings",
-        progress: 0.2,
-        detail: "inline settings"
-      });
-    } else {
-      const raw = typeof source === "string" ? source : source.kind === "npm" ? modelSourceUrl(source) : source.url;
-      const cdnBase = typeof source === "object" && source.kind === "npm" ? source.cdnBase : void 0;
-      const fetchUrl = resolveModelSourceUrl(raw, {
-        npmCdnBase: cdnBase
-      });
-      this.#report({
-        stage: "settings",
-        progress: 0.05,
-        detail: fetchUrl
-      });
-      json = await fetchModelJson(fetchUrl, (u) => {
-        const ratio = u.bytesTotal && u.bytesTotal > 0 ? u.bytesLoaded / u.bytesTotal : 0;
-        this.#report({
-          stage: "settings",
-          progress: lerp(0.05, 0.22, ratio),
-          detail: fetchUrl,
-          bytesLoaded: u.bytesLoaded,
-          bytesTotal: u.bytesTotal
-        });
-      });
-      baseUrl = fetchUrl;
-      settingsUrl = fetchUrl;
-    }
+    const lease = await this.#assets.acquire(
+      source,
+      resolver,
+      (p) => this.#report(p)
+    );
     if (gen !== this.#loadGeneration) {
+      lease.release();
       throw new Error("@doki-land/live2d: load cancelled");
     }
-    const settings = normalizeModelSettings(json, settingsUrl);
+    return await this.#attachLease(lease, drawPass, gen);
+  }
+  async loadAsset(asset) {
+    const gen = ++this.#loadGeneration;
     this.#report({
-      stage: "moc",
-      progress: 0.25,
-      detail: settings.moc
-    });
-    const assetResolver = resolver ?? createUrlAssetResolver(baseUrl, {
-      onBytesProgress: (key, u) => {
-        const isMoc = key === settings.moc;
-        const ratio = u.bytesTotal && u.bytesTotal > 0 ? u.bytesLoaded / u.bytesTotal : 0;
-        if (isMoc) {
-          this.#report({
-            stage: "moc",
-            progress: lerp(0.25, 0.8, ratio),
-            detail: key,
-            bytesLoaded: u.bytesLoaded,
-            bytesTotal: u.bytesTotal
-          });
-        } else {
-          this.#report({
-            stage: "textures",
-            progress: lerp(0.8, 0.9, ratio),
-            detail: key,
-            bytesLoaded: u.bytesLoaded,
-            bytesTotal: u.bytesTotal
-          });
-        }
-      }
+      stage: "mounting",
+      progress: 0.01,
+      detail: "prepare draw pass"
     });
-    this.#resolver = assetResolver;
-    this.#motionPlayer.clear();
-    this.#motionCache.clear();
-    const backend = selectModelBackend([...this.#backends], json);
+    const drawPass = this.ensureDrawPass();
+    const lease = this.#assets.acquireExisting(asset);
+    if (gen !== this.#loadGeneration) {
+      lease.release();
+      throw new Error("@doki-land/live2d: load cancelled");
+    }
     this.#report({
       stage: "decode",
       progress: 0.85,
-      detail: `decode ${settings.format}`
-    });
-    const next = await backend.createModel(settings, {
-      renderer: this.#renderer,
-      resolver: assetResolver
+      detail: `reuse ${asset.key}`
     });
+    return await this.#attachLease(lease, drawPass, gen);
+  }
+  async #attachLease(lease, drawPass, gen) {
+    this.#motionPlayer.clear();
+    this.#releaseLease();
+    const { model, backend } = await lease.createInstance(this.#renderer);
     if (gen !== this.#loadGeneration) {
-      backend.destroyModel(next);
+      backend.destroyModel(model);
+      lease.release();
       throw new Error("@doki-land/live2d: load cancelled");
     }
-    this.#clearTextures();
-    if (settings.textures.length > 0) {
-      this.#report({
-        stage: "textures",
-        progress: 0.88,
-        detail: `${settings.textures.length} textures`
-      });
-      const textures = await loadTextureData(
-        assetResolver,
-        settings.textures,
-        {
-          onProgress: (u) => {
-            const ratio = u.total > 0 ? (u.index + 1) / u.total : 1;
-            this.#report({
-              stage: "textures",
-              progress: lerp(0.88, 0.96, ratio),
-              detail: u.key,
-              bytesLoaded: u.bytesLoaded,
-              bytesTotal: u.bytesTotal
-            });
-          }
-        }
-      );
-      if (gen !== this.#loadGeneration) {
-        releaseTextureData(textures);
-        backend.destroyModel(next);
-        throw new Error("@doki-land/live2d: load cancelled");
-      }
-      this.#textures = textures;
-      drawPass.setTextures(textures);
-    }
     if (this.#model && this.#backend) {
       this.#backend.destroyModel(this.#model);
     }
-    this.#model = next;
+    drawPass.setTextures([...lease.textures]);
+    this.#lease = lease;
+    this.#model = model;
     this.#backend = backend;
     this.#report({
       stage: "ready",
       progress: 1,
-      detail: next.id
+      detail: model.id
     });
-    return next;
+    return model;
   }
   setParameter(id, value) {
     if (!this.#model || !this.#backend?.setParameter) return;
@@ -842,15 +687,16 @@ var ActorModelSlot = class {
     return this.#model?.settings.motionGroups ?? {};
   }
   async playMotion(group, index = 0, options = {}) {
-    if (!this.#model || !this.#resolver) return false;
+    if (!this.#model || !this.#lease) return false;
     const list = this.#model.settings.motionGroups[group];
     const def = list?.[index];
     if (!def) return false;
-    let clip = this.#motionCache.get(def.file);
+    const cache = this.#lease.motionCache;
+    let clip = cache.get(def.file);
     if (!clip) {
-      const json = await this.#resolver.fetchJson(def.file);
+      const json = await this.#lease.resolver.fetchJson(def.file);
       clip = parseMotion3(json);
-      this.#motionCache.set(def.file, clip);
+      cache.set(def.file, clip);
     }
     const fadeInTime = options.fadeInTime ?? def.fadeInTime ?? clip.fadeInTime;
     const fadeOutTime = options.fadeOutTime ?? def.fadeOutTime ?? clip.fadeOutTime;
@@ -904,14 +750,13 @@ var ActorModelSlot = class {
   destroy() {
     this.#loadGeneration += 1;
     this.#motionPlayer.clear();
-    this.#motionCache.clear();
-    this.#resolver = null;
     if (this.#model && this.#backend) {
       this.#backend.destroyModel(this.#model);
     }
     this.#model = null;
     this.#backend = null;
-    this.#clearTextures();
+    this.#releaseLease();
+    this.#drawPass?.setTextures([]);
     this.#drawPass?.destroy();
     this.#drawPass = null;
   }
@@ -1042,7 +887,7 @@ var Live2dActorImpl = class {
     this.#layer = options?.layer ?? "characters";
     this.#order = options?.order ?? 0;
     this.#slot = new ActorModelSlot({
-      backends: shared.backends,
+      assets: shared.assets,
       renderer: shared.renderer
     });
   }
@@ -1088,9 +933,34 @@ var Live2dActorImpl = class {
     }
     return await this.#slot.load(source, resolver);
   }
+  async loadAsset(asset) {
+    if (this.#destroyed) {
+      throw new Error("@doki-land/live2d: actor destroyed");
+    }
+    return await this.#slot.loadAsset(asset);
+  }
   setParameter(id, value) {
     this.#slot.setParameter(id, value);
   }
+  listParameters() {
+    return this.#slot.listParameters();
+  }
+  listMotionGroups() {
+    return this.#slot.listMotionGroups();
+  }
+  playMotion(group, index, options) {
+    return this.#slot.playMotion(
+      group,
+      index,
+      options
+    );
+  }
+  stopMotion(opts) {
+    this.#slot.stopMotion(opts);
+  }
+  listPlayingMotions() {
+    return this.#slot.listPlayingMotions();
+  }
   lookAt(stageX, stageY) {
     const { dragX, dragY } = stageFocusDrag(
       stageX,
@@ -1227,19 +1097,19 @@ function createSingleActorFacade(stage, actor, backends) {
       return hit.area;
     },
     listParameters() {
-      return actor.slot.listParameters();
+      return actor.listParameters();
     },
     listMotionGroups() {
-      return actor.slot.listMotionGroups();
+      return actor.listMotionGroups();
     },
     playMotion(group, index, options) {
-      return actor.slot.playMotion(group, index, options);
+      return actor.playMotion(group, index, options);
     },
     stopMotion(opts) {
-      actor.slot.stopMotion(opts);
+      actor.stopMotion(opts);
     },
     listPlayingMotions() {
-      return actor.slot.listPlayingMotions();
+      return actor.listPlayingMotions();
     },
     async capturePng(opts = {}) {
       if (!canvas) {
@@ -1311,9 +1181,320 @@ import {
   createMoc3Backend,
   createRenderer
 } from "@doki-land/live2d-renderer";
+
+// src/stage/model-asset-registry.ts
+import { modelSourceUrl as modelSourceUrl2 } from "@doki-land/live2d-core";
+import {
+  createUrlAssetResolver,
+  fetchModelJson,
+  normalizeModelSettings,
+  resolveModelSourceUrl
+} from "@doki-land/live2d-loader";
+import {
+  compileSharedModelCompile,
+  selectModelBackend
+} from "@doki-land/live2d-renderer";
+
+// src/load-textures.ts
+function guessMime(path) {
+  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, path) {
+  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);
+}
+async function loadTextureData(resolver, paths, options = {}) {
+  const out = [];
+  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;
+}
+function releaseTextureData(textures) {
+  for (const t of textures) {
+    const img = t.image;
+    if (typeof ImageBitmap !== "undefined" && img instanceof ImageBitmap) {
+      img.close();
+    }
+  }
+}
+
+// src/stage/model-asset-key.ts
+import { modelSourceUrl } from "@doki-land/live2d-core";
+function stableJsonKey(value) {
+  let h = 5381;
+  const text = JSON.stringify(value);
+  for (let i = 0; i < text.length; i += 1) {
+    h = (Math.imul(h, 33) ^ text.charCodeAt(i)) >>> 0;
+  }
+  return h.toString(36);
+}
+function resolveModelAssetKey(source) {
+  if (typeof source === "object" && source.kind === "json") {
+    return `json:${source.baseUrl}#${stableJsonKey(source.json)}`;
+  }
+  return modelSourceUrl(source);
+}
+
+// src/stage/model-asset-registry.ts
+function lerp(a, b, t) {
+  return a + (b - a) * Math.min(1, Math.max(0, t));
+}
+var ModelAssetHandle = class {
+  #entry;
+  constructor(entry) {
+    this.#entry = entry;
+  }
+  get key() {
+    return this.#entry.key;
+  }
+  get settings() {
+    return this.#entry.settings;
+  }
+  /** @internal */
+  get entry() {
+    return this.#entry;
+  }
+};
+var ModelAssetRegistry = class {
+  #backends;
+  #entries = /* @__PURE__ */ new Map();
+  #inFlight = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#backends = options.backends;
+  }
+  async load(source, resolver) {
+    const entry = await this.#ensureEntry(source, resolver);
+    return new ModelAssetHandle(entry);
+  }
+  async acquire(source, resolver, onProgress) {
+    const entry = await this.#ensureEntry(source, resolver, onProgress);
+    entry.refCount += 1;
+    return this.#leaseFromEntry(entry);
+  }
+  acquireExisting(asset) {
+    const handle = asset;
+    const entry = handle.entry;
+    if (!this.#entries.has(entry.key) || this.#entries.get(entry.key) !== entry) {
+      throw new Error(
+        "@doki-land/live2d: ModelAsset does not belong to this stage"
+      );
+    }
+    entry.refCount += 1;
+    return this.#leaseFromEntry(entry);
+  }
+  destroy() {
+    this.#inFlight.clear();
+    for (const entry of this.#entries.values()) {
+      releaseTextureData(entry.textures);
+      entry.motionCache.clear();
+    }
+    this.#entries.clear();
+  }
+  #leaseFromEntry(entry) {
+    let released = false;
+    return {
+      asset: new ModelAssetHandle(entry),
+      motionCache: entry.motionCache,
+      resolver: entry.resolver,
+      textures: entry.textures,
+      createInstance: async (renderer) => {
+        const model = await entry.backend.createModel(entry.settings, {
+          renderer,
+          resolver: entry.resolver,
+          sharedCompile: entry.sharedCompile
+        });
+        return { model, backend: entry.backend };
+      },
+      release: () => {
+        if (released) return;
+        released = true;
+        entry.refCount = Math.max(0, entry.refCount - 1);
+        if (entry.refCount === 0) {
+          releaseTextureData(entry.textures);
+          entry.textures.length = 0;
+          entry.motionCache.clear();
+          this.#entries.delete(entry.key);
+        }
+      }
+    };
+  }
+  async #ensureEntry(source, resolver, onProgress) {
+    const key = resolveModelAssetKey(source);
+    const existing = this.#entries.get(key);
+    if (existing) return existing;
+    let pending = this.#inFlight.get(key);
+    if (!pending) {
+      pending = this.#compileEntry(key, source, resolver, onProgress);
+      this.#inFlight.set(key, pending);
+    }
+    try {
+      const entry = await pending;
+      this.#entries.set(key, entry);
+      return entry;
+    } finally {
+      this.#inFlight.delete(key);
+    }
+  }
+  async #compileEntry(key, source, resolver, onProgress) {
+    const notify = (payload) => onProgress?.(payload);
+    notify({
+      stage: "resolve",
+      progress: 0.02,
+      detail: "resolve source"
+    });
+    let json;
+    let baseUrl;
+    let settingsUrl;
+    if (typeof source === "object" && source.kind === "json") {
+      json = source.json;
+      baseUrl = source.baseUrl;
+      settingsUrl = source.baseUrl;
+      notify({
+        stage: "settings",
+        progress: 0.2,
+        detail: "inline settings"
+      });
+    } else {
+      const raw = typeof source === "string" ? source : source.kind === "npm" ? modelSourceUrl2(source) : source.url;
+      const cdnBase = typeof source === "object" && source.kind === "npm" ? source.cdnBase : void 0;
+      const fetchUrl = resolveModelSourceUrl(raw, {
+        npmCdnBase: cdnBase
+      });
+      notify({
+        stage: "settings",
+        progress: 0.05,
+        detail: fetchUrl
+      });
+      json = await fetchModelJson(fetchUrl, (u) => {
+        const ratio = u.bytesTotal && u.bytesTotal > 0 ? u.bytesLoaded / u.bytesTotal : 0;
+        notify({
+          stage: "settings",
+          progress: lerp(0.05, 0.22, ratio),
+          detail: fetchUrl,
+          bytesLoaded: u.bytesLoaded,
+          bytesTotal: u.bytesTotal
+        });
+      });
+      baseUrl = fetchUrl;
+      settingsUrl = fetchUrl;
+    }
+    const settings = normalizeModelSettings(json, settingsUrl);
+    notify({
+      stage: "moc",
+      progress: 0.25,
+      detail: settings.moc
+    });
+    const assetResolver = resolver ?? createUrlAssetResolver(baseUrl, {
+      onBytesProgress: (assetKey, u) => {
+        const isMoc = assetKey === settings.moc;
+        const ratio = u.bytesTotal && u.bytesTotal > 0 ? u.bytesLoaded / u.bytesTotal : 0;
+        if (isMoc) {
+          notify({
+            stage: "moc",
+            progress: lerp(0.25, 0.8, ratio),
+            detail: assetKey,
+            bytesLoaded: u.bytesLoaded,
+            bytesTotal: u.bytesTotal
+          });
+        } else {
+          notify({
+            stage: "textures",
+            progress: lerp(0.8, 0.9, ratio),
+            detail: assetKey,
+            bytesLoaded: u.bytesLoaded,
+            bytesTotal: u.bytesTotal
+          });
+        }
+      }
+    });
+    const backend = selectModelBackend([...this.#backends], json);
+    notify({
+      stage: "decode",
+      progress: 0.85,
+      detail: `decode ${settings.format}`
+    });
+    const mocBytes = await assetResolver.fetchBytes(settings.moc);
+    const sharedCompile = compileSharedModelCompile(settings, mocBytes);
+    const textures = [];
+    if (settings.textures.length > 0) {
+      notify({
+        stage: "textures",
+        progress: 0.88,
+        detail: `${settings.textures.length} textures`
+      });
+      textures.push(
+        ...await loadTextureData(assetResolver, settings.textures, {
+          onProgress: (u) => {
+            const ratio = u.total > 0 ? (u.index + 1) / u.total : 1;
+            notify({
+              stage: "textures",
+              progress: lerp(0.88, 0.96, ratio),
+              detail: u.key,
+              bytesLoaded: u.bytesLoaded,
+              bytesTotal: u.bytesTotal
+            });
+          }
+        })
+      );
+    }
+    notify({
+      stage: "ready",
+      progress: 1,
+      detail: settings.name ?? key
+    });
+    return {
+      key,
+      settings,
+      backend,
+      resolver: assetResolver,
+      sharedCompile,
+      textures,
+      motionCache: /* @__PURE__ */ new Map(),
+      refCount: 0
+    };
+  }
+};
+
+// src/stage/stage.ts
 var Live2dStageImpl = class {
   #backends;
   #renderer;
+  #assets;
   #updateMode;
   #actors = /* @__PURE__ */ new Map();
   #definedLayers = [
@@ -1348,8 +1529,12 @@ var Live2dStageImpl = class {
       createMoc3Backend()
     ];
     this.#renderer = options.renderer ?? createRenderer({ prefer: options.prefer });
+    this.#assets = new ModelAssetRegistry({ backends: this.#backends });
     this.#updateMode = options.updateMode ?? "auto";
   }
+  get assets() {
+    return this.#assets;
+  }
   get actors() {
     return [...this.#actors.values()];
   }
@@ -1383,7 +1568,7 @@ var Live2dStageImpl = class {
     const actor = new Live2dActorImpl(options, {
       id,
       creationIndex,
-      backends: this.#backends,
+      assets: this.#assets,
       renderer: this.#renderer
     });
     this.#actors.set(id, actor);
@@ -1392,6 +1577,19 @@ var Live2dStageImpl = class {
     }
     return actor;
   }
+  getActor(id) {
+    return this.#actors.get(id) ?? null;
+  }
+  resize(width, height) {
+    if (!this.#canvas || this.#destroyed) return;
+    const cssW = width ?? this.#canvas.clientWidth;
+    const cssH = height ?? this.#canvas.clientHeight;
+    if (cssW <= 0 || cssH <= 0) return;
+    const dpr = typeof globalThis.devicePixelRatio === "number" ? globalThis.devicePixelRatio : 1;
+    this.#canvas.width = Math.round(cssW * dpr);
+    this.#canvas.height = Math.round(cssH * dpr);
+    this.#renderer.resize(cssW, cssH);
+  }
   removeActor(actorOrId) {
     const id = typeof actorOrId === "string" ? actorOrId : actorOrId.id;
     const actor = this.#actors.get(id);
@@ -1502,6 +1700,7 @@ var Live2dStageImpl = class {
       actor.destroy();
     }
     this.#actors.clear();
+    this.#assets.destroy();
     this.#renderer.destroy();
     this.#canvas = null;
     this.#initPromise = null;