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.jsonindex 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.jsonindex 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.mjsnew file mode 100644index 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}`);+}