@woosh/meep-engine 3.43.0 → 3.44.0

package/src/engine/physics/cloth/solver/constraint/cloth_self_row.d.ts

@@ -56,11 +56,13 @@ export function cloth_self_accumulate(accumulator: Float64Array, state: ClothSta
  *
  * A self-collision row carries nothing of the kind. What it holds apart is cloth
  * against cloth — grams, moving at the speed cloth moves relative to itself — and
- * a penalty at the top of the band produces newtons per millimetre against a
- * load of fractions of a newton. So it is a plain penalty with no multiplier, no
- * warm start and no identity across steps, which is also what makes a pair list
- * that is rebuilt from scratch every step affordable: there is nothing on a pair
- * worth carrying. `MEASUREMENTS.md` §33.
+ * at a quarter of the way up the band the penalty still produces 0.29 N per
+ * millimetre against a particle's weight of 0.2 N: a fold resting on a fold
+ * sinks into it by under a millimetre per particle it carries. So it is a plain
+ * penalty with no multiplier, no warm start and no identity across steps, which
+ * is also what makes a pair list that is rebuilt from scratch every step
+ * affordable: there is nothing on a pair worth carrying. `MEASUREMENTS.md` §33,
+ * and §65 for the stiffness.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

package/src/engine/physics/cloth/solver/constraint/cloth_self_row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_self_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_self_row.js"],"names":[],"mappings":"AAoEA;;;;;;;;;;GAUG;AACH,4EAJW,MAAM,GAEJ,MAAM,CA4FlB;AAED;;;;;;GAMG;AACH,mDAJW,YAAY,+BAEZ,MAAM,QAyBhB;AA7LD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;GAKG;AACH,iCAFU,MAAM,CAEuB"}
+{"version":3,"file":"cloth_self_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_self_row.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;GAUG;AACH,4EAJW,MAAM,GAEJ,MAAM,CA4FlB;AAED;;;;;;GAMG;AACH,mDAJW,YAAY,+BAEZ,MAAM,QAyBhB;AA/LD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH;;;;;GAKG;AACH,iCAFU,MAAM,CAEuB"}

package/src/engine/physics/cloth/solver/constraint/cloth_self_row.js

@@ -48,11 +48,13 @@ import {
  *
  * A self-collision row carries nothing of the kind. What it holds apart is cloth
  * against cloth — grams, moving at the speed cloth moves relative to itself — and
- * a penalty at the top of the band produces newtons per millimetre against a
- * load of fractions of a newton. So it is a plain penalty with no multiplier, no
- * warm start and no identity across steps, which is also what makes a pair list
- * that is rebuilt from scratch every step affordable: there is nothing on a pair
- * worth carrying. `MEASUREMENTS.md` §33.
+ * at a quarter of the way up the band the penalty still produces 0.29 N per
+ * millimetre against a particle's weight of 0.2 N: a fold resting on a fold
+ * sinks into it by under a millimetre per particle it carries. So it is a plain
+ * penalty with no multiplier, no warm start and no identity across steps, which
+ * is also what makes a pair list that is rebuilt from scratch every step
+ * affordable: there is nothing on a pair worth carrying. `MEASUREMENTS.md` §33,
+ * and §65 for the stiffness.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

package/src/engine/physics/cloth/wind/cloth_sample_air.d.ts

@@ -43,15 +43,15 @@
  *
  * @param {ClothState} state
  * @param {AbstractClothWind} wind
- * @param {Float64Array} anchor_translation the cloth frame's world origin
- * @param {Float64Array} anchor_rotation the cloth frame's world rotation, xyzw
+ * @param {Float64Array} frame_translation the cloth frame's world origin
+ * @param {Float64Array} frame_rotation the cloth frame's world rotation, xyzw
  * @param {Float64Array} [centre] written with the world-space air at the cloth's
  *   own centre — what the sleep test compares against next step
  * @param {number} [time] seconds this cloth has stepped, the clock its gust is a
  *   function of — see {@link AbstractClothWind}
  * @returns {boolean} whether the source was sampled per particle
  */
-export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, anchor_translation: Float64Array, anchor_rotation: Float64Array, centre?: Float64Array, time?: number): boolean;
+export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, frame_translation: Float64Array, frame_rotation: Float64Array, centre?: Float64Array, time?: number): boolean;
 /**
  * Whether the air at the cloth's centre has moved far enough since the last step
  * that actually applied it to be worth waking for — §10's "sleep wakes on a wind
@@ -78,8 +78,8 @@ export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, anc
  *
  * @param {ClothState} state
  * @param {AbstractClothWind} wind
- * @param {Float64Array} anchor_translation
- * @param {Float64Array} anchor_rotation
+ * @param {Float64Array} frame_translation
+ * @param {Float64Array} frame_rotation
  * @param {Float64Array} previous the air last applied to this cloth, world-space
  * @param {number} threshold m/s
  * @param {number} time seconds the cloth has stepped — the clock its gust is a
@@ -87,7 +87,7 @@ export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, anc
  *   have, because it has to be asking about the air that step would feel
  * @returns {boolean}
  */
-export function cloth_air_changed(state: ClothState, wind: AbstractClothWind, anchor_translation: Float64Array, anchor_rotation: Float64Array, previous: Float64Array, threshold: number, time: number): boolean;
+export function cloth_air_changed(state: ClothState, wind: AbstractClothWind, frame_translation: Float64Array, frame_rotation: Float64Array, previous: Float64Array, threshold: number, time: number): boolean;
 /**
  * The cloth's world-space axis-aligned bounds.
  *
@@ -97,10 +97,10 @@ export function cloth_air_changed(state: ClothState, wind: AbstractClothWind, an
  * a rotated box is not a box.
  *
  * @param {ClothState} state
- * @param {Float64Array} anchor_translation
- * @param {Float64Array} anchor_rotation
+ * @param {Float64Array} frame_translation
+ * @param {Float64Array} frame_rotation
  * @param {Float64Array} out six words, min then max
  * @returns {void}
  */
-export function cloth_air_bounds(state: ClothState, anchor_translation: Float64Array, anchor_rotation: Float64Array, out: Float64Array): void;
+export function cloth_air_bounds(state: ClothState, frame_translation: Float64Array, frame_rotation: Float64Array, out: Float64Array): void;
 //# sourceMappingURL=cloth_sample_air.d.ts.map

package/src/engine/physics/cloth/wind/cloth_sample_air.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_sample_air.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/cloth_sample_air.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;;;;;GAaG;AACH,iGARW,YAAY,mBACZ,YAAY,WACZ,YAAY,SAEZ,MAAM,GAEJ,OAAO,CA8EnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,kGATW,YAAY,mBACZ,YAAY,YACZ,YAAY,aACZ,MAAM,QACN,MAAM,GAGJ,OAAO,CAsBnB;AAED;;;;;;;;;;;;;GAaG;AACH,wEALW,YAAY,mBACZ,YAAY,OACZ,YAAY,GACV,IAAI,CAoEhB"}
+{"version":3,"file":"cloth_sample_air.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/cloth_sample_air.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;;;;;GAaG;AACH,gGARW,YAAY,kBACZ,YAAY,WACZ,YAAY,SAEZ,MAAM,GAEJ,OAAO,CA8EnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,iGATW,YAAY,kBACZ,YAAY,YACZ,YAAY,aACZ,MAAM,QACN,MAAM,GAGJ,OAAO,CAsBnB;AAED;;;;;;;;;;;;;GAaG;AACH,uEALW,YAAY,kBACZ,YAAY,OACZ,YAAY,GACV,IAAI,CAoEhB"}

package/src/engine/physics/cloth/wind/cloth_sample_air.js

@@ -47,15 +47,15 @@ import { v3_quaternion_apply_inverse } from "../../../../core/geom/vec3/v3_quate
  *
  * @param {ClothState} state
  * @param {AbstractClothWind} wind
- * @param {Float64Array} anchor_translation the cloth frame's world origin
- * @param {Float64Array} anchor_rotation the cloth frame's world rotation, xyzw
+ * @param {Float64Array} frame_translation the cloth frame's world origin
+ * @param {Float64Array} frame_rotation the cloth frame's world rotation, xyzw
  * @param {Float64Array} [centre] written with the world-space air at the cloth's
  *   own centre — what the sleep test compares against next step
  * @param {number} [time] seconds this cloth has stepped, the clock its gust is a
  *   function of — see {@link AbstractClothWind}
  * @returns {boolean} whether the source was sampled per particle
  */
-export function cloth_sample_air(state, wind, anchor_translation, anchor_rotation, centre = undefined, time = 0) {
+export function cloth_sample_air(state, wind, frame_translation, frame_rotation, centre = undefined, time = 0) {
     const particle_count = state.particle_count;
 
     const air = state.air_velocity;
@@ -66,16 +66,16 @@ export function cloth_sample_air(state, wind, anchor_translation, anchor_rotatio
 
     const position = state.position;
 
-    const anchor_x = anchor_translation[0];
-    const anchor_y = anchor_translation[1];
-    const anchor_z = anchor_translation[2];
+    const frame_x = frame_translation[0];
+    const frame_y = frame_translation[1];
+    const frame_z = frame_translation[2];
 
-    const qx = anchor_rotation[0];
-    const qy = anchor_rotation[1];
-    const qz = anchor_rotation[2];
-    const qw = anchor_rotation[3];
+    const qx = frame_rotation[0];
+    const qy = frame_rotation[1];
+    const qz = frame_rotation[2];
+    const qw = frame_rotation[3];
 
-    cloth_air_bounds(state, anchor_translation, anchor_rotation, BOUNDS);
+    cloth_air_bounds(state, frame_translation, frame_rotation, BOUNDS);
 
     const varies = wind.varies(BOUNDS[0], BOUNDS[1], BOUNDS[2], BOUNDS[3], BOUNDS[4], BOUNDS[5]);
 
@@ -121,7 +121,7 @@ export function cloth_sample_air(state, wind, anchor_translation, anchor_rotatio
 
         v3_quaternion_apply(WORLD, 0, position[p], position[p + 1], position[p + 2], qx, qy, qz, qw);
 
-        wind.sample(SAMPLE, WORLD[0] + anchor_x, WORLD[1] + anchor_y, WORLD[2] + anchor_z, time);
+        wind.sample(SAMPLE, WORLD[0] + frame_x, WORLD[1] + frame_y, WORLD[2] + frame_z, time);
 
         v3_quaternion_apply_inverse(LOCAL, 0, SAMPLE[0], SAMPLE[1], SAMPLE[2], qx, qy, qz, qw);
 
@@ -159,8 +159,8 @@ export function cloth_sample_air(state, wind, anchor_translation, anchor_rotatio
  *
  * @param {ClothState} state
  * @param {AbstractClothWind} wind
- * @param {Float64Array} anchor_translation
- * @param {Float64Array} anchor_rotation
+ * @param {Float64Array} frame_translation
+ * @param {Float64Array} frame_rotation
  * @param {Float64Array} previous the air last applied to this cloth, world-space
  * @param {number} threshold m/s
  * @param {number} time seconds the cloth has stepped — the clock its gust is a
@@ -168,12 +168,12 @@ export function cloth_sample_air(state, wind, anchor_translation, anchor_rotatio
  *   have, because it has to be asking about the air that step would feel
  * @returns {boolean}
  */
-export function cloth_air_changed(state, wind, anchor_translation, anchor_rotation, previous, threshold, time) {
+export function cloth_air_changed(state, wind, frame_translation, frame_rotation, previous, threshold, time) {
     if (state.particle_count === 0) {
         return false;
     }
 
-    cloth_air_bounds(state, anchor_translation, anchor_rotation, BOUNDS);
+    cloth_air_bounds(state, frame_translation, frame_rotation, BOUNDS);
 
     wind.sample(
         SAMPLE,
@@ -199,12 +199,12 @@ export function cloth_air_changed(state, wind, anchor_translation, anchor_rotati
  * a rotated box is not a box.
  *
  * @param {ClothState} state
- * @param {Float64Array} anchor_translation
- * @param {Float64Array} anchor_rotation
+ * @param {Float64Array} frame_translation
+ * @param {Float64Array} frame_rotation
  * @param {Float64Array} out six words, min then max
  * @returns {void}
  */
-export function cloth_air_bounds(state, anchor_translation, anchor_rotation, out) {
+export function cloth_air_bounds(state, frame_translation, frame_rotation, out) {
     const particle_count = state.particle_count;
 
     const position = state.position;
@@ -231,10 +231,10 @@ export function cloth_air_bounds(state, anchor_translation, anchor_rotation, out
         if (z > max_z) { max_z = z; }
     }
 
-    const qx = anchor_rotation[0];
-    const qy = anchor_rotation[1];
-    const qz = anchor_rotation[2];
-    const qw = anchor_rotation[3];
+    const qx = frame_rotation[0];
+    const qy = frame_rotation[1];
+    const qz = frame_rotation[2];
+    const qw = frame_rotation[3];
 
     let world_min_x = Infinity;
     let world_min_y = Infinity;
@@ -252,9 +252,9 @@ export function cloth_air_bounds(state, anchor_translation, anchor_rotation, out
             qx, qy, qz, qw
         );
 
-        const x = WORLD[0] + anchor_translation[0];
-        const y = WORLD[1] + anchor_translation[1];
-        const z = WORLD[2] + anchor_translation[2];
+        const x = WORLD[0] + frame_translation[0];
+        const y = WORLD[1] + frame_translation[1];
+        const z = WORLD[2] + frame_translation[2];
 
         if (x < world_min_x) { world_min_x = x; }
         if (y < world_min_y) { world_min_y = y; }

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

@@ -66,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#430@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#432@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#430@#clear_field"(fluid: FluidComponent): void;
+    static "__#432@#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 "__#430@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#432@#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 "__#430@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#432@#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 RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];

package/src/engine/simulation/Ticker.d.ts

@@ -4,6 +4,10 @@ export default Ticker;
  * Dispatches "tick" every animation frame or "maxDelay" time, whichever happens to be soonest
  * This is essentially the timing bus that all the simulation systems subscribe to for their step advancement
  *
+ * A tick taken in an animation frame runs inside that frame and is measured to the frame's timestamp,
+ * and {@link Ticker#onFrame} follows it, so whatever draws from `onFrame` draws the simulation as of
+ * that frame.
+ *
  *
  * @example
  *      ticker.onTick.add(delta_s => {
@@ -40,6 +44,14 @@ declare class Ticker {
      * @type {Signal<number>}
      */
     readonly onTick: any;
+    /**
+     * Dispatched once per animation frame, after that frame's tick - or with none, while paused or
+     * suspended. The place to draw: the simulation is at the frame's timestamp here.
+     * Not dispatched for the {@link start}'s `maxTimeout` fallback ticks, which are not frames.
+     * @readonly
+     * @type {Signal}
+     */
+    readonly onFrame: Signal;
     /**
      * Whether the update loop is cycling. {@link Ticker#pause} and {@link Ticker#resume} require this,
      * they throw otherwise.
@@ -66,4 +78,5 @@ declare class Ticker {
     #private;
 }
 import Clock from '../Clock.js';
+import Signal from "../../core/events/signal/Signal.js";
 //# sourceMappingURL=Ticker.d.ts.map

package/src/engine/simulation/Ticker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ticker.d.ts","sourceRoot":"","sources":["../../../../src/engine/simulation/Ticker.js"],"names":[],"mappings":";AAIA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;OAGG;IACH,gBAFU,KAAK,CAEK;IAEpB;;;;;;;;;;;;OAYG;IACH,uBAFU,OAAO,CAEY;IAkC7B;;;;OAIG;IACH,qBAAsB;IA2BtB;;;;OAIG;IACH,yBAEC;IAED;;;;OAIG;IACH,yBAEC;IAuGD;;;;OAIG;IACH;QAF4B,UAAU,GAA3B,MAAM;aAkFhB;IAED,cAWC;IAED,eAaC;IAED,aAaC;;CACJ;kBA/ViB,aAAa"}
+{"version":3,"file":"Ticker.d.ts","sourceRoot":"","sources":["../../../../src/engine/simulation/Ticker.js"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;OAGG;IACH,gBAFU,KAAK,CAEK;IAEpB;;;;;;;;;;;;OAYG;IACH,uBAFU,OAAO,CAEY;IAkC7B;;;;OAIG;IACH,qBAAsB;IAEtB;;;;;;OAMG;IACH,kBAFU,MAAM,CAEO;IA2BvB;;;;OAIG;IACH,yBAEC;IAED;;;;OAIG;IACH,yBAEC;IAuGD;;;;OAIG;IACH;QAF4B,UAAU,GAA3B,MAAM;aAuGhB;IAED,cAWC;IAED,eAaC;IAED,aAaC;;CACJ;kBAjYiB,aAAa;mBAFZ,oCAAoC"}

package/src/engine/simulation/Ticker.js

@@ -1,5 +1,6 @@
 import { assert } from "../../core/assert.js";
 import Signal from "../../core/events/signal/Signal.js";
+import { current_time_in_seconds } from "../../core/time/current_time_in_seconds.js";
 import Clock from '../Clock.js';
 
 /**
@@ -7,6 +8,10 @@ import Clock from '../Clock.js';
  * Dispatches "tick" every animation frame or "maxDelay" time, whichever happens to be soonest
  * This is essentially the timing bus that all the simulation systems subscribe to for their step advancement
  *
+ * A tick taken in an animation frame runs inside that frame and is measured to the frame's timestamp,
+ * and {@link Ticker#onFrame} follows it, so whatever draws from `onFrame` draws the simulation as of
+ * that frame.
+ *
  *
  * @example
  *      ticker.onTick.add(delta_s => {
@@ -78,6 +83,15 @@ class Ticker {
      */
     onTick = new Signal();
 
+    /**
+     * Dispatched once per animation frame, after that frame's tick - or with none, while paused or
+     * suspended. The place to draw: the simulation is at the frame's timestamp here.
+     * Not dispatched for the {@link start}'s `maxTimeout` fallback ticks, which are not frames.
+     * @readonly
+     * @type {Signal}
+     */
+    onFrame = new Signal();
+
     constructor() {
         this.clock.pause();
     }
@@ -242,12 +256,15 @@ class Ticker {
         const generation = this.#generation;
         const is_current = () => this.#generation === generation;
 
-        const update = () => {
+        /**
+         * @param {number} time in seconds, on the {@link current_time_in_seconds} timeline
+         */
+        const update = (time) => {
             if (!this.#isRunning || this.#isSuspended) {
                 return;
             }
 
-            const delta = this.clock.getDelta();
+            const delta = this.clock.getDeltaAt(time);
 
             this.#last_tick_delta_s = delta;
 
@@ -261,28 +278,46 @@ class Ticker {
                 return;
             }
 
-            animate();
+            animate(current_time_in_seconds());
         }
 
-        const animationFrameCallback = () => {
+        /**
+         * @param {number} timestamp the frame's, in milliseconds
+         */
+        const animationFrameCallback = (timestamp) => {
             clearTimeout(this.#timeoutHandle);
 
             if (!is_current()) {
                 return;
             }
 
-            //push tick beyond animation frame stack allowing draw to happen
-            this.#timeoutHandle = setTimeout(animate, 0);
+            /*
+             Ticked here, on the frame's own timestamp, and before the frame is announced. This used to
+             be pushed to a setTimeout(0) "allowing draw to happen" first, which made every frame draw
+             the simulation as of the previous frame's timeout - and that fired whenever the previous
+             draw finished, so a steady motion was drawn at a different speed every frame.
+            */
+            animate(timestamp * 1e-3);
+
+            //a tick listener is allowed to stop us
+            if (!is_current()) {
+                return;
+            }
+
+            this.onFrame.send0();
         }
 
-        const animate = () => {
+        /**
+         * @param {number} time in seconds, on the {@link current_time_in_seconds} timeline
+         */
+        const animate = (time) => {
             if (!is_current()) {
                 return;
             }
 
             this.#animationFrameHandle = requestAnimationFrame(animationFrameCallback);
 
-            update();
+            update(time);
 
             //update() dispatches onTick, and a listener is allowed to stop us from inside it
             if (!is_current()) {

package/src/shade/RENDERER_CONTRACT.md

@@ -258,9 +258,10 @@ geometry.getAttribute(StandardAttributes.Position).data   // Float32Array
 geometry.index.data                                       // Uint32Array
 ```
 
-Seven generators ship, all returning a `Geometry`, in `renderer/geometry/primitives/`:
+Ten generators ship, all returning a `Geometry`, in `renderer/geometry/primitives/`:
 `make_box_geometry`, `make_plane_geometry`, `make_polyhedron_geometry`, `make_octahedron_geometry`,
-`make_torus_geometry`, `make_cylinder_geometry`, `make_torus_knot_geometry`.
+`make_uv_sphere_geometry`, `make_capsule_geometry`, `make_cylinder_geometry`, `make_cone_geometry`,
+`make_torus_geometry`, `make_torus_knot_geometry`.
 
 **`MeshletGeometry`** is the GPU form: triangles clustered into meshlets, attributes encoded, and a
 BVH over the clusters. This is what a mesh row names, and it is what buys cluster culling and a
@@ -273,6 +274,11 @@ const meshlets = meshlet_geometry_build_from_geometry(geometry);
 **That build is a precompute.** Do it once, when the content is created or loaded. If your vertices
 change every frame, you are on the wrong path — see §8.
 
+Seven of the primitives also come ready built, as `MeshletGeometry` subclasses one per module in
+`renderer/geometry/`: `BoxGeometry`, `PlaneGeometry`, `UVSphereGeometry`, `CapsuleGeometry`,
+`CylinderGeometry`, `ConeGeometry` and `TorusGeometry`. Each constructor runs its generator and then
+this build, so constructing one is the same precompute.
+
 ### Materials
 
 `ShadeMaterial` is the base: `transparency_mode`, `draw_mode` and `draw_side`.

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

@@ -3,7 +3,8 @@ import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDatas
 import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
 import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
-import { BoxGeometry, PlaneGeometry } from "../../renderer/geometry/BoxGeometry.js";
+import { BoxGeometry } from "../../renderer/geometry/BoxGeometry.js";
+import { PlaneGeometry } from "../../renderer/geometry/PlaneGeometry.js";
 import { make_sunlight } from "../../renderer/light/make_sunlight.js";
 import { place_light } from "../../renderer/light/place_light.js";
 import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";

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

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

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

@@ -11,6 +11,8 @@ import { create_frame_loop } from "../../renderer/create_frame_loop.js";
 import { make_sunlight } from "../../renderer/light/make_sunlight.js";
 import { place_light } from "../../renderer/light/place_light.js";
 import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
+import { MeshSkin } from "../../../engine/graphics/ecs/mesh-v2/MeshSkin.js";
+import { AnimationClips } from "../../../engine/graphics3/animation/AnimationClips.js";
 import { prefab_compile } from "../../../engine/graphics3/prefab/prefab_compile.js";
 import { load_gltf } from "../../renderer/loader/gltf/load_gltf.js";
 import { row_of_entity } from "../../renderer/scene/rows/GPUSceneRows.js";
@@ -161,25 +163,15 @@ class FrameTimer {
 }
 
 /**
- * Every skinned mesh entity an instance's skins deform.
- *
- * Off the skins rather than by walking the entities: a skin already lists exactly the meshes that
- * bind to it, which is what `register_skin` uses, so this cannot disagree with what actually gets
- * deformed.
+ * Every mesh entity of an instance that a skin deforms: the ones carrying a `MeshSkin`, which is
+ * exactly what gets registered and bound.
  *
+ * @param {EntityComponentDataset} dataset
  * @param {PrefabInstance} instance
  * @returns {number[]}
  */
-function skinned_meshes_of(instance) {
-    const meshes = new Set();
-
-    for (const skin of instance.skins) {
-        for (const mesh of skin.meshes) {
-            meshes.add(mesh);
-        }
-    }
-
-    return [...meshes];
+function skinned_meshes_of(dataset, instance) {
+    return Array.from(instance.mesh_entities).filter(entity => dataset.getComponent(entity, MeshSkin) !== undefined);
 }
 
 /**
@@ -201,9 +193,9 @@ function add_dancer(scene_context, dataset, prefab, index, count) {
     // what has to move. See `place_character`.
     const { x, z } = grid_position(index, count, SPACING);
 
-    const { instance } = place_character(scene_context, dataset, prefab, x, z);
+    const { root, instance } = place_character(scene_context, dataset, prefab, x, z);
 
-    const meshes = skinned_meshes_of(instance);
+    const meshes = skinned_meshes_of(dataset, instance);
 
     if (meshes.length === 0) {
         throw new Error(`${CHARACTER_URL} has no skinned mesh — nothing here has a BLAS to refit`);
@@ -214,8 +206,8 @@ function add_dancer(scene_context, dataset, prefab, index, count) {
     // One clip, looping, at full weight. The pose accumulator sums every *bound* clip whatever its
     // weight, so binding the T-pose alongside the dance would blend the two rather than leave the
     // dance alone — only what should play is registered.
-    const clip = instance.clips.find(candidate => /samba|dance/i.test(candidate.name ?? ''))
-        ?? instance.clips[0];
+    const clips = dataset.getComponent(root, AnimationClips).clips;
+    const clip = clips.find(candidate => /samba|dance/i.test(candidate.name ?? '')) ?? clips[0];
 
     if (clip !== undefined) {
         const clip_id = animations.register_clip(clip);

package/src/shade/playground/skinned_blas_refit/place_character.d.ts

@@ -19,7 +19,7 @@
  * primitives hold a row of the `meshes` table too, over a clone of their geometry when the mesh is
  * skinned, which is the region the skinning pass deforms and the BLAS refit follows.
  *
- * This is what `MeshSystem` and `ShadedGeometrySystem` do between them for a game; a playground
+ * This is what `MeshSystem`, `ShadedGeometrySystem` and `MeshSkinSystem` do between them for a game; a playground
  * has no systems, so `prefab_place` does the same by hand and in one place — this is it, at a
  * grid position.
  *
@@ -31,14 +31,17 @@
  * @param {object} [options]
  * @param {boolean} [options.register_animation] whether the instance's skins are registered; off
  *        leaves a skinned mesh's clone undeformed, which is a question of its own
- * @returns {{root: number, instance: PrefabInstance, animation: InstanceAnimationRegistration|null}}
+ * @returns {{root: number, instance: PrefabInstance, skins: Array<{entity: number, skin_id: number}>|null}}
  */
 export function place_character(scene_context: GPUSceneContext, dataset: EntityComponentDataset, prefab: Prefab, x: number, z: number, { register_animation }?: {
     register_animation?: boolean;
 }): {
     root: number;
     instance: PrefabInstance;
-    animation: InstanceAnimationRegistration | null;
+    skins: Array<{
+        entity: number;
+        skin_id: number;
+    }> | null;
 };
 /**
  * The source geometry a mesh entity draws — for a skinned one, what its clone is a clone of.

package/src/shade/playground/skinned_blas_refit/place_character.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"place_character.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/place_character.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,oHAPW,MAAM,KACN,MAAM;IAEY,kBAAkB,GAApC,OAAO;IAEL;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,iBAAiB;IAAC,SAAS,EAAE,gCAA8B,IAAI,CAAA;CAAC,CAanG;AAED;;;;;;GAMG;AACH,qEAHW,MAAM,mBAShB;AAED;;;;;;;;;;;;GAYG;AACH,qCALW,MAAM,SACN,MAAM,WACN,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAUlC"}
+{"version":3,"file":"place_character.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/place_character.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,oHAPW,MAAM,KACN,MAAM;IAEY,kBAAkB,GAApC,OAAO;IAEL;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,iBAAiB;IAAC,KAAK,EAAE,MAAM;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,GAAC,IAAI,CAAA;CAAC,CAa1G;AAED;;;;;;GAMG;AACH,qEAHW,MAAM,mBAShB;AAED;;;;;;;;;;;;GAYG;AACH,qCALW,MAAM,SACN,MAAM,WACN,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAUlC"}