Skip to content

armgit / 67.js

Public Imported from GitHub
0

3D engine that AI agents drive

Add a script that splits a showcase world into a first part and the rest (part of #445)

Nguyen Xuan An42cc97a7e202
diff --git a/package-lock.json b/package-lock.json
index 89e18991..f9e95a7a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -25,6 +25,7 @@
"gl-matrix": "3.4.4",
"highlight.js": "11.12.0",
"manifold-3d": "3.5.4",
+ "meshoptimizer": "^1.3.0",
"playwright": "1.64.1",
"three": "0.187.0",
"three-mesh-bvh": "0.9.17",
@@ -2420,6 +2421,13 @@
"@jridgewell/sourcemap-codec": "^1.4.14"
}
},
+ "node_modules/meshoptimizer": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/meshoptimizer/-/meshoptimizer-1.3.0.tgz",
+ "integrity": "sha512-2oZqMAcEEiCtXWUjIGtZ71oPx1B0ZxYGTqIKsXB1wzWFhleNsCFxQuUJzgCV706bRcwPWtMGf1odmQvAcqKkIw==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/miniflare": {
"version": "5.20261023.3-beta",
"resolved": "https://registry.npmjs.org/miniflare/-/miniflare-5.20261023.3-beta.tgz",
diff --git a/package.json b/package.json
index 6b26803b..4f16da7f 100644
--- a/package.json
+++ b/package.json
@@ -207,6 +207,7 @@
"gl-matrix": "3.4.4",
"highlight.js": "11.12.0",
"manifold-3d": "3.5.4",
+ "meshoptimizer": "^1.3.0",
"playwright": "1.64.1",
"three": "0.187.0",
"three-mesh-bvh": "0.9.17",
diff --git a/scripts/split-showcase-glb.mjs b/scripts/split-showcase-glb.mjs
new file mode 100644
index 00000000..cd34aafb
--- /dev/null
+++ b/scripts/split-showcase-glb.mjs
@@ -0,0 +1,483 @@
+// Splits a showcase world's GLB into a small first part (the ground and the hero asset the default camera frames) and the
+// rest, and writes a small preview of the sky, so the showcase page can draw a first frame before the whole world arrives.
+//
+// node scripts/split-showcase-glb.mjs <port|airport|datacenter> --source <full.glb> [--dry-run]
+//
+// The source is the world as one GLB. The committed split files replace it, so recover the original from the commit before the
+// split: `git show <commit-before-the-split>:public/showcase/<id>/scene.glb > full.glb`.
+//
+// Nothing is re-quantized and no texture is touched: every compressed vertex stream, image and material is copied byte for byte
+// and every kept node keeps its transform. The one thing rewritten is the shared meshopt index stream. Its indices are decoded,
+// cut per accessor and encoded again (a lossless step), because one stream serves every mesh and cannot be cut in its
+// compressed form. A mesh used by several nodes goes to one part together with all of its nodes, so instancing survives.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';
+import { MeshoptEncoder } from 'meshoptimizer';
+import { parseRadianceHdr } from '../src/hdri.js';
+
+const SHOWCASE_DIRECTORY = join(dirname(fileURLToPath(import.meta.url)), '..', 'public', 'showcase');
+const GLB_MAGIC = 0x46546c67;
+const JSON_CHUNK = 0x4e4f534a;
+const BINARY_CHUNK = 0x004e4942;
+const MESHOPT = 'EXT_meshopt_compression';
+const PREVIEW_SKY_WIDTH = 128;
+const PREVIEW_SKY_HEIGHT = 64;
+
+// The nodes (by name) that make the first part. They are the ground and the hero the default camera frames; every other
+// node goes to the rest. A name picks every node that carries it.
+const FIRST_PART_NODE_NAMES = {
+ port: ['harbour_water', 'ground_baked', 'quay_concrete', 'far_ridge', 'ship_hull', 'glass', 'glow_window'],
+ airport: ['concrete', 'asphalt', 'aircraft'],
+ datacenter: ['hall_floor', 'rack_front*'],
+};
+
+// Materials of the first part's meshes whose primitives load with the rest: the airliner's landing gear detail, which is small on
+// screen and shares its textures with the ramp equipment in the rest.
+const LATER_MATERIAL_NAMES = {
+ airport: ['gear_paint', 'paint_grey', 'steel', 'paint_grime', 'dark_metal', 'chrome', 'tyre_rubber', 'hub_grey', 'brake_steel', 'plastic_black', 'Rubber', 'Landing_Gear_Black', 'landing_Gear', 'Gear_Door_Metal', 'Gear_Door_Metal.001', 'Gear_Well', 'Wheel'],
+};
+
+function readGlb(buffer) {
+ if (buffer.readUInt32LE(0) !== GLB_MAGIC) throw new Error('Not a GLB file.');
+ const jsonLength = buffer.readUInt32LE(12);
+ const json = JSON.parse(buffer.subarray(20, 20 + jsonLength).toString('utf8'));
+ const binaryStart = 20 + jsonLength;
+ if (buffer.readUInt32LE(binaryStart + 4) !== BINARY_CHUNK) throw new Error('The GLB has no binary chunk.');
+ const binaryLength = buffer.readUInt32LE(binaryStart);
+ return { json, binary: buffer.subarray(binaryStart + 8, binaryStart + 8 + binaryLength) };
+}
+
+function writeGlb(json, binary) {
+ const jsonBytes = Buffer.from(JSON.stringify(json), 'utf8');
+ const jsonPadded = Buffer.concat([jsonBytes, Buffer.alloc((4 - (jsonBytes.length % 4)) % 4, 0x20)]);
+ const binaryPadded = Buffer.concat([binary, Buffer.alloc((4 - (binary.length % 4)) % 4)]);
+ const header = Buffer.alloc(12);
+ header.writeUInt32LE(GLB_MAGIC, 0);
+ header.writeUInt32LE(2, 4);
+ header.writeUInt32LE(12 + 8 + jsonPadded.length + 8 + binaryPadded.length, 8);
+ const jsonHeader = Buffer.alloc(8);
+ jsonHeader.writeUInt32LE(jsonPadded.length, 0);
+ jsonHeader.writeUInt32LE(JSON_CHUNK, 4);
+ const binaryHeader = Buffer.alloc(8);
+ binaryHeader.writeUInt32LE(binaryPadded.length, 0);
+ binaryHeader.writeUInt32LE(BINARY_CHUNK, 4);
+ return Buffer.concat([header, jsonHeader, jsonPadded, binaryHeader, binaryPadded]);
+}
+
+function componentBytes(componentType) {
+ return { 5120: 1, 5121: 1, 5122: 2, 5123: 2, 5125: 4, 5126: 4 }[componentType];
+}
+
+const TYPE_WIDTH = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16 };
+
+// Every `index` inside a material is a texture reference (texture infos, also inside extensions).
+function remapTextureIndices(value, textureMap) {
+ if (Array.isArray(value)) return value.map(item => remapTextureIndices(item, textureMap));
+ if (value && typeof value === 'object') {
+ return Object.fromEntries(Object.entries(value).map(([key, inner]) => (
+ key === 'index' && typeof inner === 'number' ? [key, textureMap.get(inner)] : [key, remapTextureIndices(inner, textureMap)]
+ )));
+ }
+ return value;
+}
+
+function collectTextureIndices(value, found) {
+ if (Array.isArray(value)) value.forEach(item => collectTextureIndices(item, found));
+ else if (value && typeof value === 'object') {
+ for (const [key, inner] of Object.entries(value)) {
+ if (key === 'index' && typeof inner === 'number') found.add(inner);
+ else collectTextureIndices(inner, found);
+ }
+ }
+}
+
+class SourceWorld {
+ constructor(buffer) {
+ ({ json: this.json, binary: this.binary } = readGlb(buffer));
+ this.decodedIndexViews = new Map();
+ this.parentOf = new Map();
+ this.json.nodes.forEach((node, index) => (node.children ?? []).forEach(child => this.parentOf.set(child, index)));
+ for (const key of ['animations', 'cameras']) {
+ if (this.json[key]?.length) throw new Error(`The splitter does not handle ${key}.`);
+ }
+ this.drawOrder = this.listDrawOrder();
+ }
+
+ // The parts the glTF loader makes, in its order: nodes depth first, each mesh node's primitives, each primitive's instances.
+ // A part's place in this list is its rank; the page sorts the parts of all files by rank to restore the one-piece order,
+ // which fixes the order the renderer batches and draws them in.
+ listDrawOrder() {
+ const order = [];
+ const visit = nodeIndex => {
+ const node = this.json.nodes[nodeIndex];
+ if (node.mesh !== undefined) {
+ const instancing = node.extensions?.EXT_mesh_gpu_instancing;
+ const instanceCount = instancing ? this.json.accessors[Object.values(instancing.attributes)[0]].count : 1;
+ this.json.meshes[node.mesh].primitives.forEach((primitive, primitiveIndex) => {
+ for (let instance = 0; instance < instanceCount; instance++) order.push({ nodeIndex, primitive, primitiveIndex });
+ });
+ }
+ (node.children ?? []).forEach(visit);
+ };
+ this.json.scenes[this.json.scene ?? 0].nodes.forEach(visit);
+ return order;
+ }
+
+ meshNodes() {
+ return this.json.nodes.map((node, index) => (node.mesh === undefined ? null : index)).filter(index => index !== null);
+ }
+
+ // The decoded index stream of a compressed TRIANGLES view, cached.
+ decodedIndexView(viewIndex) {
+ if (!this.decodedIndexViews.has(viewIndex)) {
+ const view = this.json.bufferViews[viewIndex];
+ const extension = view.extensions[MESHOPT];
+ const decoded = new Uint8Array(extension.count * extension.byteStride);
+ const source = this.binary.subarray(extension.byteOffset, extension.byteOffset + extension.byteLength);
+ MeshoptDecoder.decodeGltfBuffer(decoded, extension.count, extension.byteStride, source, extension.mode, extension.filter ?? 'NONE');
+ this.decodedIndexViews.set(viewIndex, decoded);
+ }
+ return this.decodedIndexViews.get(viewIndex);
+ }
+
+ isIndexView(viewIndex) {
+ return this.json.bufferViews[viewIndex].extensions?.[MESHOPT]?.mode === 'TRIANGLES';
+ }
+
+ // The part holding exactly these nodes (mesh-carrying nodes) plus their ancestors; returns { json, binary }.
+ // `keepPrimitive(meshIndex, primitive)` picks the primitives of each mesh that this part draws; a node left with none is dropped.
+ extract(requestedNodeIndices, keepPrimitive = () => true) {
+ const source = this.json;
+ const meshNodeIndices = requestedNodeIndices.filter(index => source.meshes[source.nodes[index].mesh].primitives.some(primitive => keepPrimitive(source.nodes[index].mesh, primitive)));
+ const keptNodes = new Set();
+ const keepWithAncestors = nodeIndex => {
+ for (let current = nodeIndex; current !== undefined; current = this.parentOf.get(current)) keptNodes.add(current);
+ };
+ const skinOrder = [...new Set(meshNodeIndices.map(index => source.nodes[index].skin).filter(skin => skin !== undefined))].sort((a, b) => a - b);
+ const skinMap = new Map(skinOrder.map((oldIndex, newIndex) => [oldIndex, newIndex]));
+ for (const nodeIndex of meshNodeIndices) keepWithAncestors(nodeIndex);
+ for (const oldSkin of skinOrder) {
+ for (const joint of source.skins[oldSkin].joints) keepWithAncestors(joint);
+ if (source.skins[oldSkin].skeleton !== undefined) keepWithAncestors(source.skins[oldSkin].skeleton);
+ }
+ const nodeOrder = [...keptNodes].sort((a, b) => a - b);
+ const nodeMap = new Map(nodeOrder.map((oldIndex, newIndex) => [oldIndex, newIndex]));
+
+ const meshOrder = [...new Set(meshNodeIndices.map(index => source.nodes[index].mesh))].sort((a, b) => a - b);
+ const meshMap = new Map(meshOrder.map((oldIndex, newIndex) => [oldIndex, newIndex]));
+ const accessorOrder = [];
+ const accessorMap = new Map();
+ const materialOrder = [];
+ const addAccessor = oldIndex => {
+ if (oldIndex === undefined) return undefined;
+ if (!accessorMap.has(oldIndex)) {
+ accessorMap.set(oldIndex, accessorOrder.length);
+ accessorOrder.push(oldIndex);
+ }
+ return accessorMap.get(oldIndex);
+ };
+ const materialMap = new Map();
+ const meshes = meshOrder.map(oldMesh => {
+ const mesh = structuredClone(source.meshes[oldMesh]);
+ mesh.primitives = mesh.primitives.filter(primitive => keepPrimitive(oldMesh, primitive));
+ for (const primitive of mesh.primitives) {
+ if (primitive.targets || primitive.extensions) throw new Error('The splitter does not handle morph targets or primitive extensions.');
+ primitive.indices = addAccessor(primitive.indices);
+ for (const [name, accessor] of Object.entries(primitive.attributes)) primitive.attributes[name] = addAccessor(accessor);
+ if (primitive.material !== undefined) {
+ if (!materialMap.has(primitive.material)) {
+ materialMap.set(primitive.material, materialOrder.length);
+ materialOrder.push(primitive.material);
+ }
+ primitive.material = materialMap.get(primitive.material);
+ }
+ }
+ return mesh;
+ });
+ // GPU instancing keeps its per-instance transforms in accessors of their own.
+ const instancingOf = nodeIndex => source.nodes[nodeIndex].extensions?.EXT_mesh_gpu_instancing;
+ const instancingAccessors = new Map();
+ for (const nodeIndex of meshNodeIndices) {
+ const instancing = instancingOf(nodeIndex);
+ if (instancing) instancingAccessors.set(nodeIndex, Object.fromEntries(Object.entries(instancing.attributes).map(([name, accessor]) => [name, addAccessor(accessor)])));
+ }
+ const skins = skinOrder.map(oldSkin => {
+ const skin = structuredClone(source.skins[oldSkin]);
+ skin.joints = skin.joints.map(joint => nodeMap.get(joint));
+ if (skin.skeleton !== undefined) skin.skeleton = nodeMap.get(skin.skeleton);
+ skin.inverseBindMatrices = addAccessor(skin.inverseBindMatrices);
+ return skin;
+ });
+
+ const textureOrder = [];
+ const textureMap = new Map();
+ for (const oldMaterial of materialOrder) {
+ const found = new Set();
+ collectTextureIndices(source.materials[oldMaterial], found);
+ for (const texture of [...found].sort((a, b) => a - b)) {
+ if (!textureMap.has(texture)) {
+ textureMap.set(texture, textureOrder.length);
+ textureOrder.push(texture);
+ }
+ }
+ }
+ const materials = materialOrder.map(oldMaterial => remapTextureIndices(structuredClone(source.materials[oldMaterial]), textureMap));
+
+ const imageOrder = [];
+ const imageMap = new Map();
+ const samplerOrder = [];
+ const samplerMap = new Map();
+ const textures = textureOrder.map(oldTexture => {
+ const texture = structuredClone(source.textures[oldTexture]);
+ if (texture.extensions) throw new Error('The splitter does not handle texture extensions.');
+ if (!imageMap.has(texture.source)) {
+ imageMap.set(texture.source, imageOrder.length);
+ imageOrder.push(texture.source);
+ }
+ texture.source = imageMap.get(texture.source);
+ if (texture.sampler !== undefined) {
+ if (!samplerMap.has(texture.sampler)) {
+ samplerMap.set(texture.sampler, samplerOrder.length);
+ samplerOrder.push(texture.sampler);
+ }
+ texture.sampler = samplerMap.get(texture.sampler);
+ }
+ return texture;
+ });
+
+ // Buffer views: images copy whole, attribute streams copy whole, index streams are rebuilt from the kept accessors.
+ const output = { views: [], binaryChunks: [], binaryLength: 0, fallbackLength: 0 };
+ const appendBinary = bytes => {
+ const offset = output.binaryLength;
+ output.binaryChunks.push(Buffer.from(bytes));
+ const padding = (4 - (bytes.length % 4)) % 4;
+ if (padding) output.binaryChunks.push(Buffer.alloc(padding));
+ output.binaryLength += bytes.length + padding;
+ return offset;
+ };
+ const viewMap = new Map();
+ const copyView = oldView => {
+ if (viewMap.has(oldView)) return viewMap.get(oldView);
+ const view = structuredClone(source.bufferViews[oldView]);
+ const extension = view.extensions?.[MESHOPT];
+ if (extension) {
+ extension.byteOffset = appendBinary(this.binary.subarray(extension.byteOffset, extension.byteOffset + extension.byteLength));
+ extension.buffer = 0;
+ view.buffer = 1;
+ view.byteOffset = output.fallbackLength;
+ output.fallbackLength += view.byteLength + ((4 - (view.byteLength % 4)) % 4);
+ } else {
+ view.byteOffset = appendBinary(this.binary.subarray(view.byteOffset ?? 0, (view.byteOffset ?? 0) + view.byteLength));
+ view.buffer = 0;
+ }
+ output.views.push(view);
+ viewMap.set(oldView, output.views.length - 1);
+ return viewMap.get(oldView);
+ };
+
+ const indexAccessorsByView = new Map();
+ for (const oldAccessor of accessorOrder) {
+ const viewIndex = source.accessors[oldAccessor].bufferView;
+ if (!this.isIndexView(viewIndex)) continue;
+ if (!indexAccessorsByView.has(viewIndex)) indexAccessorsByView.set(viewIndex, []);
+ indexAccessorsByView.get(viewIndex).push(oldAccessor);
+ }
+ const rebuiltIndexAccessors = new Map();
+ for (const [viewIndex, oldAccessors] of indexAccessorsByView) {
+ const sourceView = source.bufferViews[viewIndex];
+ const stride = sourceView.extensions[MESHOPT].byteStride;
+ const decoded = this.decodedIndexView(viewIndex);
+ const slices = oldAccessors.map(oldAccessor => {
+ const accessor = source.accessors[oldAccessor];
+ const start = accessor.byteOffset ?? 0;
+ return decoded.subarray(start, start + accessor.count * componentBytes(accessor.componentType) * TYPE_WIDTH[accessor.type]);
+ });
+ const joined = new Uint8Array(slices.reduce((total, slice) => total + slice.length, 0));
+ let cursor = 0;
+ const offsets = slices.map(slice => {
+ joined.set(slice, cursor);
+ cursor += slice.length;
+ return cursor - slice.length;
+ });
+ const indexCount = joined.length / stride;
+ const encoded = MeshoptEncoder.encodeIndexBuffer(joined, indexCount, stride);
+ const view = structuredClone(sourceView);
+ view.extensions[MESHOPT] = { ...view.extensions[MESHOPT], buffer: 0, byteOffset: appendBinary(encoded), byteLength: encoded.length, count: indexCount };
+ view.buffer = 1;
+ view.byteOffset = output.fallbackLength;
+ view.byteLength = joined.length;
+ output.fallbackLength += joined.length + ((4 - (joined.length % 4)) % 4);
+ output.views.push(view);
+ const newViewIndex = output.views.length - 1;
+ oldAccessors.forEach((oldAccessor, position) => rebuiltIndexAccessors.set(oldAccessor, { bufferView: newViewIndex, byteOffset: offsets[position] }));
+ }
+
+ const accessors = accessorOrder.map(oldAccessor => {
+ const accessor = structuredClone(source.accessors[oldAccessor]);
+ if (accessor.sparse) throw new Error('The splitter does not handle sparse accessors.');
+ const rebuilt = rebuiltIndexAccessors.get(oldAccessor);
+ if (rebuilt) {
+ accessor.bufferView = rebuilt.bufferView;
+ accessor.byteOffset = rebuilt.byteOffset;
+ if (!accessor.byteOffset) delete accessor.byteOffset;
+ } else {
+ accessor.bufferView = copyView(accessor.bufferView);
+ }
+ return accessor;
+ });
+ const images = imageOrder.map(oldImage => {
+ const image = structuredClone(source.images[oldImage]);
+ if (image.uri) throw new Error('The splitter does not handle images with a uri.');
+ image.bufferView = copyView(image.bufferView);
+ return image;
+ });
+ const samplers = samplerOrder.map(oldSampler => structuredClone(source.samplers[oldSampler]));
+
+ const nodes = nodeOrder.map(oldNode => {
+ const node = structuredClone(source.nodes[oldNode]);
+ if (node.mesh !== undefined) {
+ if (meshNodeIndices.includes(oldNode)) {
+ node.mesh = meshMap.get(node.mesh);
+ if (instancingAccessors.has(oldNode)) node.extensions.EXT_mesh_gpu_instancing.attributes = instancingAccessors.get(oldNode);
+ if (node.skin !== undefined) node.skin = skinMap.get(node.skin);
+ } else {
+ delete node.mesh;
+ delete node.extensions?.EXT_mesh_gpu_instancing;
+ delete node.skin;
+ }
+ }
+ if (node.children) {
+ node.children = node.children.filter(child => nodeMap.has(child)).map(child => nodeMap.get(child));
+ if (!node.children.length) delete node.children;
+ }
+ return node;
+ });
+ const sceneRoots = (source.scenes[source.scene ?? 0].nodes).filter(root => nodeMap.has(root)).map(root => nodeMap.get(root));
+
+ const keptNodeSet = new Set(meshNodeIndices);
+ const partRanks = [];
+ this.drawOrder.forEach((entry, rank) => {
+ if (keptNodeSet.has(entry.nodeIndex) && keepPrimitive(source.nodes[entry.nodeIndex].mesh, entry.primitive)) partRanks.push(rank);
+ });
+ const json = {
+ asset: source.asset,
+ extensionsUsed: source.extensionsUsed,
+ extensionsRequired: source.extensionsRequired,
+ scene: 0,
+ scenes: [{ ...source.scenes[source.scene ?? 0], nodes: sceneRoots, extras: { partRanks } }],
+ nodes,
+ meshes,
+ materials,
+ accessors,
+ bufferViews: output.views,
+ buffers: [{ byteLength: output.binaryLength }, { byteLength: output.fallbackLength, extensions: { [MESHOPT]: { fallback: true } } }],
+ };
+ if (skins.length) json.skins = skins;
+ if (textures.length) json.textures = textures;
+ if (images.length) json.images = images;
+ if (samplers.length) json.samplers = samplers;
+ return { json, binary: Buffer.concat(output.binaryChunks) };
+ }
+}
+
+// A flat (not run-length) Radiance file at a fraction of the size; each output texel averages the linear colour of its block.
+function writePreviewSky(sourcePath, targetPath) {
+ const { width, height, data } = parseRadianceHdr(readFileSync(sourcePath));
+ const blockWidth = Math.floor(width / PREVIEW_SKY_WIDTH);
+ const blockHeight = Math.floor(height / PREVIEW_SKY_HEIGHT);
+ const header = Buffer.from(`#?RADIANCE\nFORMAT=32-bit_rle_rgbe\n\n-Y ${PREVIEW_SKY_HEIGHT} +X ${PREVIEW_SKY_WIDTH}\n`, 'latin1');
+ const pixels = Buffer.alloc(PREVIEW_SKY_WIDTH * PREVIEW_SKY_HEIGHT * 4);
+ for (let row = 0; row < PREVIEW_SKY_HEIGHT; row++) {
+ for (let column = 0; column < PREVIEW_SKY_WIDTH; column++) {
+ const sum = [0, 0, 0];
+ for (let blockRow = 0; blockRow < blockHeight; blockRow++) {
+ for (let blockColumn = 0; blockColumn < blockWidth; blockColumn++) {
+ const texel = ((row * blockHeight + blockRow) * width + column * blockWidth + blockColumn) * 3;
+ for (let channel = 0; channel < 3; channel++) sum[channel] += data[texel + channel];
+ }
+ }
+ const average = sum.map(value => value / (blockWidth * blockHeight));
+ const brightest = Math.max(...average);
+ const target = (row * PREVIEW_SKY_WIDTH + column) * 4;
+ if (brightest < 1e-32) continue;
+ const exponent = Math.floor(Math.log2(brightest)) + 1;
+ const scale = 256 / 2 ** exponent;
+ for (let channel = 0; channel < 3; channel++) pixels[target + channel] = Math.min(255, Math.round(average[channel] * scale));
+ pixels[target + 3] = exponent + 128;
+ }
+ }
+ const file = Buffer.concat([header, pixels]);
+ writeFileSync(targetPath, file);
+ const check = parseRadianceHdr(file);
+ if (check.width !== PREVIEW_SKY_WIDTH || check.height !== PREVIEW_SKY_HEIGHT) throw new Error('The preview sky does not parse back.');
+ return file.length;
+}
+
+function parseArguments(argv) {
+ const [worldId, ...rest] = argv;
+ const options = { worldId, source: null, dryRun: false, list: false, first: null };
+ for (let index = 0; index < rest.length; index++) {
+ if (rest[index] === '--source') options.source = rest[++index];
+ else if (rest[index] === '--dry-run') options.dryRun = true;
+ else if (rest[index] === '--first') options.first = rest[++index].split(',');
+ else if (rest[index] === '--list') {
+ options.list = true;
+ options.dryRun = true;
+ }
+ else throw new Error(`Unknown argument ${rest[index]}.`);
+ }
+ if (!FIRST_PART_NODE_NAMES[worldId]) throw new Error(`Usage: split-showcase-glb.mjs <${Object.keys(FIRST_PART_NODE_NAMES).join('|')}> --source <full.glb> [--dry-run]`);
+ if (!options.source) throw new Error('Pass --source <full.glb>: the world as one GLB (see the comment at the top of this script).');
+ return options;
+}
+
+const options = parseArguments(process.argv.slice(2));
+await Promise.all([MeshoptDecoder.ready, MeshoptEncoder.ready]);
+const world = new SourceWorld(readFileSync(options.source));
+const firstPatterns = options.first ?? FIRST_PART_NODE_NAMES[options.worldId];
+const isFirstName = (name = '') => firstPatterns.some(pattern => (pattern.endsWith('*') ? name.startsWith(pattern.slice(0, -1)) : name === pattern));
+const allMeshNodes = world.meshNodes();
+// Skinned parts always load with the first part: the renderer cannot add a skinned part to a scene that is already drawing.
+const firstMeshes = new Set(allMeshNodes
+ .filter(index => isFirstName(world.json.nodes[index].name) || world.json.nodes[index].skin !== undefined)
+ .map(index => world.json.nodes[index].mesh));
+const firstNodes = allMeshNodes.filter(index => firstMeshes.has(world.json.nodes[index].mesh));
+const restNodes = allMeshNodes.filter(index => !firstMeshes.has(world.json.nodes[index].mesh));
+if (!firstNodes.length) throw new Error('No node matches the first part names.');
+// A hero mesh can hand its fine detail (by material name) to the rest, so the first part stays small.
+const laterMaterials = new Set(LATER_MATERIAL_NAMES[options.worldId] ?? []);
+const isLaterPrimitive = primitive => laterMaterials.has(world.json.materials[primitive.material]?.name);
+const first = writeGlb(...Object.values(world.extract(firstNodes, (mesh, primitive) => !isLaterPrimitive(primitive))));
+const rest = writeGlb(...Object.values(world.extract([...firstNodes, ...restNodes], (mesh, primitive) => !firstMeshes.has(mesh) || isLaterPrimitive(primitive))));
+console.log(`${options.worldId}: first ${first.length} bytes (${firstNodes.length} nodes), rest ${rest.length} bytes (${restNodes.length} nodes), source ${readFileSync(options.source).length} bytes`);
+if (!options.dryRun) {
+ const directory = join(SHOWCASE_DIRECTORY, options.worldId);
+ writeFileSync(join(directory, 'scene.glb'), first);
+ writeFileSync(join(directory, 'scene.rest.glb'), rest);
+ const previewBytes = writePreviewSky(join(directory, 'sky.hdr'), join(directory, 'sky.preview.hdr'));
+ console.log(`wrote scene.glb, scene.rest.glb and sky.preview.hdr (${previewBytes} bytes)`);
+ // The description names the parts: "glb" is the first, "glbRest" the others, "hdriPreview" the small sky.
+ const descriptionPath = join(directory, 'scene.json');
+ const description = readFileSync(descriptionPath, 'utf8');
+ if (!description.includes('"glbRest"')) {
+ // The files use CRLF line endings; the lines added match whatever the "glb" line uses.
+ const staged = description.replace(/^([ \t]*)"glb": "([^"]*)",(\r?\n)/m, (match, indent, glbPath, newline) => (
+ `${match}${indent}"glbRest": ["${glbPath.replace(/scene\.glb$/, 'scene.rest.glb')}"],${newline}${indent}"hdriPreview": "${glbPath.replace(/scene\.glb$/, 'sky.preview.hdr')}",${newline}`
+ ));
+ if (staged === description) throw new Error('scene.json has no "glb" line to extend.');
+ writeFileSync(descriptionPath, staged);
+ }
+}
+if (options.list) {
+ // Helps to choose the first part: the size of each named node's mesh group (all nodes sharing its mesh) as a GLB of its own.
+ const sizeByName = new Map();
+ for (const index of allMeshNodes) {
+ const name = world.json.nodes[index].name;
+ if (sizeByName.has(name)) continue;
+ const sameMesh = allMeshNodes.filter(other => world.json.nodes[other].mesh === world.json.nodes[index].mesh);
+ sizeByName.set(name, `${writeGlb(...Object.values(world.extract(sameMesh))).length} bytes, ${sameMesh.length} nodes`);
+ }
+ for (const [name, size] of sizeByName) console.log(`${name}: ${size}`);
+}