@doki-land/live2d-renderer 0.0.18 → 0.0.20

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

@@ -49,11 +49,12 @@ export function moc2ParamGetterFromValues(
     return (id: string) => byId.get(id) ?? 0;
 }
 
-function normalizePositions(
+function normalizePositionsInto(
     positions: Float32Array,
     canvasWidth: number,
     canvasHeight: number,
-): Float32Array {
+    out: Float32Array,
+): void {
     // moc2 draw coords are canvas pixels with origin at the **top-left**
     // (Y increases downward), matching Live2D Cubism 2 canvas space.
     // Map to Y-up NDC so WebGL/WebGPU/Canvas2D share one convention:
@@ -61,14 +62,99 @@ function normalizePositions(
     //   y: [0, h] → [1, -1]  (top of canvas → NDC +Y)
     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: Float32Array,
+    canvasWidth: number,
+    canvasHeight: number,
+): Float32Array {
+    const out = new Float32Array(positions.length);
+    normalizePositionsInto(positions, canvasWidth, canvasHeight, out);
     return out;
 }
 
+/**
+ * Evaluate moc2 keyforms/deformers into resident {@link DrawableMesh} buffers.
+ * Mesh object identity and shared `uvs`/`indices`/`maskIndices` are preserved
+ * when vertex counts are unchanged.
+ */
+export function evaluateMoc2PoseInto(
+    model: Moc2ModelImpl,
+    getParam: (id: string) => number,
+    byId: ReadonlyMap<string, import("../types.js").DrawableMesh>,
+): void {
+    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;
+        }
+    }
+}
+
+/** Collect drawable ids in the same order {@link moc2ModelToProgram} assigns indices. */
+export function moc2DrawableIdsInProgramOrder(
+    model: Moc2ModelImpl,
+    getParam?: (id: string) => number,
+): string[] {
+    const paramDefs = model.paramDefSet?.params ?? [];
+    const gp = getParam ?? buildParamGetter(paramDefs);
+    const drafts: { id: string; renderOrder: number }[] = [];
+    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);
+}
+
 interface DraftDrawable {
     id: string;
     textureIndex: number;

package/src/moc/moc2.ts

@@ -6,11 +6,7 @@ import type {
     ModelSettings,
 } from "@doki-land/live2d-core";
 import { detectModelSettingsFormat } from "@doki-land/live2d-core";
-import {
-    createModelInstance,
-    evaluateFrame,
-    setParameterValue,
-} from "../cpu/evaluate.js";
+import { createModelInstance, setParameterValue } from "../cpu/evaluate.js";
 import type {
     ModelBackend,
     ModelBackendOptions,
@@ -19,65 +15,127 @@ import type {
 import type { BlendMode, DrawableMesh } from "../types.js";
 import { type Moc2ModelImpl, Moc2Parser } from "./moc2-objects.js";
 import {
+    evaluateMoc2PoseInto,
+    moc2DrawableIdsInProgramOrder,
     moc2ModelToProgram,
     moc2ParamGetterFromValues,
 } from "./moc2-to-program.js";
 
-function toDrawableMesh(d: FrameDrawable): DrawableMesh {
-    return {
-        index: d.index,
-        textureIndex: d.textureIndex,
-        vertexPositions: d.positions,
-        uvs: d.uvs,
-        indices: d.indices,
-        opacity: d.opacity,
-        blendMode: d.blendMode as BlendMode,
-        invertedMask: d.invertedMask,
-        renderOrder: d.renderOrder,
-        dynamicFlag: true,
-        maskIndices: [...d.maskIndices],
-        visible: d.visible,
-    };
+interface Moc2State {
+    moc: Moc2ModelImpl;
+    /** Stable program + instance (never replaced after load). */
+    instance: ModelInstance;
+    /** Resident meshes; objects and topology buffers stay identity-stable. */
+    meshes: DrawableMesh[];
+    /** Draw-order view (same mesh refs, re-sorted when pose changes). */
+    drawView: DrawableMesh[];
+    byId: Map<string, DrawableMesh>;
+    poseDirty: boolean;
+    bindings: ParameterBinding[];
+    paramIndexById: Map<string, number>;
 }
 
-function paramFingerprint(values: ArrayLike<number>): string {
-    let s = "";
-    for (let i = 0; i < values.length; i++) {
-        s += `${values[i]?.toFixed(5)},`;
+const stateByModel = new WeakMap<InternalModel, Moc2State>();
+
+function allocateMeshesFromProgram(
+    program: ReturnType<typeof moc2ModelToProgram>,
+    drawableIds: readonly string[],
+): { meshes: DrawableMesh[]; byId: Map<string, DrawableMesh> } {
+    const meshes: DrawableMesh[] = [];
+    const byId = new Map<string, DrawableMesh>();
+    for (let i = 0; i < program.drawables.length; i++) {
+        const d = program.drawables[i]!;
+        const mesh: DrawableMesh = {
+            index: d.index,
+            textureIndex: d.textureIndex,
+            vertexPositions: new Float32Array(d.positions),
+            uvs: d.uvs,
+            indices: d.indices,
+            opacity: d.opacity,
+            blendMode: d.blendMode as 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 s;
+    return { meshes, byId };
 }
 
-interface Moc2State {
-    moc: Moc2ModelImpl;
-    instance: ModelInstance;
-    lastFrame: FrameSnapshot | null;
-    bakedFingerprint: string;
+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]!;
+        const binding: ParameterBinding = {
+            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 };
 }
 
-const stateByModel = new WeakMap<InternalModel, Moc2State>();
+function syncBindingValues(state: Moc2State): 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;
+    }
+}
+
+function refreshDrawView(state: Moc2State): 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);
+}
 
-/** Re-bake moc2 geometry for current parameter values. */
+/** Re-bake moc2 geometry for current parameter values into resident meshes. */
 function bakePose(state: Moc2State): void {
-    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;
+}
 
-    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);
+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 };
 }
 
 /** moc2 (`.moc`) model backend — pure-TS decode → CPU evaluate. */
@@ -108,17 +166,30 @@ export class Moc2Backend implements ModelBackend {
             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: DrawableMesh[] = [];
         const model: InternalModel = {
             id: settings.name ?? settings.url,
             settings,
             format: "moc2",
         };
-        stateByModel.set(model, {
+        const state: Moc2State = {
             moc,
             instance,
-            lastFrame: null,
-            bakedFingerprint: paramFingerprint(instance.parameterValues),
-        });
+            meshes,
+            drawView,
+            byId,
+            poseDirty: true,
+            bindings,
+            paramIndexById,
+        };
+        bakePose(state);
+        stateByModel.set(model, state);
         return model;
     }
 
@@ -127,50 +198,50 @@ export class Moc2Backend implements ModelBackend {
         if (!state) return;
         state.instance.timeSeconds += deltaTimeSeconds;
         bakePose(state);
-        if (state.lastFrame) {
-            state.lastFrame = {
-                ...state.lastFrame,
-                timeSeconds: state.instance.timeSeconds,
-            };
-        }
     }
 
     getDrawables(model: InternalModel): DrawableMesh[] {
         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: InternalModel): FrameSnapshot | null {
         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: 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;
+    }
+
+    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 {
@@ -180,6 +251,11 @@ export class Moc2Backend implements ModelBackend {
     destroyModel(model: InternalModel): void {
         stateByModel.delete(model);
     }
+
+    /** Test/harness: stable program + instance refs. */
+    getResidentInstance(model: InternalModel): ModelInstance | null {
+        return stateByModel.get(model)?.instance ?? null;
+    }
 }
 
 export function createMoc2Backend(): Moc2Backend {

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;
+    }
+}