@woosh/meep-engine 3.60.3 → 3.60.5

package/src/engine/input/ecs/controllers/KeyboardCameraController.js

@@ -1,16 +1,15 @@
 import { assert } from "../../../../core/assert.js";
-import Vector2 from '../../../../core/geom/Vector2.js';
-import Vector3 from "../../../../core/geom/Vector3.js";
-import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
 import Script from '../../../ecs/components/Script.js';
 import { SerializationMetadata } from "../../../ecs/components/SerializationMetadata.js";
 import { Tag } from "../../../ecs/components/Tag.js";
 import Entity from '../../../ecs/Entity.js';
-import { Transform64 } from "../../../ecs/transform/Transform64.js";
+import { top_down_truck_on_ground } from "../../../graphics/ecs/camera/topdown/TopDownCameraController.js";
 import InputController from '../components/InputController.js';
 
-const v3 = new Vector3();
-
+/**
+ * WASD and the arrow keys move a top-down camera's orbit target across the ground, along the way the
+ * view is turned, at a fixed speed in world units a second.
+ */
 class KeyboardCameraController {
     /**
      *
@@ -23,8 +22,6 @@ class KeyboardCameraController {
 
         assert.notEqual(controller, undefined, 'controller is undefined');
 
-        const cameraPanSpeed = new Vector2(0, 0);
-
         const controls = {
             panUp: false,
             panDown: false,
@@ -70,43 +67,10 @@ class KeyboardCameraController {
         inputController.on.unlinked.add(clearControls);
 
         const script = new Script(function (timeDelta) {
-            cameraPanSpeed.set(0, 0);
-
-            if (controls.panDown) {
-                cameraPanSpeed.y += 1;
-            }
-            if (controls.panUp) {
-                cameraPanSpeed.y -= 1;
-            }
-            if (controls.panLeft) {
-                cameraPanSpeed.x -= 1;
-            }
-            if (controls.panRight) {
-                cameraPanSpeed.x += 1;
-            }
-
-            if (cameraPanSpeed.isZero()) {
-                // not panning
-                return;
-            }
-
-            const displacement = cameraPanSpeed.clone().multiplyScalar(keyboardPanSpeed * timeDelta);
-
-            const camera_transform = ecd.getComponent(cameraController.entity, Transform64);
-
-            // by component: a Transform64's `rotation` is four numbers in an array, and
-            // `applyQuaternion` reads `.x` off what it is given
-            v3_quaternion_apply(
-                v3, 0,
-                -displacement.x, 0, -displacement.y,
-                camera_transform.rotation_x,
-                camera_transform.rotation_y,
-                camera_transform.rotation_z,
-                camera_transform.rotation_w
-            );
-
-
-            controller.target.add(v3);
+            const right = (controls.panRight ? 1 : 0) - (controls.panLeft ? 1 : 0);
+            const forward = (controls.panUp ? 1 : 0) - (controls.panDown ? 1 : 0);
+
+            top_down_truck_on_ground(controller, right, forward, keyboardPanSpeed * timeDelta);
         });
 
         const builder = new Entity();

package/src/engine/physics/cloth/ecs/cloth_geodesic.d.ts

@@ -14,8 +14,8 @@ export function cloth_edge_incidence(node_count: number, edge: Int32Array): {
  * Distance from every node to the nearest of a set of source nodes, along the
  * edges, and which source that is.
  *
- * A node marked in `blocked` can be reached but is never passed through. That is
- * Chaos Cloth's rule for its long-range attachments (`ClothTetherData.cpp`):
+ * A node marked in `blocked` can be reached but is never passed through.
+ * That is Chaos Cloth's rule for its long-range attachments:
  * a path from one island of held particles does not run through another, because
  * the far side of another island is that island's business.
  *

package/src/engine/physics/cloth/ecs/cloth_geodesic.js

@@ -65,8 +65,8 @@ export function cloth_edge_incidence(node_count, edge) {
  * Distance from every node to the nearest of a set of source nodes, along the
  * edges, and which source that is.
  *
- * A node marked in `blocked` can be reached but is never passed through. That is
- * Chaos Cloth's rule for its long-range attachments (`ClothTetherData.cpp`):
+ * A node marked in `blocked` can be reached but is never passed through.
+ * That is Chaos Cloth's rule for its long-range attachments:
  * a path from one island of held particles does not run through another, because
  * the far side of another island is that island's business.
  *

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -66,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#478@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#481@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#478@#clear_field"(fluid: FluidComponent): void;
+    static "__#481@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -82,7 +82,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#478@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#481@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -102,7 +102,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#478@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#481@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof FluidObstacle> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof FluidComponent>)[];

package/src/shade/playground/probe_clipmap/README.md

@@ -23,6 +23,7 @@ has the two lines that put it there. Another scene loads with `?scene=/some/othe
 | Indirect light | the probe clipmap, or IBL to compare against |
 | Debug view | the brick clipmap as the probes' rays see it; the geometry caches' mesh SDF; the hits' albedo from the cards |
 | Path tracer (P) | the accumulating path tracer's image in place of the rasterized one, as ground truth; TAA is off while it is on and comes back after |
+| Re-sampling (R) | each probe update pools its rays with what four of its neighbours have already seen, where their depth confirms it (`ProbeClipmapSettings.resampling`); off by default, and measured slower to converge and a few per cent brighter on Sponza (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8) |
 | Sun height, Sun turn | where the sun stands |
 | Point lights | eight shadowed point lights along the scene's long axis, which the probes' hits take as local lights |
 | TAA | the resolve the probe pick's noise is meant for |

package/src/shade/playground/probe_clipmap/index.html

@@ -108,6 +108,11 @@
         <span>Path tracer <span class="hint">— ground truth; P flips it</span></span>
     </label>
 
+    <label>
+        <input type="checkbox" id="resampling">
+        <span>Re-sampling <span class="hint">— probes take their neighbours' radiance; R flips it</span></span>
+    </label>
+
     <hr>
 
     <label>

package/src/shade/playground/probe_clipmap/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AA0FA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA8QzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AA0FA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA4RzB"}

package/src/shade/playground/probe_clipmap/main.js

@@ -282,12 +282,26 @@ export async function start() {
 
     path_tracing_toggle.addEventListener('change', event => set_path_tracing(event.target.checked));
 
+    const resampling_toggle = element('resampling');
+
+    resampling_toggle.checked = renderer.probe_clipmap.resampling;
+    resampling_toggle.addEventListener('change', event => {
+        renderer.probe_clipmap.resampling = event.target.checked;
+    });
+
     document.addEventListener('keydown', event => {
-        // not while typing a number, nor in a select, where P picks an option
+        // not while typing a number, nor in a select, where P and R pick an option
         const typing = event.target === bake_budget || event.target instanceof HTMLSelectElement;
 
-        if (event.code === 'KeyP' && event.repeat === false && typing === false) {
+        if (event.repeat || typing) {
+            return;
+        }
+
+        if (event.code === 'KeyP') {
             set_path_tracing(!renderer.feature_path_tracing_enabled);
+        } else if (event.code === 'KeyR') {
+            resampling_toggle.checked = !resampling_toggle.checked;
+            renderer.probe_clipmap.resampling = resampling_toggle.checked;
         }
     });
 

package/src/shade/playground/vgeo_scene/README.md

@@ -273,7 +273,7 @@ every vertex shader over a meshlet emits that instance's triangle corners in the
 `triangle_list_reverse_winding`. The draw is non-indexed and the vertex shader resolves its own
 index, so which corner lands where is already the shader's choice; reversing it costs a `select`,
 no second pipeline, and no fourth field in the bucket key. It is what Nanite does for the same
-reason (`FInstanceSceneData::DeterminantSign`, read in `HWRasterizeVS`), and what the glTF spec
+reason, and what the glTF spec
 requires of a conformant renderer. The tangent frame's handedness flips with it.
 
 The parameters remain, and now read as diagnostics rather than as fixes:

package/src/shade/playground/water_refraction/README.md

@@ -51,18 +51,17 @@ wave/object checks. NSS uses the renderer's existing weight requirement and fall
 when weights have not been installed; this standalone page does not supply NSS weights.
 
 Inspection modes display prepared coverage, receiver UV, bounded path, classification/update count,
-surface radiance, residual, RGB throughput, shared front throughput and water's normalization term.
+surface radiance, RGB throughput, shared front throughput and water's normalization term.
 They replace presentation **after** shared resolve and temporal processing, so diagnostics show
 the current frame's measurements without TAA history. Internal-resolution measurements are
 displayed with nearest sampling at the output resolution.
-Shift-click requests one pixel from four prepared textures on the next frame; normal frames perform
+Shift-click requests one pixel from three prepared textures on the next frame; normal frames perform
 no readback. Arrays are `receiver=[u,v,path,status+updates/32]`,
-`transmission=[Tr,Tg,Tb,coverage]`, `radiance=[Wr,Wg,Wb,residual]`.
+`transmission=[Tr,Tg,Tb,coverage]`, `radiance=[Wr,Wg,Wb,0]`.
 Status 0 is a converged Newton hit; codes 8–13 are validated HZB hits, 16–21 undisplaced opaque fallbacks,
 24–29 bounded sky fallbacks, and 31 the below-interface control. The low three bits preserve the
 Newton miss reason: 0 none/not attempted, 1 bounds/clip, 2 sky, 3 parallel/invalid, 4 ray interval,
-5 exhausted budget/residual. The probe decodes these names and the update count. Residual is capped
-at 65504 for half-float storage. The status display uses green/cyan/purple/orange/pink for those
+5 exhausted budget/residual. The probe decodes these names and the update count. The status display uses green/cyan/purple/orange/pink for those
 five final classes; red increases with update count.
 
 Compile check compiles the production water modules on the active device. Rendering exercises
@@ -90,7 +89,7 @@ takes a validated receiver at its whole displacement, however near an object, th
 edge it lies; a pixel without one shows its own undisplaced background. It then performs one
 geometry-aware color lookup, derives water thickness from that lookup's local receiver plane and
 builds its complete optical event. Nothing fades between the two lookups: any point between them is
-one the ray never reached (see 2026-10-16 below). The raw receiver/residual displays show classified
+one the ray never reached (see 2026-10-16 below). The raw receiver display shows classified
 misses. Screen reflections fade near the ray origin and frame
 edges to avoid self-hit speckles, reusing the existing SSR back-face/thickness/vignette validation.
 As in the paper, a converged Newton root is final: screen bounds plus the one-pixel and distance

package/src/shade/playground/water_refraction/index.html

@@ -33,7 +33,7 @@ input[type=range]{width:135px}input[type=number]{width:84px}input,select,button,
 <label>Internal scale<select id="resolution"><option value="1">1×</option><option value=".75">0.75×</option><option value=".5">0.5×</option></select></label>
 <label>Opaque SSR<input id="ssr" type="checkbox"></label><label>Atmospheric fog<input id="fog" type="checkbox"></label>
 <label>Transparency<select id="transparency"><option value="avboit">AVBOIT</option><option value="mboit">MBOIT (water unavailable)</option></select></label>
-<h2>Inspect</h2><label>Display<select id="debug"><option value="0">Final composite</option><option value="1">Coverage</option><option value="2">Receiver UV</option><option value="3">Water path</option><option value="4">Trace status / updates</option><option value="5">Surface radiance</option><option value="6">Residual</option><option value="7">RGB throughput</option><option value="8">Shared front throughput</option><option value="9">Water normalization</option></select></label>
+<h2>Inspect</h2><label>Display<select id="debug"><option value="0">Final composite</option><option value="1">Coverage</option><option value="2">Receiver UV</option><option value="3">Water path</option><option value="4">Trace status / updates</option><option value="5">Surface radiance</option><option value="7">RGB throughput</option><option value="8">Shared front throughput</option><option value="9">Water normalization</option></select></label>
 <div class="row"><button id="compile">Compile check</button><button id="profile">Profile (T)</button></div><pre id="probe">Shift-click water to read a pixel.</pre>
 <h2>Reproduce a view</h2><div class="row"><button id="copy">Copy state</button><button id="apply">Apply state</button></div><textarea id="state" aria-label="Saved camera and settings"></textarea>
 <p>Rear transparent radiance is attenuated on its original screen path. Initial optics select one water interface; underwater transport and caustics are follow-on work. <a href="./README.md">Review guide</a></p>

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -2816,13 +2816,15 @@ export class Renderer {
          `GBufferTextures` is in/out at this phase, and frozen after it. An extension that wants to
          *change* surface properties — decals are the reason this exists — cannot blend into these
          targets: two of the four are integer formats, and one texture cannot be a render attachment
-         and a sampled source in the same pass. So it reads them, writes replacements, and publishes
-         the new handles. Everything downstream carries what it left.
+         and a sampled source in the same pass. So it reads a copy — of the targets, or of the part
+         it changes — and writes, and publishes the handles it wrote. Everything downstream carries
+         what it left.
 
-         Writing the originals in place would work by accident rather than by contract: a written
-         handle is a *renamed* clone of the same physical resource, so the change would land in the
+         Publishing is what makes it a contract. A written handle is a *renamed* clone of the same
+         physical resource, so a change written in place and not published would land in the
          texture the shading pass reads only because the graph happens to execute in insertion
-         order, with no dependency edge saying so. Threading the handles makes the edge real.
+         order, with no dependency edge saying so. Threading the handles makes the edge real,
+         whether they name replacements or the originals written through `write`.
         */
         gr_texture_pbr = record_gbuffer.pbr;
         gr_texture_normal = record_gbuffer.normal;

package/src/shade/renderer/atmosphere/MULTISCATTER_LUT_CONFIG.d.ts

@@ -1,21 +1,19 @@
 /**
  * Directions are drawn on an 8x8 grid, stratified in azimuth and in the cosine of the polar
- * angle. Matches Hillaire's `SQRTSAMPLECOUNT`.
+ * angle.
  * @type {number}
  */
 export const MULTISCATTER_LUT_SQRT_SAMPLES: number;
 /**
  * One thread integrates one direction, so this is also the workgroup size.
  *
- * 64 is Hillaire's `[numthreads(1,1,64)]` count. It is a multiple of every legal subgroup
- * size up to 64, and the reduction handles a subgroup wider than the workgroup, so no
- * hardware needs a different number here.
+ * 64 is a multiple of every legal subgroup size up to 64, and the reduction handles a
+ * subgroup wider than the workgroup, so no hardware needs a different number here.
  * @type {number}
  */
 export const MULTISCATTER_LUT_DIRECTION_COUNT: number;
 /**
- * Ray-march steps per direction. Hillaire's `SampleCountIni` for this LUT; the comment there
- * reads "a minimum set of step is required for accuracy unfortunately".
+ * Ray-march steps per direction for this LUT.
  *
  * Compile-time on purpose: as a uniform the inner loop cannot be unrolled and the trip count
  * has to be re-tested against an f32 every iteration.

package/src/shade/renderer/atmosphere/MULTISCATTER_LUT_CONFIG.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MULTISCATTER_LUT_CONFIG.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/MULTISCATTER_LUT_CONFIG.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;;;;;GAOG;AACH,+CAFU,MAAM,CAE8F;AAE9G;;;;;;;GAOG;AACH,qCAFU,MAAM,CAEyB;AAEzC;;;;;;;GAOG;AACH,qDAFU,MAAM,CAE2E"}
+{"version":3,"file":"MULTISCATTER_LUT_CONFIG.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/MULTISCATTER_LUT_CONFIG.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;;;;GAMG;AACH,+CAFU,MAAM,CAE8F;AAE9G;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB;AAEzC;;;;;;;GAOG;AACH,qDAFU,MAAM,CAE2E"}

package/src/shade/renderer/atmosphere/MULTISCATTER_LUT_CONFIG.js

@@ -1,36 +1,34 @@
-/**
- * Directions are drawn on an 8x8 grid, stratified in azimuth and in the cosine of the polar
- * angle. Matches Hillaire's `SQRTSAMPLECOUNT`.
- * @type {number}
- */
-export const MULTISCATTER_LUT_SQRT_SAMPLES = 8;
-
-/**
- * One thread integrates one direction, so this is also the workgroup size.
- *
- * 64 is Hillaire's `[numthreads(1,1,64)]` count. It is a multiple of every legal subgroup
- * size up to 64, and the reduction handles a subgroup wider than the workgroup, so no
- * hardware needs a different number here.
- * @type {number}
- */
-export const MULTISCATTER_LUT_DIRECTION_COUNT = MULTISCATTER_LUT_SQRT_SAMPLES * MULTISCATTER_LUT_SQRT_SAMPLES;
-
-/**
- * Ray-march steps per direction. Hillaire's `SampleCountIni` for this LUT; the comment there
- * reads "a minimum set of step is required for accuracy unfortunately".
- *
- * Compile-time on purpose: as a uniform the inner loop cannot be unrolled and the trip count
- * has to be re-tested against an f32 every iteration.
- * @type {number}
- */
-export const MULTISCATTER_LUT_STEPS = 20;
-
-/**
- * Upper bound on the number of subgroups in one workgroup, which is how many partial sums
- * the cross-subgroup reduction has to combine.
- *
- * WGSL pins the subgroup size to a power of two in [4, 128], so the worst case is
- * {@link MULTISCATTER_LUT_DIRECTION_COUNT} / 4.
- * @type {number}
- */
-export const MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS = MULTISCATTER_LUT_DIRECTION_COUNT / 4;
+/**
+ * Directions are drawn on an 8x8 grid, stratified in azimuth and in the cosine of the polar
+ * angle.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_SQRT_SAMPLES = 8;
+
+/**
+ * One thread integrates one direction, so this is also the workgroup size.
+ *
+ * 64 is a multiple of every legal subgroup size up to 64, and the reduction handles a
+ * subgroup wider than the workgroup, so no hardware needs a different number here.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_DIRECTION_COUNT = MULTISCATTER_LUT_SQRT_SAMPLES * MULTISCATTER_LUT_SQRT_SAMPLES;
+
+/**
+ * Ray-march steps per direction for this LUT.
+ *
+ * Compile-time on purpose: as a uniform the inner loop cannot be unrolled and the trip count
+ * has to be re-tested against an f32 every iteration.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_STEPS = 20;
+
+/**
+ * Upper bound on the number of subgroups in one workgroup, which is how many partial sums
+ * the cross-subgroup reduction has to combine.
+ *
+ * WGSL pins the subgroup size to a power of two in [4, 128], so the worst case is
+ * {@link MULTISCATTER_LUT_DIRECTION_COUNT} / 4.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS = MULTISCATTER_LUT_DIRECTION_COUNT / 4;

package/src/shade/renderer/atmosphere/chunk_get_multiscatter_values.d.ts

@@ -6,7 +6,7 @@
  * mean, which is what the paper's uniform phase p_u = 1/(4*PI) reduces to.
  *
  * Splitting one direction out of the loop is what lets `shader_multiscatter_lut` put a
- * thread on each of the 64 directions, the way Hillaire's `NewMultiScattCS` does.
+ * thread on each of the 64 directions.
  *
  * `pos` is assumed to be inside the atmosphere and at or above the surface, which is what
  * makes the far root of the outer sphere the atmosphere exit.

package/src/shade/renderer/atmosphere/chunk_get_multiscatter_values.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_get_multiscatter_values.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_get_multiscatter_values.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;GAgBG;AACH,4CAFU,SAAS,CA4HlB;0BAjJyB,iCAAiC"}
+{"version":3,"file":"chunk_get_multiscatter_values.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_get_multiscatter_values.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;GAgBG;AACH,4CAFU,SAAS,CA2HlB;0BAhJyB,iCAAiC"}