140 lines
4.8 KiB
JavaScript
140 lines
4.8 KiB
JavaScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import fs from "node:fs/promises";
|
|
import * as THREE from "three";
|
|
import {
|
|
BodyVisuals,
|
|
validateBodyGlb,
|
|
} from "../src/platform/render/BodyVisuals.js";
|
|
import { validatePackage } from "../src/platform/loader/SchemaValidator.js";
|
|
const config = JSON.parse(
|
|
await fs.readFile(
|
|
new URL("../public/robots/microban/robot.json", import.meta.url),
|
|
),
|
|
);
|
|
function glb(json) {
|
|
const text = new TextEncoder().encode(JSON.stringify(json));
|
|
const buffer = new ArrayBuffer(20 + text.length);
|
|
const view = new DataView(buffer);
|
|
[0x46546c67, 2, buffer.byteLength, text.length, 0x4e4f534a].forEach(
|
|
(value, i) => view.setUint32(i * 4, value, true),
|
|
);
|
|
new Uint8Array(buffer, 20).set(text);
|
|
return buffer;
|
|
}
|
|
test("all 20 Microban body GLBs embed their materials/textures and stay visual-only", async () => {
|
|
validatePackage(config);
|
|
assert.equal(config.render.body_visuals.length, 20);
|
|
let textures = 0;
|
|
for (const { body, path } of config.render.body_visuals) {
|
|
assert.ok(!config.assets.some((asset) => asset.path === path));
|
|
const bytes = await fs.readFile(
|
|
new URL(`../public/robots/microban/${path}`, import.meta.url),
|
|
);
|
|
const json = validateBodyGlb(
|
|
bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
|
|
);
|
|
assert.ok(json.materials.length > 0);
|
|
if (body === "head")
|
|
assert.ok(
|
|
json.materials.some(
|
|
(material) => material.pbrMetallicRoughness?.baseColorTexture,
|
|
),
|
|
"microban2 screen colour texture must be preserved",
|
|
);
|
|
textures += json.images?.length ?? 0;
|
|
}
|
|
assert.ok(textures >= 20);
|
|
});
|
|
test("visual schema rejects duplicate bodies, non-unit quaternions and external/escaping paths", () => {
|
|
const duplicate = structuredClone(config);
|
|
duplicate.render.body_visuals.push(duplicate.render.body_visuals[0]);
|
|
assert.throws(() => validatePackage(duplicate), /duplicate body/);
|
|
const zero = structuredClone(config);
|
|
zero.render.body_visuals[0].quaternion = [0, 0, 0, 0];
|
|
assert.throws(() => validatePackage(zero), /unit length/);
|
|
for (const path of [
|
|
"https://host/a.glb",
|
|
"../a.glb",
|
|
"/a.glb",
|
|
"a.glb?x=1",
|
|
]) {
|
|
const invalid = structuredClone(config);
|
|
invalid.render.body_visuals[0].path = path;
|
|
assert.throws(() => validatePackage(invalid), /body_visuals/);
|
|
}
|
|
});
|
|
test("GLB validation fails closed on LFS pointers, truncation and external image/buffer requests", () => {
|
|
for (const bytes of [
|
|
new ArrayBuffer(0),
|
|
new TextEncoder().encode("version https://git-lfs.github.com/spec/v1")
|
|
.buffer,
|
|
glb({}).slice(0, -1),
|
|
])
|
|
assert.throws(() => validateBodyGlb(bytes), /invalid GLB/);
|
|
for (const json of [
|
|
{ images: [{ uri: "https://host/normal.png" }] },
|
|
{ buffers: [{ uri: "../buffer.bin" }] },
|
|
])
|
|
assert.throws(() => validateBodyGlb(glb(json)), /embed all/);
|
|
});
|
|
test("body attachments track MuJoCo body transforms without touching simulation arrays", () => {
|
|
const data = {
|
|
xpos: [0, 0, 0, 1, 2, 3],
|
|
xquat: [1, 0, 0, 0, 0.5, 0.5, 0.5, 0.5],
|
|
};
|
|
const before = structuredClone(data);
|
|
const visuals = new BodyVisuals(data),
|
|
frame = new THREE.Group();
|
|
visuals.items.push({ id: 1, frame });
|
|
visuals.sync();
|
|
assert.deepEqual(frame.position.toArray(), [1, 2, 3]);
|
|
assert.deepEqual(frame.quaternion.toArray(), [0.5, 0.5, 0.5, 0.5]);
|
|
assert.deepEqual(data, before);
|
|
});
|
|
test("shared GLB geometries, materials, textures and ImageBitmaps are released exactly once", () => {
|
|
const visuals = new BodyVisuals({}),
|
|
scene = new THREE.Group();
|
|
const geometry = new THREE.BoxGeometry(),
|
|
texture = new THREE.Texture();
|
|
let closed = 0;
|
|
texture.source.data = { close: () => closed++ };
|
|
const material = new THREE.MeshStandardMaterial({
|
|
map: texture,
|
|
normalMap: texture,
|
|
});
|
|
const counts = { geometry: 0, material: 0, texture: 0 };
|
|
geometry.addEventListener("dispose", () => counts.geometry++);
|
|
material.addEventListener("dispose", () => counts.material++);
|
|
texture.addEventListener("dispose", () => counts.texture++);
|
|
scene.add(
|
|
new THREE.Mesh(geometry, material),
|
|
new THREE.Mesh(geometry, material),
|
|
);
|
|
visuals.scenes.push(scene, scene);
|
|
const parent = new THREE.Group();
|
|
parent.add(visuals.root);
|
|
visuals.dispose();
|
|
visuals.dispose();
|
|
assert.deepEqual(counts, { geometry: 1, material: 1, texture: 1 });
|
|
assert.equal(closed, 1);
|
|
assert.equal(parent.children.length, 0);
|
|
});
|
|
test("missing body bindings fail before any asset request", async () => {
|
|
const mujoco = { mj_name2id: () => -1, mjtObj: { mjOBJ_BODY: { value: 1 } } };
|
|
await assert.rejects(
|
|
BodyVisuals.load(
|
|
mujoco,
|
|
{},
|
|
{},
|
|
{
|
|
config,
|
|
asset: () => {
|
|
throw new Error("must not fetch");
|
|
},
|
|
},
|
|
),
|
|
/missing robot body trunk/,
|
|
);
|
|
});
|