@smarterplan/ngx-smarterplan-core 1.4.21 → 1.4.22

package/esm2022/lib/services/obj-to-glb.mjs

@@ -0,0 +1,649 @@
+/**
+ * Converts an .obj model, with its .mtl and textures, into the .glb the Three.js viewer loads - in
+ * the browser, as the model is added, with nothing to install.
+ *
+ * It does what obj2gltf did in converte-modelo.sh, and the reason is the same. An .obj lists every
+ * corner of every triangle; loaded as it is, a captured model's 2.6 million distinct vertices become
+ * 12.6 million, one per corner. Here each position and texture coordinate pair becomes one vertex,
+ * shared by every triangle that uses it, so what reaches the graphics card is the 2.6 million.
+ *
+ * Textures go in as they are, their bytes untouched: a JPEG re-encoded would lose quality and gain
+ * nothing. Normals are only written when the .obj has them; without, the viewer works them out as
+ * it loads the model. The axes are left as the .obj has them - the viewer finds which way is up.
+ *
+ * The .obj is read as a stream, so a file of hundreds of megabytes is never held whole.
+ */
+/** Whether a set of files holds an .obj model to convert. */
+export function hasObjModel(files) {
+    return files.some((file) => /\.obj$/i.test(file.name));
+}
+/**
+ * Converts the .obj among `files` into a .glb, using the .mtl and the images found with it.
+ */
+export async function convertObjToGlb(files, options = {}) {
+    const objs = files.filter((file) => /\.obj$/i.test(file.name));
+    if (objs.length !== 1) {
+        throw new Error(objs.length === 0 ? 'No .obj file was given.' : 'Give one .obj file at a time.');
+    }
+    const obj = objs[0];
+    const byName = new Map(files.map((file) => [baseName(file.name).toLowerCase(), file]));
+    // The .obj's own reading is most of the time; the rest is shared out over what follows.
+    const parsed = await readObj(obj.stream(), obj.size, {
+        ...options,
+        onProgress: (fraction) => options.onProgress?.(fraction * 0.85),
+    });
+    if (parsed.triangleCount === 0) {
+        throw new Error(`${obj.name} has no faces.`);
+    }
+    // Materials: from the .mtl files the .obj names, or failing that any .mtl given with it.
+    const named = parsed.materialLibraries.map((library) => byName.get(baseName(library).toLowerCase())).filter(Boolean);
+    const libraries = named.length > 0 ? named : files.filter((file) => /\.mtl$/i.test(file.name));
+    const materials = new Map();
+    for (const library of libraries) {
+        parseMtl(await library.text()).forEach((material) => materials.set(material.name, material));
+    }
+    await pause(options.signal);
+    const breaks = new Breaks(options.signal, options.onProgress);
+    const geometry = await indexGeometry(parsed, breaks);
+    options.onProgress?.(0.95);
+    await pause(options.signal);
+    const missing = new Set();
+    const glb = await writeGlb(parsed, geometry, materials, byName, missing, obj.name, breaks);
+    options.onProgress?.(1);
+    return {
+        file: new File([glb], obj.name.replace(/\.obj$/i, '') + '.glb', { type: 'model/gltf-binary' }),
+        vertices: geometry.vertexCount,
+        triangles: parsed.triangleCount,
+        materials: parsed.groups.length,
+        missingTextures: [...missing],
+    };
+}
+/** The file name without its folders, which is how an .mtl or a texture is looked up. */
+function baseName(path) {
+    return path.trim().replace(/^"|"$/g, '').split(/[\\/]/).pop() ?? path;
+}
+/** Lets the page draw and answer for a moment, and stops here if the conversion was cancelled. */
+async function pause(signal) {
+    if (signal?.aborted) {
+        throw new DOMException('Model conversion cancelled', 'AbortError');
+    }
+    await new Promise((resolve) => setTimeout(resolve, 0));
+}
+/**
+ * Stops a long loop now and then so the page can draw and answer clicks. Checked only every few
+ * thousand turns of the loop: waiting on a promise every turn would cost more than the loop.
+ */
+class Breaks {
+    signal;
+    onProgress;
+    last = performance.now();
+    constructor(signal, onProgress) {
+        this.signal = signal;
+        this.onProgress = onProgress;
+    }
+    /** Whether this turn of the loop should stop for a moment. Synchronous: it is asked every turn. */
+    due(turn) {
+        return (turn & 0x3fff) === 0 && performance.now() - this.last > 40;
+    }
+    /** Stops for a moment, reporting how far the conversion has got. */
+    async take(fraction) {
+        this.onProgress?.(fraction);
+        await pause(this.signal);
+        this.last = performance.now();
+    }
+}
+/** A growable typed array: an .obj does not say up front how many of anything it holds. */
+class Growable {
+    data;
+    length = 0;
+    constructor(data) {
+        this.data = data;
+    }
+    push(value) {
+        if (this.length === this.data.length) {
+            const bigger = new this.data.constructor(this.data.length * 2);
+            bigger.set(this.data);
+            this.data = bigger;
+        }
+        this.data[this.length] = value;
+        this.length += 1;
+    }
+    view() {
+        return this.data.subarray(0, this.length);
+    }
+}
+/**
+ * Reads an .obj from a stream of its bytes: positions, texture coordinates, normals, and triangles
+ * grouped by material. Polygons are split into triangles; negative indices, counting back from the
+ * end, are resolved; anything else (objects, groups, smoothing) is skipped.
+ */
+export async function readObj(stream, size, options = {}) {
+    const parser = new ObjParser();
+    const reader = stream.getReader();
+    let read = 0;
+    let lastBreak = performance.now();
+    try {
+        for (;;) {
+            if (options.signal?.aborted) {
+                throw new DOMException('Model conversion cancelled', 'AbortError');
+            }
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            parser.push(value);
+            read += value.length;
+            if (performance.now() - lastBreak > 40) {
+                options.onProgress?.(size > 0 ? Math.min(read / size, 1) : 0);
+                await new Promise((resolve) => setTimeout(resolve, 0));
+                lastBreak = performance.now();
+            }
+        }
+    }
+    finally {
+        reader.cancel().catch(() => undefined);
+    }
+    parser.end();
+    options.onProgress?.(1);
+    return parser.result();
+}
+/**
+ * Line by line, straight from the bytes. Building a string for each of the millions of lines of a
+ * captured model would be most of the work; this reads the numbers off the bytes instead.
+ */
+class ObjParser {
+    positions = new Growable(new Float64Array(1 << 16));
+    uvs = new Growable(new Float64Array(1 << 16));
+    normals = new Growable(new Float64Array(1 << 16));
+    groups = [];
+    groupByMaterial = new Map();
+    current = null;
+    materialLibraries = [];
+    triangleCount = 0;
+    /** The bytes of the line being read, kept across chunks. */
+    line = new Uint8Array(256);
+    lineLength = 0;
+    // The corners of the face being read, as position/texture/normal indices.
+    face = new Int32Array(3 * 64);
+    push(bytes) {
+        for (let index = 0; index < bytes.length; index += 1) {
+            const byte = bytes[index];
+            if (byte === 10) {
+                this.readLine();
+                this.lineLength = 0;
+            }
+            else {
+                if (this.lineLength === this.line.length) {
+                    const longer = new Uint8Array(this.line.length * 2);
+                    longer.set(this.line);
+                    this.line = longer;
+                }
+                this.line[this.lineLength] = byte;
+                this.lineLength += 1;
+            }
+        }
+    }
+    end() {
+        this.readLine();
+        this.lineLength = 0;
+    }
+    result() {
+        return {
+            positions: this.positions.view(),
+            uvs: this.uvs.view(),
+            normals: this.normals.view(),
+            groups: this.groups.filter((group) => group.corners.length > 0),
+            materialLibraries: this.materialLibraries,
+            triangleCount: this.triangleCount,
+        };
+    }
+    readLine() {
+        const line = this.line;
+        const length = this.lineLength;
+        let at = 0;
+        while (at < length && (line[at] === 32 || line[at] === 9)) {
+            at += 1;
+        }
+        if (at + 1 >= length) {
+            return;
+        }
+        const first = line[at];
+        const second = line[at + 1];
+        if (first === 118 && (second === 32 || second === 9)) {
+            // v x y z
+            this.readNumbers(at + 2, 3, this.positions);
+        }
+        else if (first === 118 && second === 116) {
+            // vt u v
+            this.readNumbers(at + 3, 2, this.uvs);
+        }
+        else if (first === 118 && second === 110) {
+            // vn x y z
+            this.readNumbers(at + 3, 3, this.normals);
+        }
+        else if (first === 102 && (second === 32 || second === 9)) {
+            this.readFace(at + 2);
+        }
+        else if (this.startsWith(at, 'usemtl')) {
+            this.useMaterial(this.restOfLine(at + 6));
+        }
+        else if (this.startsWith(at, 'mtllib')) {
+            this.materialLibraries.push(...this.restOfLine(at + 6).split(/\s+(?=\S+\.mtl\b)/i).filter(Boolean));
+        }
+    }
+    startsWith(at, word) {
+        for (let index = 0; index < word.length; index += 1) {
+            if (this.line[at + index] !== word.charCodeAt(index)) {
+                return false;
+            }
+        }
+        const after = this.line[at + word.length];
+        return after === 32 || after === 9;
+    }
+    restOfLine(at) {
+        let end = this.lineLength;
+        while (end > at && (this.line[end - 1] === 13 || this.line[end - 1] === 32 || this.line[end - 1] === 9)) {
+            end -= 1;
+        }
+        return new TextDecoder().decode(this.line.subarray(at, end)).trim();
+    }
+    useMaterial(name) {
+        let group = this.groupByMaterial.get(name);
+        if (!group) {
+            group = { material: name, corners: new Growable(new Int32Array(1 << 12)) };
+            this.groupByMaterial.set(name, group);
+            this.groups.push(group);
+        }
+        this.current = group;
+    }
+    /** Reads up to `count` numbers from `at` onwards into `target`, padding a short line with 0. */
+    readNumbers(at, count, target) {
+        let read = 0;
+        let position = at;
+        while (read < count) {
+            const [value, next] = this.readNumber(position);
+            if (next === position) {
+                break;
+            }
+            target.push(value);
+            read += 1;
+            position = next;
+        }
+        for (; read < count; read += 1) {
+            target.push(0);
+        }
+    }
+    /** Reads one number starting at or after `at`; returns it and where it ended. */
+    readNumber(at) {
+        const line = this.line;
+        const length = this.lineLength;
+        let index = at;
+        while (index < length && (line[index] === 32 || line[index] === 9 || line[index] === 13)) {
+            index += 1;
+        }
+        const start = index;
+        let negative = false;
+        if (line[index] === 45 || line[index] === 43) {
+            negative = line[index] === 45;
+            index += 1;
+        }
+        let whole = 0;
+        let fraction = 0;
+        let scale = 1;
+        let digits = 0;
+        while (index < length && line[index] >= 48 && line[index] <= 57) {
+            whole = whole * 10 + (line[index] - 48);
+            index += 1;
+            digits += 1;
+        }
+        if (line[index] === 46) {
+            index += 1;
+            while (index < length && line[index] >= 48 && line[index] <= 57) {
+                fraction = fraction * 10 + (line[index] - 48);
+                scale *= 10;
+                index += 1;
+                digits += 1;
+            }
+        }
+        if (digits === 0) {
+            return [0, at];
+        }
+        let value = whole + fraction / scale;
+        if (line[index] === 101 || line[index] === 69) {
+            index += 1;
+            let negativeExponent = false;
+            if (line[index] === 45 || line[index] === 43) {
+                negativeExponent = line[index] === 45;
+                index += 1;
+            }
+            let exponent = 0;
+            while (index < length && line[index] >= 48 && line[index] <= 57) {
+                exponent = exponent * 10 + (line[index] - 48);
+                index += 1;
+            }
+            value *= 10 ** (negativeExponent ? -exponent : exponent);
+        }
+        return [negative ? -value : value, index === start ? at : index];
+    }
+    /** f v/vt/vn ... - any of the three forms, any number of corners, split into a fan. */
+    readFace(at) {
+        const line = this.line;
+        const length = this.lineLength;
+        let corners = 0;
+        let index = at;
+        while (index < length) {
+            while (index < length && (line[index] === 32 || line[index] === 9 || line[index] === 13)) {
+                index += 1;
+            }
+            if (index >= length) {
+                break;
+            }
+            // One corner: up to three integers separated by '/', any of the last two possibly empty.
+            const values = [0, 0, 0];
+            for (let slot = 0; slot < 3; slot += 1) {
+                let negative = false;
+                if (line[index] === 45) {
+                    negative = true;
+                    index += 1;
+                }
+                let value = 0;
+                let digits = 0;
+                while (index < length && line[index] >= 48 && line[index] <= 57) {
+                    value = value * 10 + (line[index] - 48);
+                    index += 1;
+                    digits += 1;
+                }
+                values[slot] = digits === 0 ? 0 : negative ? -value : value;
+                if (line[index] !== 47) {
+                    break;
+                }
+                index += 1;
+            }
+            if (corners < 64 && values[0] !== 0) {
+                // To zero-based indices, counting a negative one back from what has been read so far; -1
+                // means "none" for the texture and normal.
+                this.face[corners * 3] = this.resolve(values[0], this.positions.length / 3);
+                this.face[corners * 3 + 1] = values[1] === 0 ? -1 : this.resolve(values[1], this.uvs.length / 2);
+                this.face[corners * 3 + 2] = values[2] === 0 ? -1 : this.resolve(values[2], this.normals.length / 3);
+                corners += 1;
+            }
+            // Skip to the next separator, past anything unexpected in this token.
+            while (index < length && line[index] !== 32 && line[index] !== 9) {
+                index += 1;
+            }
+        }
+        if (corners < 3) {
+            return;
+        }
+        if (!this.current) {
+            this.useMaterial(null);
+        }
+        const target = this.current.corners;
+        for (let corner = 1; corner + 1 < corners; corner += 1) {
+            for (const which of [0, corner, corner + 1]) {
+                target.push(this.face[which * 3]);
+                target.push(this.face[which * 3 + 1]);
+                target.push(this.face[which * 3 + 2]);
+            }
+            this.triangleCount += 1;
+        }
+    }
+    resolve(index, count) {
+        return index > 0 ? index - 1 : count + index;
+    }
+}
+/**
+ * Turns corners into shared vertices: one vertex per distinct position, texture and normal triple.
+ *
+ * Corners are grouped by position first, and the few corners that share a position are compared
+ * with one another. That needs no table of every triple ever seen - which, over millions of
+ * corners, would cost far more memory than the model itself.
+ */
+async function indexGeometry(parsed, breaks) {
+    const positionCount = parsed.positions.length / 3;
+    const groups = parsed.groups.map((group) => group.corners.view());
+    const cornerCount = groups.reduce((sum, corners) => sum + corners.length / 3, 0);
+    // Every corner, numbered across all groups, listed under its position.
+    const perPosition = new Int32Array(positionCount + 1);
+    groups.forEach((corners) => {
+        for (let at = 0; at < corners.length; at += 3) {
+            perPosition[corners[at] + 1] += 1;
+        }
+    });
+    for (let position = 0; position < positionCount; position += 1) {
+        perPosition[position + 1] += perPosition[position];
+    }
+    const filled = perPosition.slice(0, positionCount);
+    const byPosition = new Int32Array(cornerCount);
+    const cornerStart = [];
+    let numbered = 0;
+    groups.forEach((corners) => {
+        cornerStart.push(numbered);
+        for (let at = 0; at < corners.length; at += 3) {
+            byPosition[filled[corners[at]]] = numbered;
+            filled[corners[at]] += 1;
+            numbered += 1;
+        }
+    });
+    // Which group each corner is in, so its triple can be read back where it already is rather than
+    // from a copy of every corner.
+    const groupOf = new Uint16Array(cornerCount);
+    groups.forEach((corners, group) => groupOf.fill(group, cornerStart[group], cornerStart[group] + corners.length / 3));
+    const vertexOfCorner = new Uint32Array(cornerCount);
+    const sources = new Growable(new Int32Array(Math.max(16, positionCount * 3 * 1.3) | 0));
+    let vertexCount = 0;
+    for (let position = 0; position < positionCount; position += 1) {
+        if (breaks.due(position)) {
+            await breaks.take(0.85 + 0.07 * (position / positionCount));
+        }
+        const first = vertexCount;
+        for (let at = perPosition[position]; at < perPosition[position + 1]; at += 1) {
+            const corner = byPosition[at];
+            const group = groupOf[corner];
+            const triple = (corner - cornerStart[group]) * 3;
+            const uv = groups[group][triple + 1];
+            const normal = groups[group][triple + 2];
+            let found = -1;
+            for (let vertex = first; vertex < vertexCount; vertex += 1) {
+                if (sources.data[vertex * 3 + 1] === uv && sources.data[vertex * 3 + 2] === normal) {
+                    found = vertex;
+                    break;
+                }
+            }
+            if (found < 0) {
+                found = vertexCount;
+                sources.push(position);
+                sources.push(uv);
+                sources.push(normal);
+                vertexCount += 1;
+            }
+            vertexOfCorner[corner] = found;
+        }
+    }
+    return {
+        vertexCount,
+        sources: sources.view(),
+        indices: groups.map((corners, group) => vertexOfCorner.slice(cornerStart[group], cornerStart[group] + corners.length / 3)),
+    };
+}
+/** The parts of an .mtl that matter here: the colour, the opacity and the colour texture. */
+function parseMtl(text) {
+    const materials = [];
+    let current = null;
+    text.split(/\r?\n/).forEach((raw) => {
+        const line = raw.trim();
+        const [keyword, ...rest] = line.split(/\s+/);
+        if (keyword === 'newmtl') {
+            current = { name: rest.join(' '), colour: [1, 1, 1], opacity: 1, texture: null };
+            materials.push(current);
+        }
+        else if (!current) {
+            return;
+        }
+        else if (keyword === 'Kd' && rest.length >= 3) {
+            current.colour = [Number(rest[0]), Number(rest[1]), Number(rest[2])];
+        }
+        else if (keyword === 'd' && rest.length >= 1) {
+            current.opacity = Number(rest[0]);
+        }
+        else if (keyword === 'map_Kd' && rest.length >= 1) {
+            // Options (-s 1 1 1, -o ..., -bm 0.5) come before the file name, which is what is left.
+            current.texture = rest[rest.length - 1];
+        }
+    });
+    return materials;
+}
+/**
+ * Writes the .glb. The binary part is assembled from the arrays and the texture files as they are,
+ * into a Blob - so the textures are never read into memory, nor the whole file built in one buffer.
+ */
+async function writeGlb(parsed, geometry, materials, files, missing, name, breaks) {
+    const { vertexCount, sources } = geometry;
+    const hasUv = parsed.uvs.length > 0 && hasAny(sources, 1);
+    const hasNormals = parsed.normals.length > 0 && hasAny(sources, 2);
+    const positions = new Float32Array(vertexCount * 3);
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    const uvs = hasUv ? new Float32Array(vertexCount * 2) : null;
+    const normals = hasNormals ? new Float32Array(vertexCount * 3) : null;
+    for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+        if (breaks.due(vertex)) {
+            await breaks.take(0.95 + 0.04 * (vertex / vertexCount));
+        }
+        const position = sources[vertex * 3];
+        for (let axis = 0; axis < 3; axis += 1) {
+            const value = parsed.positions[position * 3 + axis];
+            positions[vertex * 3 + axis] = value;
+            min[axis] = Math.min(min[axis], Math.fround(value));
+            max[axis] = Math.max(max[axis], Math.fround(value));
+        }
+        if (uvs) {
+            const uv = sources[vertex * 3 + 1];
+            // An .obj counts v up from the bottom of the image, glTF down from the top.
+            uvs[vertex * 2] = uv >= 0 ? parsed.uvs[uv * 2] : 0;
+            uvs[vertex * 2 + 1] = uv >= 0 ? 1 - parsed.uvs[uv * 2 + 1] : 0;
+        }
+        if (normals) {
+            const normal = sources[vertex * 3 + 2];
+            for (let axis = 0; axis < 3; axis += 1) {
+                normals[vertex * 3 + axis] = normal >= 0 ? parsed.normals[normal * 3 + axis] : 0;
+            }
+        }
+    }
+    const parts = [];
+    const bufferViews = [];
+    let byteLength = 0;
+    const addView = (part, size, target) => {
+        const padding = (4 - (byteLength % 4)) % 4;
+        if (padding) {
+            parts.push(new Uint8Array(padding));
+            byteLength += padding;
+        }
+        parts.push(part);
+        bufferViews.push({ buffer: 0, byteOffset: byteLength, byteLength: size, ...(target ? { target } : {}) });
+        byteLength += size;
+        return bufferViews.length - 1;
+    };
+    const accessors = [];
+    const addAccessor = (data, type, count, extra = {}, target) => {
+        const view = addView(data, data.byteLength, target);
+        accessors.push({ bufferView: view, componentType: data instanceof Float32Array ? 5126 : 5125, count, type, ...extra });
+        return accessors.length - 1;
+    };
+    const attributes = {
+        POSITION: addAccessor(positions, 'VEC3', vertexCount, { min, max }, 34962),
+    };
+    if (normals) {
+        attributes['NORMAL'] = addAccessor(normals, 'VEC3', vertexCount, {}, 34962);
+    }
+    if (uvs) {
+        attributes['TEXCOORD_0'] = addAccessor(uvs, 'VEC2', vertexCount, {}, 34962);
+    }
+    // Materials, each texture file stored once however many materials use it.
+    const images = [];
+    const textures = [];
+    const textureOf = new Map();
+    const textureIndex = (fileName) => {
+        const key = baseName(fileName).toLowerCase();
+        if (textureOf.has(key)) {
+            return textureOf.get(key);
+        }
+        const file = files.get(key);
+        if (!file) {
+            missing.add(baseName(fileName));
+            return null;
+        }
+        const mimeType = /\.png$/i.test(file.name) ? 'image/png' : 'image/jpeg';
+        images.push({ bufferView: addView(file, file.size), mimeType, name: baseName(file.name) });
+        textures.push({ source: images.length - 1, sampler: 0 });
+        textureOf.set(key, textures.length - 1);
+        return textures.length - 1;
+    };
+    const gltfMaterials = [];
+    const primitives = parsed.groups.map((group, index) => {
+        const material = group.material !== null ? materials.get(group.material) : undefined;
+        const texture = material?.texture ? textureIndex(material.texture) : null;
+        gltfMaterials.push({
+            name: group.material ?? 'default',
+            pbrMetallicRoughness: {
+                ...(texture !== null ? { baseColorTexture: { index: texture } } : {}),
+                baseColorFactor: texture !== null ? [1, 1, 1, material?.opacity ?? 1] : [...(material?.colour ?? [0.8, 0.8, 0.8]), material?.opacity ?? 1],
+                metallicFactor: 0,
+                roughnessFactor: 1,
+            },
+            ...(material && material.opacity < 1 ? { alphaMode: 'BLEND' } : {}),
+        });
+        const triangles = geometry.indices[index];
+        return {
+            attributes,
+            indices: addAccessor(triangles, 'SCALAR', triangles.length, {}, 34963),
+            material: gltfMaterials.length - 1,
+        };
+    });
+    const json = {
+        asset: { version: '2.0', generator: 'SmarterPlan obj-to-glb' },
+        scene: 0,
+        scenes: [{ nodes: [0] }],
+        nodes: [{ mesh: 0, name: name.replace(/\.obj$/i, '') }],
+        meshes: [{ primitives }],
+        materials: gltfMaterials,
+        ...(textures.length ? {
+            textures,
+            images,
+            // Linear filtering with mipmaps, repeating: what a captured model's atlas expects.
+            samplers: [{ magFilter: 9729, minFilter: 9987, wrapS: 10497, wrapT: 10497 }],
+        } : {}),
+        accessors,
+        bufferViews,
+        buffers: [{ byteLength }],
+    };
+    let jsonBytes = new TextEncoder().encode(JSON.stringify(json));
+    const jsonPadding = (4 - (jsonBytes.length % 4)) % 4;
+    if (jsonPadding) {
+        const padded = new Uint8Array(jsonBytes.length + jsonPadding).fill(32);
+        padded.set(jsonBytes);
+        jsonBytes = padded;
+    }
+    const binPadding = (4 - (byteLength % 4)) % 4;
+    const binLength = byteLength + binPadding;
+    const header = new DataView(new ArrayBuffer(12 + 8));
+    header.setUint32(0, 0x46546c67, true); // "glTF"
+    header.setUint32(4, 2, true);
+    header.setUint32(8, 12 + 8 + jsonBytes.length + 8 + binLength, true);
+    header.setUint32(12, jsonBytes.length, true);
+    header.setUint32(16, 0x4e4f534a, true); // "JSON"
+    const binHeader = new DataView(new ArrayBuffer(8));
+    binHeader.setUint32(0, binLength, true);
+    binHeader.setUint32(4, 0x004e4942, true); // "BIN"
+    return new Blob([header, jsonBytes, binHeader, ...parts, new Uint8Array(binPadding)]);
+}
+/** Whether any vertex uses the given slot of its source triple (texture or normal). */
+function hasAny(sources, slot) {
+    for (let at = slot; at < sources.length; at += 3) {
+        if (sources[at] >= 0) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"obj-to-glb.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/obj-to-glb.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Converts an .obj model, with its .mtl and textures, into the .glb the Three.js viewer loads - in\n * the browser, as the model is added, with nothing to install.\n *\n * It does what obj2gltf did in converte-modelo.sh, and the reason is the same. An .obj lists every\n * corner of every triangle; loaded as it is, a captured model's 2.6 million distinct vertices become\n * 12.6 million, one per corner. Here each position and texture coordinate pair becomes one vertex,\n * shared by every triangle that uses it, so what reaches the graphics card is the 2.6 million.\n *\n * Textures go in as they are, their bytes untouched: a JPEG re-encoded would lose quality and gain\n * nothing. Normals are only written when the .obj has them; without, the viewer works them out as\n * it loads the model. The axes are left as the .obj has them - the viewer finds which way is up.\n *\n * The .obj is read as a stream, so a file of hundreds of megabytes is never held whole.\n */\n\nexport interface ConvertedModel {\n  /** The model as a .glb. */\n  file: File;\n  vertices: number;\n  triangles: number;\n  materials: number;\n  /** Textures the .mtl names that were not among the files given; those materials go untextured. */\n  missingTextures: string[];\n}\n\nexport interface ObjConversionOptions {\n  /** Called as the conversion goes, with the share done so far. */\n  onProgress?: (fraction: number) => void;\n  /** Stops the conversion; it then rejects with an AbortError. */\n  signal?: AbortSignal;\n}\n\n/** Whether a set of files holds an .obj model to convert. */\nexport function hasObjModel(files: { name: string }[]): boolean {\n  return files.some((file) => /\\.obj$/i.test(file.name));\n}\n\n/**\n * Converts the .obj among `files` into a .glb, using the .mtl and the images found with it.\n */\nexport async function convertObjToGlb(files: File[], options: ObjConversionOptions = {}): Promise<ConvertedModel> {\n  const objs = files.filter((file) => /\\.obj$/i.test(file.name));\n  if (objs.length !== 1) {\n    throw new Error(objs.length === 0 ? 'No .obj file was given.' : 'Give one .obj file at a time.');\n  }\n  const obj = objs[0];\n  const byName = new Map(files.map((file) => [baseName(file.name).toLowerCase(), file]));\n\n  // The .obj's own reading is most of the time; the rest is shared out over what follows.\n  const parsed = await readObj(obj.stream(), obj.size, {\n    ...options,\n    onProgress: (fraction) => options.onProgress?.(fraction * 0.85),\n  });\n  if (parsed.triangleCount === 0) {\n    throw new Error(`${obj.name} has no faces.`);\n  }\n\n  // Materials: from the .mtl files the .obj names, or failing that any .mtl given with it.\n  const named = parsed.materialLibraries.map((library) => byName.get(baseName(library).toLowerCase())).filter(Boolean);\n  const libraries = named.length > 0 ? named : files.filter((file) => /\\.mtl$/i.test(file.name));\n  const materials = new Map<string, MtlMaterial>();\n  for (const library of libraries) {\n    parseMtl(await library.text()).forEach((material) => materials.set(material.name, material));\n  }\n  await pause(options.signal);\n\n  const breaks = new Breaks(options.signal, options.onProgress);\n  const geometry = await indexGeometry(parsed, breaks);\n  options.onProgress?.(0.95);\n  await pause(options.signal);\n\n  const missing = new Set<string>();\n  const glb = await writeGlb(parsed, geometry, materials, byName, missing, obj.name, breaks);\n  options.onProgress?.(1);\n\n  return {\n    file: new File([glb], obj.name.replace(/\\.obj$/i, '') + '.glb', { type: 'model/gltf-binary' }),\n    vertices: geometry.vertexCount,\n    triangles: parsed.triangleCount,\n    materials: parsed.groups.length,\n    missingTextures: [...missing],\n  };\n}\n\n/** The file name without its folders, which is how an .mtl or a texture is looked up. */\nfunction baseName(path: string): string {\n  return path.trim().replace(/^\"|\"$/g, '').split(/[\\\\/]/).pop() ?? path;\n}\n\n/** Lets the page draw and answer for a moment, and stops here if the conversion was cancelled. */\nasync function pause(signal?: AbortSignal): Promise<void> {\n  if (signal?.aborted) {\n    throw new DOMException('Model conversion cancelled', 'AbortError');\n  }\n  await new Promise((resolve) => setTimeout(resolve, 0));\n}\n\n/**\n * Stops a long loop now and then so the page can draw and answer clicks. Checked only every few\n * thousand turns of the loop: waiting on a promise every turn would cost more than the loop.\n */\nclass Breaks {\n  private last = performance.now();\n\n  constructor(private readonly signal?: AbortSignal, private readonly onProgress?: (fraction: number) => void) {}\n\n  /** Whether this turn of the loop should stop for a moment. Synchronous: it is asked every turn. */\n  due(turn: number): boolean {\n    return (turn & 0x3fff) === 0 && performance.now() - this.last > 40;\n  }\n\n  /** Stops for a moment, reporting how far the conversion has got. */\n  async take(fraction: number): Promise<void> {\n    this.onProgress?.(fraction);\n    await pause(this.signal);\n    this.last = performance.now();\n  }\n}\n\n/** A growable typed array: an .obj does not say up front how many of anything it holds. */\nclass Growable<T extends Float64Array | Float32Array | Int32Array> {\n  length = 0;\n\n  constructor(public data: T) {}\n\n  push(value: number): void {\n    if (this.length === this.data.length) {\n      const bigger = new (this.data.constructor as any)(this.data.length * 2) as T;\n      bigger.set(this.data);\n      this.data = bigger;\n    }\n    this.data[this.length] = value;\n    this.length += 1;\n  }\n\n  view(): T {\n    return this.data.subarray(0, this.length) as T;\n  }\n}\n\n/** The triangles that use one material, as corners: position, texture and normal index each. */\ninterface FaceGroup {\n  material: string | null;\n  corners: Growable<Int32Array>;\n}\n\nexport interface ParsedObj {\n  positions: Float64Array;\n  uvs: Float64Array;\n  normals: Float64Array;\n  groups: FaceGroup[];\n  materialLibraries: string[];\n  triangleCount: number;\n}\n\n/**\n * Reads an .obj from a stream of its bytes: positions, texture coordinates, normals, and triangles\n * grouped by material. Polygons are split into triangles; negative indices, counting back from the\n * end, are resolved; anything else (objects, groups, smoothing) is skipped.\n */\nexport async function readObj(\n  stream: ReadableStream<Uint8Array>,\n  size: number,\n  options: ObjConversionOptions = {},\n): Promise<ParsedObj> {\n  const parser = new ObjParser();\n  const reader = stream.getReader();\n  let read = 0;\n  let lastBreak = performance.now();\n  try {\n    for (;;) {\n      if (options.signal?.aborted) {\n        throw new DOMException('Model conversion cancelled', 'AbortError');\n      }\n      const { done, value } = await reader.read();\n      if (done) {\n        break;\n      }\n      parser.push(value);\n      read += value.length;\n      if (performance.now() - lastBreak > 40) {\n        options.onProgress?.(size > 0 ? Math.min(read / size, 1) : 0);\n        await new Promise((resolve) => setTimeout(resolve, 0));\n        lastBreak = performance.now();\n      }\n    }\n  } finally {\n    reader.cancel().catch(() => undefined);\n  }\n  parser.end();\n  options.onProgress?.(1);\n  return parser.result();\n}\n\n/**\n * Line by line, straight from the bytes. Building a string for each of the millions of lines of a\n * captured model would be most of the work; this reads the numbers off the bytes instead.\n */\nclass ObjParser {\n  private readonly positions = new Growable(new Float64Array(1 << 16));\n\n  private readonly uvs = new Growable(new Float64Array(1 << 16));\n\n  private readonly normals = new Growable(new Float64Array(1 << 16));\n\n  private readonly groups: FaceGroup[] = [];\n\n  private readonly groupByMaterial = new Map<string | null, FaceGroup>();\n\n  private current: FaceGroup | null = null;\n\n  private readonly materialLibraries: string[] = [];\n\n  private triangleCount = 0;\n\n  /** The bytes of the line being read, kept across chunks. */\n  private line = new Uint8Array(256);\n\n  private lineLength = 0;\n\n  // The corners of the face being read, as position/texture/normal indices.\n  private readonly face = new Int32Array(3 * 64);\n\n  push(bytes: Uint8Array): void {\n    for (let index = 0; index < bytes.length; index += 1) {\n      const byte = bytes[index];\n      if (byte === 10) {\n        this.readLine();\n        this.lineLength = 0;\n      } else {\n        if (this.lineLength === this.line.length) {\n          const longer = new Uint8Array(this.line.length * 2);\n          longer.set(this.line);\n          this.line = longer;\n        }\n        this.line[this.lineLength] = byte;\n        this.lineLength += 1;\n      }\n    }\n  }\n\n  end(): void {\n    this.readLine();\n    this.lineLength = 0;\n  }\n\n  result(): ParsedObj {\n    return {\n      positions: this.positions.view(),\n      uvs: this.uvs.view(),\n      normals: this.normals.view(),\n      groups: this.groups.filter((group) => group.corners.length > 0),\n      materialLibraries: this.materialLibraries,\n      triangleCount: this.triangleCount,\n    };\n  }\n\n  private readLine(): void {\n    const line = this.line;\n    const length = this.lineLength;\n    let at = 0;\n    while (at < length && (line[at] === 32 || line[at] === 9)) {\n      at += 1;\n    }\n    if (at + 1 >= length) {\n      return;\n    }\n    const first = line[at];\n    const second = line[at + 1];\n    if (first === 118 && (second === 32 || second === 9)) {\n      // v x y z\n      this.readNumbers(at + 2, 3, this.positions);\n    } else if (first === 118 && second === 116) {\n      // vt u v\n      this.readNumbers(at + 3, 2, this.uvs);\n    } else if (first === 118 && second === 110) {\n      // vn x y z\n      this.readNumbers(at + 3, 3, this.normals);\n    } else if (first === 102 && (second === 32 || second === 9)) {\n      this.readFace(at + 2);\n    } else if (this.startsWith(at, 'usemtl')) {\n      this.useMaterial(this.restOfLine(at + 6));\n    } else if (this.startsWith(at, 'mtllib')) {\n      this.materialLibraries.push(...this.restOfLine(at + 6).split(/\\s+(?=\\S+\\.mtl\\b)/i).filter(Boolean));\n    }\n  }\n\n  private startsWith(at: number, word: string): boolean {\n    for (let index = 0; index < word.length; index += 1) {\n      if (this.line[at + index] !== word.charCodeAt(index)) {\n        return false;\n      }\n    }\n    const after = this.line[at + word.length];\n    return after === 32 || after === 9;\n  }\n\n  private restOfLine(at: number): string {\n    let end = this.lineLength;\n    while (end > at && (this.line[end - 1] === 13 || this.line[end - 1] === 32 || this.line[end - 1] === 9)) {\n      end -= 1;\n    }\n    return new TextDecoder().decode(this.line.subarray(at, end)).trim();\n  }\n\n  private useMaterial(name: string | null): void {\n    let group = this.groupByMaterial.get(name);\n    if (!group) {\n      group = { material: name, corners: new Growable(new Int32Array(1 << 12)) };\n      this.groupByMaterial.set(name, group);\n      this.groups.push(group);\n    }\n    this.current = group;\n  }\n\n  /** Reads up to `count` numbers from `at` onwards into `target`, padding a short line with 0. */\n  private readNumbers(at: number, count: number, target: Growable<Float64Array>): void {\n    let read = 0;\n    let position = at;\n    while (read < count) {\n      const [value, next] = this.readNumber(position);\n      if (next === position) {\n        break;\n      }\n      target.push(value);\n      read += 1;\n      position = next;\n    }\n    for (; read < count; read += 1) {\n      target.push(0);\n    }\n  }\n\n  /** Reads one number starting at or after `at`; returns it and where it ended. */\n  private readNumber(at: number): [number, number] {\n    const line = this.line;\n    const length = this.lineLength;\n    let index = at;\n    while (index < length && (line[index] === 32 || line[index] === 9 || line[index] === 13)) {\n      index += 1;\n    }\n    const start = index;\n    let negative = false;\n    if (line[index] === 45 || line[index] === 43) {\n      negative = line[index] === 45;\n      index += 1;\n    }\n    let whole = 0;\n    let fraction = 0;\n    let scale = 1;\n    let digits = 0;\n    while (index < length && line[index] >= 48 && line[index] <= 57) {\n      whole = whole * 10 + (line[index] - 48);\n      index += 1;\n      digits += 1;\n    }\n    if (line[index] === 46) {\n      index += 1;\n      while (index < length && line[index] >= 48 && line[index] <= 57) {\n        fraction = fraction * 10 + (line[index] - 48);\n        scale *= 10;\n        index += 1;\n        digits += 1;\n      }\n    }\n    if (digits === 0) {\n      return [0, at];\n    }\n    let value = whole + fraction / scale;\n    if (line[index] === 101 || line[index] === 69) {\n      index += 1;\n      let negativeExponent = false;\n      if (line[index] === 45 || line[index] === 43) {\n        negativeExponent = line[index] === 45;\n        index += 1;\n      }\n      let exponent = 0;\n      while (index < length && line[index] >= 48 && line[index] <= 57) {\n        exponent = exponent * 10 + (line[index] - 48);\n        index += 1;\n      }\n      value *= 10 ** (negativeExponent ? -exponent : exponent);\n    }\n    return [negative ? -value : value, index === start ? at : index];\n  }\n\n  /** f v/vt/vn ... - any of the three forms, any number of corners, split into a fan. */\n  private readFace(at: number): void {\n    const line = this.line;\n    const length = this.lineLength;\n    let corners = 0;\n    let index = at;\n    while (index < length) {\n      while (index < length && (line[index] === 32 || line[index] === 9 || line[index] === 13)) {\n        index += 1;\n      }\n      if (index >= length) {\n        break;\n      }\n      // One corner: up to three integers separated by '/', any of the last two possibly empty.\n      const values = [0, 0, 0];\n      for (let slot = 0; slot < 3; slot += 1) {\n        let negative = false;\n        if (line[index] === 45) {\n          negative = true;\n          index += 1;\n        }\n        let value = 0;\n        let digits = 0;\n        while (index < length && line[index] >= 48 && line[index] <= 57) {\n          value = value * 10 + (line[index] - 48);\n          index += 1;\n          digits += 1;\n        }\n        values[slot] = digits === 0 ? 0 : negative ? -value : value;\n        if (line[index] !== 47) {\n          break;\n        }\n        index += 1;\n      }\n      if (corners < 64 && values[0] !== 0) {\n        // To zero-based indices, counting a negative one back from what has been read so far; -1\n        // means \"none\" for the texture and normal.\n        this.face[corners * 3] = this.resolve(values[0], this.positions.length / 3);\n        this.face[corners * 3 + 1] = values[1] === 0 ? -1 : this.resolve(values[1], this.uvs.length / 2);\n        this.face[corners * 3 + 2] = values[2] === 0 ? -1 : this.resolve(values[2], this.normals.length / 3);\n        corners += 1;\n      }\n      // Skip to the next separator, past anything unexpected in this token.\n      while (index < length && line[index] !== 32 && line[index] !== 9) {\n        index += 1;\n      }\n    }\n    if (corners < 3) {\n      return;\n    }\n    if (!this.current) {\n      this.useMaterial(null);\n    }\n    const target = this.current.corners;\n    for (let corner = 1; corner + 1 < corners; corner += 1) {\n      for (const which of [0, corner, corner + 1]) {\n        target.push(this.face[which * 3]);\n        target.push(this.face[which * 3 + 1]);\n        target.push(this.face[which * 3 + 2]);\n      }\n      this.triangleCount += 1;\n    }\n  }\n\n  private resolve(index: number, count: number): number {\n    return index > 0 ? index - 1 : count + index;\n  }\n}\n\ninterface IndexedGeometry {\n  vertexCount: number;\n  /** For each vertex, the position, texture and normal index it was made from. */\n  sources: Int32Array;\n  /** Per face group, its triangles as vertex indices. */\n  indices: Uint32Array[];\n}\n\n/**\n * Turns corners into shared vertices: one vertex per distinct position, texture and normal triple.\n *\n * Corners are grouped by position first, and the few corners that share a position are compared\n * with one another. That needs no table of every triple ever seen - which, over millions of\n * corners, would cost far more memory than the model itself.\n */\nasync function indexGeometry(parsed: ParsedObj, breaks: Breaks): Promise<IndexedGeometry> {\n  const positionCount = parsed.positions.length / 3;\n  const groups = parsed.groups.map((group) => group.corners.view());\n  const cornerCount = groups.reduce((sum, corners) => sum + corners.length / 3, 0);\n\n  // Every corner, numbered across all groups, listed under its position.\n  const perPosition = new Int32Array(positionCount + 1);\n  groups.forEach((corners) => {\n    for (let at = 0; at < corners.length; at += 3) {\n      perPosition[corners[at] + 1] += 1;\n    }\n  });\n  for (let position = 0; position < positionCount; position += 1) {\n    perPosition[position + 1] += perPosition[position];\n  }\n  const filled = perPosition.slice(0, positionCount);\n  const byPosition = new Int32Array(cornerCount);\n  const cornerStart: number[] = [];\n  let numbered = 0;\n  groups.forEach((corners) => {\n    cornerStart.push(numbered);\n    for (let at = 0; at < corners.length; at += 3) {\n      byPosition[filled[corners[at]]] = numbered;\n      filled[corners[at]] += 1;\n      numbered += 1;\n    }\n  });\n\n  // Which group each corner is in, so its triple can be read back where it already is rather than\n  // from a copy of every corner.\n  const groupOf = new Uint16Array(cornerCount);\n  groups.forEach((corners, group) => groupOf.fill(group, cornerStart[group], cornerStart[group] + corners.length / 3));\n\n  const vertexOfCorner = new Uint32Array(cornerCount);\n  const sources = new Growable(new Int32Array(Math.max(16, positionCount * 3 * 1.3) | 0));\n  let vertexCount = 0;\n  for (let position = 0; position < positionCount; position += 1) {\n    if (breaks.due(position)) {\n      await breaks.take(0.85 + 0.07 * (position / positionCount));\n    }\n    const first = vertexCount;\n    for (let at = perPosition[position]; at < perPosition[position + 1]; at += 1) {\n      const corner = byPosition[at];\n      const group = groupOf[corner];\n      const triple = (corner - cornerStart[group]) * 3;\n      const uv = groups[group][triple + 1];\n      const normal = groups[group][triple + 2];\n      let found = -1;\n      for (let vertex = first; vertex < vertexCount; vertex += 1) {\n        if (sources.data[vertex * 3 + 1] === uv && sources.data[vertex * 3 + 2] === normal) {\n          found = vertex;\n          break;\n        }\n      }\n      if (found < 0) {\n        found = vertexCount;\n        sources.push(position);\n        sources.push(uv);\n        sources.push(normal);\n        vertexCount += 1;\n      }\n      vertexOfCorner[corner] = found;\n    }\n  }\n\n  return {\n    vertexCount,\n    sources: sources.view(),\n    indices: groups.map((corners, group) => vertexOfCorner.slice(cornerStart[group], cornerStart[group] + corners.length / 3)),\n  };\n}\n\ninterface MtlMaterial {\n  name: string;\n  colour: [number, number, number];\n  opacity: number;\n  texture: string | null;\n}\n\n/** The parts of an .mtl that matter here: the colour, the opacity and the colour texture. */\nfunction parseMtl(text: string): MtlMaterial[] {\n  const materials: MtlMaterial[] = [];\n  let current: MtlMaterial | null = null;\n  text.split(/\\r?\\n/).forEach((raw) => {\n    const line = raw.trim();\n    const [keyword, ...rest] = line.split(/\\s+/);\n    if (keyword === 'newmtl') {\n      current = { name: rest.join(' '), colour: [1, 1, 1], opacity: 1, texture: null };\n      materials.push(current);\n    } else if (!current) {\n      return;\n    } else if (keyword === 'Kd' && rest.length >= 3) {\n      current.colour = [Number(rest[0]), Number(rest[1]), Number(rest[2])];\n    } else if (keyword === 'd' && rest.length >= 1) {\n      current.opacity = Number(rest[0]);\n    } else if (keyword === 'map_Kd' && rest.length >= 1) {\n      // Options (-s 1 1 1, -o ..., -bm 0.5) come before the file name, which is what is left.\n      current.texture = rest[rest.length - 1];\n    }\n  });\n  return materials;\n}\n\n/**\n * Writes the .glb. The binary part is assembled from the arrays and the texture files as they are,\n * into a Blob - so the textures are never read into memory, nor the whole file built in one buffer.\n */\nasync function writeGlb(\n  parsed: ParsedObj,\n  geometry: IndexedGeometry,\n  materials: Map<string, MtlMaterial>,\n  files: Map<string, File>,\n  missing: Set<string>,\n  name: string,\n  breaks: Breaks,\n): Promise<Blob> {\n  const { vertexCount, sources } = geometry;\n  const hasUv = parsed.uvs.length > 0 && hasAny(sources, 1);\n  const hasNormals = parsed.normals.length > 0 && hasAny(sources, 2);\n\n  const positions = new Float32Array(vertexCount * 3);\n  const min = [Infinity, Infinity, Infinity];\n  const max = [-Infinity, -Infinity, -Infinity];\n  const uvs = hasUv ? new Float32Array(vertexCount * 2) : null;\n  const normals = hasNormals ? new Float32Array(vertexCount * 3) : null;\n  for (let vertex = 0; vertex < vertexCount; vertex += 1) {\n    if (breaks.due(vertex)) {\n      await breaks.take(0.95 + 0.04 * (vertex / vertexCount));\n    }\n    const position = sources[vertex * 3];\n    for (let axis = 0; axis < 3; axis += 1) {\n      const value = parsed.positions[position * 3 + axis];\n      positions[vertex * 3 + axis] = value;\n      min[axis] = Math.min(min[axis], Math.fround(value));\n      max[axis] = Math.max(max[axis], Math.fround(value));\n    }\n    if (uvs) {\n      const uv = sources[vertex * 3 + 1];\n      // An .obj counts v up from the bottom of the image, glTF down from the top.\n      uvs[vertex * 2] = uv >= 0 ? parsed.uvs[uv * 2] : 0;\n      uvs[vertex * 2 + 1] = uv >= 0 ? 1 - parsed.uvs[uv * 2 + 1] : 0;\n    }\n    if (normals) {\n      const normal = sources[vertex * 3 + 2];\n      for (let axis = 0; axis < 3; axis += 1) {\n        normals[vertex * 3 + axis] = normal >= 0 ? parsed.normals[normal * 3 + axis] : 0;\n      }\n    }\n  }\n\n  const parts: BlobPart[] = [];\n  const bufferViews: any[] = [];\n  let byteLength = 0;\n  const addView = (part: Blob | ArrayBufferView, size: number, target?: number): number => {\n    const padding = (4 - (byteLength % 4)) % 4;\n    if (padding) {\n      parts.push(new Uint8Array(padding));\n      byteLength += padding;\n    }\n    parts.push(part as BlobPart);\n    bufferViews.push({ buffer: 0, byteOffset: byteLength, byteLength: size, ...(target ? { target } : {}) });\n    byteLength += size;\n    return bufferViews.length - 1;\n  };\n\n  const accessors: any[] = [];\n  const addAccessor = (data: Float32Array | Uint32Array, type: string, count: number, extra: object = {}, target?: number) => {\n    const view = addView(data, data.byteLength, target);\n    accessors.push({ bufferView: view, componentType: data instanceof Float32Array ? 5126 : 5125, count, type, ...extra });\n    return accessors.length - 1;\n  };\n  const attributes: Record<string, number> = {\n    POSITION: addAccessor(positions, 'VEC3', vertexCount, { min, max }, 34962),\n  };\n  if (normals) {\n    attributes['NORMAL'] = addAccessor(normals, 'VEC3', vertexCount, {}, 34962);\n  }\n  if (uvs) {\n    attributes['TEXCOORD_0'] = addAccessor(uvs, 'VEC2', vertexCount, {}, 34962);\n  }\n\n  // Materials, each texture file stored once however many materials use it.\n  const images: any[] = [];\n  const textures: any[] = [];\n  const textureOf = new Map<string, number>();\n  const textureIndex = (fileName: string): number | null => {\n    const key = baseName(fileName).toLowerCase();\n    if (textureOf.has(key)) {\n      return textureOf.get(key);\n    }\n    const file = files.get(key);\n    if (!file) {\n      missing.add(baseName(fileName));\n      return null;\n    }\n    const mimeType = /\\.png$/i.test(file.name) ? 'image/png' : 'image/jpeg';\n    images.push({ bufferView: addView(file, file.size), mimeType, name: baseName(file.name) });\n    textures.push({ source: images.length - 1, sampler: 0 });\n    textureOf.set(key, textures.length - 1);\n    return textures.length - 1;\n  };\n  const gltfMaterials: any[] = [];\n  const primitives = parsed.groups.map((group, index) => {\n    const material = group.material !== null ? materials.get(group.material) : undefined;\n    const texture = material?.texture ? textureIndex(material.texture) : null;\n    gltfMaterials.push({\n      name: group.material ?? 'default',\n      pbrMetallicRoughness: {\n        ...(texture !== null ? { baseColorTexture: { index: texture } } : {}),\n        baseColorFactor: texture !== null ? [1, 1, 1, material?.opacity ?? 1] : [...(material?.colour ?? [0.8, 0.8, 0.8]), material?.opacity ?? 1],\n        metallicFactor: 0,\n        roughnessFactor: 1,\n      },\n      ...(material && material.opacity < 1 ? { alphaMode: 'BLEND' } : {}),\n    });\n    const triangles = geometry.indices[index];\n    return {\n      attributes,\n      indices: addAccessor(triangles, 'SCALAR', triangles.length, {}, 34963),\n      material: gltfMaterials.length - 1,\n    };\n  });\n\n  const json = {\n    asset: { version: '2.0', generator: 'SmarterPlan obj-to-glb' },\n    scene: 0,\n    scenes: [{ nodes: [0] }],\n    nodes: [{ mesh: 0, name: name.replace(/\\.obj$/i, '') }],\n    meshes: [{ primitives }],\n    materials: gltfMaterials,\n    ...(textures.length ? {\n      textures,\n      images,\n      // Linear filtering with mipmaps, repeating: what a captured model's atlas expects.\n      samplers: [{ magFilter: 9729, minFilter: 9987, wrapS: 10497, wrapT: 10497 }],\n    } : {}),\n    accessors,\n    bufferViews,\n    buffers: [{ byteLength }],\n  };\n\n  let jsonBytes = new TextEncoder().encode(JSON.stringify(json));\n  const jsonPadding = (4 - (jsonBytes.length % 4)) % 4;\n  if (jsonPadding) {\n    const padded = new Uint8Array(jsonBytes.length + jsonPadding).fill(32);\n    padded.set(jsonBytes);\n    jsonBytes = padded;\n  }\n  const binPadding = (4 - (byteLength % 4)) % 4;\n  const binLength = byteLength + binPadding;\n  const header = new DataView(new ArrayBuffer(12 + 8));\n  header.setUint32(0, 0x46546c67, true); // \"glTF\"\n  header.setUint32(4, 2, true);\n  header.setUint32(8, 12 + 8 + jsonBytes.length + 8 + binLength, true);\n  header.setUint32(12, jsonBytes.length, true);\n  header.setUint32(16, 0x4e4f534a, true); // \"JSON\"\n  const binHeader = new DataView(new ArrayBuffer(8));\n  binHeader.setUint32(0, binLength, true);\n  binHeader.setUint32(4, 0x004e4942, true); // \"BIN\"\n  return new Blob([header, jsonBytes, binHeader, ...parts, new Uint8Array(binPadding)]);\n}\n\n/** Whether any vertex uses the given slot of its source triple (texture or normal). */\nfunction hasAny(sources: Int32Array, slot: number): boolean {\n  for (let at = slot; at < sources.length; at += 3) {\n    if (sources[at] >= 0) {\n      return true;\n    }\n  }\n  return false;\n}\n"]}