@driftengine/assets 4.6.1 → 4.7.1

package/dist/blendGeometry.js

@@ -0,0 +1,210 @@
+/**
+ * A `.blend` mesh as triangle primitives, one per material slot, in glTF's conventions.
+ *
+ * **The same conversion serves every route out of a `.blend`.** `blendGltf.ts` writes these into a
+ * glTF document for `readModel`, and a bake that keeps a world's instancing calls this once per
+ * distinct mesh rather than once per object. So what a corner becomes — its position turned Y up,
+ * its UV flipped to glTF's origin, its colour linear — is decided here and nowhere else.
+ *
+ * **Vertices are shared where every attribute agrees exactly**, which is how Blender's exporter
+ * builds them, found by walking the exported copies of each source vertex rather than by hashing,
+ * so a fifty-million-corner city costs a scan rather than fifty million string keys.
+ *
+ * **Faces are triangulated as Blender does it**: a quad split from its first corner, an ngon by ear
+ * clipping in its own plane. Blender clips ears in a different order, so an ngon's diagonals can
+ * differ from Blender's; on a planar face that changes no pixel, on a bent one it changes the bend.
+ */
+import { POINT } from './blendMesh.js';
+import { faceNormals } from './blendNormals.js';
+/** Blender Z up to glTF Y up: (x, y, z) becomes (x, z, -y). */
+export function toYUp(out, at, x, y, z) {
+    out[at] = x;
+    out[at + 1] = z;
+    out[at + 2] = -y;
+}
+/** Triangles of one face, as corner indices, appended to `out`. */
+export function triangulateFace(mesh, face, normal, out) {
+    const start = mesh.faceOffsets[face];
+    const end = mesh.faceOffsets[face + 1];
+    const n = end - start;
+    if (n < 3)
+        return;
+    if (n === 3) {
+        out.push(start, start + 1, start + 2);
+        return;
+    }
+    if (n === 4) {
+        out.push(start, start + 1, start + 2, start, start + 2, start + 3);
+        return;
+    }
+    /* Project onto the face's plane, then clip ears. */
+    const [nx, ny, nz] = normal;
+    const ax = Math.abs(nx);
+    const ay = Math.abs(ny);
+    const az = Math.abs(nz);
+    const drop = az >= ax && az >= ay ? 2 : ax >= ay ? 0 : 1;
+    const flip = (drop === 2 ? nz : drop === 0 ? nx : ny) < 0;
+    const p = mesh.positions;
+    const xs = [];
+    const ys = [];
+    for (let c = start; c < end; c++) {
+        const v = mesh.cornerVerts[c] * 3;
+        /* The two axes left after dropping one, in right-handed order: (y, z), (z, x) or (x, y). */
+        const a = p[v + ((drop + 1) % 3)];
+        const b = p[v + ((drop + 2) % 3)];
+        xs.push(flip ? b : a);
+        ys.push(flip ? a : b);
+    }
+    const ring = Array.from({ length: n }, (_, i) => i);
+    const cross = (i, j, k) => (xs[j] - xs[i]) * (ys[k] - ys[i]) -
+        (ys[j] - ys[i]) * (xs[k] - xs[i]);
+    const inside = (i, j, k, q) => cross(i, j, q) >= 0 && cross(j, k, q) >= 0 && cross(k, i, q) >= 0;
+    let guard = 0;
+    while (ring.length > 3 && guard++ < n * n) {
+        let clipped = false;
+        for (let r = 0; r < ring.length; r++) {
+            const i = ring[(r + ring.length - 1) % ring.length];
+            const j = ring[r];
+            const k = ring[(r + 1) % ring.length];
+            if (cross(i, j, k) <= 0)
+                continue;
+            let blocked = false;
+            for (const q of ring) {
+                if (q !== i && q !== j && q !== k && inside(i, j, k, q)) {
+                    blocked = true;
+                    break;
+                }
+            }
+            if (blocked)
+                continue;
+            out.push(start + i, start + j, start + k);
+            ring.splice(r, 1);
+            clipped = true;
+            break;
+        }
+        /* A face too bent or degenerate to clip: fan the rest, which is what remains drawable. */
+        if (!clipped)
+            break;
+    }
+    for (let r = 1; r + 1 < ring.length; r++)
+        out.push(start + ring[0], start + ring[r], start + ring[r + 1]);
+}
+/** Split a mesh into one primitive per material slot it uses. */
+export function meshPrimitives(mesh, normals, slots, needs) {
+    const faces = mesh.faceOffsets.length - 1;
+    const face = faceNormals(mesh);
+    const bySlot = new Map();
+    for (let f = 0; f < faces; f++) {
+        const raw = mesh.materialIndex === null ? 0 : mesh.materialIndex[f];
+        const slot = slots === 0 ? -1 : Math.max(0, Math.min(slots - 1, raw));
+        let list = bySlot.get(slot);
+        if (list === undefined)
+            bySlot.set(slot, (list = []));
+        list.push(f);
+    }
+    const out = [];
+    for (const slot of [...bySlot.keys()].sort((a, b) => a - b)) {
+        const need = slot < 0 ? { vertexColor: null, uvMap: null, uvTransform: null } : needs(slot);
+        const corners = [];
+        for (const f of bySlot.get(slot))
+            triangulateFace(mesh, f, [face[f * 3], face[f * 3 + 1], face[f * 3 + 2]], corners);
+        out.push(build(mesh, normals, slot, need, corners));
+    }
+    return out;
+}
+function uvLayer(mesh, name) {
+    if (mesh.uvs.length === 0)
+        return null;
+    const found = name === null ? -1 : mesh.uvs.findIndex((u) => u.name === name);
+    return (mesh.uvs[found >= 0 ? found : mesh.renderUv] ?? mesh.uvs[0])?.uv ?? null;
+}
+function colorLayer(mesh, name) {
+    if (name === null || mesh.colors.length === 0)
+        return null;
+    const found = name === '' ? -1 : mesh.colors.findIndex((c) => c.name === name);
+    return mesh.colors[found >= 0 ? found : mesh.renderColor] ?? null;
+}
+function build(mesh, normals, slot, need, corners) {
+    const uv = uvLayer(mesh, need.uvMap);
+    const color = colorLayer(mesh, need.vertexColor);
+    const t = need.uvTransform;
+    const verts = mesh.positions.length / 3;
+    /* Exported copies of each source vertex, as a chain: head per vertex, next per copy. */
+    const head = new Int32Array(verts).fill(-1);
+    const next = [];
+    const corner = [];
+    const source = [];
+    const indices = new Uint32Array(corners.length);
+    const same = (a, b) => {
+        for (let k = 0; k < 3; k++)
+            if (normals[a * 3 + k] !== normals[b * 3 + k])
+                return false;
+        if (uv !== null)
+            for (let k = 0; k < 2; k++)
+                if (uv[a * 2 + k] !== uv[b * 2 + k])
+                    return false;
+        if (color !== null && color.domain !== POINT)
+            for (let k = 0; k < 4; k++)
+                if (color.rgba[a * 4 + k] !== color.rgba[b * 4 + k])
+                    return false;
+        return true;
+    };
+    for (let i = 0; i < corners.length; i++) {
+        const c = corners[i];
+        const v = mesh.cornerVerts[c];
+        let found = -1;
+        for (let e = head[v]; e >= 0; e = next[e]) {
+            if (same(corner[e], c)) {
+                found = e;
+                break;
+            }
+        }
+        if (found < 0) {
+            found = corner.length;
+            corner.push(c);
+            source.push(v);
+            next.push(head[v]);
+            head[v] = found;
+        }
+        indices[i] = found;
+    }
+    const count = corner.length;
+    const positions = new Float32Array(count * 3);
+    const outNormals = new Float32Array(count * 3);
+    const uvs = uv === null ? null : new Float32Array(count * 2);
+    const colors = color === null ? null : new Float32Array(count * 4);
+    const p = mesh.positions;
+    for (let e = 0; e < count; e++) {
+        const c = corner[e];
+        const v = source[e];
+        toYUp(positions, e * 3, p[v * 3], p[v * 3 + 1], p[v * 3 + 2]);
+        toYUp(outNormals, e * 3, normals[c * 3], normals[c * 3 + 1], normals[c * 3 + 2]);
+        if (uvs !== null) {
+            let u = uv?.[c * 2];
+            let w = uv?.[c * 2 + 1];
+            if (t !== null) {
+                const tu = t[0] * u + t[3] * w + t[6];
+                const tv = t[1] * u + t[4] * w + t[7];
+                u = tu;
+                w = tv;
+            }
+            uvs[e * 2] = u;
+            uvs[e * 2 + 1] = 1 - w;
+        }
+        if (colors !== null && color !== null) {
+            const at = color.domain === POINT ? v : c;
+            for (let k = 0; k < 4; k++)
+                colors[e * 4 + k] = color.rgba[at * 4 + k];
+        }
+    }
+    return {
+        slot,
+        positions,
+        normals: outNormals,
+        uvs,
+        colors,
+        indices,
+        sourceVertex: Int32Array.from(source),
+        sourceCorner: Int32Array.from(corner),
+    };
+}

package/dist/blendGltf.d.ts

@@ -0,0 +1,65 @@
+/**
+ * A `.blend` as a glTF document in memory, so that `readModel` reads it through the glTF reader.
+ *
+ * **Why glTF in the middle.** Blender's own exporter writes glTF, and the baker hands a file it
+ * cannot read directly to that exporter. Building the same document here means the two routes share
+ * every step after it — materials, textures, skins, lights, the flattening into world space — and
+ * so cannot drift apart on any of them. It also makes Blender's export of a fixture an independent
+ * check on this one: the two documents should say the same thing.
+ *
+ * **What it refuses** it lists in `refusals`, and `readBlend` declines the whole file: a modifier,
+ * a constraint, a rig, a curve. Half a scene is worse than an error, because nobody can see what is
+ * missing. **What it approximates** — a node graph glTF cannot hold, animation it does not read —
+ * it lists in `approximations` and draws anyway, as Blender's exporter would.
+ */
+import type { BlendData, BlendStruct } from './blendData.ts';
+import type { GltfDocument } from './gltf.ts';
+export interface BlendGltf {
+    readonly doc: GltfDocument;
+    readonly binary: Uint8Array;
+    /** What only Blender can evaluate. `readBlend` refuses the file over any of these. */
+    readonly refusals: string[];
+    /** What Blender's own exporter would do better: animation, a channel glTF needs repacked. */
+    readonly approximations: string[];
+    /** What glTF cannot hold by either route, said once each. */
+    readonly warnings: string[];
+    readonly notes: string[];
+}
+/** The bytes a packed image holds, or null where it lives in a file beside the `.blend`. */
+export declare function packedImage(image: BlendStruct): Uint8Array | null;
+/**
+ * Whether an image stores one channel: a grey PNG, or a JPEG of one component. An image that is not
+ * packed cannot be looked at here and is taken to be grey, which is what a scalar map usually is.
+ */
+export declare function isGreyImage(image: BlendStruct): boolean;
+/** A packed image's media type, from its first bytes. */
+export declare function imageMime(bytes: Uint8Array): string | null;
+/** Where an unpacked image lives, relative to the `.blend` when Blender wrote it that way. */
+export declare function imagePath(image: BlendStruct): string;
+/** What `blendToGltf` reads, where the whole open scene is not wanted. */
+export interface BlendGltfOptions {
+    /**
+     * One object alone at the origin rather than the scene: a bake that keeps a world's instancing
+     * converts each distinct mesh once this way and places the copies itself.
+     */
+    readonly only?: BlendStruct;
+    /**
+     * Name each image by `imageUri` rather than carrying its bytes. A bake converting thousands of
+     * objects that share a few thousand images reads each image once, itself, rather than once a
+     * document.
+     */
+    readonly imageUri?: (image: BlendStruct) => string;
+}
+/** Build the document. */
+export declare function blendToGltf(blend: BlendData, options?: BlendGltfOptions): BlendGltf;
+/** An object's material slots: the object's own material where its slot says so, else the mesh's. */
+export declare function materialSlots(object: BlendStruct, mesh: BlendStruct): (BlendStruct | null)[];
+/**
+ * The colour of a black body at `kelvin`, in linear Rec. 709, scaled to unit luminance: what
+ * Blender multiplies a light's colour by when the light takes its colour from a temperature.
+ *
+ * Planck's law through the CIE 1931 observer, by the multi-lobe fit of Wyman, Sloan and Shirley.
+ * **Within 1% of Blender's table, not equal to it**: Blender's is fitted per range to its own colour
+ * configuration, and at 3000 K reads (1.771, 0.844, 0.272) where this reads (1.752, 0.850, 0.271).
+ */
+export declare function blackbody(kelvin: number): [number, number, number];