@doki-land/live2d-renderer 0.0.0 → 0.0.11

package/src/moc/moc3-reader.ts

@@ -0,0 +1,215 @@
+/**
+ * Parse official MOC3 bytes into typed section tables (no deform evaluation).
+ */
+
+import {
+    MOC3_COUNT_MAX,
+    MOC3_HEADER_SIZE,
+    MOC3_MAGIC,
+    MOC3_SECTION_LAYOUT,
+    MOC3_SOT_COUNT,
+    type SectionEntry,
+} from "./moc3-layout.js";
+
+export interface Moc3CanvasInfo {
+    readonly pixelsPerUnit: number;
+    readonly originX: number;
+    readonly originY: number;
+    readonly canvasWidth: number;
+    readonly canvasHeight: number;
+    readonly flags: number;
+}
+
+export interface Moc3Document {
+    readonly version: number;
+    readonly littleEndian: boolean;
+    readonly counts: Int32Array;
+    readonly canvas: Moc3CanvasInfo;
+    readonly sections: ReadonlyMap<string, unknown>;
+}
+
+function readMagic(bytes: ArrayBuffer): string {
+    if (bytes.byteLength < 4) return "";
+    return String.fromCharCode(...new Uint8Array(bytes, 0, 4));
+}
+
+function sectionCount(counts: Int32Array, entry: SectionEntry): number {
+    if (entry.countIdx < 0 || entry.countIdx >= counts.length) return 0;
+    return Math.max(0, counts[entry.countIdx]!);
+}
+
+function readI32Array(
+    view: DataView,
+    offset: number,
+    count: number,
+    le: boolean,
+): Int32Array {
+    const out = new Int32Array(count);
+    for (let i = 0; i < count; i++) {
+        out[i] = view.getInt32(offset + i * 4, le);
+    }
+    return out;
+}
+
+function readF32Array(
+    view: DataView,
+    offset: number,
+    count: number,
+    le: boolean,
+): Float32Array {
+    const out = new Float32Array(count);
+    for (let i = 0; i < count; i++) {
+        out[i] = view.getFloat32(offset + i * 4, le);
+    }
+    return out;
+}
+
+function readI16Array(
+    view: DataView,
+    offset: number,
+    count: number,
+    le: boolean,
+): Int16Array {
+    const out = new Int16Array(count);
+    for (let i = 0; i < count; i++) {
+        out[i] = view.getInt16(offset + i * 2, le);
+    }
+    return out;
+}
+
+function readStr64Array(
+    bytes: Uint8Array,
+    offset: number,
+    count: number,
+): string[] {
+    const out: string[] = [];
+    for (let i = 0; i < count; i++) {
+        const start = offset + i * 64;
+        const slice = bytes.subarray(start, start + 64);
+        let end = slice.indexOf(0);
+        if (end < 0) end = 64;
+        out.push(String.fromCharCode(...slice.subarray(0, end)));
+    }
+    return out;
+}
+
+function readSection(
+    bytes: Uint8Array,
+    view: DataView,
+    offset: number,
+    entry: SectionEntry,
+    count: number,
+    le: boolean,
+): unknown {
+    if (count <= 0 || offset <= 0 || offset >= bytes.byteLength) {
+        return entry.elemType === "str64" ? [] : new Int32Array(0);
+    }
+    switch (entry.elemType) {
+        case "runtime":
+            return bytes.subarray(offset, offset + count * 8);
+        case "str64":
+            return readStr64Array(bytes, offset, count);
+        case "i32":
+        case "bool":
+            return readI32Array(view, offset, count, le);
+        case "f32":
+            return readF32Array(view, offset, count, le);
+        case "i16":
+            return readI16Array(view, offset, count, le);
+        case "u8":
+            return bytes.subarray(offset, offset + count);
+        default:
+            return new Int32Array(0);
+    }
+}
+
+/** Parse MOC3 binary into section tables. */
+export function parseMoc3Document(buffer: ArrayBuffer): Moc3Document {
+    if (buffer.byteLength < MOC3_HEADER_SIZE + MOC3_SOT_COUNT * 4) {
+        throw new Error("@doki-land/live2d-renderer: truncated MOC3 header");
+    }
+    const magic = readMagic(buffer);
+    if (magic !== MOC3_MAGIC) {
+        throw new Error(
+            `@doki-land/live2d-renderer: unrecognized moc3 bytes (magic=${JSON.stringify(magic)})`,
+        );
+    }
+
+    const bytes = new Uint8Array(buffer);
+    const version = bytes[4]!;
+    const littleEndian = bytes[5] === 0;
+    const view = new DataView(buffer);
+
+    const sot = new Int32Array(MOC3_SOT_COUNT);
+    for (let i = 0; i < MOC3_SOT_COUNT; i++) {
+        sot[i] = view.getInt32(MOC3_HEADER_SIZE + i * 4, littleEndian);
+    }
+
+    const countInfoOff = sot[0]!;
+    if (
+        countInfoOff <= 0 ||
+        countInfoOff + MOC3_COUNT_MAX * 4 > buffer.byteLength
+    ) {
+        throw new Error(
+            "@doki-land/live2d-renderer: invalid MOC3 count info offset",
+        );
+    }
+    const counts = readI32Array(
+        view,
+        countInfoOff,
+        MOC3_COUNT_MAX,
+        littleEndian,
+    );
+
+    const canvasOff = sot[1]!;
+    if (canvasOff <= 0 || canvasOff + 24 > buffer.byteLength) {
+        throw new Error(
+            "@doki-land/live2d-renderer: invalid MOC3 canvas info offset",
+        );
+    }
+    const canvas: Moc3CanvasInfo = {
+        pixelsPerUnit: view.getFloat32(canvasOff, littleEndian),
+        originX: view.getFloat32(canvasOff + 4, littleEndian),
+        originY: view.getFloat32(canvasOff + 8, littleEndian),
+        canvasWidth: view.getFloat32(canvasOff + 12, littleEndian),
+        canvasHeight: view.getFloat32(canvasOff + 16, littleEndian),
+        flags: bytes[canvasOff + 20]!,
+    };
+
+    const sections = new Map<string, unknown>();
+    for (let i = 0; i < MOC3_SECTION_LAYOUT.length; i++) {
+        const entry = MOC3_SECTION_LAYOUT[i]!;
+        const sotIdx = i + 2;
+        const offset = sotIdx < sot.length ? sot[sotIdx]! : 0;
+        const count = sectionCount(counts, entry);
+        sections.set(
+            entry.name,
+            readSection(bytes, view, offset, entry, count, littleEndian),
+        );
+    }
+
+    return { version, littleEndian, counts, canvas, sections };
+}
+
+export function moc3SectionI32(doc: Moc3Document, name: string): Int32Array {
+    const v = doc.sections.get(name);
+    return v instanceof Int32Array ? v : new Int32Array(0);
+}
+
+export function moc3SectionF32(doc: Moc3Document, name: string): Float32Array {
+    const v = doc.sections.get(name);
+    return v instanceof Float32Array ? v : new Float32Array(0);
+}
+
+export function moc3SectionI16(doc: Moc3Document, name: string): Int16Array {
+    const v = doc.sections.get(name);
+    return v instanceof Int16Array ? v : new Int16Array(0);
+}
+
+export function moc3SectionStrings(
+    doc: Moc3Document,
+    name: string,
+): readonly string[] {
+    const v = doc.sections.get(name);
+    return Array.isArray(v) ? (v as string[]) : [];
+}

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

@@ -0,0 +1,305 @@
+/**
+ * Lower parsed MOC3 document → ModelProgram.
+ *
+ * Samples art-mesh keyforms at the given parameters, applies the parent
+ * warp / rotation deformer chain, then moc3 Glue (seam pull), then normalize.
+ * Constant flags (blend / invert-mask) and drawable mask tables are preserved.
+ */
+
+import type {
+    DrawableProgram,
+    ModelProgram,
+    ParameterProgram,
+} from "@doki-land/live2d-core";
+import { decodeMoc3DrawableFlags } from "./drawable-flags.js";
+import {
+    applyParentToPoints,
+    bakeMoc3Deformers,
+    loadMoc3KeyTables,
+} from "./moc3-deform.js";
+import { applyMoc3Glues, loadMoc3Glues } from "./moc3-glue.js";
+import {
+    blendKeyformFloats,
+    blendKeyformScalar,
+    resolveMoc3KeyformBlend,
+} from "./moc3-keyforms.js";
+import { CountIdx } from "./moc3-layout.js";
+import {
+    type Moc3Document,
+    moc3SectionF32,
+    moc3SectionI16,
+    moc3SectionI32,
+    moc3SectionStrings,
+} from "./moc3-reader.js";
+
+function normalizePositions(
+    positions: Float32Array,
+    canvasWidth: number,
+    canvasHeight: number,
+    pixelsPerUnit: number,
+): Float32Array {
+    // Cubism deformer output is in logical units (canvas / ppu), center origin.
+    // Authoring Y grows upward in the editor, but the runtime draw path that
+    // matches Cubism Web samples presents with Y flipped into our shared
+    // Y-up NDC (head / bowl toward +Y). Negate Y once here — same contract as
+    // moc2 after top-left pixel 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;
+    }
+    return out;
+}
+
+export interface Moc3ToProgramOptions {
+    /** Parameter values by index; defaults to each param's defaultValue. */
+    getParamByIndex?: (index: number) => number;
+}
+
+interface DraftDrawable {
+    artMeshIndex: number;
+    textureIndex: number;
+    positions: Float32Array;
+    uvs: Float32Array;
+    indices: Uint16Array;
+    opacity: number;
+    renderOrder: number;
+    blendMode: number;
+    invertedMask: boolean;
+    rawMaskArtMeshes: number[];
+    visible: boolean;
+}
+
+/** Convert a parsed MOC3 document into a ModelProgram at the given pose. */
+export function moc3DocumentToProgram(
+    doc: Moc3Document,
+    options: Moc3ToProgramOptions = {},
+): ModelProgram {
+    const meshCount = doc.counts[CountIdx.ART_MESHES] ?? 0;
+    const paramCount = doc.counts[CountIdx.PARAMETERS] ?? 0;
+
+    const paramIds = moc3SectionStrings(doc, "parameter.ids");
+    const maxValues = moc3SectionF32(doc, "parameter.max_values");
+    const minValues = moc3SectionF32(doc, "parameter.min_values");
+    const defaultValues = moc3SectionF32(doc, "parameter.default_values");
+
+    const parameters: ParameterProgram[] = [];
+    for (let i = 0; i < paramCount; i++) {
+        parameters.push({
+            id: paramIds[i] || `param_${i}`,
+            min: minValues[i] ?? 0,
+            max: maxValues[i] ?? 0,
+            defaultValue: defaultValues[i] ?? 0,
+        });
+    }
+
+    const getParamByIndex =
+        options.getParamByIndex ??
+        ((index: number) => defaultValues[index] ?? 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 textureIndices = moc3SectionI32(doc, "art_mesh.texture_indices");
+    const drawableFlags = moc3SectionI32(doc, "art_mesh.drawable_flags");
+    const vertexCounts = moc3SectionI32(doc, "art_mesh.vertex_counts");
+    const uvBegins = moc3SectionI32(doc, "art_mesh.uv_begin_indices");
+    const indexBegins = moc3SectionI32(
+        doc,
+        "art_mesh.position_index_begin_indices",
+    );
+    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 maskBegins = moc3SectionI32(doc, "art_mesh.mask_begin_indices");
+    const maskCounts = moc3SectionI32(doc, "art_mesh.mask_counts");
+    const maskArtMeshes = moc3SectionI32(doc, "drawable_mask.art_mesh_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 uvsAll = moc3SectionF32(doc, "uv.xys");
+    const indicesAll = moc3SectionI16(doc, "position_index.indices");
+
+    const cw = doc.canvas.canvasWidth;
+    const ch = doc.canvas.canvasHeight;
+    const ppu = doc.canvas.pixelsPerUnit;
+
+    // World positions for every mesh that participates in glue or draw.
+    const worldByMesh = new Map<number, Float32Array>();
+    const meshMeta = new Map<
+        number,
+        {
+            textureIndex: number;
+            uvs: Float32Array;
+            indices: Uint16Array;
+            opacity: number;
+            renderOrder: number;
+            blendMode: number;
+            invertedMask: boolean;
+            rawMaskArtMeshes: number[];
+            visible: boolean;
+        }
+    >();
+
+    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, 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);
+
+        const uvBegin = uvBegins[i] ?? 0;
+        const uvs = new Float32Array(vertexCount * 2);
+        for (let v = 0; v < vertexCount * 2; v++) {
+            uvs[v] = uvsAll[uvBegin + v] ?? 0;
+        }
+
+        const indexBegin = indexBegins[i] ?? 0;
+        const indices = new Uint16Array(indexCount);
+        for (let t = 0; t < indexCount; t++) {
+            indices[t] = indicesAll[indexBegin + t] ?? 0;
+        }
+
+        const opacity = blendKeyformScalar(
+            keyformOpacities,
+            kfBegin,
+            kfCount,
+            blend,
+            1,
+        );
+        const renderOrder = Math.round(
+            blendKeyformScalar(keyformDrawOrders, kfBegin, kfCount, blend, i),
+        );
+
+        const flags = decodeMoc3DrawableFlags(drawableFlags[i] ?? 0);
+        const maskCount = maskCounts[i] ?? 0;
+        const maskBegin = maskBegins[i] ?? 0;
+        const rawMasks: number[] = [];
+        for (let m = 0; m < maskCount; m++) {
+            const mi = maskArtMeshes[maskBegin + m];
+            if (mi !== undefined && mi >= 0) rawMasks.push(mi);
+        }
+
+        meshMeta.set(i, {
+            textureIndex: Math.max(0, textureIndices[i] ?? 0),
+            uvs,
+            indices,
+            opacity,
+            renderOrder,
+            blendMode: flags.blendMode,
+            invertedMask: flags.invertedMask,
+            rawMaskArtMeshes: rawMasks,
+            visible: (visibles[i] ?? 1) !== 0,
+        });
+    }
+
+    applyMoc3Glues(
+        worldByMesh,
+        glues,
+        keyTables,
+        getParamByIndex,
+        glueIntensities,
+    );
+
+    const drafts: DraftDrawable[] = [];
+    for (const [artMeshIndex, world] of worldByMesh) {
+        const meta = meshMeta.get(artMeshIndex);
+        if (!meta) continue;
+        drafts.push({
+            artMeshIndex,
+            textureIndex: meta.textureIndex,
+            positions: normalizePositions(world, cw, ch, ppu),
+            uvs: meta.uvs,
+            indices: meta.indices,
+            opacity: meta.opacity,
+            renderOrder: meta.renderOrder,
+            blendMode: meta.blendMode,
+            invertedMask: meta.invertedMask,
+            rawMaskArtMeshes: meta.rawMaskArtMeshes,
+            visible: meta.visible,
+        });
+    }
+
+    drafts.sort((a, b) => a.renderOrder - b.renderOrder);
+
+    const artToProgram = new Map<number, number>();
+    for (let i = 0; i < drafts.length; i++) {
+        artToProgram.set(drafts[i]!.artMeshIndex, i);
+    }
+
+    const drawables: DrawableProgram[] = drafts.map((d, index) => {
+        const maskIndices: number[] = [];
+        for (const art of d.rawMaskArtMeshes) {
+            const mapped = artToProgram.get(art);
+            if (mapped !== undefined) maskIndices.push(mapped);
+        }
+        return {
+            index,
+            textureIndex: d.textureIndex,
+            positions: d.positions,
+            uvs: d.uvs,
+            indices: d.indices,
+            opacity: d.opacity,
+            renderOrder: d.renderOrder,
+            blendMode: d.blendMode,
+            invertedMask: d.invertedMask,
+            maskIndices,
+            visible: d.visible,
+            deformParamIndex: -1,
+            deformDeltas: null,
+        };
+    });
+
+    return {
+        format: "moc3",
+        codec: "moc3",
+        parameters,
+        drawables,
+    };
+}