diff --git a/server/app.go b/server/app.go
index f6b7498..37c7be3 100644
--- a/server/app.go
+++ b/server/app.go
@@ -36,7 +36,7 @@ func newApplication(store *playgroundStore, packages map[string]memoryAsset, mon
return nil, err
}
pages := make(map[string][]byte)
- for _, name := range []string{"home.html", "docs.html", "playground.html", "gltf.html"} {
+ for _, name := range []string{"home.html", "docs.html", "playground.html", "gltf.html", "assets/sculpt/index.html"} {
content, err := webFiles.ReadFile("web/" + name)
if err != nil {
return nil, err
@@ -89,6 +89,8 @@ func (app *application) routes() http.Handler {
mux.HandleFunc("/playground/", app.servePlayground)
mux.HandleFunc("/view/gltf", app.servePage("gltf.html"))
mux.HandleFunc("/view/gltf/", app.servePage("gltf.html"))
+ mux.HandleFunc("/view/sculpt", app.servePage("assets/sculpt/index.html"))
+ mux.HandleFunc("/view/sculpt/", app.servePage("assets/sculpt/index.html"))
mux.HandleFunc("/", app.serveHome)
return app.headers(mux)
}
diff --git a/server/web/assets/sculpt/README.md b/server/web/assets/sculpt/README.md
new file mode 100644
index 0000000..e4fb8e1
--- /dev/null
+++ b/server/web/assets/sculpt/README.md
@@ -0,0 +1,50 @@
+# Yawn Sculpt
+
+Open `/view/sculpt` on the Yawn server (`npm run server`). All example code lives here; the only integration outside this folder is the embedded-page route in `server/app.go`. Rendering imports **only `@yawn/core`**. No handles, third-party scene graph, or remote document storage.
+
+## Workflow
+
+Five brushes: Draw, Inflate, Smooth, Flatten, Grab. X symmetry merges reflected displacement without double deposition. Pen pressure modulates strength through `clamp(gain × pressure^gamma, 0, 1)`; pressure-radius is optional. Mouse/touch use constant pressure. Settings and temporary Shift-smooth / Alt-invert are captured at stroke start. Grab uses a fixed camera-facing drag plane and stroke-start positions.
+
+The compact left icon rail contains brushes, brush settings, undo/redo and Settings. Hover or tap the settings icons to reveal their panels; tap inside to keep one open. Projects and palm rejection live in Settings, with less-used pen/display controls in disclosures. Panels overlay the canvas without resizing it and close on viewport resize. Orientation changes preserve apparent zoom, pan and rotation.
+
+Drag the top-right XYZ gizmo to orbit, or its neighboring pan/zoom icons to move the view. Click an axis endpoint to align the camera; click the facing endpoint again to flip sides. The scene is Y-up. Navigation captures its pointer outside the controls and never sculpts; Escape, lost capture, blur and viewport changes restore the starting view. Navigation waits for an unfinished sculpt transaction to settle. Axis buttons and navigation controls also support keyboard use.
+
+Controls use the locally vendored Basecoat 1.0.2 standalone stylesheet (shadcn-style native HTML components); provenance and license are in `vendor/basecoat/`. No React, UI JavaScript runtime, CDN, or additional build step. Exclude the unmodified vendor stylesheet from formatters. `styles.css` handles layout/density; `Menus` remains the visibility controller.
+
+Palm rejection defaults on: canvas touch is ignored, including outside-menu dismissal, while touch controls remain usable. With rejection off, one finger sculpts and two fingers pan/pinch, rolling back any provisional one-finger sculpt. Right-drag rotates, middle-drag pans, and the wheel zooms. Escape, blur, canceled input and unexpected capture loss roll back the stroke. Undo/redo acts on whole strokes. Native `.yawn-sculpt` projects preserve mesh geometry and density (not history or settings); OBJ export is one-way. Download before leaving—there is no automatic persistence.
+
+## Performance bounds and limitations
+
+| New sphere | Vertices | Triangles | History cap |
+| ---------- | -------: | --------: | ----------: |
+| Simple | 2,562 | 5,120 | 8 MiB |
+| Balanced | 10,242 | 20,480 | 16 MiB |
+| Fine | 40,962 | 81,920 | 32 MiB |
+
+History is capped by bytes and 50 entries, with a separate bounded active-stroke position snapshot. A refitted triangle BVH accelerates picking and brush neighborhoods. Affected normals include all incident faces at brush boundaries. Display quality changes pixel budgets (~0.6/1/2 MP) and frame caps (30/60/60), never mesh density. The 8 MiB shared-row arena is **not** the application's total memory budget.
+
+Input occupies **one 64-byte `sculptSample` row in core's SAB**, not a sample queue. Main publishes the latest endpoint/pressure; subtracting the previously consumed endpoint gives the accumulated movement. Atomic version tokens protect a coherent snapshot and retire only the consumed update, leaving concurrent newer input pending. A dedicated worker samples this slot with its own `requestAnimationFrame` and performs brush raycasts, deformation, normals and BVH refits. It interpolates straight segments between consumed endpoints; this frame-level approximation does not retain intermediate bends or pressure changes. Grab separately preserves the first effective pressure that establishes its influence.
+
+The worker retains at most one unfinished segment plus the latest shared endpoint. Resumable interpolation yields after a soft 4 ms budget or 64 brush attempts; an unfinished segment exceeding 250 ms cancels the provisional stroke. One synchronous dab can exceed the budget, especially for large brushes and Detail. Shared memory avoids an input message queue, not the CPU cost of sculpting. Worker and renderer animation frames are independently scheduled, not a same-frame presentation guarantee.
+
+Worker geometry packets are immutable, transferred, and single-flight; main applies them to its document mirror and acknowledges them. GPU uploads retain their separate single-flight staging guard. Initial picking, document/history operations, and one face-normal/BVH maintenance pass at stroke completion remain on main. Completed geometry/history survive renderer or sculpt-worker failure; unfinished work rolls back. Resize recreates both workers and the shared row because core does not expose surface resizing. Viewport rectangle changes cancel unfinished strokes immediately; new strokes wait for cancellation acknowledgement and the matching renderer size. The sculpt worker stops its animation loop between strokes; core's renderer still has its own loop.
+
+Requires WebGPU, OffscreenCanvas, shared memory, cross-origin isolation, and dedicated-worker animation frames. Observable initialization/upload failures preserve the document and expose Retry plus Save/Export; core does not expose comprehensive device-loss detection. A front-facing brush filter is not geodesic/occlusion isolation on folded surfaces. This is a fixed-topology, single-sphere sculpting studio inspired by Nomad, **not Nomad parity**: no remesh, dynamic topology, layers, painting, multi-object scenes or arbitrary mesh import. Coordinates are bounded to ±8 model units.
+
+## Verification
+
+```sh
+node --test server/web/assets/sculpt/*.test.js
+go test ./server
+```
+
+Tests exercise topology, brute-force picking comparisons, local normals, pressure, symmetry, history, projects, resumable sampling, input transactions and staged uploads. Benchmark output is orb CPU timing, not a low-end hardware or frame-rate guarantee. Physical pen feel, palm behavior and constrained-device performance require real-device testing.
+
+In a fresh browser page, `await (await import('/assets/sculpt/latency-check.js')).check()` replays Draw and Grab at 1, 4, and 16 coalesced samples per animation frame on Balanced-density spheres. It verifies zero main-thread dabs and fixed shared-input storage, and reports main input/packet handling, uploads, release-to-Save-enabled delay and cancellations separately. This synthetic check does not measure physical pen-to-display latency. Unit tests include a real two-thread SAB stress test and deterministic delayed-publication/cancellation races.
+
+For visual checks in the orb, use `agent-browser --headed --webgpu`: this environment's headless WebGPU presentation can be blank even when rendering succeeds. Inspect desktop, narrow portrait/landscape, settings open, error, and modified/undo/redo states. Test save/reopen and rejected files. Use the page's Help for all gestures and shortcuts.
+
+Run `await (await import('/assets/sculpt/browser-check.js')).check()` on a fresh page for transaction and UI regressions. This harness stubs pointer capture; native acceptance must use a separate fresh page. Through the browser CDP endpoint (`agent-browser get cdp-url`), use `Input.dispatchMouseEvent` with `pointerType: 'pen'` to drag each navigation control beyond its bounds. Assert actual `hasPointerCapture(event.pointerId)`, release outside, and verify Escape restores all camera fields. During a visibly deforming stroke, focus Center view, send Escape with `Input.dispatchKeyEvent`, release the pen, and verify exact geometry and unchanged history after settlement.
+
+For rail scrolling, enable `Emulation.setTouchEmulationEnabled` and set a 640×360 CSS-pixel viewport. Verify `(pointer: coarse)` and `scrollHeight > clientHeight`, then use `Input.dispatchTouchEvent` to swipe upward from the center of a brush button. Assert increasing rail `scrollTop`, unchanged selected brush and geometry, and successful tapping of Settings at the bottom. Temporarily overriding rail buttons to `touch-action: none` should reproduce zero scrolling. Do not substitute dispatched DOM pointer events, wheel scrolling, or assigning `scrollTop` for this native gesture check. Browser emulation is not physical-tablet verification.
diff --git a/server/web/assets/sculpt/app.js b/server/web/assets/sculpt/app.js
new file mode 100644
index 0000000..80b7fb4
--- /dev/null
+++ b/server/web/assets/sculpt/app.js
@@ -0,0 +1,573 @@
+import {
+ Sculpt,
+ defaults,
+ pressureValue,
+ saveProject,
+ loadProject,
+ exportOBJ,
+} from "./engine.js";
+import { sphere } from "./mesh.js";
+import { Renderer } from "./renderer.js";
+import { Input } from "./input.js";
+import { StrokeClient } from "./stroke-client.js";
+import { clamp, clampZoom, cameraBasis } from "./math.js";
+import { Menus } from "./menus.js";
+import { Navigation } from "./navigation.js";
+
+const $ = (id) => document.getElementById(id),
+ viewport = $("viewport");
+const settings = { ...defaults },
+ camera = {
+ yaw: 0,
+ pitch: 0,
+ zoom: 1.5,
+ target: [0, 0, 0],
+ color: [0.5, 0.3, 0.2],
+ };
+let engine = new Sculpt(),
+ renderer = null,
+ initializing = false,
+ pendingResize = false,
+ frameRequest = 0,
+ publishing = false;
+let viewRevision = 0,
+ published = -1,
+ generation = 0,
+ lastSize = "",
+ modified = false,
+ saved = engine.mesh.positions.slice(),
+ fileBusy = false;
+const brushes = ["draw", "inflate", "smooth", "flatten", "grab"];
+let viewNavigation, cameraAspect, messageTimer;
+const input = new Input(viewport, {
+ engine: () => engine,
+ processor: () => renderer.processor,
+ camera,
+ settings,
+ ready: () =>
+ !!renderer &&
+ !initializing &&
+ !fileBusy &&
+ !viewNavigation?.busy &&
+ sizeKey() === lastSize,
+ blocked: () => !!viewNavigation?.busy,
+ navigation: () => "sculpt",
+ palmRejection: () => $("palm-rejection").checked,
+ schedule,
+ invalidate,
+ changed: updateUI,
+ committed: checkModified,
+ message,
+ cursor,
+ pressure,
+});
+const menus = new Menus(
+ () => !interactionBusy(),
+ (e) => e.target === viewport.querySelector("canvas") && input.rejectsTouch(e),
+);
+viewNavigation = new Navigation($("view-navigation"), viewport, {
+ camera,
+ ready: () =>
+ !!renderer &&
+ !initializing &&
+ !fileBusy &&
+ !input.busy &&
+ sizeKey() === lastSize &&
+ !document.querySelector("dialog[open]"),
+ start: () => {
+ menus.close(false);
+ cursor(null);
+ },
+ changed: updateUI,
+ invalidate,
+});
+function interactionBusy() {
+ return input.busy || !!viewNavigation?.busy;
+}
+$("palm-rejection").onchange = () => {
+ if ($("palm-rejection").checked && input.active?.type === "touch")
+ input.cancel();
+};
+
+function message(text) {
+ $("status").textContent = text;
+ $("status").classList.add("visible");
+ clearTimeout(messageTimer);
+ messageTimer = setTimeout(
+ () => $("status").classList.remove("visible"),
+ 3500,
+ );
+}
+function checkModified() {
+ modified = !engine.mesh.positions.every((v, i) => v === saved[i]);
+ updateUI();
+}
+function updateUI() {
+ const busy = interactionBusy() || initializing || fileBusy;
+ $("undo").disabled = busy || !engine.undoStack.length;
+ $("redo").disabled = busy || !engine.redoStack.length;
+ for (const id of ["new", "open", "quality"]) $(id).disabled = busy;
+ for (const id of ["save", "export"])
+ $(id).disabled = interactionBusy() || fileBusy;
+ $("modified").hidden = !modified;
+ if (pendingResize && !resizeTimer && !interactionBusy() && !initializing) {
+ queueMicrotask(() => {
+ if (pendingResize && !resizeTimer) recreate();
+ });
+ }
+}
+function cursor(sample) {
+ const el = $("cursor");
+ el.hidden = !sample || !renderer || initializing || !!viewNavigation?.busy;
+ if (!sample) return;
+ const s = engine.stroke?.settings ?? settings;
+ const p = pressureValue(sample.pressure, s.gain, s.gamma),
+ radius =
+ (s.radius *
+ (s.pressureRadius ? 0.25 + 0.75 * p : 1) *
+ viewport.clientHeight) /
+ (2 * camera.zoom);
+ el.style.width = el.style.height = `${radius * 2}px`;
+ el.style.left = `${sample.x}px`;
+ el.style.top = `${sample.y}px`;
+}
+function pressure(value) {
+ $("pen-state").textContent =
+ value === null ? "Mouse / touch" : `Pen · ${Math.round(value * 100)}%`;
+ $("pressure-fill").style.width =
+ `${value === null ? 0 : pressureValue(value, settings.gain, settings.gamma) * 100}%`;
+}
+function invalidate() {
+ viewRevision++;
+ schedule();
+}
+function schedule() {
+ if (!frameRequest) frameRequest = requestAnimationFrame(tick);
+}
+function fail(error) {
+ viewNavigation?.cancel();
+ generation++;
+ renderer?.dispose();
+ renderer = null;
+ engine.markAll();
+ input.cancel();
+ $("loading").hidden = true;
+ $("error").hidden = false;
+ console.error(error);
+ $("error-detail").textContent =
+ "The canvas could not start. Try again, or open this page in an up-to-date browser. You can still download your project in Settings.";
+ message("Canvas paused. Your completed work is still here.");
+ updateUI();
+}
+function tick() {
+ frameRequest = 0;
+ viewNavigation.checkViewport();
+ viewNavigation.render();
+ input.checkViewport();
+ if (
+ renderer &&
+ !initializing &&
+ !publishing &&
+ (published !== viewRevision || engine.dirty.size)
+ ) {
+ const active = renderer,
+ token = generation,
+ revision = viewRevision;
+ const snapshot = {
+ ...camera,
+ target: camera.target.slice(),
+ color: camera.color.slice(),
+ };
+ publishing = true;
+ active
+ .publish(engine, snapshot)
+ .then(() => {
+ if (token === generation) published = revision;
+ })
+ .catch((error) => {
+ if (token === generation) fail(error);
+ })
+ .finally(() => {
+ publishing = false;
+ if (
+ renderer &&
+ !initializing &&
+ (published !== viewRevision || engine.dirty.size)
+ )
+ schedule();
+ });
+ }
+}
+function sizeKey() {
+ const rect = viewport.getBoundingClientRect();
+ return `${rect.width}:${rect.height}:${devicePixelRatio}:${$("quality").value}`;
+}
+async function recreate() {
+ if (interactionBusy() || initializing) {
+ pendingResize = true;
+ return;
+ }
+ if (!viewport.clientWidth || !viewport.clientHeight) return;
+ const aspect = viewport.clientWidth / viewport.clientHeight;
+ if (cameraAspect)
+ camera.zoom *= Math.min(1, cameraAspect) / Math.min(1, aspect);
+ cameraAspect = aspect;
+ clearTimeout(resizeTimer);
+ resizeTimer = 0;
+ pendingResize = false;
+ initializing = true;
+ const token = ++generation;
+ lastSize = sizeKey();
+ renderer?.dispose();
+ renderer = null;
+ $("loading").hidden = false;
+ $("error").hidden = true;
+ cursor(null);
+ updateUI();
+ try {
+ if (!crossOriginIsolated || typeof SharedArrayBuffer === "undefined")
+ throw new Error("Cross-origin isolation is required");
+ if (!navigator.gpu) throw new Error("WebGPU is not available");
+ const canvas = document.createElement("canvas");
+ canvas.setAttribute("aria-label", "3D sculpt");
+ viewport.querySelector("canvas").replaceWith(canvas);
+ const next = await Renderer.create(
+ canvas,
+ engine.mesh,
+ camera,
+ $("quality").value,
+ );
+ if (token !== generation) {
+ next.dispose();
+ return;
+ }
+ renderer = next;
+ next.processor = new StrokeClient(
+ next.sample,
+ engine.mesh.level,
+ (error) => {
+ if (token === generation) fail(error);
+ },
+ );
+ await next.processor.ready;
+ if (token !== generation) {
+ next.dispose();
+ return;
+ }
+ engine.markAll();
+ published = -1;
+ $("loading").hidden = true;
+ if (sizeKey() !== lastSize) resized();
+ else message("Ready to sculpt");
+ } catch (error) {
+ if (token === generation) fail(error);
+ } finally {
+ initializing = false;
+ updateUI();
+ if (renderer) invalidate();
+ }
+}
+function frameModel() {
+ cameraAspect = viewport.clientWidth / viewport.clientHeight;
+ const bounds = engine.bvh.root;
+ camera.target = bounds.min.map((v, k) => (v + bounds.max[k]) / 2);
+ const { right, up } = cameraBasis(camera.yaw, camera.pitch);
+ const half = bounds.max.map((v, k) => (v - bounds.min[k]) / 2);
+ const width = half.reduce((sum, v, k) => sum + v * Math.abs(right[k]), 0);
+ const height = half.reduce((sum, v, k) => sum + v * Math.abs(up[k]), 0);
+ camera.zoom = Math.max(
+ 0.2,
+ 1.45 *
+ Math.max(height, (width * viewport.clientHeight) / viewport.clientWidth),
+ );
+ invalidate();
+}
+function replace(mesh, name) {
+ engine = new Sculpt(mesh, 2 ** (mesh.level - 4) * 8 * 1048576);
+ saved = mesh.positions.slice();
+ modified = false;
+ $("document-name").textContent = name;
+ camera.yaw = 0;
+ camera.pitch = 0;
+ frameModel();
+ recreate();
+ updateUI();
+}
+function download(text, name, type) {
+ const url = URL.createObjectURL(new Blob([text], { type }));
+ const a = document.createElement("a");
+ a.href = url;
+ a.download = name;
+ a.click();
+ setTimeout(() => URL.revokeObjectURL(url), 1000);
+}
+$("save").onclick = () => {
+ if (interactionBusy() || fileBusy) return;
+ download(saveProject(engine.mesh), "sculpt.yawn-sculpt", "application/json");
+ saved = engine.mesh.positions.slice();
+ modified = false;
+ updateUI();
+ message("Project downloaded");
+};
+$("export").onclick = () => {
+ if (interactionBusy() || fileBusy) return;
+ download(exportOBJ(engine.mesh), "sculpt.obj", "text/plain");
+ message("Model downloaded");
+};
+$("open").onclick = () => {
+ if (!interactionBusy() && !initializing) $("file").click();
+};
+$("file").onchange = async () => {
+ const file = $("file").files[0];
+ $("file").value = "";
+ if (!file || interactionBusy() || initializing) return;
+ fileBusy = true;
+ updateUI();
+ try {
+ if (file.size > 8 * 1048576)
+ throw new Error("Project exceeds the 8 MiB limit");
+ const mesh = loadProject(await file.text());
+ if (
+ modified &&
+ !confirm(
+ "Replace your current sculpt? Download it first if you want to keep it.",
+ )
+ )
+ return;
+ replace(mesh, file.name.replace(/\.yawn-sculpt$/, ""));
+ } catch (error) {
+ console.error(error);
+ message(
+ "Could not open this project. Choose a project downloaded from Sculpt.",
+ );
+ } finally {
+ fileBusy = false;
+ updateUI();
+ }
+};
+$("new").onclick = () => {
+ if (interactionBusy() || initializing) return;
+ $("new-warning").textContent = modified
+ ? "This replaces your unsaved sculpt. Save it first to keep it."
+ : "Choose how much detail you want.";
+ $("new-dialog").returnValue = "cancel";
+ $("new-dialog").showModal();
+};
+$("new-dialog").addEventListener("close", () => {
+ if ($("new-dialog").returnValue === "create")
+ replace(sphere(Number($("density").value)), "Untitled sphere");
+});
+$("help").onclick = () => $("help-dialog").showModal();
+$("undo").onclick = () => {
+ if (!interactionBusy() && engine.restore()) {
+ checkModified();
+ invalidate();
+ message("Undo");
+ }
+};
+$("redo").onclick = () => {
+ if (!interactionBusy() && engine.restore(true)) {
+ checkModified();
+ invalidate();
+ message("Redo");
+ }
+};
+$("frame").onclick = () => {
+ if (!interactionBusy()) frameModel();
+};
+function chooseBrush(name) {
+ if (interactionBusy()) return;
+ settings.brush = name;
+ document
+ .querySelectorAll("[data-brush]")
+ .forEach((b) =>
+ b.setAttribute("aria-pressed", String(b.dataset.brush === name)),
+ );
+ $("brush-title").textContent = name[0].toUpperCase() + name.slice(1);
+ $("invert").disabled = !["draw", "inflate"].includes(name);
+}
+document
+ .querySelectorAll("[data-brush]")
+ .forEach((b) => (b.onclick = () => chooseBrush(b.dataset.brush)));
+function settingsUI() {
+ for (const id of ["radius", "strength", "gain", "gamma"]) {
+ settings[id] = Number($(id).value);
+ $(id).style.setProperty(
+ "--slider-value",
+ `${(100 * (settings[id] - Number($(id).min))) / (Number($(id).max) - Number($(id).min))}%`,
+ );
+ $(id + "-value").textContent =
+ id === "radius"
+ ? `${Math.round((settings[id] / 0.6) * 100)}%`
+ : id === "strength"
+ ? `${Math.round(settings[id] * 100)}%`
+ : settings[id].toFixed(2) + (id === "gain" ? "×" : "");
+ }
+ for (const id of ["symmetry", "invert", "pressureRadius"])
+ settings[id] = $(id).checked;
+ $("curve-line").setAttribute(
+ "d",
+ Array.from(
+ { length: 41 },
+ (_, i) =>
+ `${i ? "L" : "M"}${i * 5} ${53 - 52 * pressureValue(i / 40, settings.gain, settings.gamma)}`,
+ ).join(" "),
+ );
+}
+for (const id of [
+ "radius",
+ "strength",
+ "gain",
+ "gamma",
+ "symmetry",
+ "invert",
+ "pressureRadius",
+])
+ $(id).addEventListener("input", settingsUI);
+$("reset-pressure").onclick = () => {
+ $("gain").value = "1";
+ $("gamma").value = "1";
+ $("pressureRadius").checked = false;
+ settingsUI();
+};
+document.querySelectorAll("[data-color]").forEach(
+ (b) =>
+ (b.onclick = () => {
+ camera.color = b.dataset.color.split(",").map(Number);
+ document
+ .querySelectorAll("[data-color]")
+ .forEach((x) => x.setAttribute("aria-pressed", String(x === b)));
+ invalidate();
+ }),
+);
+$("fullscreen").hidden = !document.fullscreenEnabled;
+$("fullscreen").onclick = async () => {
+ try {
+ if (document.fullscreenElement) await document.exitFullscreen();
+ else await document.documentElement.requestFullscreen();
+ } catch {
+ message("Full screen isn't available in this browser.");
+ }
+};
+document.addEventListener("fullscreenchange", () => {
+ $("fullscreen").textContent = document.fullscreenElement
+ ? "Exit full screen"
+ : "Full screen";
+});
+$("quality").onchange = () => {
+ pendingResize = true;
+ recreate();
+};
+$("retry").onclick = recreate;
+let resizeTimer;
+function resized() {
+ viewNavigation.checkViewport();
+ clearTimeout(resizeTimer);
+ resizeTimer = setTimeout(() => {
+ resizeTimer = 0;
+ if (sizeKey() !== lastSize) {
+ pendingResize = true;
+ recreate();
+ }
+ }, 200);
+ const unchanged = input.checkViewport();
+ if (sizeKey() !== lastSize) {
+ cursor(null);
+ if (unchanged) message("Updating viewport…");
+ }
+}
+new ResizeObserver(resized).observe(viewport);
+window.addEventListener("resize", resized);
+function watchDpr() {
+ const query = matchMedia(`(resolution: ${devicePixelRatio}dppx)`);
+ query.addEventListener(
+ "change",
+ () => {
+ resized();
+ watchDpr();
+ },
+ { once: true },
+ );
+}
+watchDpr();
+window.addEventListener("beforeunload", (e) => {
+ if (modified || engine.stroke) {
+ e.preventDefault();
+ e.returnValue = "";
+ }
+});
+document.addEventListener("visibilitychange", () => {
+ if (document.hidden) input.cancel();
+ const active = renderer,
+ token = generation;
+ if (!active) return;
+ (document.hidden ? active.core.pause() : active.core.play())
+ .then(() => {
+ if (token === generation && !document.hidden) invalidate();
+ })
+ .catch((error) => {
+ if (token === generation) fail(error);
+ });
+});
+window.addEventListener("keydown", (e) => {
+ if (e.key === "Escape" && !document.querySelector("dialog[open]")) {
+ viewNavigation.cancel();
+ input.cancel();
+ return;
+ }
+ if (
+ document.querySelector("dialog[open]") ||
+ e.target.closest?.(".panel,.tool-rail,#view-navigation") ||
+ /INPUT|SELECT|TEXTAREA/.test(e.target.tagName) ||
+ e.target.isContentEditable
+ )
+ return;
+ if (interactionBusy()) return;
+ const key = e.key.toLowerCase(),
+ mod = e.ctrlKey || e.metaKey;
+ if (mod && ["z", "s", "o", "y"].includes(key)) {
+ e.preventDefault();
+ $(
+ key === "s"
+ ? "save"
+ : key === "o"
+ ? "open"
+ : key === "y" || e.shiftKey
+ ? "redo"
+ : "undo",
+ ).click();
+ return;
+ }
+ if (mod || e.altKey) return;
+ if (/^[1-5]$/.test(key)) chooseBrush(brushes[Number(key) - 1]);
+ else if (key === "f") $("frame").click();
+ else if (key === "?") $("help").click();
+ else if (key === "[" || key === "]") {
+ $("radius").value = String(
+ clamp(settings.radius + (key === "]" ? 0.01 : -0.01), 0.04, 0.6),
+ );
+ settingsUI();
+ } else if (
+ ["arrowleft", "arrowright", "arrowup", "arrowdown", "+", "=", "-"].includes(
+ key,
+ )
+ ) {
+ e.preventDefault();
+ if (key === "arrowleft") camera.yaw -= 0.1;
+ else if (key === "arrowright") camera.yaw += 0.1;
+ else if (key === "arrowup")
+ camera.pitch = clamp(camera.pitch + 0.1, -Math.PI / 2, Math.PI / 2);
+ else if (key === "arrowdown")
+ camera.pitch = clamp(camera.pitch - 0.1, -Math.PI / 2, Math.PI / 2);
+ else
+ camera.zoom = clampZoom(
+ camera.zoom * (key === "-" ? 1.1 : 0.9),
+ viewport.getBoundingClientRect(),
+ );
+ invalidate();
+ }
+});
+settingsUI();
+frameModel();
+updateUI();
+recreate();
diff --git a/server/web/assets/sculpt/browser-check.js b/server/web/assets/sculpt/browser-check.js
new file mode 100644
index 0000000..9e9d8d8
--- /dev/null
+++ b/server/web/assets/sculpt/browser-check.js
@@ -0,0 +1,492 @@
+// Run explicitly in a fresh /view/sculpt page:
+// await (await import('/assets/sculpt/browser-check.js')).check()
+// Synthetic input checks logic, not physical pen feel. Hooks are always restored.
+import { Renderer } from "./renderer.js";
+import { Navigation } from "./navigation.js";
+
+export async function check() {
+ const $ = (id) => document.getElementById(id),
+ results = [];
+ const assert = (value, message) => {
+ if (!value) throw new Error(message);
+ };
+ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+ const wait = async (fn) => {
+ const start = performance.now();
+ while (!fn()) {
+ if (performance.now() - start > 15000)
+ throw new Error("Timed out waiting for UI");
+ await sleep(25);
+ }
+ };
+ const viewport = $("viewport"),
+ capture = viewport.setPointerCapture,
+ createURL = URL.createObjectURL,
+ publish = Renderer.prototype.publish;
+ const navRoot = $("view-navigation"),
+ navCapture = navRoot.setPointerCapture,
+ navRender = Navigation.prototype.render;
+ let nav;
+ navRoot.setPointerCapture = () => {};
+ Navigation.prototype.render = function () {
+ nav = this;
+ return navRender.call(this);
+ };
+ let blob,
+ engine,
+ camera,
+ processor,
+ publications = 0,
+ failNext = false;
+ viewport.setPointerCapture = () => {};
+ URL.createObjectURL = function (value) {
+ blob = value;
+ return createURL.call(this, value);
+ };
+ Renderer.prototype.publish = function (...args) {
+ engine = args[0];
+ camera = args[1];
+ processor = this.processor;
+ publications++;
+ if (failNext) {
+ failNext = false;
+ return Promise.reject(new Error("Synthetic upload failure"));
+ }
+ return publish.apply(this, args);
+ };
+ const saved = async () => {
+ await wait(() => !$("save").disabled);
+ $("save").click();
+ return JSON.parse(await blob.text());
+ };
+ const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+ const pointer = (type, x, y, pressure = 0.7, pointerType = "pen", id = 7) => {
+ const r = viewport.getBoundingClientRect();
+ viewport.querySelector("canvas").dispatchEvent(
+ new PointerEvent(type, {
+ bubbles: true,
+ pointerId: id,
+ pointerType,
+ clientX: r.left + r.width * x,
+ clientY: r.top + r.height * y,
+ pressure,
+ button: 0,
+ buttons: type === "pointerup" ? 0 : 1,
+ }),
+ );
+ };
+ const stroke = async (p) => {
+ pointer("pointerdown", 0.55, 0.44, p);
+ pointer("pointermove", 0.59, 0.51, p);
+ pointer("pointerup", 0.59, 0.51, 0);
+ await wait(() => !$("save").disabled);
+ await sleep(100);
+ };
+ try {
+ await wait(() => $("loading").hidden && $("error").hidden);
+ const initialCanvas = viewport.querySelector("canvas");
+ const bounds = JSON.stringify(viewport.getBoundingClientRect());
+ assert(
+ $("tools-panel").hidden && $("inspector").hidden,
+ "Panels must start closed",
+ );
+ const hover = (id, type = "pointerenter") =>
+ $(id).dispatchEvent(
+ new PointerEvent(type, { pointerType: "pen", buttons: 0 }),
+ );
+ hover("tools-toggle");
+ assert(!$("tools-panel").hidden, "Pen hover did not reveal brushes");
+ const palette = $("tools-panel").getBoundingClientRect();
+ assert(
+ palette.left >= 50 && palette.width <= 216,
+ "Brush popover overlaps rail or has oversized width",
+ );
+ assert(
+ document.querySelectorAll(".tool-rail [data-brush] svg").length === 5,
+ "Brush rail must have five icons",
+ );
+ assert(
+ $("radius").style.getPropertyValue("--slider-value").startsWith("32.14"),
+ "Basecoat size fill is not synchronized",
+ );
+ pointer("pointerdown", 0.8, 0.8, 1, "touch", 91);
+ pointer("pointermove", 0.82, 0.81, 1, "touch", 91);
+ pointer("pointerup", 0.82, 0.81, 0, "touch", 91);
+ assert(!$("tools-panel").hidden, "Rejected palm dismissed hover tools");
+ hover("tools-toggle", "pointerleave");
+ await sleep(100);
+ hover("tools-panel");
+ await sleep(300);
+ assert(!$("tools-panel").hidden, "Crossing panel gap closed tools");
+ hover("tools-panel", "pointerleave");
+ await sleep(300);
+ assert($("tools-panel").hidden, "Hover panel did not dismiss");
+ $("settings-toggle").click();
+ hover("settings-toggle", "pointerleave");
+ await sleep(300);
+ assert(!$("inspector").hidden, "Tapped panel did not stay open");
+ pointer("pointerdown", 0.2, 0.8, 1, "touch", 91);
+ pointer("pointerup", 0.2, 0.8, 0, "touch", 91);
+ assert(!$("inspector").hidden, "Rejected palm dismissed pinned settings");
+ $("pen-settings").open = true;
+ assert(
+ $("reset-pressure").getBoundingClientRect().bottom <=
+ $("pen-settings").nextElementSibling.getBoundingClientRect().top,
+ "Expanded pen controls overlap display disclosure",
+ );
+ $("gain").dispatchEvent(
+ new PointerEvent("pointerdown", { pointerType: "pen", bubbles: true }),
+ );
+ pointer("pointerdown", 0.2, 0.8, 1, "touch", 91);
+ assert(
+ !$("inspector").hidden,
+ "Rejected palm interrupted slider interaction",
+ );
+ pointer("pointerup", 0.2, 0.8, 0, "touch", 91);
+ $("gain").focus();
+ $("gain").dispatchEvent(
+ new KeyboardEvent("keydown", { key: "Escape", bubbles: true }),
+ );
+ assert(
+ $("inspector").hidden && document.activeElement === $("settings-toggle"),
+ "Escape did not restore launcher focus",
+ );
+ $("pen-settings").open = false;
+ assert(
+ initialCanvas === viewport.querySelector("canvas") &&
+ bounds === JSON.stringify(viewport.getBoundingClientRect()),
+ "Menus resized/replaced canvas",
+ );
+ results.push(
+ "pen hover / gap grace / auto-hide / tap pin / palm-safe panels and slider / Escape focus / unchanged canvas",
+ );
+ $("new").click();
+ $("density").value = "4";
+ $("new-dialog").close("create");
+ await wait(
+ () =>
+ viewport.querySelector("canvas") !== initialCanvas &&
+ $("loading").hidden &&
+ !$("new").disabled,
+ );
+ await sleep(100);
+ const original = await saved();
+ await stroke(0);
+ assert(same(original, await saved()), "Zero pen pressure altered geometry");
+ results.push("zero pen pressure");
+ await stroke(0.8);
+ const edited = await saved();
+ assert(!same(original, edited), "Pen stroke did not deform mesh");
+ assert(!$("undo").disabled, "Undo unavailable");
+ $("undo").click();
+ assert(same(original, await saved()), "Undo not exact");
+ $("redo").click();
+ assert(same(edited, await saved()), "Redo not exact");
+ results.push("pen sculpt / exact undo / redo");
+ pointer("pointerdown", 0.48, 0.5, 0.9);
+ await sleep(100);
+ pointer("pointermove", 0.52, 0.55, 0.9);
+ viewport.dispatchEvent(new PointerEvent("pointercancel", { pointerId: 7 }));
+ assert(same(edited, await saved()), "Cancel did not restore mesh");
+ results.push("pointer cancellation");
+ for (const settling of [false, true]) {
+ const before = engine.mesh.positions.slice();
+ const history = [...engine.undoStack];
+ const redoHistory = [...engine.redoStack];
+ pointer("pointerdown", 0.48, 0.5, 0.9);
+ pointer("pointermove", 0.56, 0.55, 0.9);
+ await wait(() => engine.mesh.positions.some((v, i) => v !== before[i]));
+ $("frame").focus();
+ if (settling) pointer("pointerup", 0.56, 0.55, 0);
+ $("frame").dispatchEvent(
+ new KeyboardEvent("keydown", {
+ key: "Escape",
+ bubbles: true,
+ cancelable: true,
+ }),
+ );
+ assert(
+ engine.mesh.positions.every((v, i) => v === before[i]),
+ "Focused navigation swallowed sculpt cancellation",
+ );
+ if (!settling) pointer("pointerup", 0.56, 0.55, 0);
+ await wait(() => !$("save").disabled);
+ assert(
+ engine.mesh.positions.every((v, i) => v === before[i]) &&
+ engine.undoStack.length === history.length &&
+ engine.undoStack.every((v, i) => v === history[i]) &&
+ engine.redoStack.length === redoHistory.length &&
+ engine.redoStack.every((v, i) => v === redoHistory[i]),
+ "Focused navigation cancellation changed geometry/history after settlement",
+ );
+ }
+ results.push(
+ "focused navigation Escape rolls back active and settling sculpt",
+ );
+ assert($("palm-rejection").checked, "Palm rejection must default on");
+ await sleep(100);
+ const beforePalm = structuredClone(camera);
+ pointer("pointerdown", 0.48, 0.5, 1, "touch", 1);
+ pointer("pointermove", 0.58, 0.54, 1, "touch", 1);
+ pointer("pointerup", 0.58, 0.54, 0, "touch", 1);
+ await sleep(100);
+ assert(
+ same(beforePalm, camera) && same(edited, await saved()),
+ "Palm changed canvas",
+ );
+ results.push("default palm rejection");
+ $("palm-rejection").checked = false;
+ $("palm-rejection").dispatchEvent(new Event("change"));
+ pointer("pointerdown", 0.48, 0.5, 1, "touch", 1);
+ await sleep(100);
+ pointer("pointerdown", 0.56, 0.52, 1, "touch", 2);
+ pointer("pointermove", 0.58, 0.54, 1, "touch", 2);
+ pointer("pointerup", 0.48, 0.5, 0, "touch", 1);
+ pointer("pointerup", 0.58, 0.54, 0, "touch", 2);
+ assert(same(edited, await saved()), "Pinch left sculpt marks");
+ await wait(() => camera.zoom !== beforePalm.zoom);
+ $("palm-rejection").checked = true;
+ $("palm-rejection").dispatchEvent(new Event("change"));
+ results.push("two-touch rollback/navigation");
+ $("quality").value = "economy";
+ $("quality").dispatchEvent(new Event("change"));
+ await wait(() => $("loading").hidden && !$("quality").disabled);
+ assert(same(edited, await saved()), "Quality changed geometry");
+ assert(!$("undo").disabled, "Quality lost history");
+ results.push("quality preserves mesh/history");
+ const oldCanvas = viewport.querySelector("canvas");
+ viewport.style.width = "85%";
+ await wait(
+ () =>
+ viewport.querySelector("canvas") !== oldCanvas && $("loading").hidden,
+ );
+ assert(same(edited, await saved()), "Resize changed geometry");
+ assert(!$("undo").disabled, "Resize lost history");
+ const smallCanvas = viewport.querySelector("canvas");
+ viewport.style.width = "";
+ await wait(
+ () =>
+ viewport.querySelector("canvas") !== smallCanvas && $("loading").hidden,
+ );
+ results.push("resize preserves mesh/history");
+ const positions = engine.mesh.positions.slice(),
+ undo = [...engine.undoStack],
+ redo = [...engine.redoStack],
+ bytes = engine.historyBytes;
+ pointer("pointerdown", 0.48, 0.5, 0.9);
+ pointer("pointermove", 0.56, 0.55, 0.9);
+ await wait(() => engine.mesh.positions.some((v, i) => v !== positions[i]));
+ const beforeResize = viewport.querySelector("canvas");
+ viewport.style.width = "90%";
+ // Release in this task, before ResizeObserver or the 200 ms debounce runs.
+ pointer("pointerup", 0.56, 0.55, 0);
+ const exact = () =>
+ engine.mesh.positions.every((v, i) => v === positions[i]) &&
+ engine.undoStack.length === undo.length &&
+ engine.undoStack.every((v, i) => v === undo[i]) &&
+ engine.redoStack.length === redo.length &&
+ engine.redoStack.every((v, i) => v === redo[i]) &&
+ engine.historyBytes === bytes;
+ assert(
+ exact(),
+ "Resize/release committed or retained provisional geometry",
+ );
+ pointer("pointerdown", 0.5, 0.5, 0.9);
+ assert(!engine.stroke, "Stroke started against a stale renderer size");
+ pointer("pointerup", 0.5, 0.5, 0);
+ await wait(
+ () =>
+ viewport.querySelector("canvas") !== beforeResize &&
+ $("loading").hidden,
+ );
+ assert(exact(), "Resize recreation changed history or geometry");
+ await stroke(0.8);
+ assert(
+ !same(edited, await saved()),
+ "New stroke failed after resize recovery",
+ );
+ $("undo").click();
+ assert(same(edited, await saved()), "Recovery stroke undo failed");
+ const resizedCanvas = viewport.querySelector("canvas");
+ viewport.style.width = "";
+ await wait(
+ () =>
+ viewport.querySelector("canvas") !== resizedCanvas &&
+ $("loading").hidden,
+ );
+ results.push(
+ "resize during stroke: immediate exact rollback / stale-start gate / recovery",
+ );
+ const dt = new DataTransfer();
+ dt.items.add(new File(['{"version":42}'], "invalid.yawn-sculpt"));
+ $("file").files = dt.files;
+ $("file").dispatchEvent(new Event("change"));
+ await wait(() => !$("open").disabled);
+ assert(same(edited, await saved()), "Invalid project replaced geometry");
+ results.push("invalid project preservation");
+ const native = JSON.stringify(edited),
+ valid = new DataTransfer();
+ valid.items.add(new File([native], "roundtrip.yawn-sculpt"));
+ $("file").files = valid.files;
+ $("file").dispatchEvent(new Event("change"));
+ await wait(() => !$("open").disabled && $("loading").hidden);
+ assert(same(edited, await saved()), "Project roundtrip changed geometry");
+ results.push("native project roundtrip");
+ $("export").click();
+ const obj = await blob.text();
+ assert(
+ obj.split("\n").filter((l) => l.startsWith("v ")).length === 2562,
+ "OBJ vertex count",
+ );
+ assert(
+ obj.split("\n").filter((l) => l.startsWith("f ")).length === 5120,
+ "OBJ face count",
+ );
+ results.push("OBJ export");
+ const navPointer = (mode, type, x = 100, y = 100) =>
+ document.querySelector(`[data-nav="${mode}"]`).dispatchEvent(
+ new PointerEvent(type, {
+ bubbles: true,
+ pointerType: "pen",
+ pointerId: 90,
+ button: 0,
+ clientX: x,
+ clientY: y,
+ }),
+ );
+ await wait(() => nav);
+ for (const mode of ["orbit", "pan", "zoom"]) {
+ const before = structuredClone(nav.host.camera);
+ navPointer(mode, "pointerdown");
+ assert(nav.busy, "Navigation did not capture gesture");
+ pointer("pointerdown", 0.5, 0.5);
+ assert(!engine.stroke, "Canvas sculpt started during navigation");
+ viewport.dispatchEvent(
+ new WheelEvent("wheel", {
+ deltaY: 200,
+ bubbles: true,
+ cancelable: true,
+ }),
+ );
+ assert(same(nav.host.camera, before), "Wheel competed with navigation");
+ navPointer(mode, "pointermove", 126, 119);
+ assert(!same(nav.host.camera, before), "Navigation did not move camera");
+ navRoot.dispatchEvent(
+ new KeyboardEvent("keydown", { key: "Escape", bubbles: true }),
+ );
+ assert(
+ !nav.busy && same(nav.host.camera, before),
+ "Escape did not restore camera",
+ );
+ navPointer(mode, "pointerdown");
+ navPointer(mode, "pointerup", 126, 119);
+ assert(
+ !nav.busy && !same(nav.host.camera, before),
+ "Navigation release did not finish",
+ );
+ await sleep(80);
+ }
+ const navBefore = structuredClone(nav.host.camera);
+ pointer("pointerdown", 0.5, 0.5);
+ navPointer("orbit", "pointerdown");
+ assert(!nav.busy, "Navigation started during sculpt");
+ pointer("pointerup", 0.5, 0.5, 0);
+ navPointer("orbit", "pointerdown");
+ assert(!nav.busy, "Navigation started during worker settlement");
+ await wait(() => !$("save").disabled);
+ $("undo").click();
+ assert(
+ same(nav.host.camera, navBefore),
+ "Rejected navigation changed camera",
+ );
+ const viewBefore = structuredClone(camera),
+ aspectBefore = viewport.clientWidth / viewport.clientHeight;
+ const shortZoom = viewBefore.zoom * Math.min(1, aspectBefore);
+ const resizeTo = async (width, height) => {
+ const previous = viewport.querySelector("canvas");
+ viewport.style.width = width;
+ viewport.style.height = height;
+ await wait(
+ () =>
+ viewport.querySelector("canvas") !== previous && $("loading").hidden,
+ );
+ await sleep(100);
+ };
+ await resizeTo("600px", "1000px");
+ assert(
+ Math.abs(camera.zoom * 0.6 - shortZoom) < 1e-9,
+ "Portrait changed apparent zoom",
+ );
+ assert(
+ same(camera.target, viewBefore.target) &&
+ camera.yaw === viewBefore.yaw &&
+ camera.pitch === viewBefore.pitch,
+ "Orientation reset camera pose",
+ );
+ await resizeTo("", "");
+ assert(
+ Math.abs(camera.zoom - viewBefore.zoom) < 1e-9,
+ "Orientation roundtrip changed zoom",
+ );
+ assert(same(edited, await saved()), "Navigation changed geometry");
+ document.querySelector('[data-brush="draw"]').click();
+ results.push(
+ "direct navigation / mutual exclusion / Escape rollback / orientation / geometry intact",
+ );
+ await sleep(300);
+ const idle = publications;
+ await sleep(500);
+ assert(publications === idle, "Idle repeated publications");
+ results.push("idle: zero publications over 500 ms");
+ failNext = true;
+ $("frame").click();
+ await wait(() => !$("error").hidden);
+ assert(!$("save").disabled, "Error disabled save");
+ assert(same(edited, await saved()), "Upload failure lost geometry");
+ $("retry").click();
+ await wait(() => $("loading").hidden && $("error").hidden);
+ assert(same(edited, await saved()), "Retry lost geometry");
+ results.push("upload failure / save / retry");
+ const recovered = engine.mesh.positions.slice();
+ pointer("pointerdown", 0.5, 0.5, 0.9);
+ await wait(() => engine.mesh.positions.some((v, i) => v !== recovered[i]));
+ // Publication captures the renderer's client after recreation; geometry can
+ // arrive first. Never inject into the previous, already-disposed worker.
+ await wait(() => processor && !processor.disposed && processor.job);
+ const oldProcessor = processor;
+ oldProcessor.worker.dispatchEvent(new Event("error"));
+ await wait(() => !$("error").hidden && !$("save").disabled);
+ assert(
+ same(edited, await saved()),
+ "Worker failure retained provisional geometry",
+ );
+ assert(oldProcessor.disposed, "Failed worker was not terminated");
+ $("retry").click();
+ await wait(
+ () =>
+ $("loading").hidden && $("error").hidden && processor !== oldProcessor,
+ );
+ await stroke(0.8);
+ assert(
+ !same(edited, await saved()),
+ "New worker failed to sculpt after retry",
+ );
+ $("undo").click();
+ assert(same(edited, await saved()), "Recovered worker undo failed");
+ results.push(
+ "sculpt worker failure / exact rollback / new worker / sculpt / undo",
+ );
+ return {
+ passed: results.length,
+ checks: results,
+ publications,
+ physicalPenVerified: false,
+ };
+ } finally {
+ viewport.setPointerCapture = capture;
+ URL.createObjectURL = createURL;
+ Renderer.prototype.publish = publish;
+ navRoot.setPointerCapture = navCapture;
+ Navigation.prototype.render = navRender;
+ }
+}
diff --git a/server/web/assets/sculpt/bvh.js b/server/web/assets/sculpt/bvh.js
new file mode 100644
index 0000000..64e3d99
--- /dev/null
+++ b/server/web/assets/sculpt/bvh.js
@@ -0,0 +1,169 @@
+import { add, mul, sub, dot, cross, unit, point } from "./math.js";
+
+export function triangleHit(mesh, f, origin, direction) {
+ const ids = mesh.indices.subarray(f * 3, f * 3 + 3);
+ const a = point(mesh.positions, ids[0]);
+ const e1 = sub(point(mesh.positions, ids[1]), a),
+ e2 = sub(point(mesh.positions, ids[2]), a);
+ const h = cross(direction, e2),
+ det = dot(e1, h);
+ if (Math.abs(det) < 1e-9) return null;
+ const s = sub(origin, a),
+ u = dot(s, h) / det;
+ if (u < 0 || u > 1) return null;
+ const q = cross(s, e1),
+ v = dot(direction, q) / det;
+ if (v < 0 || u + v > 1) return null;
+ const t = dot(e2, q) / det;
+ return t > 0
+ ? {
+ t,
+ position: add(origin, mul(direction, t)),
+ normal: unit(cross(e1, e2)),
+ face: f,
+ }
+ : null;
+}
+
+export class BVH {
+ constructor(mesh) {
+ this.mesh = mesh;
+ this.leaves = new Array(mesh.indices.length / 3);
+ const centers = Array.from({ length: this.leaves.length }, (_, f) =>
+ [0, 1, 2].map(
+ (k) =>
+ (mesh.positions[mesh.indices[f * 3] * 3 + k] +
+ mesh.positions[mesh.indices[f * 3 + 1] * 3 + k] +
+ mesh.positions[mesh.indices[f * 3 + 2] * 3 + k]) /
+ 3,
+ ),
+ );
+ const build = (faces, parent = null) => {
+ const node = { parent, min: [0, 0, 0], max: [0, 0, 0] };
+ if (faces.length <= 8) {
+ node.faces = faces;
+ for (const f of faces) this.leaves[f] = node;
+ } else {
+ const spans = [0, 1, 2].map((k) => {
+ let lo = Infinity,
+ hi = -Infinity;
+ for (const f of faces) {
+ lo = Math.min(lo, centers[f][k]);
+ hi = Math.max(hi, centers[f][k]);
+ }
+ return hi - lo;
+ });
+ const axis = spans.indexOf(Math.max(...spans));
+ faces.sort((a, b) => centers[a][axis] - centers[b][axis]);
+ const mid = faces.length >> 1;
+ node.left = build(faces.slice(0, mid), node);
+ node.right = build(faces.slice(mid), node);
+ }
+ this.bounds(node);
+ return node;
+ };
+ this.root = build(Array.from({ length: this.leaves.length }, (_, i) => i));
+ this.marks = new Uint32Array(mesh.positions.length / 3);
+ this.generation = 0;
+ }
+ bounds(node) {
+ for (let k = 0; k < 3; k++) {
+ let lo = Infinity,
+ hi = -Infinity;
+ if (node.faces)
+ for (const f of node.faces)
+ for (let j = 0; j < 3; j++) {
+ const v = this.mesh.positions[this.mesh.indices[f * 3 + j] * 3 + k];
+ lo = Math.min(lo, v);
+ hi = Math.max(hi, v);
+ }
+ else {
+ lo = Math.min(node.left.min[k], node.right.min[k]);
+ hi = Math.max(node.left.max[k], node.right.max[k]);
+ }
+ node.min[k] = lo;
+ node.max[k] = hi;
+ }
+ }
+ refit(faces) {
+ const dirty = new Set(faces.map((f) => this.leaves[f]));
+ for (const leaf of dirty) this.bounds(leaf);
+ let parents = new Set([...dirty].map((n) => n.parent).filter(Boolean));
+ while (parents.size) {
+ const next = new Set();
+ for (const n of parents) {
+ this.bounds(n);
+ if (n.parent) next.add(n.parent);
+ }
+ parents = next;
+ }
+ }
+ raycast(origin, direction) {
+ let best = null;
+ const entry = (n) => {
+ let near = 0,
+ far = best?.t ?? Infinity;
+ for (let k = 0; k < 3; k++) {
+ if (Math.abs(direction[k]) < 1e-12) {
+ if (origin[k] < n.min[k] || origin[k] > n.max[k]) return Infinity;
+ continue;
+ }
+ const a = (n.min[k] - origin[k]) / direction[k],
+ b = (n.max[k] - origin[k]) / direction[k];
+ near = Math.max(near, Math.min(a, b));
+ far = Math.min(far, Math.max(a, b));
+ if (near > far) return Infinity;
+ }
+ return near;
+ };
+ const visit = (n) => {
+ if (entry(n) === Infinity) return;
+ if (n.faces) {
+ for (const f of n.faces) {
+ const hit = triangleHit(this.mesh, f, origin, direction);
+ if (hit && (!best || hit.t < best.t)) best = hit;
+ }
+ } else if (entry(n.left) < entry(n.right)) {
+ visit(n.left);
+ visit(n.right);
+ } else {
+ visit(n.right);
+ visit(n.left);
+ }
+ };
+ visit(this.root);
+ return best;
+ }
+ within(center, radius) {
+ const result = [],
+ gen = ++this.generation,
+ r2 = radius * radius;
+ const visit = (n) => {
+ let d = 0;
+ for (let k = 0; k < 3; k++) {
+ const e = Math.max(n.min[k] - center[k], 0, center[k] - n.max[k]);
+ d += e * e;
+ }
+ if (d > r2) return;
+ if (n.faces)
+ for (const f of n.faces)
+ for (let j = 0; j < 3; j++) {
+ const v = this.mesh.indices[f * 3 + j];
+ if (this.marks[v] === gen) continue;
+ this.marks[v] = gen;
+ const p = this.mesh.positions;
+ const d2 =
+ (p[v * 3] - center[0]) ** 2 +
+ (p[v * 3 + 1] - center[1]) ** 2 +
+ (p[v * 3 + 2] - center[2]) ** 2;
+ if (d2 < r2) result.push(v);
+ }
+ else {
+ visit(n.left);
+ visit(n.right);
+ }
+ };
+ visit(this.root);
+ return result;
+ }
+}
diff --git a/server/web/assets/sculpt/engine.js b/server/web/assets/sculpt/engine.js
new file mode 100644
index 0000000..f375ed6
--- /dev/null
+++ b/server/web/assets/sculpt/engine.js
@@ -0,0 +1,269 @@
+import { sphere, updateNormals } from "./mesh.js";
+import { BVH } from "./bvh.js";
+import { point, sub, dot, clamp } from "./math.js";
+
+export const pressureValue = (pressure, gain = 1, gamma = 1) =>
+ clamp(gain * clamp(pressure, 0, 1) ** gamma, 0, 1);
+export const defaults = {
+ brush: "draw",
+ radius: 0.22,
+ strength: 0.45,
+ gain: 1,
+ gamma: 1,
+ symmetry: true,
+ invert: false,
+ pressureRadius: false,
+};
+
+export class Sculpt {
+ constructor(mesh = sphere(), historyCap = 16 * 1024 * 1024) {
+ this.mesh = mesh;
+ this.bvh = new BVH(mesh);
+ this.undoStack = [];
+ this.redoStack = [];
+ this.historyCap = historyCap;
+ this.revision = 0;
+ this.dirty = new Set();
+ this.markAll();
+ this.stroke = null;
+ }
+ markAll() {
+ for (let v = 0; v < this.mesh.positions.length / 3; v++) this.dirty.add(v);
+ this.revision++;
+ }
+ get historyBytes() {
+ return [...this.undoStack, ...this.redoStack].reduce(
+ (sum, e) =>
+ sum + e.ids.byteLength + e.before.byteLength + e.after.byteLength,
+ 0,
+ );
+ }
+ begin(settings) {
+ if (this.stroke) throw new Error("A stroke is already active.");
+ this.stroke = {
+ settings: { ...defaults, ...settings },
+ before: this.mesh.positions.slice(),
+ touched: new Set(),
+ grab: null,
+ };
+ }
+ changed(ids) {
+ if (!ids.length) return;
+ const { faces, vertices } = updateNormals(this.mesh, ids);
+ this.bvh.refit(faces);
+ for (const v of vertices) this.dirty.add(v);
+ this.revision++;
+ }
+ dab(hit, rawPressure = 1, drag = [0, 0, 0]) {
+ if (!this.stroke || !hit) return;
+ const { settings: s } = this.stroke;
+ const pressure = pressureValue(rawPressure, s.gain, s.gamma);
+ if (pressure === 0) return;
+ const radius = s.radius * (s.pressureRadius ? 0.25 + 0.75 * pressure : 1);
+ const p = this.mesh.positions,
+ n = this.mesh.normals;
+ // Merge reflected influence instead of applying two sequential dabs at the seam.
+ let affected = this.stroke.grab;
+ if (!affected) {
+ affected = new Map();
+ for (const mirror of s.symmetry ? [1, -1] : [1]) {
+ const center = [
+ hit.position[0] * mirror,
+ hit.position[1],
+ hit.position[2],
+ ];
+ const normal = [hit.normal[0] * mirror, hit.normal[1], hit.normal[2]];
+ for (const v of this.bvh.within(center, radius)) {
+ if (dot(point(n, v), normal) < 0.05) continue;
+ const delta = sub(point(p, v), center),
+ weight = (1 - dot(delta, delta) / (radius * radius)) ** 2;
+ if (!affected.has(v)) affected.set(v, []);
+ affected.get(v).push({ weight, center, normal, mirror });
+ }
+ }
+ if (s.brush === "grab") this.stroke.grab = affected;
+ }
+ const moved = [],
+ updates = [];
+ for (const [v, contributions] of affected) {
+ const position = point(p, v),
+ displacement = [0, 0, 0];
+ let total = 0,
+ envelope = 0;
+ for (const { weight, center, normal, mirror } of contributions) {
+ total += weight;
+ envelope = Math.max(envelope, weight);
+ let delta;
+ if (s.brush === "smooth") {
+ const neighbors = this.mesh.neighbors[v];
+ delta = [0, 1, 2].map((k) => {
+ let sum = 0;
+ for (const neighbor of neighbors) sum += p[neighbor * 3 + k];
+ return sum / neighbors.length - position[k];
+ });
+ } else if (s.brush === "flatten") {
+ const distance = dot(sub(position, center), normal);
+ delta = normal.map((x) => -x * distance);
+ } else if (s.brush === "grab") {
+ delta = drag.map((x, k) => x * (k === 0 ? mirror : 1));
+ } else {
+ const direction = s.brush === "inflate" ? point(n, v) : normal;
+ delta = direction.map((x) => x * radius * 0.12 * (s.invert ? -1 : 1));
+ }
+ for (let k = 0; k < 3; k++) displacement[k] += delta[k] * weight;
+ }
+ const base = s.brush === "grab" ? point(this.stroke.before, v) : position;
+ let next = base.map(
+ (x, k) =>
+ x + (displacement[k] * s.strength * pressure * envelope) / total,
+ );
+ if (s.symmetry && this.stroke.before[v * 3] === 0) next[0] = 0;
+ // Bounded document coordinates keep camera and project validation meaningful.
+ next = next.map((x) => clamp(x, -8, 8));
+ if (next.some((x, k) => Math.fround(x) !== position[k])) {
+ moved.push(v);
+ updates.push(...next);
+ this.stroke.touched.add(v);
+ }
+ }
+ // Jacobi update: smoothing reads only the pre-dab mesh, independent of iteration order.
+ for (let i = 0; i < moved.length; i++)
+ p.set(updates.slice(i * 3, i * 3 + 3), moved[i] * 3);
+ this.changed(moved);
+ }
+ end(cancel = false) {
+ if (!this.stroke) return;
+ const { before, touched } = this.stroke;
+ this.stroke = null;
+ const ids = Uint32Array.from(
+ [...touched].filter((v) =>
+ [0, 1, 2].some(
+ (k) => before[v * 3 + k] !== this.mesh.positions[v * 3 + k],
+ ),
+ ),
+ );
+ if (cancel) {
+ for (const v of ids)
+ this.mesh.positions.set(before.subarray(v * 3, v * 3 + 3), v * 3);
+ this.changed(Array.from(ids));
+ return;
+ }
+ if (!ids.length) return;
+ const entry = {
+ ids,
+ before: new Float32Array(ids.length * 3),
+ after: new Float32Array(ids.length * 3),
+ };
+ ids.forEach((v, i) => {
+ entry.before.set(before.subarray(v * 3, v * 3 + 3), i * 3);
+ entry.after.set(this.mesh.positions.subarray(v * 3, v * 3 + 3), i * 3);
+ });
+ this.redoStack = [];
+ this.undoStack.push(entry);
+ while (this.undoStack.length > 50 || this.historyBytes > this.historyCap)
+ this.undoStack.shift();
+ }
+ restore(redo = false) {
+ if (this.stroke) return false;
+ const source = redo ? this.redoStack : this.undoStack,
+ target = redo ? this.undoStack : this.redoStack,
+ entry = source.pop();
+ if (!entry) return false;
+ const values = redo ? entry.after : entry.before;
+ entry.ids.forEach((v, i) =>
+ this.mesh.positions.set(values.subarray(i * 3, i * 3 + 3), v * 3),
+ );
+ target.push(entry);
+ this.changed(Array.from(entry.ids));
+ return true;
+ }
+}
+
+// Screen-space arc-length sampler. Call break() when the ray misses the surface.
+export class StrokePath {
+ constructor(spacing, emit) {
+ this.spacing = spacing;
+ this.emit = emit;
+ this.break();
+ }
+ break() {
+ this.generation = (this.generation ?? 0) + 1;
+ this.last = null;
+ this.remaining = 0;
+ }
+ push(sample, budget = Infinity) {
+ const generation = this.generation;
+ if (!this.last) {
+ this.last = sample;
+ this.remaining = this.spacing;
+ this.emit(sample);
+ return true;
+ }
+ const a = this.last,
+ dx = sample.x - a.x,
+ dy = sample.y - a.y,
+ length = Math.hypot(dx, dy);
+ let distance = this.remaining;
+ let emitted = 0;
+ while (distance <= length && length > 0) {
+ const t = distance / length;
+ const current = {
+ x: a.x + dx * t,
+ y: a.y + dy * t,
+ pressure: a.pressure + (sample.pressure - a.pressure) * t,
+ };
+ this.emit(current);
+ if (this.generation !== generation) return true;
+ distance += this.spacing;
+ if (++emitted >= budget && distance <= length) {
+ this.last = current;
+ this.remaining = this.spacing;
+ return false;
+ }
+ }
+ this.remaining = distance - length;
+ this.last = sample;
+ return true;
+ }
+}
+
+export function saveProject(mesh) {
+ return JSON.stringify({
+ version: 1,
+ level: mesh.level,
+ positions: Array.from(mesh.positions),
+ });
+}
+export function loadProject(text) {
+ if (text.length > 8 * 1024 * 1024)
+ throw new Error("Project exceeds the 8 MiB limit.");
+ const data = JSON.parse(text);
+ if (
+ data?.version !== 1 ||
+ !Number.isInteger(data.level) ||
+ data.level < 4 ||
+ data.level > 6 ||
+ !Array.isArray(data.positions) ||
+ data.positions.length !== (10 * 4 ** data.level + 2) * 3 ||
+ !data.positions.every(
+ (v) => typeof v === "number" && Number.isFinite(v) && Math.abs(v) <= 8,
+ )
+ )
+ throw new Error("Invalid sculpt project.");
+ const mesh = sphere(data.level);
+ mesh.positions.set(data.positions);
+ updateNormals(mesh);
+ return mesh;
+}
+export function exportOBJ(mesh) {
+ const lines = ["# Yawn Sculpt — local mesh export"];
+ for (let i = 0; i < mesh.positions.length; i += 3)
+ lines.push(
+ `v ${mesh.positions[i]} ${mesh.positions[i + 1]} ${mesh.positions[i + 2]}`,
+ );
+ for (let i = 0; i < mesh.indices.length; i += 3)
+ lines.push(
+ `f ${mesh.indices[i] + 1} ${mesh.indices[i + 1] + 1} ${mesh.indices[i + 2] + 1}`,
+ );
+ return lines.join("\n");
+}
diff --git a/server/web/assets/sculpt/engine.test.js b/server/web/assets/sculpt/engine.test.js
new file mode 100644
index 0000000..630674e
--- /dev/null
+++ b/server/web/assets/sculpt/engine.test.js
@@ -0,0 +1,342 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { sphere, updateNormals } from "./mesh.js";
+import { triangleHit } from "./bvh.js";
+import {
+ Sculpt,
+ pressureValue,
+ StrokePath,
+ saveProject,
+ loadProject,
+ exportOBJ,
+} from "./engine.js";
+import { point, dot, unit, clampZoom } from "./math.js";
+
+const hit = { position: [0.19, 0.11, 0.97], normal: unit([0.19, 0.11, 0.97]) };
+const near = (a, b, epsilon = 1e-6) =>
+ assert.ok(Math.abs(a - b) < epsilon, `${a} != ${b}`);
+test("zoom limits use apparent scale, including portrait values outside landscape limits", () => {
+ const portrait = { width: 600, height: 1000 },
+ landscape = { width: 1000, height: 600 };
+ near(clampZoom(20, portrait), 20);
+ near(clampZoom(30, portrait), 14 / 0.6);
+ near(clampZoom(0.1, portrait), 0.2 / 0.6);
+ near(clampZoom(20, landscape), 14);
+ near(clampZoom(0.1, landscape), 0.2);
+});
+test("welded outward sphere has two faces per edge and expected topology", () => {
+ const m = sphere(4),
+ edges = new Map();
+ assert.equal(m.positions.length / 3, 2562);
+ assert.equal(m.indices.length / 3, 5120);
+ for (let f = 0; f < m.indices.length / 3; f++) {
+ const ids = m.indices.subarray(f * 3, f * 3 + 3);
+ assert.ok(dot(point(m.faceNormals, f), point(m.positions, ids[0])) > 0);
+ for (let k = 0; k < 3; k++) {
+ const a = ids[k],
+ b = ids[(k + 1) % 3],
+ key = [Math.min(a, b), Math.max(a, b)].join(":");
+ edges.set(key, (edges.get(key) || 0) + 1);
+ }
+ }
+ assert.ok([...edges.values()].every((n) => n === 2));
+});
+test("BVH agrees with brute-force picking and sphere queries after edits and undo", () => {
+ const s = new Sculpt(sphere(4));
+ const check = () => {
+ for (const origin of [
+ [0.19, 0.11, 4],
+ [-0.31, 0.42, 4],
+ [1.4, 0, 4],
+ [0.01, -0.99, 4],
+ ]) {
+ const direction = [0, 0, -1];
+ let expected = null;
+ for (let f = 0; f < s.mesh.indices.length / 3; f++) {
+ const h = triangleHit(s.mesh, f, origin, direction);
+ if (h && (!expected || h.t < expected.t)) expected = h;
+ }
+ const actual = s.bvh.raycast(origin, direction);
+ assert.equal(!!actual, !!expected);
+ if (actual) near(actual.t, expected.t);
+ }
+ const expected = [];
+ for (let v = 0; v < s.mesh.positions.length / 3; v++)
+ if (
+ Math.hypot(
+ ...point(s.mesh.positions, v).map((x, k) => x - hit.position[k]),
+ ) < 0.37
+ )
+ expected.push(v);
+ assert.deepEqual(
+ s.bvh.within(hit.position, 0.37).sort((a, b) => a - b),
+ expected,
+ );
+ };
+ check();
+ s.begin({ radius: 0.37 });
+ for (let i = 0; i < 12; i++) s.dab(hit, 0.7);
+ s.end();
+ check();
+ s.restore();
+ check();
+});
+test("local normals equal full recomputation including brush boundary", () => {
+ const s = new Sculpt(sphere(4));
+ s.begin({ radius: 0.29, symmetry: false });
+ s.dab(hit);
+ s.end();
+ const local = s.mesh.normals.slice();
+ updateNormals(s.mesh);
+ local.forEach((v, i) => near(v, s.mesh.normals[i]));
+});
+test("pressure zero is a no-op; nonlinear pressure has the independently expected displacement ratio", () => {
+ assert.equal(pressureValue(0, 2, 0.5), 0);
+ assert.equal(pressureValue(0.5, 1, 2), 0.25);
+ const a = new Sculpt(sphere(4)),
+ b = new Sculpt(sphere(4));
+ const before = a.mesh.positions.slice();
+ a.begin({ symmetry: false });
+ a.dab(hit, 0);
+ a.end();
+ assert.equal(a.undoStack.length, 0);
+ for (const [s, p] of [
+ [a, 0.5],
+ [b, 1],
+ ]) {
+ s.begin({ symmetry: false, gamma: 2 });
+ s.dab(hit, p);
+ s.end();
+ }
+ let da = 0,
+ db = 0;
+ before.forEach((x, i) => {
+ da += Math.abs(a.mesh.positions[i] - x);
+ db += Math.abs(b.mesh.positions[i] - x);
+ });
+ near(da / db, 0.25, 1e-4);
+});
+test("symmetry does not double strength on seam", () => {
+ const a = new Sculpt(sphere(4)),
+ b = new Sculpt(sphere(4));
+ for (const [s, symmetry] of [
+ [a, false],
+ [b, true],
+ ]) {
+ s.begin({ symmetry });
+ s.dab({ position: [0, 0, 1], normal: [0, 0, 1] });
+ s.end();
+ }
+ assert.deepEqual(a.mesh.positions, b.mesh.positions);
+});
+test("grab uses stroke origin, not repeated accumulated deltas; smooth is order independent", () => {
+ const a = new Sculpt(sphere(4)),
+ b = new Sculpt(sphere(4));
+ a.begin({ brush: "grab", symmetry: false });
+ b.begin({ brush: "grab", symmetry: false });
+ a.dab(hit, 1, [0.1, 0.04, 0]);
+ a.dab(hit, 1, [0.2, 0.08, 0]);
+ b.dab(hit, 1, [0.2, 0.08, 0]);
+ assert.deepEqual(a.mesh.positions, b.mesh.positions);
+ a.end();
+ b.end();
+ const original = b.bvh.within.bind(b.bvh);
+ b.bvh.within = (...args) => original(...args).reverse();
+ for (const s of [a, b]) {
+ s.begin({ brush: "smooth", symmetry: false });
+ s.dab(hit);
+ s.end();
+ }
+ assert.deepEqual(a.mesh.positions, b.mesh.positions);
+});
+test("exact history, cancel, redo truncation and byte cap", () => {
+ const s = new Sculpt(sphere(4), 12000),
+ original = s.mesh.positions.slice();
+ s.begin({});
+ s.dab(hit);
+ s.end();
+ const after = s.mesh.positions.slice();
+ assert.ok(s.historyBytes > 0);
+ s.restore();
+ assert.deepEqual(s.mesh.positions, original);
+ s.restore(true);
+ assert.deepEqual(s.mesh.positions, after);
+ s.begin({});
+ s.dab(hit);
+ s.end(true);
+ assert.deepEqual(s.mesh.positions, after);
+ assert.equal(s.undoStack.length, 1);
+ s.restore();
+ s.begin({ brush: "inflate" });
+ s.dab(hit);
+ s.end();
+ assert.equal(s.redoStack.length, 0);
+ for (let i = 0; i < 60; i++) {
+ s.begin({});
+ s.dab(hit);
+ s.end();
+ }
+ assert.ok(s.historyBytes <= 12000);
+ assert.ok(s.undoStack.length <= 50);
+});
+test("arc-length and interpolated pressure do not depend on event frequency", () => {
+ const run = (step) => {
+ const samples = [];
+ const path = new StrokePath(7, (p) => samples.push(p));
+ for (let x = 0; x <= 100; x += step)
+ path.push({ x, y: 0, pressure: x / 100 });
+ return samples;
+ };
+ const a = run(1),
+ b = run(25);
+ assert.equal(a.length, 15);
+ assert.equal(a.length, b.length);
+ a.forEach((p, i) => {
+ near(p.x, b[i].x);
+ near(p.pressure, b[i].pressure);
+ });
+});
+test("project roundtrip, malformed project rejection, OBJ indices", () => {
+ const s = new Sculpt(sphere(4));
+ s.begin({});
+ s.dab(hit);
+ s.end();
+ const mesh = loadProject(saveProject(s.mesh));
+ assert.deepEqual(mesh.positions, s.mesh.positions);
+ for (const data of [
+ { version: 2 },
+ { version: 1, level: 99, positions: [] },
+ { version: 1, level: 4, positions: ["x"] },
+ ])
+ assert.throws(() => loadProject(JSON.stringify(data)));
+ const obj = exportOBJ(mesh).split("\n");
+ assert.equal(obj.filter((l) => l.startsWith("v ")).length, 2562);
+ assert.equal(obj.filter((l) => l.startsWith("f ")).length, 5120);
+});
+test("directional symmetry and Grab strength preserve the seam and overlap envelope", () => {
+ const center = { position: [0, 0, 1], normal: [0, 0, 1] };
+ const a = new Sculpt(sphere(4)),
+ b = new Sculpt(sphere(4));
+ const before = a.mesh.positions.slice();
+ a.begin({ brush: "grab", symmetry: true, strength: 1 });
+ a.dab(center, 1, [0.2, 0, 0]);
+ a.end();
+ assert.deepEqual(a.mesh.positions, before);
+ for (const [s, symmetry] of [
+ [a, true],
+ [b, false],
+ ]) {
+ s.begin({ brush: "grab", symmetry, strength: 0.5 });
+ s.dab(center, 1, [0, 0.12, 0.08]);
+ s.end();
+ }
+ assert.deepEqual(a.mesh.positions, b.mesh.positions);
+ const s = new Sculpt(sphere(4));
+ s.dirty.clear();
+ const revision = s.revision;
+ s.begin({ brush: "grab", strength: 0 });
+ s.dab(hit, 1, [0.3, 0.1, 0.2]);
+ s.end();
+ assert.equal(s.revision, revision);
+ assert.equal(s.dirty.size, 0);
+ assert.equal(s.undoStack.length, 0);
+ const original = s.mesh.positions.slice(),
+ radius = 0.4,
+ drag = [0.13, 0.09, 0.05];
+ s.begin({ brush: "grab", strength: 0.5, symmetry: true, radius });
+ s.dab(hit, 0.8, drag);
+ s.end();
+ let overlaps = 0;
+ for (let v = 0; v < original.length / 3; v++) {
+ const p = point(original, v),
+ normal = point(sphereReference.normals, v);
+ const weights = [1, -1].map((m) => {
+ const c = [hit.position[0] * m, ...hit.position.slice(1)],
+ n = [hit.normal[0] * m, ...hit.normal.slice(1)];
+ const d2 = p.reduce((sum, x, k) => sum + (x - c[k]) ** 2, 0);
+ return d2 < radius ** 2 && dot(normal, n) >= 0.05
+ ? (1 - d2 / radius ** 2) ** 2
+ : 0;
+ });
+ if (weights.every((w) => w > 0) && Math.abs(weights[0] - weights[1]) > 1e-4)
+ overlaps++;
+ const total = weights[0] + weights[1];
+ if (!total) continue;
+ for (let k = 0; k < 3; k++) {
+ const blend = k === 0 ? weights[0] - weights[1] : total;
+ const expected =
+ k === 0 && p[0] === 0
+ ? 0
+ : p[k] + (drag[k] * 0.5 * 0.8 * Math.max(...weights) * blend) / total;
+ near(s.mesh.positions[v * 3 + k], expected);
+ }
+ }
+ assert.ok(overlaps > 0);
+});
+const sphereReference = sphere(4);
+test("breaking inside the sampler callback aborts interpolation and resets continuity", () => {
+ const samples = [];
+ let path;
+ path = new StrokePath(7, (p) => {
+ samples.push(Math.round(p.x));
+ if (p.x >= 14) path.break();
+ });
+ path.push({ x: 0, y: 0, pressure: 1 });
+ path.push({ x: 100, y: 0, pressure: 1 });
+ assert.deepEqual(samples, [0, 7, 14]);
+ assert.equal(path.last, null);
+ path.push({ x: 101, y: 0, pressure: 0.3 });
+ assert.deepEqual(samples, [0, 7, 14, 101]);
+});
+test("history count eviction retains exactly the latest fifty real commits", () => {
+ const s = new Sculpt(sphere(4), 64 * 1024 * 1024),
+ snapshots = [];
+ for (let i = 0; i < 55; i++) {
+ const previous = s.mesh.positions.slice();
+ const h = s.bvh.raycast([0.19, 0.11, 4], [0, 0, -1]);
+ s.begin({ brush: "grab", strength: 1, symmetry: false });
+ s.dab(h, 1, [0.001, 0.0005, 0]);
+ s.end();
+ assert.notDeepEqual(s.mesh.positions, previous);
+ snapshots.push(s.mesh.positions.slice());
+ assert.ok(s.historyBytes < 64 * 1024 * 1024);
+ }
+ assert.equal(s.undoStack.length, 50);
+ for (let i = 0; i < 50; i++) assert.equal(s.restore(), true);
+ assert.deepEqual(s.mesh.positions, snapshots[4]);
+ assert.equal(s.restore(), false);
+ for (let i = 0; i < 50; i++) assert.equal(s.restore(true), true);
+ assert.deepEqual(s.mesh.positions, snapshots[54]);
+});
+test("bounded-resolution benchmark (CPU only, not a device guarantee)", () => {
+ for (const level of [4, 5, 6]) {
+ const s = new Sculpt(sphere(level));
+ s.dirty.clear();
+ const times = [];
+ s.begin({ radius: 0.22 });
+ for (let i = 0; i < 35; i++) {
+ const start = performance.now();
+ const h = s.bvh.raycast([0.19, 0.11, 4], [0, 0, -1]);
+ s.dab(h, 0.65);
+ times.push(performance.now() - start);
+ }
+ s.end();
+ times.sort((a, b) => a - b);
+ let lo = Infinity,
+ hi = -1;
+ for (const v of s.dirty) {
+ lo = Math.min(lo, v);
+ hi = Math.max(hi, v);
+ }
+ console.log(
+ JSON.stringify({
+ level,
+ vertices: s.mesh.positions.length / 3,
+ p50ms: times[17].toFixed(2),
+ p95ms: times[33].toFixed(2),
+ uploadBytes: (hi - lo + 1) * 32,
+ historyBytes: s.historyBytes,
+ }),
+ );
+ }
+});
diff --git a/server/web/assets/sculpt/index.html b/server/web/assets/sculpt/index.html
new file mode 100644
index 0000000..09fead2
--- /dev/null
+++ b/server/web/assets/sculpt/index.html
@@ -0,0 +1,472 @@
+
+
+
+
+
+
+
+ Sculpt — Yawn
+
+
+
+
+
+
+
+
+
+
+
Preparing your clay.
+
A moment to get ready.
+
+
Your sculpt is safe.
+
+
+