@woosh/meep-engine 3.43.0 → 3.44.0

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