293 lines
8.8 KiB
TypeScript
293 lines
8.8 KiB
TypeScript
import { bytesToBase64 } from "@add-ideas/toolbox-helpers";
|
|
import { describe, expect, it } from "vitest";
|
|
import {
|
|
exportBinaryStl,
|
|
exportAsciiPly,
|
|
exportObj,
|
|
modelStats,
|
|
parseModel,
|
|
removeDegenerateTriangles,
|
|
transformModel,
|
|
} from "../../src/core/model";
|
|
|
|
const encode = (value: string) => new TextEncoder().encode(value);
|
|
|
|
describe("bounded 3D parsing", () => {
|
|
it("triangulates OBJ polygons and resolves negative indices", () => {
|
|
const model = parseModel(
|
|
"quad.obj",
|
|
encode(
|
|
[
|
|
"o Quad",
|
|
"v 0 0 0",
|
|
"v 1 0 0",
|
|
"v 1 1 0",
|
|
"v 0 1 0",
|
|
"f -4 -3 -2 -1",
|
|
].join("\n"),
|
|
),
|
|
"OBJ",
|
|
);
|
|
expect(model.indices).toHaveLength(6);
|
|
expect(model.nodes).toEqual(["Quad"]);
|
|
expect(modelStats(model)).toMatchObject({
|
|
triangles: 2,
|
|
surfaceArea: 1,
|
|
degenerateTriangles: 0,
|
|
});
|
|
expect(exportObj(model)).toContain("f 1//1 2//2 3//3");
|
|
});
|
|
|
|
it("round-trips normalized geometry through binary STL", () => {
|
|
const source = parseModel(
|
|
"triangle.obj",
|
|
encode("v 0 0 0\nv 1 0 0\nv 0 1 0\nf 1 2 3\n"),
|
|
"OBJ",
|
|
);
|
|
const binary = exportBinaryStl(source);
|
|
const parsed = parseModel("triangle.stl", binary, "STL");
|
|
expect(parsed.indices).toHaveLength(3);
|
|
expect(modelStats(parsed).surfaceArea).toBeCloseTo(0.5);
|
|
});
|
|
|
|
it("parses ASCII and binary little-endian PLY", () => {
|
|
const ascii = parseModel(
|
|
"triangle.ply",
|
|
encode(
|
|
[
|
|
"ply",
|
|
"format ascii 1.0",
|
|
"element vertex 3",
|
|
"property float x",
|
|
"property float y",
|
|
"property float z",
|
|
"element face 1",
|
|
"property list uchar int vertex_indices",
|
|
"end_header",
|
|
"0 0 0",
|
|
"1 0 0",
|
|
"0 1 0",
|
|
"3 0 1 2",
|
|
"",
|
|
].join("\n"),
|
|
),
|
|
"PLY",
|
|
);
|
|
expect(ascii.indices).toEqual(Uint32Array.of(0, 1, 2));
|
|
|
|
const header = encode(
|
|
[
|
|
"ply",
|
|
"format binary_little_endian 1.0",
|
|
"element vertex 3",
|
|
"property float x",
|
|
"property float y",
|
|
"property float z",
|
|
"element face 1",
|
|
"property list uchar int vertex_indices",
|
|
"end_header",
|
|
"",
|
|
].join("\n"),
|
|
);
|
|
const body = new Uint8Array(36 + 13);
|
|
const view = new DataView(body.buffer);
|
|
[0, 0, 0, 1, 0, 0, 0, 1, 0].forEach((value, index) =>
|
|
view.setFloat32(index * 4, value, true),
|
|
);
|
|
body[36] = 3;
|
|
view.setInt32(37, 0, true);
|
|
view.setInt32(41, 1, true);
|
|
view.setInt32(45, 2, true);
|
|
const binary = new Uint8Array(header.length + body.length);
|
|
binary.set(header);
|
|
binary.set(body, header.length);
|
|
expect(parseModel("triangle.ply", binary, "PLY").indices).toHaveLength(3);
|
|
});
|
|
|
|
it("parses embedded glTF and GLB geometry without external resources", () => {
|
|
const buffer = gltfBuffer();
|
|
const document = gltfDocument(
|
|
"data:application/octet-stream;base64," + bytesToBase64(buffer),
|
|
buffer.length,
|
|
);
|
|
const model = parseModel(
|
|
"triangle.gltf",
|
|
encode(JSON.stringify(document)),
|
|
"glTF",
|
|
);
|
|
expect(model.indices).toEqual(Uint32Array.of(0, 1, 2));
|
|
expect(model.materials).toEqual(["Local"]);
|
|
expect(model.materialDetails?.[0]).toMatchObject({
|
|
name: "Local",
|
|
baseColorFactor: [0.2, 0.4, 0.6, 1],
|
|
metallicFactor: 0.25,
|
|
roughnessFactor: 0.7,
|
|
alphaMode: "OPAQUE",
|
|
});
|
|
|
|
const glb = makeGlb(gltfDocument(undefined, buffer.length), buffer);
|
|
expect(parseModel("triangle.glb", glb, "GLB").indices).toHaveLength(3);
|
|
});
|
|
|
|
it("flattens the selected glTF scene hierarchy and mesh instances", () => {
|
|
const buffer = gltfBuffer();
|
|
const document = gltfDocument(
|
|
"data:application/octet-stream;base64," + bytesToBase64(buffer),
|
|
buffer.length,
|
|
);
|
|
Object.assign(document, {
|
|
scene: 0,
|
|
scenes: [{ nodes: [0, 2] }, { nodes: [3] }],
|
|
nodes: [
|
|
{ name: "Parent", translation: [10, 0, 0], children: [1] },
|
|
{ name: "Scaled child", mesh: 0, scale: [2, 1, 1] },
|
|
{ name: "Second instance", mesh: 0, translation: [0, 5, 0] },
|
|
{ name: "Other scene", mesh: 0, translation: [100, 0, 0] },
|
|
],
|
|
});
|
|
const model = parseModel(
|
|
"scene.gltf",
|
|
encode(JSON.stringify(document)),
|
|
"glTF",
|
|
);
|
|
const stats = modelStats(model);
|
|
expect(stats).toMatchObject({ vertices: 6, triangles: 2, nodes: 3 });
|
|
expect(stats.bounds.min).toEqual([0, 0, 0]);
|
|
expect(stats.bounds.max).toEqual([12, 6, 0]);
|
|
expect(stats.surfaceArea).toBeCloseTo(1.5);
|
|
expect(model.nodes).toEqual(["Parent", "Scaled child", "Second instance"]);
|
|
});
|
|
|
|
it("applies glTF matrices and repairs mirrored winding", () => {
|
|
const buffer = gltfBuffer();
|
|
const document = gltfDocument(
|
|
"data:application/octet-stream;base64," + bytesToBase64(buffer),
|
|
buffer.length,
|
|
);
|
|
Object.assign(document, {
|
|
scene: 0,
|
|
scenes: [{ nodes: [0] }],
|
|
nodes: [
|
|
{
|
|
mesh: 0,
|
|
matrix: [-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 3, 0, 0, 1],
|
|
},
|
|
],
|
|
});
|
|
const model = parseModel(
|
|
"mirror.gltf",
|
|
encode(JSON.stringify(document)),
|
|
"glTF",
|
|
);
|
|
expect(model.indices).toEqual(Uint32Array.of(0, 2, 1));
|
|
expect(modelStats(model).bounds).toMatchObject({
|
|
min: [2, 0, 0],
|
|
max: [3, 1, 0],
|
|
});
|
|
expect(model.normals[2]).toBeCloseTo(1);
|
|
});
|
|
|
|
it("rejects remote glTF buffers and safely transforms normals/winding", () => {
|
|
const remote = gltfDocument("https://example.invalid/model.bin", 42);
|
|
expect(() =>
|
|
parseModel("remote.gltf", encode(JSON.stringify(remote)), "glTF"),
|
|
).toThrow(/External glTF buffer URLs/u);
|
|
const model = parseModel(
|
|
"triangle.obj",
|
|
encode("v 0 0 0\nv 1 0 0\nv 0 1 0\nf 1 2 3\n"),
|
|
"OBJ",
|
|
);
|
|
const transformed = transformModel(model, {
|
|
translate: [1, 2, 3],
|
|
rotate: [0, 0, 90],
|
|
scale: -2,
|
|
});
|
|
expect(modelStats(transformed).surfaceArea).toBeCloseTo(2);
|
|
expect(transformed.indices).toEqual(Uint32Array.of(0, 2, 1));
|
|
const nonUniform = transformModel(model, {
|
|
translate: [0, 0, 0],
|
|
rotate: [0, 0, 0],
|
|
scale: [2, 3, 1],
|
|
});
|
|
expect(modelStats(nonUniform).surfaceArea).toBeCloseTo(3);
|
|
});
|
|
|
|
it("removes only degenerate triangles and exports bounded ASCII PLY", () => {
|
|
const model = parseModel(
|
|
"repair.obj",
|
|
encode("v 0 0 0\nv 1 0 0\nv 0 1 0\nf 1 2 3\nf 1 1 2\n"),
|
|
"OBJ",
|
|
);
|
|
expect(modelStats(model).degenerateTriangles).toBe(1);
|
|
const repaired = removeDegenerateTriangles(model);
|
|
expect(modelStats(repaired)).toMatchObject({
|
|
triangles: 1,
|
|
degenerateTriangles: 0,
|
|
});
|
|
expect(exportAsciiPly(repaired)).toContain("element face 1");
|
|
});
|
|
});
|
|
|
|
function gltfBuffer(): Uint8Array {
|
|
const output = new Uint8Array(44);
|
|
const view = new DataView(output.buffer);
|
|
[0, 0, 0, 1, 0, 0, 0, 1, 0].forEach((value, index) =>
|
|
view.setFloat32(index * 4, value, true),
|
|
);
|
|
view.setUint16(36, 0, true);
|
|
view.setUint16(38, 1, true);
|
|
view.setUint16(40, 2, true);
|
|
return output;
|
|
}
|
|
|
|
function gltfDocument(uri: string | undefined, length: number) {
|
|
return {
|
|
asset: { version: "2.0" },
|
|
buffers: [{ ...(uri ? { uri } : {}), byteLength: length }],
|
|
bufferViews: [
|
|
{ buffer: 0, byteOffset: 0, byteLength: 36 },
|
|
{ buffer: 0, byteOffset: 36, byteLength: 6 },
|
|
],
|
|
accessors: [
|
|
{ bufferView: 0, componentType: 5126, count: 3, type: "VEC3" },
|
|
{ bufferView: 1, componentType: 5123, count: 3, type: "SCALAR" },
|
|
],
|
|
materials: [
|
|
{
|
|
name: "Local",
|
|
pbrMetallicRoughness: {
|
|
baseColorFactor: [0.2, 0.4, 0.6, 1],
|
|
metallicFactor: 0.25,
|
|
roughnessFactor: 0.7,
|
|
},
|
|
},
|
|
],
|
|
meshes: [
|
|
{
|
|
primitives: [{ attributes: { POSITION: 0 }, indices: 1, material: 0 }],
|
|
},
|
|
],
|
|
nodes: [{ name: "Triangle", mesh: 0 }],
|
|
};
|
|
}
|
|
|
|
function makeGlb(document: object, binary: Uint8Array): Uint8Array {
|
|
const rawJson = encode(JSON.stringify(document));
|
|
const jsonLength = Math.ceil(rawJson.length / 4) * 4;
|
|
const binaryLength = Math.ceil(binary.length / 4) * 4;
|
|
const output = new Uint8Array(12 + 8 + jsonLength + 8 + binaryLength);
|
|
const view = new DataView(output.buffer);
|
|
view.setUint32(0, 0x46546c67, true);
|
|
view.setUint32(4, 2, true);
|
|
view.setUint32(8, output.length, true);
|
|
view.setUint32(12, jsonLength, true);
|
|
view.setUint32(16, 0x4e4f534a, true);
|
|
output.fill(0x20, 20, 20 + jsonLength);
|
|
output.set(rawJson, 20);
|
|
const binaryHeader = 20 + jsonLength;
|
|
view.setUint32(binaryHeader, binaryLength, true);
|
|
view.setUint32(binaryHeader + 4, 0x004e4942, true);
|
|
output.set(binary, binaryHeader + 8);
|
|
return output;
|
|
}
|