@woosh/meep-engine 3.43.0 → 3.45.0

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/format/texture/basis/transcode/etc1s_to_astc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"etc1s_to_astc.d.ts","sourceRoot":"","sources":["../../../../../../src/format/texture/basis/transcode/etc1s_to_astc.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+DARW,aAAW,SAAS,uEAGlB,UAAU,CA6BtB"}
+{"version":3,"file":"etc1s_to_astc.d.ts","sourceRoot":"","sources":["../../../../../../src/format/texture/basis/transcode/etc1s_to_astc.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+DARW,aAAW,SAAS,uEAGlB,UAAU,CA6BtB"}

package/src/format/texture/basis/transcode/etc1s_to_astc.js

@@ -6,6 +6,7 @@ import {
     astc_write_block
 } from "../astc_block.js";
 import { etc1s_block_colors } from "../etc1s/etc1s_block_colors.js";
+import { number_compare_ascending } from "../../../../core/primitives/numbers/number_compare_ascending.js";
 
 /**
  * Bits a weight takes in the blocks this writes, and the levels that follow from it.
@@ -142,7 +143,7 @@ function fit_block(endpoints_out, weights_out, palette, selector_values, selecto
         }
     }
 
-    used.sort((a, b) => a - b);
+    used.sort(number_compare_ascending);
 
     let best_error = Infinity;
 

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/image_decode_bench/main.js

@@ -1,4 +1,5 @@
 import { jpeg_decode } from "../../../format/image/jpeg/jpeg_decode.js";
+import { number_compare_ascending } from "../../../core/primitives/numbers/number_compare_ascending.js";
 
 /**
  * Measures the trade `ImageRGBADataLoader`'s codec chain makes for a JPEG.
@@ -37,7 +38,7 @@ const table = document.getElementById("results");
  * @returns {number} the median, which a single GC pause cannot move
  */
 function median(values) {
-    const sorted = [...values].sort((a, b) => a - b);
+    const sorted = [...values].sort(number_compare_ascending);
     return sorted[sorted.length >> 1];
 }
 

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/diff_traced_against_rasterized.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diff_traced_against_rasterized.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/diff_traced_against_rasterized.js"],"names":[],"mappings":"AAsaA;;GAEG;AACH,2CAEC;AAoED;;;;;;;;;;;;;;;GAeG;AACH;IAT6B,QAAQ;IACC,MAAM;IAClB,KAAK;IACc,OAAO,UAAhC,OAAO,KAAG,IAAI;IAEN,OAAO,GAAxB,MAAM;IAEJ,QAAQ,MAAM,CAAC,CA2O3B"}
+{"version":3,"file":"diff_traced_against_rasterized.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/diff_traced_against_rasterized.js"],"names":[],"mappings":"AAuaA;;GAEG;AACH,2CAEC;AAoED;;;;;;;;;;;;;;;GAeG;AACH;IAT6B,QAAQ;IACC,MAAM;IAClB,KAAK;IACc,OAAO,UAAhC,OAAO,KAAG,IAAI;IAEN,OAAO,GAAxB,MAAM;IAEJ,QAAQ,MAAM,CAAC,CA2O3B"}

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

@@ -1,4 +1,5 @@
 import { use_flat_environment } from "./flat_environment.js";
+import { number_compare_descending } from "../../../core/primitives/numbers/number_compare_descending.js";
 
 /**
  * Render the current view both ways and show, pixel by pixel, where they disagree.
@@ -415,7 +416,7 @@ function component_sizes(mask, width, height) {
         sizes.push(size);
     }
 
-    sizes.sort((a, b) => b - a);
+    sizes.sort(number_compare_descending);
 
     return sizes;
 }

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"}

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

@@ -1,90 +1,90 @@
-import { assert } from "../../../core/assert.js";
-import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
-import { ShadedGeometry } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
-import { prefab_place } from "../../../engine/graphics3/prefab/prefab_place.js";
-
-/**
- * Stand one character on the floor at `(x, 0, z)`, the way the engine stands one: as entities.
- *
- * ## What a placed character is
- *
- * A prefab instance under a placement entity. The placement's `Transform64` is the offset and
- * nothing else; every node the file had is an entity below it, holding its own offset from its
- * parent in a `TransformAttachment`, and the file's own transform — the centimetre scale and the
- * up-axis rotation an FBX-derived glTF carries on its root — stays where the prefab put it, on the
- * entity that stands for that root. "Compose, do not replace": a `Transform64` composes as
- * `T · R · S`, so a translation written into the file's root would not be the world offset but one
- * the rotation and scale then act on.
- *
- * ## Where the GPU reads it
- *
- * Every entity of the instance holds a row of the `transforms` table, at `entity + 1`, and the
- * hierarchy pass composes each row's `global` from its offset and its parent's row — so the joints
- * the pose accumulator drives are carried by the placement without anyone writing to them. The
- * 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
- * has no systems, so `prefab_place` does the same by hand and in one place — this is it, at a
- * grid position.
- *
- * @param {GPUSceneContext} scene_context the scene's context — its rows are where the instance goes
- * @param {EntityComponentDataset} dataset the dataset the scene is bound to
- * @param {Prefab} prefab the character, compiled once
- * @param {number} x
- * @param {number} z
- * @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}}
- */
-export function place_character(scene_context, dataset, prefab, x, z, { register_animation = true } = {}) {
-    const placement = new Transform64();
-
-    // `Transform64` keeps its matrix by hand: setting a component leaves the matrix holding what it
-    // held before, so the write is only real after `updateMatrix`.
-    placement.setTranslation(x, 0, z);
-    placement.updateMatrix();
-
-    const { root, instance, animation } = prefab_place(scene_context, dataset, prefab, placement, { register_animation });
-
-    return { root, instance, animation };
-}
-
-/**
- * The source geometry a mesh entity draws — for a skinned one, what its clone is a clone of.
- *
- * @param {EntityComponentDataset} dataset
- * @param {number} entity
- * @returns {MeshletGeometry}
- */
-export function geometry_of(dataset, entity) {
-    const geometry = dataset.getComponent(entity, ShadedGeometry);
-
-    assert.defined(geometry, `entity ${entity} carries no ShadedGeometry`);
-
-    return geometry.geometry;
-}
-
-/**
- * Where the `index`-th of `count` characters stands: a square-ish grid centred on the origin, laid
- * out in rows along +x.
- *
- * Centred rather than growing from the origin so that `?count=N` frames the same way for every N —
- * the camera is aimed at the union of the cast, and a grid that walks away from the origin as it
- * grows pushes that union off with it.
- *
- * @param {number} index
- * @param {number} count
- * @param {number} spacing distance between neighbours
- * @returns {{x: number, z: number}}
- */
-export function grid_position(index, count, spacing) {
-    const columns = Math.ceil(Math.sqrt(count));
-    const rows = Math.ceil(count / columns);
-
-    return {
-        x: ((index % columns) - (columns - 1) / 2) * spacing,
-        z: (Math.floor(index / columns) - (rows - 1) / 2) * spacing,
-    };
-}
+import { assert } from "../../../core/assert.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { ShadedGeometry } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { prefab_place } from "../../../engine/graphics3/prefab/prefab_place.js";
+
+/**
+ * Stand one character on the floor at `(x, 0, z)`, the way the engine stands one: as entities.
+ *
+ * ## What a placed character is
+ *
+ * A prefab instance under a placement entity. The placement's `Transform64` is the offset and
+ * nothing else; every node the file had is an entity below it, holding its own offset from its
+ * parent in a `TransformAttachment`, and the file's own transform — the centimetre scale and the
+ * up-axis rotation an FBX-derived glTF carries on its root — stays where the prefab put it, on the
+ * entity that stands for that root. "Compose, do not replace": a `Transform64` composes as
+ * `T · R · S`, so a translation written into the file's root would not be the world offset but one
+ * the rotation and scale then act on.
+ *
+ * ## Where the GPU reads it
+ *
+ * Every entity of the instance holds a row of the `transforms` table, at `entity + 1`, and the
+ * hierarchy pass composes each row's `global` from its offset and its parent's row — so the joints
+ * the pose accumulator drives are carried by the placement without anyone writing to them. The
+ * 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`, `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.
+ *
+ * @param {GPUSceneContext} scene_context the scene's context — its rows are where the instance goes
+ * @param {EntityComponentDataset} dataset the dataset the scene is bound to
+ * @param {Prefab} prefab the character, compiled once
+ * @param {number} x
+ * @param {number} z
+ * @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, skins: Array<{entity: number, skin_id: number}>|null}}
+ */
+export function place_character(scene_context, dataset, prefab, x, z, { register_animation = true } = {}) {
+    const placement = new Transform64();
+
+    // `Transform64` keeps its matrix by hand: setting a component leaves the matrix holding what it
+    // held before, so the write is only real after `updateMatrix`.
+    placement.setTranslation(x, 0, z);
+    placement.updateMatrix();
+
+    const { root, instance, skins } = prefab_place(scene_context, dataset, prefab, placement, { register_animation });
+
+    return { root, instance, skins };
+}
+
+/**
+ * The source geometry a mesh entity draws — for a skinned one, what its clone is a clone of.
+ *
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ * @returns {MeshletGeometry}
+ */
+export function geometry_of(dataset, entity) {
+    const geometry = dataset.getComponent(entity, ShadedGeometry);
+
+    assert.defined(geometry, `entity ${entity} carries no ShadedGeometry`);
+
+    return geometry.geometry;
+}
+
+/**
+ * Where the `index`-th of `count` characters stands: a square-ish grid centred on the origin, laid
+ * out in rows along +x.
+ *
+ * Centred rather than growing from the origin so that `?count=N` frames the same way for every N —
+ * the camera is aimed at the union of the cast, and a grid that walks away from the origin as it
+ * grows pushes that union off with it.
+ *
+ * @param {number} index
+ * @param {number} count
+ * @param {number} spacing distance between neighbours
+ * @returns {{x: number, z: number}}
+ */
+export function grid_position(index, count, spacing) {
+    const columns = Math.ceil(Math.sqrt(count));
+    const rows = Math.ceil(count / columns);
+
+    return {
+        x: ((index % columns) - (columns - 1) / 2) * spacing,
+        z: (Math.floor(index / columns) - (rows - 1) / 2) * spacing,
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_mesh_soup/main.js"],"names":[],"mappings":"AAsMA;;;;GAIG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAmTzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_mesh_soup/main.js"],"names":[],"mappings":"AA+LA;;;;GAIG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAmTzB"}