232 lines
10 KiB
JavaScript
232 lines
10 KiB
JavaScript
#!/usr/bin/env node
|
|
import { createHash } from "node:crypto";
|
|
import { copyFile, readFile, rm, stat, writeFile } from "node:fs/promises";
|
|
import path from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
|
|
const projectRoot = path.resolve(scriptDirectory, "../..");
|
|
const publicRoot = path.join(projectRoot, "public");
|
|
const KTX2_IDENTIFIER = Buffer.from([0xab, 0x4b, 0x54, 0x58, 0x20, 0x32, 0x30, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a]);
|
|
|
|
async function readJson(file) {
|
|
return JSON.parse(await readFile(file, "utf8"));
|
|
}
|
|
|
|
async function writeJson(file, value) {
|
|
await writeFile(file, `${JSON.stringify(value, null, 2)}\n`, "utf8");
|
|
}
|
|
|
|
function parseGlb(buffer, label) {
|
|
if (buffer.length < 20 || buffer.toString("utf8", 0, 4) !== "glTF"
|
|
|| buffer.readUInt32LE(4) !== 2 || buffer.readUInt32LE(8) !== buffer.length) {
|
|
throw new Error(`${label} is not a complete binary glTF 2.0 file.`);
|
|
}
|
|
let json = null;
|
|
let binary = null;
|
|
let offset = 12;
|
|
while (offset + 8 <= buffer.length) {
|
|
const length = buffer.readUInt32LE(offset);
|
|
const type = buffer.readUInt32LE(offset + 4);
|
|
const start = offset + 8;
|
|
const end = start + length;
|
|
if (end > buffer.length) throw new Error(`${label} contains a truncated GLB chunk.`);
|
|
const chunk = buffer.subarray(start, end);
|
|
if (type === 0x4e4f534a) json = JSON.parse(chunk.toString("utf8").replace(/\0+$/u, "").trim());
|
|
if (type === 0x004e4942) binary = chunk;
|
|
offset = end;
|
|
}
|
|
if (!json || !binary) throw new Error(`${label} must contain JSON and BIN chunks.`);
|
|
return { json, binary };
|
|
}
|
|
|
|
function inspectCandidate(buffer, label) {
|
|
const { json, binary } = parseGlb(buffer, label);
|
|
if (!json.extensionsUsed?.includes("EXT_meshopt_compression")
|
|
|| !json.bufferViews?.some((view) => view.extensions?.EXT_meshopt_compression?.byteLength > 0)) {
|
|
throw new Error(`${label} must retain EXT_meshopt_compression buffer views after KTX2 encoding.`);
|
|
}
|
|
let triangleCount = 0;
|
|
for (const mesh of json.meshes ?? []) {
|
|
for (const primitive of mesh.primitives ?? []) {
|
|
if (primitive.mode !== undefined && primitive.mode !== 4) continue;
|
|
const accessorIndex = primitive.indices ?? primitive.attributes?.POSITION;
|
|
const accessor = json.accessors?.[accessorIndex];
|
|
if (!Number.isInteger(accessor?.count) || accessor.count % 3 !== 0) {
|
|
throw new Error(`${label} has an invalid triangle accessor.`);
|
|
}
|
|
triangleCount += accessor.count / 3;
|
|
}
|
|
}
|
|
const images = json.images ?? [];
|
|
if (!images.length || images.some((image) => image.mimeType !== "image/ktx2")) {
|
|
throw new Error(`${label} must contain only embedded KTX2 images.`);
|
|
}
|
|
for (const [index, image] of images.entries()) {
|
|
const view = json.bufferViews?.[image.bufferView];
|
|
if (!view) throw new Error(`${label} image ${index} references a missing buffer view.`);
|
|
const start = view.byteOffset ?? 0;
|
|
const bytes = binary.subarray(start, start + view.byteLength);
|
|
if (bytes.length < 48 || !bytes.subarray(0, 12).equals(KTX2_IDENTIFIER)) {
|
|
throw new Error(`${label} image ${index} has an invalid KTX2 header.`);
|
|
}
|
|
}
|
|
return {
|
|
triangleCount,
|
|
imageCount: images.length,
|
|
meshoptBufferViewCount: json.bufferViews.filter((view) => view.extensions?.EXT_meshopt_compression).length,
|
|
};
|
|
}
|
|
|
|
function updateVisualDescriptors(targets, descriptor) {
|
|
for (const { label, packageDefinition } of targets) {
|
|
const visual = packageDefinition?.visual?.[0];
|
|
if (!visual || visual.url !== descriptor.url) {
|
|
throw new Error(`${label} visual URL does not match target ${descriptor.url}.`);
|
|
}
|
|
}
|
|
for (const { packageDefinition } of targets) {
|
|
Object.assign(packageDefinition.visual[0], {
|
|
checksum: descriptor.checksum,
|
|
byteLength: descriptor.byteLength,
|
|
triangleCount: descriptor.triangleCount,
|
|
compression: "meshopt+ktx2",
|
|
});
|
|
}
|
|
}
|
|
|
|
function resolvePublicAsset(url, label) {
|
|
if (typeof url !== "string" || !url.startsWith("/assets/game/")) {
|
|
throw new Error(`${label} does not have a canonical public asset URL.`);
|
|
}
|
|
const file = path.resolve(publicRoot, url.replace(/^\//u, ""));
|
|
const relative = path.relative(publicRoot, file);
|
|
if (relative.startsWith("..") || path.isAbsolute(relative)) {
|
|
throw new Error(`${label} URL escapes the public asset root.`);
|
|
}
|
|
return file;
|
|
}
|
|
|
|
async function collisionNavigationHashes(stagePack) {
|
|
const assets = [
|
|
...(stagePack.collision ?? []).map((asset) => ({ label: asset.id, ...asset })),
|
|
...(stagePack.navigation ? [{ label: "navigation", ...stagePack.navigation }] : []),
|
|
];
|
|
return Promise.all(assets.map(async (asset) => {
|
|
const file = resolvePublicAsset(asset.url, asset.label);
|
|
const bytes = await readFile(file);
|
|
const checksum = createHash("sha256").update(bytes).digest("hex");
|
|
if (asset.checksum && checksum !== asset.checksum) {
|
|
throw new Error(`${asset.label} checksum does not match stage-pack metadata before visual publish.`);
|
|
}
|
|
return { id: asset.label, url: asset.url, checksum, byteLength: bytes.length };
|
|
}));
|
|
}
|
|
|
|
async function main() {
|
|
const [, , slug, candidateArgument, ...flags] = process.argv;
|
|
if (!slug || !candidateArgument || flags.some((flag) => flag !== "--apply")) {
|
|
throw new Error("Usage: node scripts/dungeon-pipeline/apply-wow-visual-optimization.mjs <slug> <candidate.glb> [--apply]");
|
|
}
|
|
const apply = flags.includes("--apply");
|
|
const candidatePath = path.resolve(projectRoot, candidateArgument);
|
|
const candidateBytes = await readFile(candidatePath);
|
|
const candidateStats = inspectCandidate(candidateBytes, candidatePath);
|
|
const checksum = createHash("sha256").update(candidateBytes).digest("hex");
|
|
const byteLength = (await stat(candidatePath)).size;
|
|
|
|
const dungeonPackPath = path.join(publicRoot, "assets/game/dungeons", slug, "dungeon-pack.json");
|
|
const dungeonPack = await readJson(dungeonPackPath);
|
|
const environmentVisualUrl = dungeonPack.environment?.visual?.[0]?.url;
|
|
if (!environmentVisualUrl) throw new Error(`${dungeonPackPath} has no canonical environment visual URL.`);
|
|
const stagePackPath = path.resolve(publicRoot, path.posix.join(
|
|
path.posix.dirname(environmentVisualUrl.replace(/^\/+/, "")),
|
|
"stage-pack.json",
|
|
));
|
|
if (!await stat(stagePackPath).then(() => true, () => false)) {
|
|
throw new Error(`${slug} does not resolve to a canonical public Manastorm package.`);
|
|
}
|
|
const stagePack = await readJson(stagePackPath);
|
|
const visual = stagePack.visual?.[0];
|
|
if (!visual?.url) throw new Error(`${stagePackPath} has no canonical visual descriptor.`);
|
|
const visualPath = path.resolve(publicRoot, visual.url.replace(/^\/+/, ""));
|
|
const relativeVisual = path.relative(publicRoot, visualPath);
|
|
if (relativeVisual.startsWith("..") || path.isAbsolute(relativeVisual)) {
|
|
throw new Error(`${slug} visual URL escapes the public asset root.`);
|
|
}
|
|
const descriptor = {
|
|
url: visual.url,
|
|
checksum,
|
|
byteLength,
|
|
triangleCount: candidateStats.triangleCount,
|
|
};
|
|
|
|
const assetRegistryPath = path.join(projectRoot, "src/game/generated/manastormAssetPackages.json");
|
|
const assetRegistry = await readJson(assetRegistryPath);
|
|
const registryPackage = assetRegistry.packages.find((entry) => entry.id === stagePack.id);
|
|
if (!registryPackage) throw new Error(`Generated Manastorm registry has no package ${stagePack.id}.`);
|
|
|
|
const importRegistryPath = path.join(projectRoot, "src/game/generated/fivePlayerDungeonImports.json");
|
|
const importRegistry = await readJson(importRegistryPath);
|
|
const dungeonImport = importRegistry.imports.find((entry) => entry.slug === slug);
|
|
if (!dungeonImport || dungeonImport.environment?.id !== stagePack.id) {
|
|
throw new Error(`Generated five-player imports have no matching ${slug} environment ${stagePack.id}.`);
|
|
}
|
|
|
|
if (dungeonPack.environment?.id !== stagePack.id) {
|
|
throw new Error(`${dungeonPackPath} does not point to ${stagePack.id}.`);
|
|
}
|
|
const updateTargets = [
|
|
{ label: "Manastorm stage pack", packageDefinition: stagePack },
|
|
{ label: "Generated Manastorm registry", packageDefinition: registryPackage },
|
|
{ label: "Generated five-player import", packageDefinition: dungeonImport.environment },
|
|
{ label: "Dungeon package", packageDefinition: dungeonPack.environment },
|
|
];
|
|
for (const target of updateTargets) {
|
|
const targetVisual = target.packageDefinition?.visual?.[0];
|
|
if (!targetVisual || targetVisual.url !== descriptor.url) {
|
|
throw new Error(`${target.label} visual URL does not match target ${descriptor.url}.`);
|
|
}
|
|
}
|
|
const collisionNavigationBefore = await collisionNavigationHashes(stagePack);
|
|
const pendingVisualPath = `${visualPath}.pending`;
|
|
const plan = {
|
|
slug,
|
|
candidate: path.relative(projectRoot, candidatePath).replaceAll("\\", "/"),
|
|
publishedVisual: path.relative(projectRoot, visualPath).replaceAll("\\", "/"),
|
|
checksum,
|
|
byteLength,
|
|
triangleCount: candidateStats.triangleCount,
|
|
imageCount: candidateStats.imageCount,
|
|
meshoptBufferViewCount: candidateStats.meshoptBufferViewCount,
|
|
collisionNavigationHashesBefore: collisionNavigationBefore,
|
|
apply,
|
|
};
|
|
if (!apply) {
|
|
console.log(JSON.stringify(plan, null, 2));
|
|
return;
|
|
}
|
|
|
|
updateVisualDescriptors(updateTargets, descriptor);
|
|
await copyFile(candidatePath, pendingVisualPath);
|
|
await copyFile(pendingVisualPath, visualPath);
|
|
await rm(pendingVisualPath, { force: true });
|
|
await Promise.all([
|
|
writeJson(stagePackPath, stagePack),
|
|
writeJson(assetRegistryPath, assetRegistry),
|
|
writeJson(importRegistryPath, importRegistry),
|
|
writeJson(dungeonPackPath, dungeonPack),
|
|
]);
|
|
const collisionNavigationAfter = await collisionNavigationHashes(await readJson(stagePackPath));
|
|
if (JSON.stringify(collisionNavigationAfter) !== JSON.stringify(collisionNavigationBefore)) {
|
|
throw new Error("Collision or navigation assets changed during visual publishing.");
|
|
}
|
|
console.log(JSON.stringify({ ...plan, collisionNavigationHashesAfter: collisionNavigationAfter }, null, 2));
|
|
}
|
|
|
|
if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
|
|
await main();
|
|
}
|
|
|
|
export { updateVisualDescriptors };
|