@driftengine/assets 4.6.1 → 4.7.1

package/dist/blendMatrix.js

@@ -0,0 +1,245 @@
+/**
+ * The little matrix arithmetic a `.blend` scene needs, in the conventions Blender stores it in.
+ *
+ * Column-major 4x4 as plain number arrays, which is both how Blender lays out `float[4][4]` in a
+ * file and how glTF writes `matrix`, so a matrix read from one is written to the other without a
+ * transpose. Doubles throughout: these run once per object at import, and a parent chain composes
+ * enough of them that single precision drifts visibly on a deep rig.
+ *
+ * **Every rotation here is Blender's definition, not a generic one**, because a rotation mode is a
+ * claim about order: Blender's `XYZ` turns about X first, so its matrix is `Rz · Ry · Rx`. The
+ * fixtures under `scripts/fixtures/blend` hold an object in each of the eight modes and Blender's
+ * own export of where they ended up.
+ */
+export const identity = () => [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+export function multiply(a, b) {
+    const out = new Array(16);
+    for (let c = 0; c < 4; c++) {
+        for (let r = 0; r < 4; r++) {
+            let sum = 0;
+            for (let k = 0; k < 4; k++)
+                sum += a[k * 4 + r] * b[c * 4 + k];
+            out[c * 4 + r] = sum;
+        }
+    }
+    return out;
+}
+export function multiply3(a, b) {
+    const out = new Array(9);
+    for (let c = 0; c < 3; c++) {
+        for (let r = 0; r < 3; r++) {
+            let sum = 0;
+            for (let k = 0; k < 3; k++)
+                sum += a[k * 3 + r] * b[c * 3 + k];
+            out[c * 3 + r] = sum;
+        }
+    }
+    return out;
+}
+export function invert(m) {
+    const a = m;
+    const inv = new Array(16);
+    const g = (i) => a[i];
+    inv[0] =
+        g(5) * g(10) * g(15) -
+            g(5) * g(11) * g(14) -
+            g(9) * g(6) * g(15) +
+            g(9) * g(7) * g(14) +
+            g(13) * g(6) * g(11) -
+            g(13) * g(7) * g(10);
+    inv[4] =
+        -g(4) * g(10) * g(15) +
+            g(4) * g(11) * g(14) +
+            g(8) * g(6) * g(15) -
+            g(8) * g(7) * g(14) -
+            g(12) * g(6) * g(11) +
+            g(12) * g(7) * g(10);
+    inv[8] =
+        g(4) * g(9) * g(15) -
+            g(4) * g(11) * g(13) -
+            g(8) * g(5) * g(15) +
+            g(8) * g(7) * g(13) +
+            g(12) * g(5) * g(11) -
+            g(12) * g(7) * g(9);
+    inv[12] =
+        -g(4) * g(9) * g(14) +
+            g(4) * g(10) * g(13) +
+            g(8) * g(5) * g(14) -
+            g(8) * g(6) * g(13) -
+            g(12) * g(5) * g(10) +
+            g(12) * g(6) * g(9);
+    inv[1] =
+        -g(1) * g(10) * g(15) +
+            g(1) * g(11) * g(14) +
+            g(9) * g(2) * g(15) -
+            g(9) * g(3) * g(14) -
+            g(13) * g(2) * g(11) +
+            g(13) * g(3) * g(10);
+    inv[5] =
+        g(0) * g(10) * g(15) -
+            g(0) * g(11) * g(14) -
+            g(8) * g(2) * g(15) +
+            g(8) * g(3) * g(14) +
+            g(12) * g(2) * g(11) -
+            g(12) * g(3) * g(10);
+    inv[9] =
+        -g(0) * g(9) * g(15) +
+            g(0) * g(11) * g(13) +
+            g(8) * g(1) * g(15) -
+            g(8) * g(3) * g(13) -
+            g(12) * g(1) * g(11) +
+            g(12) * g(3) * g(9);
+    inv[13] =
+        g(0) * g(9) * g(14) -
+            g(0) * g(10) * g(13) -
+            g(8) * g(1) * g(14) +
+            g(8) * g(2) * g(13) +
+            g(12) * g(1) * g(10) -
+            g(12) * g(2) * g(9);
+    inv[2] =
+        g(1) * g(6) * g(15) -
+            g(1) * g(7) * g(14) -
+            g(5) * g(2) * g(15) +
+            g(5) * g(3) * g(14) +
+            g(13) * g(2) * g(7) -
+            g(13) * g(3) * g(6);
+    inv[6] =
+        -g(0) * g(6) * g(15) +
+            g(0) * g(7) * g(14) +
+            g(4) * g(2) * g(15) -
+            g(4) * g(3) * g(14) -
+            g(12) * g(2) * g(7) +
+            g(12) * g(3) * g(6);
+    inv[10] =
+        g(0) * g(5) * g(15) -
+            g(0) * g(7) * g(13) -
+            g(4) * g(1) * g(15) +
+            g(4) * g(3) * g(13) +
+            g(12) * g(1) * g(7) -
+            g(12) * g(3) * g(5);
+    inv[14] =
+        -g(0) * g(5) * g(14) +
+            g(0) * g(6) * g(13) +
+            g(4) * g(1) * g(14) -
+            g(4) * g(2) * g(13) -
+            g(12) * g(1) * g(6) +
+            g(12) * g(2) * g(5);
+    inv[3] =
+        -g(1) * g(6) * g(11) +
+            g(1) * g(7) * g(10) +
+            g(5) * g(2) * g(11) -
+            g(5) * g(3) * g(10) -
+            g(9) * g(2) * g(7) +
+            g(9) * g(3) * g(6);
+    inv[7] =
+        g(0) * g(6) * g(11) -
+            g(0) * g(7) * g(10) -
+            g(4) * g(2) * g(11) +
+            g(4) * g(3) * g(10) +
+            g(8) * g(2) * g(7) -
+            g(8) * g(3) * g(6);
+    inv[11] =
+        -g(0) * g(5) * g(11) +
+            g(0) * g(7) * g(9) +
+            g(4) * g(1) * g(11) -
+            g(4) * g(3) * g(9) -
+            g(8) * g(1) * g(7) +
+            g(8) * g(3) * g(5);
+    inv[15] =
+        g(0) * g(5) * g(10) -
+            g(0) * g(6) * g(9) -
+            g(4) * g(1) * g(10) +
+            g(4) * g(2) * g(9) +
+            g(8) * g(1) * g(6) -
+            g(8) * g(2) * g(5);
+    const det = g(0) * inv[0] +
+        g(1) * inv[4] +
+        g(2) * inv[8] +
+        g(3) * inv[12];
+    /* Blender's `invert_m4` leaves a singular matrix as it found it, and so does this. */
+    if (Math.abs(det) < 1e-30)
+        return [...m];
+    return inv.map((v) => v / det);
+}
+export function translation(x, y, z) {
+    return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z, 1];
+}
+/** Rotation and scale in a 3x3, translation beside it: `T · R · S`. */
+export function compose(location, rotation, scale) {
+    const out = identity();
+    for (let c = 0; c < 3; c++) {
+        const s = scale[c];
+        for (let r = 0; r < 3; r++)
+            out[c * 4 + r] = rotation[c * 3 + r] * s;
+    }
+    out[12] = location[0];
+    out[13] = location[1];
+    out[14] = location[2];
+    return out;
+}
+function axis(index, angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    if (index === 0)
+        return [1, 0, 0, 0, c, s, 0, -s, c];
+    if (index === 1)
+        return [c, 0, -s, 0, 1, 0, s, 0, c];
+    return [c, s, 0, -s, c, 0, 0, 0, 1];
+}
+/**
+ * Blender's Euler rotation modes, by the value `Object.rotmode` stores: 1 `XYZ` to 6 `ZYX`.
+ * Each names the axes in the order they are turned about.
+ */
+const ORDERS = {
+    1: [0, 1, 2],
+    2: [0, 2, 1],
+    3: [1, 0, 2],
+    4: [1, 2, 0],
+    5: [2, 0, 1],
+    6: [2, 1, 0],
+};
+export function eulerMatrix(e, mode) {
+    const order = ORDERS[mode] ?? ORDERS[1];
+    const [first, second, third] = order;
+    const turn = (i) => axis(i, e[i]);
+    return multiply3(turn(third), multiply3(turn(second), turn(first)));
+}
+/** A quaternion as Blender stores it, `w` first, normalised before use as Blender does. */
+export function quaternionMatrix(q) {
+    let [w, x, y, z] = q;
+    const length = Math.hypot(w, x, y, z);
+    if (length < 1e-12)
+        return [1, 0, 0, 0, 1, 0, 0, 0, 1];
+    w /= length;
+    x /= length;
+    y /= length;
+    z /= length;
+    return [
+        1 - 2 * (y * y + z * z),
+        2 * (x * y + w * z),
+        2 * (x * z - w * y),
+        2 * (x * y - w * z),
+        1 - 2 * (x * x + z * z),
+        2 * (y * z + w * x),
+        2 * (x * z + w * y),
+        2 * (y * z - w * x),
+        1 - 2 * (x * x + y * y),
+    ];
+}
+export function axisAngleMatrix(direction, angle) {
+    const [x, y, z] = direction;
+    const length = Math.hypot(x, y, z);
+    if (length < 1e-12)
+        return [1, 0, 0, 0, 1, 0, 0, 0, 1];
+    const s = Math.sin(angle / 2) / length;
+    return quaternionMatrix([Math.cos(angle / 2), x * s, y * s, z * s]);
+}
+/** Transform a point by a column-major 4x4. */
+export function transformPoint(m, x, y, z) {
+    const g = (i) => m[i];
+    return [
+        g(0) * x + g(4) * y + g(8) * z + g(12),
+        g(1) * x + g(5) * y + g(9) * z + g(13),
+        g(2) * x + g(6) * y + g(10) * z + g(14),
+    ];
+}

package/dist/blendMesh.d.ts

@@ -0,0 +1,70 @@
+/**
+ * A `.blend` mesh's stored data, read the same way whichever Blender wrote it.
+ *
+ * **Three layouts, one result.** Until 3.4 a mesh was arrays of structs — `MVert`, `MEdge`,
+ * `MPoly`, `MLoop` — with UVs and colours in `CustomData` layers beside them. From 3.5 to 4.x the
+ * same data became named attributes in `CustomData`: `position`, `.edge_verts`, `.corner_vert`,
+ * `sharp_face`. From 5.0 the attributes moved again, into `AttributeStorage`, with a type code of
+ * their own. Each is read here into `BlendMeshData`, which is plain arrays and knows nothing about
+ * where they came from.
+ *
+ * **What is read is what is stored.** Nothing is evaluated: a mesh with modifiers is the mesh
+ * before them, and `blend.ts` refuses such a file rather than drawing the wrong shape.
+ *
+ * **Old meaning is translated to current meaning**, because the comparison is with Blender as it
+ * is now opening the file. Before 4.1 a sharp edge did nothing unless the mesh had auto smooth on,
+ * and Blender drops those edges when it opens such a file; with auto smooth on, it adds a modifier
+ * that splits by angle, which is exactly the angle this reader applies.
+ */
+import type { BlendData, BlendStruct } from './blendData.ts';
+/** Domains, in the order both of Blender's attribute systems number them. */
+export declare const POINT = 0;
+export declare const EDGE = 1;
+export declare const FACE = 2;
+export declare const CORNER = 3;
+export interface BlendColorLayer {
+    readonly name: string;
+    readonly domain: typeof POINT | typeof CORNER;
+    /** RGBA per element, linear. A byte colour is stored sRGB-encoded and decoded here. */
+    readonly rgba: Float32Array;
+}
+export interface BlendMeshData {
+    readonly name: string;
+    readonly positions: Float32Array;
+    /** Face `f` owns corners `faceOffsets[f]` to `faceOffsets[f + 1]`. */
+    readonly faceOffsets: Int32Array;
+    readonly cornerVerts: Int32Array;
+    readonly cornerEdges: Int32Array;
+    readonly edgeVerts: Int32Array;
+    readonly materialIndex: Int32Array | null;
+    readonly sharpFace: Uint8Array | null;
+    readonly sharpEdge: Uint8Array | null;
+    /** UV maps in the file's order, two floats per corner. */
+    readonly uvs: readonly {
+        name: string;
+        uv: Float32Array;
+    }[];
+    /** Which UV map renders when a texture names none: Blender's "active render" map. */
+    readonly renderUv: number;
+    readonly colors: readonly BlendColorLayer[];
+    /** The colour attribute a material's unnamed Color Attribute node reads. */
+    readonly renderColor: number;
+    /** Custom normals in Blender's packed form: two shorts per corner, relative to its fan. */
+    readonly packedNormals: Int16Array | null;
+    /** Custom normals stored as plain vectors, 4.5 on, in the domain they were written to. */
+    readonly freeNormals: {
+        domain: number;
+        normals: Float32Array;
+    } | null;
+    /** The split angle a pre-4.1 file's auto smooth asked for, or null where it was off. */
+    readonly autoSmooth: number | null;
+    /** Per vertex, the groups it belongs to and how much: flattened `(group, weight)` pairs. */
+    readonly weights: {
+        offsets: Int32Array;
+        groups: Int32Array;
+        values: Float32Array;
+    } | null;
+    readonly groupNames: readonly string[];
+}
+/** Read a mesh datablock into plain arrays. */
+export declare function readBlendMesh(blend: BlendData, mesh: BlendStruct): BlendMeshData;