@doki-land/live2d-renderer 0.0.17 → 0.0.19

package/dist/index.js

@@ -2551,10 +2551,21 @@ function createModelInstance(program) {
     timeSeconds: 0
   };
 }
+var paramIndexCache = /* @__PURE__ */ new WeakMap();
+function parameterIndex(instance, parameterId) {
+  let map = paramIndexCache.get(instance.program);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < instance.program.parameters.length; i++) {
+      map.set(instance.program.parameters[i].id, i);
+    }
+    paramIndexCache.set(instance.program, map);
+  }
+  const index = map.get(parameterId);
+  return index ?? -1;
+}
 function setParameterValue(instance, parameterId, value) {
-  const index = instance.program.parameters.findIndex(
-    (p2) => p2.id === parameterId
-  );
+  const index = parameterIndex(instance, parameterId);
   if (index < 0) {
     throw new Error(
       `@doki-land/live2d-renderer: unknown parameter "${parameterId}"`
@@ -2604,6 +2615,32 @@ function evaluateFrame(instance) {
     drawables
   };
 }
+function evaluateFrameInto(instance, meshes, poseOpacity) {
+  const byIndex = /* @__PURE__ */ new Map();
+  for (const m of meshes) byIndex.set(m.index, m);
+  for (const d of instance.program.drawables) {
+    const sink = byIndex.get(d.index);
+    if (!sink) continue;
+    let positions = sink.vertexPositions;
+    if (positions.length !== d.positions.length) {
+      positions = new Float32Array(d.positions.length);
+      sink.vertexPositions = positions;
+    }
+    positions.set(d.positions);
+    if (d.deformParamIndex >= 0 && d.deformDeltas) {
+      const w = paramWeight(instance, d.deformParamIndex);
+      for (let i = 0; i < positions.length; i++) {
+        positions[i] = positions[i] + w * d.deformDeltas[i];
+      }
+    }
+    sink.opacity = d.opacity;
+    sink.renderOrder = d.renderOrder;
+    sink.visible = d.visible;
+    if (d.index >= 0 && d.index < poseOpacity.length) {
+      poseOpacity[d.index] = d.opacity;
+    }
+  }
+}
 function fingerprintSnapshot(snapshot) {
   const parts = [`t=${snapshot.timeSeconds.toFixed(4)}`];
   for (const d of snapshot.drawables) {
@@ -2620,97 +2657,6 @@ function fingerprintSnapshot(snapshot) {
   return parts.join("|");
 }
 
-// src/runtime/create-renderer.ts
-var DEFAULT_PREFER = ["webgpu", "webgl2", "canvas2d"];
-var INIT_TIMEOUT_MS = {
-  webgpu: 2500,
-  webgl2: 1500,
-  canvas2d: 1e3
-};
-function instantiate(kind, options) {
-  if (kind === "webgpu") return createWebGpuRenderer(options.webgpu);
-  if (kind === "webgl2") return createWebGl2Renderer(options.webgl2);
-  return createCanvas2DRenderer(options.canvas2d);
-}
-async function initializeWithTimeout(kind, candidate, canvas) {
-  const ms = INIT_TIMEOUT_MS[kind];
-  let timer;
-  try {
-    await Promise.race([
-      candidate.initialize(canvas),
-      new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          reject(
-            new Error(
-              `@doki-land/live2d-renderer: ${kind} initialize timed out after ${ms}ms`
-            )
-          );
-        }, ms);
-      })
-    ]);
-  } finally {
-    if (timer !== void 0) clearTimeout(timer);
-  }
-}
-var FallbackRenderer = class {
-  #inner = null;
-  #kind = "webgpu";
-  #prefer;
-  #options;
-  constructor(prefer, options) {
-    this.#prefer = prefer;
-    this.#options = options;
-  }
-  get kind() {
-    return this.#inner?.kind ?? this.#kind;
-  }
-  async initialize(canvas) {
-    const errors = [];
-    for (const kind of this.#prefer) {
-      const candidate = instantiate(kind, this.#options);
-      try {
-        await initializeWithTimeout(kind, candidate, canvas);
-        this.#inner = candidate;
-        this.#kind = candidate.kind;
-        return;
-      } catch (err) {
-        candidate.destroy();
-        errors.push(
-          `${kind}: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    throw new Error(
-      `@doki-land/live2d-renderer: no renderer initialized (${errors.join("; ")})`
-    );
-  }
-  createModelDrawPass() {
-    if (!this.#inner) {
-      throw new Error(
-        "@doki-land/live2d-renderer: renderer not initialized"
-      );
-    }
-    return this.#inner.createModelDrawPass();
-  }
-  beginFrame() {
-    this.#inner?.beginFrame();
-  }
-  endFrame() {
-    this.#inner?.endFrame();
-  }
-  resize(width, height) {
-    this.#inner?.resize(width, height);
-  }
-  destroy() {
-    this.#inner?.destroy();
-    this.#inner = null;
-  }
-};
-function createRenderer(options = {}) {
-  const prefer = options.prefer?.length ? options.prefer : DEFAULT_PREFER;
-  return new FallbackRenderer(prefer, options);
-}
-
 // src/format/detect-format.ts
 import { detectModelSettingsFormat } from "@doki-land/live2d-core";
 function detectMocBinaryFormat(bytes) {
@@ -3702,16 +3648,81 @@ function moc2ParamGetterFromValues(params, values) {
   }
   return (id) => byId.get(id) ?? 0;
 }
-function normalizePositions(positions, canvasWidth, canvasHeight) {
+function normalizePositionsInto(positions, canvasWidth, canvasHeight, out) {
   const w = canvasWidth > 0 ? canvasWidth : 1;
   const h = canvasHeight > 0 ? canvasHeight : 1;
-  const out = new Float32Array(positions.length);
   for (let i = 0; i + 1 < positions.length; i += 2) {
     out[i] = positions[i] / w * 2 - 1;
     out[i + 1] = 1 - positions[i + 1] / h * 2;
   }
+}
+function normalizePositions(positions, canvasWidth, canvasHeight) {
+  const out = new Float32Array(positions.length);
+  normalizePositionsInto(positions, canvasWidth, canvasHeight, out);
   return out;
 }
+function evaluateMoc2PoseInto(model, getParam, byId) {
+  const ops = bakeDeformerOps(model, getParam);
+  const w = model.canvasWidth;
+  const h = model.canvasHeight;
+  for (const part of model.parts) {
+    for (const mesh of part.drawData) {
+      const sink = byId.get(mesh.id);
+      if (!sink) continue;
+      const floatCount = mesh.numPoints * 2;
+      const local = interpolateKeyforms(
+        mesh.keyforms,
+        mesh.pivotManager,
+        getParam,
+        floatCount
+      );
+      const world = transformDrawablePositions(mesh, local, ops);
+      let pos = sink.vertexPositions;
+      if (pos.length !== world.length) {
+        pos = new Float32Array(world.length);
+        sink.vertexPositions = pos;
+      }
+      normalizePositionsInto(world, w, h, pos);
+      sink.opacity = interpolateScalarTable(
+        mesh.opacities,
+        mesh.pivotManager,
+        getParam,
+        1
+      );
+      sink.renderOrder = Math.round(
+        interpolateScalarTable(
+          mesh.drawOrders,
+          mesh.pivotManager,
+          getParam,
+          mesh.averageDrawOrder
+        )
+      );
+      sink.visible = part.visible;
+    }
+  }
+}
+function moc2DrawableIdsInProgramOrder(model, getParam) {
+  const paramDefs = model.paramDefSet?.params ?? [];
+  const gp = getParam ?? buildParamGetter(paramDefs);
+  const drafts = [];
+  for (const part of model.parts) {
+    for (const mesh of part.drawData) {
+      drafts.push({
+        id: mesh.id,
+        renderOrder: Math.round(
+          interpolateScalarTable(
+            mesh.drawOrders,
+            mesh.pivotManager,
+            gp,
+            mesh.averageDrawOrder
+          )
+        )
+      });
+    }
+  }
+  drafts.sort((a, b) => a.renderOrder - b.renderOrder);
+  return drafts.map((d) => d.id);
+}
 function lowerDrawable(mesh, getParam, ops, canvasWidth, canvasHeight, partVisible) {
   const floatCount = mesh.numPoints * 2;
   const local = interpolateKeyforms(
@@ -4942,15 +4953,24 @@ function meanGlueSeamDistance(positionsByMesh, glue) {
 }
 
 // src/moc/moc3-to-program.ts
-function normalizePositions2(positions, canvasWidth, canvasHeight, pixelsPerUnit) {
+function normalizePositionsInto2(positions, canvasWidth, canvasHeight, pixelsPerUnit, out) {
   const ppu = pixelsPerUnit > 0 ? pixelsPerUnit : 1;
   const hw = canvasWidth > 0 ? canvasWidth / ppu * 0.5 : 0.5;
   const hh = canvasHeight > 0 ? canvasHeight / ppu * 0.5 : 0.5;
-  const out = new Float32Array(positions.length);
   for (let i = 0; i + 1 < positions.length; i += 2) {
     out[i] = positions[i] / hw;
     out[i + 1] = -positions[i + 1] / hh;
   }
+}
+function normalizePositions2(positions, canvasWidth, canvasHeight, pixelsPerUnit) {
+  const out = new Float32Array(positions.length);
+  normalizePositionsInto2(
+    positions,
+    canvasWidth,
+    canvasHeight,
+    pixelsPerUnit,
+    out
+  );
   return out;
 }
 function moc3DocumentToProgram(doc, options = {}) {
@@ -5136,6 +5156,155 @@ function moc3DocumentToProgram(doc, options = {}) {
     drawables
   };
 }
+function moc3ArtMeshIndicesInProgramOrder(doc, getParamByIndex) {
+  const meshCount = doc.counts[CountIdx.ART_MESHES] ?? 0;
+  const defaultValues = moc3SectionF32(doc, "parameter.default_values");
+  const gp = getParamByIndex ?? ((index) => defaultValues[index] ?? 0);
+  const keyTables = loadMoc3KeyTables(doc);
+  const enables = moc3SectionI32(doc, "art_mesh.enables");
+  const vertexCounts = moc3SectionI32(doc, "art_mesh.vertex_counts");
+  const indexCounts = moc3SectionI32(doc, "art_mesh.position_index_counts");
+  const keyformBegins = moc3SectionI32(doc, "art_mesh.keyform_begin_indices");
+  const keyformCounts = moc3SectionI32(doc, "art_mesh.keyform_counts");
+  const bandIndices = moc3SectionI32(
+    doc,
+    "art_mesh.keyform_binding_band_indices"
+  );
+  const keyformDrawOrders = moc3SectionF32(
+    doc,
+    "art_mesh_keyform.draw_orders"
+  );
+  const drafts = [];
+  for (let i = 0; i < meshCount; i++) {
+    if ((enables[i] ?? 1) === 0) continue;
+    const vertexCount = vertexCounts[i] ?? 0;
+    const indexCount = indexCounts[i] ?? 0;
+    if (vertexCount <= 0 || indexCount < 3) continue;
+    const kfBegin = keyformBegins[i] ?? 0;
+    const kfCount = keyformCounts[i] ?? 0;
+    if (kfCount <= 0) continue;
+    const band = bandIndices[i] ?? -1;
+    const blend = resolveMoc3KeyformBlend(keyTables, band, gp);
+    drafts.push({
+      artMeshIndex: i,
+      renderOrder: Math.round(
+        blendKeyformScalar(
+          keyformDrawOrders,
+          kfBegin,
+          kfCount,
+          blend,
+          i
+        )
+      )
+    });
+  }
+  drafts.sort((a, b) => a.renderOrder - b.renderOrder);
+  return drafts.map((d) => d.artMeshIndex);
+}
+function evaluateMoc3PoseInto(doc, getParamByIndex, byArtMesh, poseOpacity) {
+  const meshCount = doc.counts[CountIdx.ART_MESHES] ?? 0;
+  const keyTables = loadMoc3KeyTables(doc);
+  const deformers = bakeMoc3Deformers(doc, keyTables, getParamByIndex);
+  const glues = loadMoc3Glues(doc);
+  const glueIntensities = moc3SectionF32(doc, "glue_keyform.intensities");
+  const visibles = moc3SectionI32(doc, "art_mesh.visibles");
+  const enables = moc3SectionI32(doc, "art_mesh.enables");
+  const vertexCounts = moc3SectionI32(doc, "art_mesh.vertex_counts");
+  const indexCounts = moc3SectionI32(doc, "art_mesh.position_index_counts");
+  const keyformBegins = moc3SectionI32(doc, "art_mesh.keyform_begin_indices");
+  const keyformCounts = moc3SectionI32(doc, "art_mesh.keyform_counts");
+  const bandIndices = moc3SectionI32(
+    doc,
+    "art_mesh.keyform_binding_band_indices"
+  );
+  const parentDeformers = moc3SectionI32(
+    doc,
+    "art_mesh.parent_deformer_indices"
+  );
+  const keyformOpacities = moc3SectionF32(doc, "art_mesh_keyform.opacities");
+  const keyformDrawOrders = moc3SectionF32(
+    doc,
+    "art_mesh_keyform.draw_orders"
+  );
+  const keyformPosBegins = moc3SectionI32(
+    doc,
+    "art_mesh_keyform.keyform_position_begin_indices"
+  );
+  const keyformPositions = moc3SectionF32(doc, "keyform_position.xys");
+  const cw = doc.canvas.canvasWidth;
+  const ch = doc.canvas.canvasHeight;
+  const ppu = doc.canvas.pixelsPerUnit;
+  const worldByMesh = /* @__PURE__ */ new Map();
+  const opacityByMesh = /* @__PURE__ */ new Map();
+  const orderByMesh = /* @__PURE__ */ new Map();
+  const visibleByMesh = /* @__PURE__ */ new Map();
+  for (let i = 0; i < meshCount; i++) {
+    if (!byArtMesh.has(i)) continue;
+    if ((enables[i] ?? 1) === 0) continue;
+    const vertexCount = vertexCounts[i] ?? 0;
+    const indexCount = indexCounts[i] ?? 0;
+    if (vertexCount <= 0 || indexCount < 3) continue;
+    const kfBegin = keyformBegins[i] ?? 0;
+    const kfCount = keyformCounts[i] ?? 0;
+    if (kfCount <= 0) continue;
+    const band = bandIndices[i] ?? -1;
+    const blend = resolveMoc3KeyformBlend(keyTables, band, getParamByIndex);
+    const local = blendKeyformFloats(
+      keyformPositions,
+      keyformPosBegins,
+      kfBegin,
+      kfCount,
+      vertexCount * 2,
+      blend
+    );
+    const parentIndex = parentDeformers[i] ?? -1;
+    const parent = parentIndex >= 0 ? deformers[parentIndex] ?? null : null;
+    const world = parent ? applyParentToPoints(local, parent) : local;
+    worldByMesh.set(i, world);
+    opacityByMesh.set(
+      i,
+      blendKeyformScalar(keyformOpacities, kfBegin, kfCount, blend, 1)
+    );
+    orderByMesh.set(
+      i,
+      Math.round(
+        blendKeyformScalar(
+          keyformDrawOrders,
+          kfBegin,
+          kfCount,
+          blend,
+          i
+        )
+      )
+    );
+    visibleByMesh.set(i, (visibles[i] ?? 1) !== 0);
+  }
+  applyMoc3Glues(
+    worldByMesh,
+    glues,
+    keyTables,
+    getParamByIndex,
+    glueIntensities
+  );
+  for (const [artMeshIndex, world] of worldByMesh) {
+    const sink = byArtMesh.get(artMeshIndex);
+    if (!sink) continue;
+    let pos = sink.vertexPositions;
+    if (pos.length !== world.length) {
+      pos = new Float32Array(world.length);
+      sink.vertexPositions = pos;
+    }
+    normalizePositionsInto2(world, cw, ch, ppu, pos);
+    const opacity = opacityByMesh.get(artMeshIndex) ?? 1;
+    sink.renderOrder = orderByMesh.get(artMeshIndex) ?? sink.renderOrder;
+    sink.visible = visibleByMesh.get(artMeshIndex) ?? true;
+    const slot = sink.index;
+    if (slot >= 0 && slot < poseOpacity.length) {
+      poseOpacity[slot] = opacity;
+    }
+    sink.opacity = opacity;
+  }
+}
 
 // src/moc/decode.ts
 function readMagic2(bytes) {
@@ -5186,49 +5355,90 @@ async function decodeMoc3(bytes) {
 
 // src/moc/moc2.ts
 import { detectModelSettingsFormat as detectModelSettingsFormat2 } from "@doki-land/live2d-core";
-function toDrawableMesh(d) {
-  return {
-    index: d.index,
-    textureIndex: d.textureIndex,
-    vertexPositions: d.positions,
-    uvs: d.uvs,
-    indices: d.indices,
-    opacity: d.opacity,
-    blendMode: d.blendMode,
-    invertedMask: d.invertedMask,
-    renderOrder: d.renderOrder,
-    dynamicFlag: true,
-    maskIndices: [...d.maskIndices],
-    visible: d.visible
-  };
+var stateByModel = /* @__PURE__ */ new WeakMap();
+function allocateMeshesFromProgram(program, drawableIds) {
+  const meshes = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (let i = 0; i < program.drawables.length; i++) {
+    const d = program.drawables[i];
+    const mesh = {
+      index: d.index,
+      textureIndex: d.textureIndex,
+      vertexPositions: new Float32Array(d.positions),
+      uvs: d.uvs,
+      indices: d.indices,
+      opacity: d.opacity,
+      blendMode: d.blendMode,
+      invertedMask: d.invertedMask,
+      renderOrder: d.renderOrder,
+      dynamicFlag: true,
+      maskIndices: [...d.maskIndices],
+      visible: d.visible
+    };
+    meshes.push(mesh);
+    const id = drawableIds[i];
+    if (id) byId.set(id, mesh);
+  }
+  return { meshes, byId };
+}
+function buildBindings(instance) {
+  const bindings = [];
+  const paramIndexById = /* @__PURE__ */ new Map();
+  for (let i = 0; i < instance.program.parameters.length; i++) {
+    const p = instance.program.parameters[i];
+    const binding = {
+      id: p.id,
+      min: p.min,
+      max: p.max,
+      defaultValue: p.defaultValue,
+      value: instance.parameterValues[i] ?? p.defaultValue
+    };
+    bindings.push(binding);
+    paramIndexById.set(p.id, i);
+  }
+  return { bindings, paramIndexById };
 }
-function paramFingerprint(values) {
-  let s = "";
-  for (let i = 0; i < values.length; i++) {
-    s += `${values[i]?.toFixed(5)},`;
+function syncBindingValues(state) {
+  for (let i = 0; i < state.bindings.length; i++) {
+    const b = state.bindings[i];
+    b.value = state.instance.parameterValues[i] ?? b.defaultValue;
   }
-  return s;
 }
-var stateByModel = /* @__PURE__ */ new WeakMap();
+function refreshDrawView(state) {
+  const view = state.drawView;
+  view.length = 0;
+  for (const m of state.meshes) view.push(m);
+  view.sort((a, b) => a.renderOrder - b.renderOrder || a.index - b.index);
+}
 function bakePose(state) {
-  const values = Float32Array.from(state.instance.parameterValues);
-  const timeSeconds = state.instance.timeSeconds;
-  const fp = paramFingerprint(values);
-  if (fp === state.bakedFingerprint && state.lastFrame) {
-    return;
+  if (!state.poseDirty) return;
+  const getParam = moc2ParamGetterFromValues(
+    state.instance.program.parameters,
+    state.instance.parameterValues
+  );
+  evaluateMoc2PoseInto(state.moc, getParam, state.byId);
+  refreshDrawView(state);
+  syncBindingValues(state);
+  state.poseDirty = false;
+}
+function frameFromMeshes(meshes, timeSeconds) {
+  const drawables = [];
+  for (const m of meshes) {
+    drawables.push({
+      index: m.index,
+      textureIndex: m.textureIndex,
+      positions: m.vertexPositions,
+      uvs: m.uvs,
+      indices: m.indices,
+      opacity: m.opacity,
+      blendMode: m.blendMode,
+      renderOrder: m.renderOrder,
+      visible: m.visible,
+      invertedMask: m.invertedMask,
+      maskIndices: m.maskIndices
+    });
   }
-  const program = moc2ModelToProgram(state.moc, {
-    getParam: moc2ParamGetterFromValues(
-      state.moc.paramDefSet.params,
-      values
-    )
-  });
-  const next = createModelInstance(program);
-  next.parameterValues.set(values);
-  next.timeSeconds = timeSeconds;
-  state.instance = next;
-  state.bakedFingerprint = fp;
-  state.lastFrame = evaluateFrame(next);
+  return { timeSeconds, drawables };
 }
 var Moc2Backend = class {
   format = "moc2";
@@ -5249,17 +5459,30 @@ var Moc2Backend = class {
     const moc = shared?.moc2Model ?? new Moc2Parser(bytes).parseModel();
     const program = moc2ModelToProgram(moc);
     const instance = createModelInstance(program);
+    const drawableIds = moc2DrawableIdsInProgramOrder(moc);
+    const { meshes, byId } = allocateMeshesFromProgram(
+      program,
+      drawableIds
+    );
+    const { bindings, paramIndexById } = buildBindings(instance);
+    const drawView = [];
     const model = {
       id: settings.name ?? settings.url,
       settings,
       format: "moc2"
     };
-    stateByModel.set(model, {
+    const state = {
       moc,
       instance,
-      lastFrame: null,
-      bakedFingerprint: paramFingerprint(instance.parameterValues)
-    });
+      meshes,
+      drawView,
+      byId,
+      poseDirty: true,
+      bindings,
+      paramIndexById
+    };
+    bakePose(state);
+    stateByModel.set(model, state);
     return model;
   }
   updateModel(model, deltaTimeSeconds) {
@@ -5267,46 +5490,43 @@ var Moc2Backend = class {
     if (!state) return;
     state.instance.timeSeconds += deltaTimeSeconds;
     bakePose(state);
-    if (state.lastFrame) {
-      state.lastFrame = {
-        ...state.lastFrame,
-        timeSeconds: state.instance.timeSeconds
-      };
-    }
   }
   getDrawables(model) {
     const state = stateByModel.get(model);
     if (!state) return [];
     bakePose(state);
-    const frame = state.lastFrame ?? evaluateFrame(state.instance);
-    state.lastFrame = frame;
-    return frame.drawables.map(toDrawableMesh);
+    return state.drawView;
   }
   captureFrame(model) {
     const state = stateByModel.get(model);
     if (!state) return null;
     bakePose(state);
-    const frame = state.lastFrame ?? evaluateFrame(state.instance);
-    state.lastFrame = frame;
-    return frame;
+    return frameFromMeshes(state.drawView, state.instance.timeSeconds);
   }
   setParameter(model, id, value) {
     const state = stateByModel.get(model);
     if (!state) return;
     setParameterValue(state.instance, id, value);
-    state.lastFrame = null;
-    state.bakedFingerprint = "";
+    const index = state.paramIndexById.get(id);
+    if (index !== void 0) {
+      const binding = state.bindings[index];
+      if (binding) {
+        binding.value = state.instance.parameterValues[index] ?? binding.defaultValue;
+      }
+    }
+    state.poseDirty = true;
+  }
+  resolveParameter(model, id) {
+    const state = stateByModel.get(model);
+    if (!state) return void 0;
+    return state.paramIndexById.get(id);
   }
   listParameters(model) {
     const state = stateByModel.get(model);
     if (!state) return [];
-    return state.instance.program.parameters.map((p, i) => ({
-      id: p.id,
-      min: p.min,
-      max: p.max,
-      defaultValue: p.defaultValue,
-      value: state.instance.parameterValues[i] ?? p.defaultValue
-    }));
+    bakePose(state);
+    syncBindingValues(state);
+    return state.bindings;
   }
   hitTest(_model, _x, _y) {
     return null;
@@ -5314,6 +5534,10 @@ var Moc2Backend = class {
   destroyModel(model) {
     stateByModel.delete(model);
   }
+  /** Test/harness: stable program + instance refs. */
+  getResidentInstance(model) {
+    return stateByModel.get(model)?.instance ?? null;
+  }
 };
 function createMoc2Backend() {
   return new Moc2Backend();
@@ -5352,11 +5576,12 @@ function cascadedPartOpacity(tables, artMeshIndex, overrides) {
 }
 
 // src/moc/moc3.ts
-function toDrawableMesh2(d) {
-  return {
+var stateByModel2 = /* @__PURE__ */ new WeakMap();
+function allocateMeshesFromProgram2(program) {
+  return program.drawables.map((d) => ({
     index: d.index,
     textureIndex: d.textureIndex,
-    vertexPositions: d.positions,
+    vertexPositions: new Float32Array(d.positions),
     uvs: d.uvs,
     indices: d.indices,
     opacity: d.opacity,
@@ -5366,34 +5591,82 @@ function toDrawableMesh2(d) {
     dynamicFlag: true,
     maskIndices: [...d.maskIndices],
     visible: d.visible
-  };
+  }));
+}
+function buildBindings2(instance) {
+  const bindings = [];
+  const paramIndexById = /* @__PURE__ */ new Map();
+  for (let i = 0; i < instance.program.parameters.length; i++) {
+    const p = instance.program.parameters[i];
+    bindings.push({
+      id: p.id,
+      min: p.min,
+      max: p.max,
+      defaultValue: p.defaultValue,
+      value: instance.parameterValues[i] ?? p.defaultValue
+    });
+    paramIndexById.set(p.id, i);
+  }
+  return { bindings, paramIndexById };
 }
-function paramFingerprint2(values) {
-  let s = "";
-  for (let i = 0; i < values.length; i++) {
-    s += `${values[i]?.toFixed(5)},`;
+function syncBindingValues2(state) {
+  for (let i = 0; i < state.bindings.length; i++) {
+    const b = state.bindings[i];
+    b.value = state.instance.parameterValues[i] ?? b.defaultValue;
+  }
+}
+function refreshDrawView2(state) {
+  const view = state.drawView;
+  view.length = 0;
+  for (const m of state.meshes) view.push(m);
+  view.sort((a, b) => a.renderOrder - b.renderOrder || a.index - b.index);
+}
+function applyPartOpacity(state) {
+  const tables = state.doc ? readMoc3PartTables(state.doc) : null;
+  for (const mesh of state.meshes) {
+    const base = state.poseOpacity[mesh.index] ?? mesh.opacity;
+    if (!tables || state.partOpacity.size === 0) {
+      mesh.opacity = base;
+      continue;
+    }
+    mesh.opacity = base * cascadedPartOpacity(tables, mesh.index, state.partOpacity);
   }
-  return s;
 }
-var stateByModel2 = /* @__PURE__ */ new WeakMap();
 function bakePose2(state) {
-  if (!state.doc) {
-    state.lastFrame = evaluateFrame(state.instance);
-    return;
+  if (!state.poseDirty) return;
+  if (state.doc) {
+    const values = state.instance.parameterValues;
+    evaluateMoc3PoseInto(
+      state.doc,
+      (i) => values[i] ?? 0,
+      state.byArtMesh,
+      state.poseOpacity
+    );
+  } else {
+    evaluateFrameInto(state.instance, state.meshes, state.poseOpacity);
   }
-  const values = Float32Array.from(state.instance.parameterValues);
-  const timeSeconds = state.instance.timeSeconds;
-  const fp = paramFingerprint2(values);
-  if (fp === state.bakedFingerprint && state.lastFrame) return;
-  const program = moc3DocumentToProgram(state.doc, {
-    getParamByIndex: (i) => values[i] ?? 0
-  });
-  const next = createModelInstance(program);
-  next.parameterValues.set(values);
-  next.timeSeconds = timeSeconds;
-  state.instance = next;
-  state.bakedFingerprint = fp;
-  state.lastFrame = evaluateFrame(next);
+  refreshDrawView2(state);
+  syncBindingValues2(state);
+  state.poseDirty = false;
+}
+function frameFromMeshes2(meshes, timeSeconds) {
+  const drawables = [];
+  for (const m of meshes) {
+    drawables.push({
+      index: m.index,
+      textureIndex: m.textureIndex,
+      positions: m.vertexPositions,
+      uvs: m.uvs,
+      indices: m.indices,
+      opacity: m.opacity,
+      blendMode: m.blendMode,
+      renderOrder: m.renderOrder,
+      visible: m.visible,
+      invertedMask: m.invertedMask,
+      maskIndices: m.maskIndices
+    });
+  }
+  return { timeSeconds, drawables };
 }
 var Moc3Backend = class {
   format = "moc3";
@@ -5421,18 +5694,39 @@ var Moc3Backend = class {
       program = moc3DocumentToProgram(doc);
     }
     const instance = createModelInstance(program);
+    const meshes = allocateMeshesFromProgram2(program);
+    const byArtMesh = /* @__PURE__ */ new Map();
+    if (doc) {
+      const artOrder = moc3ArtMeshIndicesInProgramOrder(doc);
+      for (let i = 0; i < artOrder.length; i++) {
+        const art = artOrder[i];
+        const mesh = meshes[i];
+        if (mesh) byArtMesh.set(art, mesh);
+      }
+    }
+    const poseOpacity = new Float32Array(meshes.length);
+    for (const m of meshes) poseOpacity[m.index] = m.opacity;
+    const { bindings, paramIndexById } = buildBindings2(instance);
     const model = {
       id: settings.name ?? settings.url,
       settings,
       format: "moc3"
     };
-    stateByModel2.set(model, {
+    const state = {
       doc,
       instance,
-      lastFrame: null,
-      bakedFingerprint: paramFingerprint2(instance.parameterValues),
-      partOpacity: /* @__PURE__ */ new Map()
-    });
+      meshes,
+      drawView: [],
+      byArtMesh,
+      poseOpacity,
+      poseDirty: true,
+      partOpacity: /* @__PURE__ */ new Map(),
+      bindings,
+      paramIndexById
+    };
+    bakePose2(state);
+    applyPartOpacity(state);
+    stateByModel2.set(model, state);
     return model;
   }
   updateModel(model, deltaTimeSeconds) {
@@ -5440,49 +5734,34 @@ var Moc3Backend = class {
     if (!state) return;
     state.instance.timeSeconds += deltaTimeSeconds;
     bakePose2(state);
-    if (state.lastFrame) {
-      state.lastFrame = {
-        ...state.lastFrame,
-        timeSeconds: state.instance.timeSeconds
-      };
-    }
+    applyPartOpacity(state);
   }
   getDrawables(model) {
     const state = stateByModel2.get(model);
     if (!state) return [];
     bakePose2(state);
-    const frame = state.lastFrame ?? evaluateFrame(state.instance);
-    state.lastFrame = frame;
-    const tables = state.doc ? readMoc3PartTables(state.doc) : null;
-    return frame.drawables.map((d) => {
-      const mesh = toDrawableMesh2(d);
-      if (!tables || state.partOpacity.size === 0) return mesh;
-      const mul = cascadedPartOpacity(tables, d.index, state.partOpacity);
-      return { ...mesh, opacity: mesh.opacity * mul };
-    });
+    applyPartOpacity(state);
+    return state.drawView;
   }
   captureFrame(model) {
     const state = stateByModel2.get(model);
     if (!state) return null;
     bakePose2(state);
-    const frame = state.lastFrame ?? evaluateFrame(state.instance);
-    state.lastFrame = frame;
-    const tables = state.doc ? readMoc3PartTables(state.doc) : null;
-    if (!tables || state.partOpacity.size === 0) return frame;
-    return {
-      ...frame,
-      drawables: frame.drawables.map((d) => ({
-        ...d,
-        opacity: d.opacity * cascadedPartOpacity(tables, d.index, state.partOpacity)
-      }))
-    };
+    applyPartOpacity(state);
+    return frameFromMeshes2(state.drawView, state.instance.timeSeconds);
   }
   setParameter(model, id, value) {
     const state = stateByModel2.get(model);
     if (!state) return;
     setParameterValue(state.instance, id, value);
-    state.lastFrame = null;
-    state.bakedFingerprint = "";
+    const index = state.paramIndexById.get(id);
+    if (index !== void 0) {
+      const binding = state.bindings[index];
+      if (binding) {
+        binding.value = state.instance.parameterValues[index] ?? binding.defaultValue;
+      }
+    }
+    state.poseDirty = true;
   }
   setPartOpacity(model, id, value) {
     const state = stateByModel2.get(model);
@@ -5490,16 +5769,17 @@ var Moc3Backend = class {
     const v = Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 1;
     state.partOpacity.set(id, v);
   }
+  resolveParameter(model, id) {
+    const state = stateByModel2.get(model);
+    if (!state) return void 0;
+    return state.paramIndexById.get(id);
+  }
   listParameters(model) {
     const state = stateByModel2.get(model);
     if (!state) return [];
-    return state.instance.program.parameters.map((p, i) => ({
-      id: p.id,
-      min: p.min,
-      max: p.max,
-      defaultValue: p.defaultValue,
-      value: state.instance.parameterValues[i] ?? p.defaultValue
-    }));
+    bakePose2(state);
+    syncBindingValues2(state);
+    return state.bindings;
   }
   hitTest(_model, _x, _y) {
     return null;
@@ -5507,11 +5787,105 @@ var Moc3Backend = class {
   destroyModel(model) {
     stateByModel2.delete(model);
   }
+  getResidentInstance(model) {
+    return stateByModel2.get(model)?.instance ?? null;
+  }
 };
 function createMoc3Backend() {
   return new Moc3Backend();
 }
 
+// src/runtime/create-renderer.ts
+var DEFAULT_PREFER = ["webgpu", "webgl2", "canvas2d"];
+var INIT_TIMEOUT_MS = {
+  webgpu: 2500,
+  webgl2: 1500,
+  canvas2d: 1e3
+};
+function instantiate(kind, options) {
+  if (kind === "webgpu") return createWebGpuRenderer(options.webgpu);
+  if (kind === "webgl2") return createWebGl2Renderer(options.webgl2);
+  return createCanvas2DRenderer(options.canvas2d);
+}
+async function initializeWithTimeout(kind, candidate, canvas) {
+  const ms = INIT_TIMEOUT_MS[kind];
+  let timer;
+  try {
+    await Promise.race([
+      candidate.initialize(canvas),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          reject(
+            new Error(
+              `@doki-land/live2d-renderer: ${kind} initialize timed out after ${ms}ms`
+            )
+          );
+        }, ms);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+var FallbackRenderer = class {
+  #inner = null;
+  #kind = "webgpu";
+  #prefer;
+  #options;
+  constructor(prefer, options) {
+    this.#prefer = prefer;
+    this.#options = options;
+  }
+  get kind() {
+    return this.#inner?.kind ?? this.#kind;
+  }
+  async initialize(canvas) {
+    const errors = [];
+    for (const kind of this.#prefer) {
+      const candidate = instantiate(kind, this.#options);
+      try {
+        await initializeWithTimeout(kind, candidate, canvas);
+        this.#inner = candidate;
+        this.#kind = candidate.kind;
+        return;
+      } catch (err) {
+        candidate.destroy();
+        errors.push(
+          `${kind}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    throw new Error(
+      `@doki-land/live2d-renderer: no renderer initialized (${errors.join("; ")})`
+    );
+  }
+  createModelDrawPass() {
+    if (!this.#inner) {
+      throw new Error(
+        "@doki-land/live2d-renderer: renderer not initialized"
+      );
+    }
+    return this.#inner.createModelDrawPass();
+  }
+  beginFrame() {
+    this.#inner?.beginFrame();
+  }
+  endFrame() {
+    this.#inner?.endFrame();
+  }
+  resize(width, height) {
+    this.#inner?.resize(width, height);
+  }
+  destroy() {
+    this.#inner?.destroy();
+    this.#inner = null;
+  }
+};
+function createRenderer(options = {}) {
+  const prefer = options.prefer?.length ? options.prefer : DEFAULT_PREFER;
+  return new FallbackRenderer(prefer, options);
+}
+
 // src/runtime/model-runtime.ts
 function selectModelBackend(backends, json) {
   const hit = backends.find((b) => b.canHandle(json));