@woosh/meep-engine 3.23.0 → 3.24.0

package/src/shade/playground/skinned_mesh_soup/verify_clone_vertices.js

@@ -8,25 +8,26 @@
  * with no pattern is the joint palette.
  *
  * This runs in the **bind pose** — `?skin=bind`, no clip registered — because that is the one pose
- * whose answer needs no GPU. At bind, `joint.global × inverse_bind` is the identity for every joint
- * (verified on the CPU for Michelle: every one of her 19 106 vertices lands back on its rest
- * position to the bit), so the blend collapses whatever the weights are and the shader's output is
- * just its input under the mesh-local fold:
+ * whose answer needs no GPU. At bind every joint's skin matrix is the skin's own frame under the
+ * placement, and the mesh entity's row is that same frame under the same placement — the prefab put
+ * it there — so the fold `inverse(mesh.global) × joint.global × inverse_bind` is the identity for
+ * every joint, the blend collapses whatever the weights are, and the shader's output is its input:
  *
  * ```
- * clone_position = inverse(mesh.transform_global) × source_position
+ * clone_position = source_position
  * ```
  *
- * — the leftmost factor of the glTF skinning formula, which `chunk_skin_blend_mesh_local` folds
- * into each joint matrix so the rasterizer can re-apply `mesh.global` afterwards. Nothing about
- * that expression involves the pose, so a disagreement here is the skinning *machinery* — the
- * addressing, the layout, the matrix range — and not the animation.
+ * Wherever the character stands. Nothing about that involves the pose, so a disagreement here is
+ * the skinning *machinery* — the addressing, the layout, the matrix range, the frame — and not the
+ * animation.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
 
 import { assert } from "../../../core/assert.js";
+import { ShadedGeometry } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { ShadedGeometryFlags } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometryFlags.js";
 import {
     MESHLET_METADATA_STRUCT
 } from "../../renderer/geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
@@ -162,9 +163,9 @@ function runs_of(values) {
  * @param {object} options
  * @param {Renderer} options.renderer
  * @param {Scene} options.scene
- * @param {SkinnedMesh} options.mesh
- * @param {number} [options.tolerance] in mesh-local units. Since `register_skin` puts the mesh on
- *        the skin's bind transform, mesh-local *is* world scale — a metre is a metre here, and at
+ * @param {number} options.entity a skinned mesh entity
+ * @param {number} [options.tolerance] in mesh-local units. Since compiling the model puts the mesh
+ *        on the skin's bind transform, mesh-local *is* world scale — a metre is a metre here, and at
  *        bind the clone should hold the source's own positions. `1e-4` is f32 headroom over a
  *        chain — a matrix product, a quaternion conversion and a screw motion, all at single
  *        precision — against a smallest real violation of `1.6`, so there are four orders between
@@ -173,9 +174,19 @@ function runs_of(values) {
  *        the CPU now reads zero at bind.
  * @returns {Promise<object>}
  */
-export async function verify_clone_vertices({ renderer, scene, mesh, tolerance = 1e-4 }) {
-    assert.defined(mesh, 'mesh');
-    assert.equal(mesh.isSkinnedMesh, true, 'mesh.isSkinnedMesh !== true');
+export async function verify_clone_vertices({ renderer, scene, entity, tolerance = 1e-4 }) {
+    assert.isNonNegativeInteger(entity, 'entity');
+
+    const dataset = scene.dataset;
+
+    assert.defined(dataset, 'scene.dataset');
+
+    const shaded = dataset.getComponent(entity, ShadedGeometry);
+
+    assert.defined(shaded, `entity ${entity} carries no ShadedGeometry`);
+    assert.ok(shaded.getFlag(ShadedGeometryFlags.Skinned), `entity ${entity} is not a skinned mesh`);
+
+    const geometry = shaded.geometry;
 
     const graphics = renderer.graphics;
     const device = graphics.device;
@@ -183,7 +194,16 @@ export async function verify_clone_vertices({ renderer, scene, mesh, tolerance =
 
     const scene_context = renderer.scenes.obtain(scene);
 
-    const geometry_index = scene_context.skinning.obtain_geometry_index(mesh);
+    const clone = scene_context.skinning.clone_of(entity);
+
+    if (clone === undefined) {
+        return {
+            verdict: `FAIL — entity ${entity} has no clone; its mesh row has not been written, or it `
+                + `is not skinned`,
+        };
+    }
+
+    const geometry_index = clone.index;
 
     // ---- where the clone's meshlets are, as the GPU has it -------------------------------------
 
@@ -201,7 +221,7 @@ export async function verify_clone_vertices({ renderer, scene, mesh, tolerance =
         GEOMETRY_METADATA_STRUCT.get('meshlets_count').offset, true
     );
 
-    const source_batch = mesh.geometry.meshlets;
+    const source_batch = geometry.meshlets;
 
     if (meshlets_count !== source_batch.count) {
         return {
@@ -234,7 +254,7 @@ export async function verify_clone_vertices({ renderer, scene, mesh, tolerance =
      source no rasterizer ever wanted deformed goes with them. The addresses differing by one
      constant is the whole contract, and it is checkable before a single vertex is compared.
     */
-    const source_record = geometries.get_metadata(mesh.geometry);
+    const source_record = geometries.get_metadata(geometry);
 
     if (source_record === undefined) {
         return {
@@ -307,11 +327,7 @@ export async function verify_clone_vertices({ renderer, scene, mesh, tolerance =
         (data_high - data_low) * 4
     ));
 
-    // ---- the answer the CPU knows ---------------------------------------------------------------
-
-    const to_mesh_local = affine_inverse(mesh.transform_global.matrix);
-
-    // ---- and the comparison ---------------------------------------------------------------------
+    // ---- the comparison: the answer the CPU knows is the source itself ---------------------------------------------------------------------
 
     let vertices = 0;
     let wrong = 0;
@@ -356,17 +372,10 @@ export async function verify_clone_vertices({ renderer, scene, mesh, tolerance =
         for (let v = 0; v < clone_vertex_count; v++) {
             vertices++;
 
-            const expected = transform_point(
-                to_mesh_local,
-                source.attribute_position[v * 3],
-                source.attribute_position[v * 3 + 1],
-                source.attribute_position[v * 3 + 2],
-            );
-
             const error = Math.max(
-                Math.abs(positions[v * 3] - expected[0]),
-                Math.abs(positions[v * 3 + 1] - expected[1]),
-                Math.abs(positions[v * 3 + 2] - expected[2]),
+                Math.abs(positions[v * 3] - source.attribute_position[v * 3]),
+                Math.abs(positions[v * 3 + 1] - source.attribute_position[v * 3 + 1]),
+                Math.abs(positions[v * 3 + 2] - source.attribute_position[v * 3 + 2]),
             );
 
             if (error > worst) {

package/src/shade/playground/sponza_path_trace/main.d.ts

@@ -5,4 +5,5 @@
  * @returns {Promise<void>}
  */
 export function start(): Promise<void>;
+export type SceneBundle = import("../../renderer/loader/SceneBundle.js").SceneBundle;
 //# sourceMappingURL=main.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/sponza_path_trace/main.js"],"names":[],"mappings":"AA+IA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAuNzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/sponza_path_trace/main.js"],"names":[],"mappings":"AA2KA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAyNzB;0BAhRY,OAAO,sCAAsC,EAAE,WAAW"}