Update Healer Man server

scripts/dungeon-pipeline/optimize-environment.test.mjs

@@ -13,6 +13,7 @@ import {
   dungeonEnvironmentFinalPackingArguments,
   dungeonEnvironmentOptimizationArguments,
 } from "./optimize-environment.mjs";
+import { loadRecipe } from "./lib.mjs";
 
 const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 const projectRoot = path.resolve(scriptDirectory, "../..");
@@ -94,6 +95,37 @@ function geometryUvStats(document) {
   return { triangles, degenerateUvTriangles };
 }
 
+function precisionFixture(document, buffer) {
+  const positions = new Float32Array([
+    0, 0, 0, 1, 0, 0, 0, 1, 0,
+    2, 0, 0, 3, 0, 0, 2, 1, 0,
+  ]);
+  const texcoords = new Float32Array([
+    0, 0, 1, 0, 0, 1,
+    0.3141, 0.1, 0.31415, 0.1, 0.3141, 0.9,
+  ]);
+  const primitive = document.createPrimitive()
+    .setAttribute("POSITION", document.createAccessor("precision-positions").setType("VEC3").setArray(positions).setBuffer(buffer))
+    .setAttribute("TEXCOORD_0", document.createAccessor("precision-texcoords").setType("VEC2").setArray(texcoords).setBuffer(buffer))
+    .setIndices(document.createAccessor("precision-indices").setType("SCALAR").setArray(new Uint16Array([0, 1, 2, 3, 4, 5])).setBuffer(buffer));
+  const scene = document.createScene("precision-scene").addChild(
+    document.createNode("precision-mesh").setMesh(document.createMesh("precision-mesh").addPrimitive(primitive)),
+  );
+  document.getRoot().setDefaultScene(scene);
+}
+
+test("Utgarde Pinnacle's recipe opts into spatial boundary preservation", async () => {
+  const recipe = await loadRecipe("utgarde-pinnacle");
+  assert.equal(recipe.visualOptimization?.preserveSpatialBoundaries, true);
+  const args = dungeonEnvironmentOptimizationArguments("source.glb", "optimized.glb", {
+    preserveSpatialBoundaries: recipe.visualOptimization.preserveSpatialBoundaries,
+  });
+  assert.equal(args[args.indexOf("--instance") + 1], "false");
+  assert.equal(args[args.indexOf("--flatten") + 1], "false");
+  assert.equal(args[args.indexOf("--join") + 1], "false");
+  assert.equal(args[args.indexOf("--weld") + 1], "false");
+});
+
 test("WoW visual optimization preserves source texture dimensions and UV topology", async (context) => {
   const width = 4096;
   const height = 8;
@@ -132,10 +164,21 @@ test("WoW visual optimization preserves source texture dimensions and UV topolog
 
   const args = dungeonEnvironmentOptimizationArguments(sourceFile, outputFile);
   assert.deepEqual(args.slice(3), [
-    "--compress", "meshopt", "--meshopt-level", "high",
+    "--compress", "false", "--meshopt-level", "high",
     "--instance", "true", "--instance-min", "3",
+    "--flatten", "true", "--join", "true", "--weld", "true",
     "--simplify", "false", "--texture-compress", "false",
   ]);
+  assert.deepEqual(
+    dungeonEnvironmentOptimizationArguments(sourceFile, outputFile, { preserveSpatialBoundaries: true }).slice(3),
+    [
+      "--compress", "false", "--meshopt-level", "high",
+      "--instance", "false", "--instance-min", "3",
+      "--flatten", "false", "--join", "false", "--weld", "false",
+      "--simplify", "false", "--texture-compress", "false",
+    ],
+    "a recipe can opt out of global instancing and geometry regrouping while retaining the common non-lossy preparation steps",
+  );
 
   const run = spawnSync(process.execPath, [gltfTransformCli, ...args], {
     cwd: projectRoot,
@@ -163,10 +206,9 @@ test("WoW visual optimization preserves source texture dimensions and UV topolog
   const packedFile = path.join(workingDirectory, "meshopt-final.glb");
   const finalPackingArgs = dungeonEnvironmentFinalPackingArguments(outputFile, packedFile);
   assert.deepEqual(finalPackingArgs.slice(3), [
-    "--compress", "meshopt", "--meshopt-level", "high",
-    "--instance", "true", "--instance-min", "3",
-    "--simplify", "false", "--texture-compress", "false",
+    "--level", "high", "--quantize-position", "16", "--quantize-texcoord", "16",
   ]);
+  assert.equal(finalPackingArgs[0], "meshopt");
   const finalPacking = spawnSync(process.execPath, [gltfTransformCli, ...finalPackingArgs], {
     cwd: projectRoot,
     encoding: "utf8",
@@ -200,4 +242,30 @@ test("WoW visual optimization preserves source texture dimensions and UV topolog
     simplifiedStats.triangles < optimizedStats.triangles || simplifiedStats.degenerateUvTriangles > 0,
     "the atlas fixture must detect topology loss or UV collapse when simplification is enabled",
   );
+
+  const precisionSource = path.join(workingDirectory, "precision-source.glb");
+  const precision12File = path.join(workingDirectory, "precision-12bit.glb");
+  const precision16File = path.join(workingDirectory, "precision-16bit.glb");
+  const precisionDocument = new Document();
+  precisionFixture(precisionDocument, precisionDocument.createBuffer());
+  await io.write(precisionSource, precisionDocument);
+  const precisionSourceStats = geometryUvStats(await io.read(precisionSource));
+  assert.deepEqual(precisionSourceStats, { triangles: 2, degenerateUvTriangles: 0 });
+
+  for (const [bits, targetFile] of [[12, precision12File], [16, precision16File]]) {
+    const precisionRun = spawnSync(process.execPath, [gltfTransformCli,
+      "meshopt", precisionSource, targetFile,
+      "--level", "high", "--quantize-position", "16", "--quantize-texcoord", String(bits)], {
+      cwd: projectRoot,
+      encoding: "utf8",
+      windowsHide: true,
+    });
+    assert.equal(precisionRun.status, 0, `${precisionRun.stdout}\n${precisionRun.stderr}`);
+  }
+  const lowPrecisionStats = geometryUvStats(await io.read(precision12File));
+  const highPrecisionStats = geometryUvStats(await io.read(precision16File));
+  assert.equal(lowPrecisionStats.degenerateUvTriangles, 1,
+    "12-bit atlas quantization must collapse the narrowly separated fixture UVs");
+  assert.equal(highPrecisionStats.degenerateUvTriangles, 0,
+    "16-bit atlas quantization must preserve the same non-zero UV triangle");
 });