@doki-land/live2d-renderer 0.0.18 → 0.0.19

package/src/moc/moc3-to-program.ts

@@ -32,23 +32,39 @@ import {
     moc3SectionStrings,
 } from "./moc3-reader.js";
 
-function normalizePositions(
+function normalizePositionsInto(
     positions: Float32Array,
     canvasWidth: number,
     canvasHeight: number,
     pixelsPerUnit: number,
-): Float32Array {
+    out: Float32Array,
+): void {
     // Deformer output uses logical canvas/ppu units around the model center.
     // Convert the decoded authoring orientation once into the renderer's shared
     // Y-up NDC contract, matching the moc2 path after top-left normalization.
     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 normalizePositions(
+    positions: Float32Array,
+    canvasWidth: number,
+    canvasHeight: number,
+    pixelsPerUnit: number,
+): Float32Array {
+    const out = new Float32Array(positions.length);
+    normalizePositionsInto(
+        positions,
+        canvasWidth,
+        canvasHeight,
+        pixelsPerUnit,
+        out,
+    );
     return out;
 }
 
@@ -301,3 +317,177 @@ export function moc3DocumentToProgram(
         drawables,
     };
 }
+
+/** Art-mesh indices in the same order {@link moc3DocumentToProgram} assigns drawable indices. */
+export function moc3ArtMeshIndicesInProgramOrder(
+    doc: Moc3Document,
+    getParamByIndex?: (index: number) => number,
+): number[] {
+    const meshCount = doc.counts[CountIdx.ART_MESHES] ?? 0;
+    const defaultValues = moc3SectionF32(doc, "parameter.default_values");
+    const gp =
+        getParamByIndex ?? ((index: number) => 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: { artMeshIndex: number; renderOrder: number }[] = [];
+    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);
+}
+
+/**
+ * Evaluate moc3 keyforms/deformers/glue into resident meshes keyed by art-mesh index.
+ * Topology buffers (`uvs`/`indices`/`maskIndices`) stay shared; positions are written in place.
+ */
+export function evaluateMoc3PoseInto(
+    doc: Moc3Document,
+    getParamByIndex: (index: number) => number,
+    byArtMesh: ReadonlyMap<number, import("../types.js").DrawableMesh>,
+    poseOpacity: Float32Array,
+): void {
+    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 = new Map<number, Float32Array>();
+    const opacityByMesh = new Map<number, number>();
+    const orderByMesh = new Map<number, number>();
+    const visibleByMesh = new Map<number, boolean>();
+
+    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;
+        }
+        normalizePositionsInto(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;
+    }
+}

package/src/moc/moc3.ts

@@ -10,7 +10,7 @@ import { detectModelSettingsFormat } from "@doki-land/live2d-core";
 import { isCpuProgramBytes, parseCpuProgram } from "../cpu/cpu-program.js";
 import {
     createModelInstance,
-    evaluateFrame,
+    evaluateFrameInto,
     setParameterValue,
 } from "../cpu/evaluate.js";
 import type {
@@ -21,13 +21,34 @@ import type {
 import type { BlendMode, DrawableMesh } from "../types.js";
 import { cascadedPartOpacity, readMoc3PartTables } from "./moc3-parts.js";
 import { type Moc3Document, parseMoc3Document } from "./moc3-reader.js";
-import { moc3DocumentToProgram } from "./moc3-to-program.js";
+import {
+    evaluateMoc3PoseInto,
+    moc3ArtMeshIndicesInProgramOrder,
+    moc3DocumentToProgram,
+} from "./moc3-to-program.js";
 
-function toDrawableMesh(d: FrameDrawable): DrawableMesh {
-    return {
+interface Moc3State {
+    /** Present for binary MOC3 input; null for cpu-program fixtures. */
+    doc: Moc3Document | null;
+    instance: ModelInstance;
+    meshes: DrawableMesh[];
+    drawView: DrawableMesh[];
+    /** art-mesh index → mesh (binary path); empty for cpu-program. */
+    byArtMesh: Map<number, DrawableMesh>;
+    poseOpacity: Float32Array;
+    poseDirty: boolean;
+    partOpacity: Map<string, number>;
+    bindings: ParameterBinding[];
+    paramIndexById: Map<string, number>;
+}
+
+const stateByModel = new WeakMap<InternalModel, Moc3State>();
+
+function allocateMeshesFromProgram(program: ModelProgram): DrawableMesh[] {
+    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,
@@ -37,49 +58,96 @@ function toDrawableMesh(d: FrameDrawable): DrawableMesh {
         dynamicFlag: true,
         maskIndices: [...d.maskIndices],
         visible: d.visible,
-    };
+    }));
+}
+
+function buildBindings(instance: ModelInstance): {
+    bindings: ParameterBinding[];
+    paramIndexById: Map<string, number>;
+} {
+    const bindings: ParameterBinding[] = [];
+    const paramIndexById = new Map<string, number>();
+    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 paramFingerprint(values: ArrayLike<number>): string {
-    let s = "";
-    for (let i = 0; i < values.length; i++) {
-        s += `${values[i]?.toFixed(5)},`;
+function syncBindingValues(state: Moc3State): void {
+    for (let i = 0; i < state.bindings.length; i++) {
+        const b = state.bindings[i]!;
+        (b as { value: number }).value =
+            state.instance.parameterValues[i] ?? b.defaultValue;
     }
-    return s;
 }
 
-interface Moc3State {
-    /** Present for binary MOC3 input; null for cpu-program fixtures. */
-    doc: Moc3Document | null;
-    instance: ModelInstance;
-    lastFrame: FrameSnapshot | null;
-    bakedFingerprint: string;
-    /** Runtime PartOpacity overrides (id → 0..1). */
-    partOpacity: Map<string, number>;
+function refreshDrawView(state: Moc3State): void {
+    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);
 }
 
-const stateByModel = new WeakMap<InternalModel, Moc3State>();
+function applyPartOpacity(state: Moc3State): void {
+    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);
+    }
+}
 
 function bakePose(state: Moc3State): void {
-    if (!state.doc) {
-        state.lastFrame = evaluateFrame(state.instance);
-        return;
-    }
-
-    const values = Float32Array.from(state.instance.parameterValues);
-    const timeSeconds = state.instance.timeSeconds;
-    const fp = paramFingerprint(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);
+    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);
+    }
+    refreshDrawView(state);
+    syncBindingValues(state);
+    state.poseDirty = false;
+}
+
+function frameFromMeshes(
+    meshes: readonly DrawableMesh[],
+    timeSeconds: number,
+): FrameSnapshot {
+    const drawables: FrameDrawable[] = [];
+    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 };
 }
 
 /** moc3 model backend for binary `.moc3` input or CPU `.program.json` fixtures. */
@@ -121,18 +189,39 @@ export class Moc3Backend implements ModelBackend {
         }
 
         const instance = createModelInstance(program);
+        const meshes = allocateMeshesFromProgram(program);
+        const byArtMesh = new Map<number, DrawableMesh>();
+        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 } = buildBindings(instance);
         const model: InternalModel = {
             id: settings.name ?? settings.url,
             settings,
             format: "moc3",
         };
-        stateByModel.set(model, {
+        const state: Moc3State = {
             doc,
             instance,
-            lastFrame: null,
-            bakedFingerprint: paramFingerprint(instance.parameterValues),
+            meshes,
+            drawView: [],
+            byArtMesh,
+            poseOpacity,
+            poseDirty: true,
             partOpacity: new Map(),
-        });
+            bindings,
+            paramIndexById,
+        };
+        bakePose(state);
+        applyPartOpacity(state);
+        stateByModel.set(model, state);
         return model;
     }
 
@@ -141,54 +230,39 @@ export class Moc3Backend implements ModelBackend {
         if (!state) return;
         state.instance.timeSeconds += deltaTimeSeconds;
         bakePose(state);
-        if (state.lastFrame) {
-            state.lastFrame = {
-                ...state.lastFrame,
-                timeSeconds: state.instance.timeSeconds,
-            };
-        }
+        applyPartOpacity(state);
     }
 
     getDrawables(model: InternalModel): DrawableMesh[] {
         const state = stateByModel.get(model);
         if (!state) return [];
         bakePose(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 = toDrawableMesh(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: InternalModel): FrameSnapshot | null {
         const state = stateByModel.get(model);
         if (!state) return null;
         bakePose(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 frameFromMeshes(state.drawView, state.instance.timeSeconds);
     }
 
     setParameter(model: InternalModel, id: string, value: number): void {
         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 !== undefined) {
+            const binding = state.bindings[index];
+            if (binding) {
+                (binding as { value: number }).value =
+                    state.instance.parameterValues[index] ??
+                    binding.defaultValue;
+            }
+        }
+        state.poseDirty = true;
     }
 
     setPartOpacity(model: InternalModel, id: string, value: number): void {
@@ -196,19 +270,20 @@ export class Moc3Backend implements ModelBackend {
         if (!state) return;
         const v = Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 1;
         state.partOpacity.set(id, v);
-        // Opacity is applied in getDrawables; no need to rebake deform.
+    }
+
+    resolveParameter(model: InternalModel, id: string): number | undefined {
+        const state = stateByModel.get(model);
+        if (!state) return undefined;
+        return state.paramIndexById.get(id);
     }
 
     listParameters(model: InternalModel): readonly ParameterBinding[] {
         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: InternalModel, _x: number, _y: number): string | null {
@@ -218,6 +293,10 @@ export class Moc3Backend implements ModelBackend {
     destroyModel(model: InternalModel): void {
         stateByModel.delete(model);
     }
+
+    getResidentInstance(model: InternalModel): ModelInstance | null {
+        return stateByModel.get(model)?.instance ?? null;
+    }
 }
 
 export function createMoc3Backend(): Moc3Backend {

package/src/runtime/model-runtime.ts

@@ -69,6 +69,12 @@ export interface ModelBackend {
     /** Optional PartOpacity override (moc3 parts / pose / motion). */
     setPartOpacity?(model: InternalModel, id: string, value: number): void;
 
+    /**
+     * Resolve parameter id → index (O(1) after load).
+     * Used by motion blend / hosts instead of `listParameters().find`.
+     */
+    resolveParameter?(model: InternalModel, id: string): number | undefined;
+
     listParameters?(model: InternalModel): readonly ParameterBinding[];
 }
 

package/src/types.ts

@@ -36,7 +36,7 @@ export interface TextureData {
 export interface ModelDrawPass {
     setTextures(textures: TextureData[]): void;
 
-    draw(drawables: DrawableMesh[], modelMatrix: Float32Array): void;
+    draw(drawables: readonly DrawableMesh[], modelMatrix: Float32Array): void;
 
     destroy(): void;
 }