@ludic-labs/assembly 0.0.0-stage → 0.4.0

package/dist/mesh.js

@@ -0,0 +1,153 @@
+import { requireValue } from "./required.js";
+import { cross, sub } from "./math.js";
+import { linear } from "./compat.js";
+export function meshForAsset(asset, tint) {
+    const result = emptyMesh();
+    if (tint !== undefined && !/^#[a-fA-F0-9]{6}$/.test(tint))
+        throw new RangeError("Tint must be #rrggbb");
+    const color = tint ? [1, 3, 5].map((i) => linear(parseInt(tint.slice(i, i + 2), 16))) : [1, 1, 1];
+    for (const [material, mesh] of Object.entries(asset.layers))
+        appendMesh(result, {
+            ...mesh,
+            colors: requireValue(asset.materials[material]).tintable && tint
+                ? mesh.colors.map((v, i) => v * requireValue(color[i % 3]))
+                : mesh.colors,
+        });
+    return result;
+}
+export const emptyMesh = () => ({ positions: [], normals: [], colors: [], indices: [] });
+export function appendMesh(target, source, offset = [0, 0, 0]) {
+    const first = target.positions.length / 3;
+    for (let i = 0; i < source.positions.length; i++)
+        target.positions.push(requireValue(source.positions[i]) + requireValue(offset[i % 3]));
+    for (const n of source.normals)
+        target.normals.push(n);
+    for (const c of source.colors)
+        target.colors.push(c);
+    for (const i of source.indices)
+        target.indices.push(i + first);
+    // Joint indices are carried only when either side is rigged; static vertices use -1.
+    if (source.joints || target.joints) {
+        target.joints ??= new Array(first).fill(-1);
+        if (source.joints)
+            for (const j of source.joints)
+                target.joints.push(j);
+        else
+            for (let i = 0; i < source.positions.length / 3; i++)
+                target.joints.push(-1);
+    }
+    return target;
+}
+export function meshBounds(mesh) {
+    if (!mesh.positions.length)
+        throw new RangeError("Bounds require nonempty geometry");
+    const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+    for (let i = 0; i < mesh.positions.length; i++) {
+        const v = requireValue(mesh.positions[i]), a = i % 3;
+        min[a] = Math.min(requireValue(min[a]), v);
+        max[a] = Math.max(requireValue(max[a]), v);
+    }
+    return { min, max };
+}
+/** Remove collapsed bevel bands without changing legacy MeshBuilder output. */
+export function removeDegenerateTriangles(mesh) {
+    const indices = [];
+    for (let i = 0; i < mesh.indices.length; i += 3) {
+        const ids = mesh.indices.slice(i, i + 3);
+        const [a, b, c] = ids.map((id) => mesh.positions.slice(id * 3, id * 3 + 3));
+        if (Math.hypot(...cross(sub(requireValue(b), requireValue(a)), sub(requireValue(c), requireValue(a)))) >
+            1e-16)
+            indices.push(...ids);
+    }
+    mesh.indices = indices;
+    return mesh;
+}
+export function validateMesh(mesh) {
+    const errors = [], n = mesh.positions.length;
+    if (!n ||
+        n % 3 ||
+        mesh.normals.length !== n ||
+        mesh.colors.length !== n ||
+        !mesh.indices.length ||
+        mesh.indices.length % 3)
+        errors.push("ATTRIBUTE_LENGTH");
+    if ([...mesh.positions, ...mesh.normals, ...mesh.colors].some((v) => !Number.isFinite(v)))
+        errors.push("NON_FINITE_GEOMETRY");
+    if (mesh.indices.some((i) => !Number.isInteger(i) || i < 0 || i >= n / 3))
+        errors.push("INVALID_INDEX");
+    for (let i = 0; i < mesh.normals.length; i += 3) {
+        const x = mesh.normals[i], y = mesh.normals[i + 1], z = mesh.normals[i + 2];
+        if (typeof x !== "number" || typeof y !== "number" || typeof z !== "number") {
+            errors.push("INVALID_NORMAL");
+            break;
+        }
+        const length = Math.hypot(x, y, z);
+        if (!Number.isFinite(length) || Math.abs(length - 1) > 1e-5) {
+            errors.push("INVALID_NORMAL");
+            break;
+        }
+    }
+    return errors;
+}
+export function canonicalJSON(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJSON).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.keys(value)
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${canonicalJSON(value[k])}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+/** Portable SHA-256 over canonical JSON. No Node, browser or asynchronous crypto dependency. */
+export function sourceHash(value) {
+    const bytes = new TextEncoder().encode(canonicalJSON(value)), bitLength = bytes.length * 8;
+    const data = new Uint8Array(Math.ceil((bytes.length + 9) / 64) * 64);
+    data.set(bytes);
+    data[bytes.length] = 128;
+    const dv = new DataView(data.buffer);
+    dv.setUint32(data.length - 8, Math.floor(bitLength / 2 ** 32));
+    dv.setUint32(data.length - 4, bitLength >>> 0);
+    const primes = [];
+    for (let n = 2; primes.length < 64; n++)
+        if (!primes.some((p) => n % p === 0))
+            primes.push(n);
+    const k = primes.map((p) => ((Math.cbrt(p) % 1) * 2 ** 32) >>> 0);
+    const h = primes.slice(0, 8).map((p) => ((Math.sqrt(p) % 1) * 2 ** 32) >>> 0);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let offset = 0; offset < data.length; offset += 64) {
+        const w = new Uint32Array(64);
+        for (let i = 0; i < 16; i++)
+            w[i] = dv.getUint32(offset + i * 4);
+        for (let i = 16; i < 64; i++) {
+            const x = requireValue(w[i - 15]), y = requireValue(w[i - 2]);
+            w[i] =
+                (requireValue(w[i - 16]) +
+                    (rotr(x, 7) ^ rotr(x, 18) ^ (x >>> 3)) +
+                    requireValue(w[i - 7]) +
+                    (rotr(y, 17) ^ rotr(y, 19) ^ (y >>> 10))) >>>
+                    0;
+        }
+        let [a, b, c, d, e, f, g, j] = h;
+        for (let i = 0; i < 64; i++) {
+            const t1 = (j +
+                (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) +
+                ((e & f) ^ (~e & g)) +
+                requireValue(k[i]) +
+                requireValue(w[i])) >>>
+                0;
+            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) >>> 0;
+            j = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        for (const [i, v] of [a, b, c, d, e, f, g, j].entries())
+            h[i] = (requireValue(h[i]) + v) >>> 0;
+    }
+    return h.map((v) => v.toString(16).padStart(8, "0")).join("");
+}

package/dist/motion.d.ts

@@ -0,0 +1,63 @@
+import type { CompiledAsset, CompiledClip, CompiledMotion, Diagnostic, MeshData, SampledPose, Vec3 } from "./types.js";
+/** Motion sets for asset-assembly/0.2 characters. */
+export declare const MOTION_SCHEMA: "motion-set/0.1";
+/** Lift and ground-penetration tolerance as a fraction of the asset's rest height. */
+export declare const CONTACT_TOLERANCE = 0.02;
+/** Planted-effector drift tolerance as a fraction of the asset's rest height. */
+export declare const SLIP_TOLERANCE = 0.04;
+/** Uniform verification samples per clip; contact intervals receive 16 additional samples each. */
+export declare const VERIFICATION_SAMPLES = 48;
+/** Normalized clip time over which the planted correction blends in before touchdown and out after lift-off. */
+export declare const SOLVE_BLEND = 0.08;
+/**
+ * Validate a motion set against a compiled rigged asset and verify its declared contacts.
+ * Throws AssetCompileError with every diagnostic; use checkMotion to keep measured-only results.
+ */
+export declare function compileMotion(input: unknown, asset: CompiledAsset): CompiledMotion;
+/** Diagnostics that measure a valid motion rather than reject its description. */
+export declare const MEASURED_CODES: readonly string[];
+/**
+ * For editors and repair loops: returns the compiled motion together with its diagnostics whenever
+ * every diagnostic is a measurement (slip, lift, penetration). Structural or semantic errors leave
+ * `motion` undefined. compileMotion remains the strict path.
+ */
+export declare function checkMotion(input: unknown, asset: CompiledAsset): {
+    motion?: CompiledMotion;
+    diagnostics: Diagnostic[];
+};
+export declare function validateMotion(input: unknown, asset: CompiledAsset): Diagnostic[];
+/**
+ * Sample a compiled clip, pose or expression at an integer frame, or at a normalized phase.
+ * `face` overlays a face-only clip (an expression or face clip): it replaces every face DOF and state,
+ * sampled at the same time on its own duration, while body joints, grounding and travel come from `clip`.
+ */
+export declare function samplePose(asset: CompiledAsset, clip: CompiledClip, time: {
+    frame: number;
+    fps: number;
+} | {
+    phase: number;
+}, options?: {
+    face?: CompiledClip;
+}): SampledPose;
+/**
+ * A new compiled asset with posed geometry, bounds and anchors, containing the instances visible in the
+ * pose's states. Rest `translation` values are kept.
+ */
+export declare function poseAsset(asset: CompiledAsset, pose: SampledPose): CompiledAsset;
+/**
+ * Place a character clip that uses anchor grounding on a furniture anchor and measure floor clearance.
+ * Both assets share the frame convention (front is −Z), so no rotation is involved.
+ */
+export declare function seatOn(character: CompiledAsset, clip: CompiledClip, furniture: CompiledAsset, seat: {
+    part: string;
+    anchor: string;
+}): {
+    offset: Vec3;
+    clearance: {
+        min: number;
+        max: number;
+    };
+    diagnostics: Diagnostic[];
+};
+/** Combine visible posed geometry without constructing posed instances, anchors or bounds. */
+export declare function posedMesh(asset: CompiledAsset, pose: SampledPose, tint?: string): MeshData;