@woosh/meep-engine 3.24.0 → 3.25.0

package/src/shade/renderer/scene/rows/GPUSceneRows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAWA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAmID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAuChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QA2BjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAsCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IAmMD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;OAEG;IACH,gBA+BC;;CACJ;qCAnmCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}
+{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAYA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAmID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAuChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QAgDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAsCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IAmMD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;OAEG;IACH,gBA+BC;;CACJ;qCAxnCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}

package/src/shade/renderer/scene/rows/GPUSceneRows.js

@@ -8,6 +8,7 @@ import { Transform64 } from "../../../../engine/ecs/transform/Transform64.js";
 import { generate_record_writer } from "../../buffer/table/serde/generate_record_writer.js";
 import { MESH_INSTANCE_METADATA_STRUCT } from "../MESH_INSTANCE_METADATA_STRUCT.js";
 import { NODE3D_SCENE_ID, NODE3D_STRUCT } from "../NODE3D_STRUCT.js";
+import { TransparencyMode } from "../../material/TransparencyMode.js";
 
 /**
  * @typedef {import("../../../../engine/ecs/EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
@@ -640,6 +641,27 @@ export class GPUSceneRows {
         assert.defined(material, 'material');
         assert.isBoolean(skinned, 'skinned');
 
+        if (geometry.isVirtualGeometry === true
+            && material.transparency_mode !== TransparencyMode.Opaque) {
+            /*
+             It would draw nothing at all, silently. A virtual geometry expands to zero static
+             meshlets by construction, and the cut that fills that gap runs only in the opaque
+             rasterization paths — `prepare_meshlet_draw_commands_by_material`, which serves the
+             transparent and alpha-tested buckets, has no seam. VIRTUAL_GEOMETRY_DESIGN §9 scopes
+             v1 that way; what it did not do until now was say so, and the code cited it anyway
+             (REVIEW_LEDGER M14).
+
+             A warning rather than a refusal, because the attachment is otherwise legal and the
+             asset is fine — what is missing is a path, and the next campaign may add one.
+             */
+            console.warn(
+                `virtual geometry: entity ${entity} carries a ${
+                    geometry.name ?? 'virtual'
+                } geometry with a non-opaque material, and will draw nothing.`
+                + ` The cut runs only in the opaque paths (DESIGN §9).`
+            );
+        }
+
         let entry = this.#mesh_entries.get(entity);
 
         if (entry === undefined) {

package/src/shade/renderer/shader/chunk/geometry/mat3/chunk_mat3_singular_values.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The largest and smallest singular values of a 3×3 matrix.
+ *
+ * They are what "how much does this transform stretch a distance" actually means: a vector's length
+ * is scaled by something between σ_min and σ_max, and both bounds are attained. Column lengths are
+ * the obvious stand-in and they are **not** the same number — for
+ * `[[1,0,0],[k,1,0],[0,0,1]]`, every column has length 1 or √(1+k²) while the true ratio grows
+ * without bound in `k`. A shear has no scale in any column and stretches space anyway.
+ *
+ * Computed as the square roots of the eigenvalues of `MᵀM`, which is symmetric and positive
+ * semi-definite, through the closed form for a symmetric 3×3 (Smith 1961). No iteration, no
+ * branching past the diagonal case, and **exact for a uniform scale**: `MᵀM` is then `s²I`, the
+ * off-diagonal sum is zero, and both values come back as `s`. That matters more than the general
+ * case — a conservative bound that answered 5.2 for an unscaled instance would over-refine every
+ * ordinary object in a scene to buy correctness for a sheared one.
+ *
+ * **Not a degeneracy test.** σ_min is zero exactly when the matrix is singular *in exact
+ * arithmetic*, and this once said so without the qualifier. In f32 it holds only on the diagonal
+ * branch: the trigonometric one computes the smallest eigenvalue as a difference of nearly equal
+ * numbers, and the `sqrt` turns its absolute error of about `eps·σ_max²` into about
+ * `sqrt(eps)·σ_max ≈ 3.4e-4·σ_max` in σ_min. A rotated matrix with one column of zeros therefore
+ * comes back with a σ_min near 1e-4 rather than 0, and a caller testing `σ_min > 0` before
+ * inverting is let through with the NaN it was guarding against
+ * (`shader_vgeo_cut_collect`, REVIEW_LEDGER M3). A caller about to invert should test the
+ * **determinant**, which is the number the inverse divides by and which is exactly zero whenever a
+ * column is.
+ *
+ * @type {CodeChunk}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const chunk_mat3_singular_values: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mat3_singular_values.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/mat3/chunk_mat3_singular_values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mat3_singular_values.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/mat3/chunk_mat3_singular_values.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCALU,SAAS,CA6DZ;0BA1FmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/mat3/chunk_mat3_singular_values.js

@@ -0,0 +1,91 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * The largest and smallest singular values of a 3×3 matrix.
+ *
+ * They are what "how much does this transform stretch a distance" actually means: a vector's length
+ * is scaled by something between σ_min and σ_max, and both bounds are attained. Column lengths are
+ * the obvious stand-in and they are **not** the same number — for
+ * `[[1,0,0],[k,1,0],[0,0,1]]`, every column has length 1 or √(1+k²) while the true ratio grows
+ * without bound in `k`. A shear has no scale in any column and stretches space anyway.
+ *
+ * Computed as the square roots of the eigenvalues of `MᵀM`, which is symmetric and positive
+ * semi-definite, through the closed form for a symmetric 3×3 (Smith 1961). No iteration, no
+ * branching past the diagonal case, and **exact for a uniform scale**: `MᵀM` is then `s²I`, the
+ * off-diagonal sum is zero, and both values come back as `s`. That matters more than the general
+ * case — a conservative bound that answered 5.2 for an unscaled instance would over-refine every
+ * ordinary object in a scene to buy correctness for a sheared one.
+ *
+ * **Not a degeneracy test.** σ_min is zero exactly when the matrix is singular *in exact
+ * arithmetic*, and this once said so without the qualifier. In f32 it holds only on the diagonal
+ * branch: the trigonometric one computes the smallest eigenvalue as a difference of nearly equal
+ * numbers, and the `sqrt` turns its absolute error of about `eps·σ_max²` into about
+ * `sqrt(eps)·σ_max ≈ 3.4e-4·σ_max` in σ_min. A rotated matrix with one column of zeros therefore
+ * comes back with a σ_min near 1e-4 rather than 0, and a caller testing `σ_min > 0` before
+ * inverting is let through with the NaN it was guarding against
+ * (`shader_vgeo_cut_collect`, REVIEW_LEDGER M3). A caller about to invert should test the
+ * **determinant**, which is the number the inverse divides by and which is exactly zero whenever a
+ * column is.
+ *
+ * @type {CodeChunk}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const chunk_mat3_singular_values = CodeChunk.from(
+    //language=WGSL
+    `
+/**
+ * @returns (largest, smallest) singular value
+ */
+fn mat3_singular_values(m: mat3x3<f32>) -> vec2<f32> {
+    // MtM, symmetric and positive semi-definite; its eigenvalues are the squared singular values
+    let a00 = dot(m[0], m[0]);
+    let a11 = dot(m[1], m[1]);
+    let a22 = dot(m[2], m[2]);
+    let a01 = dot(m[0], m[1]);
+    let a02 = dot(m[0], m[2]);
+    let a12 = dot(m[1], m[2]);
+
+    let p1 = a01 * a01 + a02 * a02 + a12 * a12;
+
+    if (p1 <= 0.0) {
+        // already diagonal — the uniform-scale case lands here, and lands exactly
+        let high = max(a00, max(a11, a22));
+        let low = min(a00, min(a11, a22));
+
+        return vec2<f32>(sqrt(max(high, 0.0)), sqrt(max(low, 0.0)));
+    }
+
+    let q = (a00 + a11 + a22) / 3.0;
+
+    let d0 = a00 - q;
+    let d1 = a11 - q;
+    let d2 = a22 - q;
+
+    let p2 = d0 * d0 + d1 * d1 + d2 * d2 + 2.0 * p1;
+
+    let p = sqrt(p2 / 6.0);
+
+    // det(B) / 2, with B = (A - qI) / p
+    let b00 = d0 / p;
+    let b11 = d1 / p;
+    let b22 = d2 / p;
+    let b01 = a01 / p;
+    let b02 = a02 / p;
+    let b12 = a12 / p;
+
+    let determinant = b00 * (b11 * b22 - b12 * b12)
+        - b01 * (b01 * b22 - b12 * b02)
+        + b02 * (b01 * b12 - b11 * b02);
+
+    // clamped because rounding can push it a hair outside acos's domain, where the whole
+    // computation would otherwise come back NaN for a perfectly ordinary matrix
+    let phi = acos(clamp(determinant * 0.5, -1.0, 1.0)) / 3.0;
+
+    let high = q + 2.0 * p * cos(phi);
+    let low = q + 2.0 * p * cos(phi + 2.0 * 3.14159265358979 / 3.0);
+
+    return vec2<f32>(sqrt(max(high, 0.0)), sqrt(max(low, 0.0)));
+}
+`, []);

package/src/engine/graphics3/instantiate_scene_bundle.d.ts

@@ -1,54 +0,0 @@
-/**
- * Instantiate a loaded asset for one owner.
- *
- * Skins and clips come back pointing at the returned tree and nothing else, so they are ready for
- * {@link GPUAnimationManager#register_skin} and {@link GPUAnimationManager#register_clip} as they
- * are. Every node a clip drives is handed to the GPU
- * ({@link TransformAuthority.GPU}): the pose accumulator writes those rows, and a CPU that also
- * wrote them would race the animation it is trying to show. That same rule is what makes the CPU
- * pose evaluator correct, since it reads `transform_local` as the rest pose.
- *
- * Nothing in the bundle is modified.
- *
- * @param {SceneBundle} bundle
- * @returns {SceneBundleInstance}
- */
-export function instantiate_scene_bundle(bundle: SceneBundle): SceneBundleInstance;
-/**
- * One entity's private copy of a loaded asset: its own node tree, its own skins bound to that
- * tree's joints, and its own clips retargeted onto it.
- *
- * A loader's {@link SceneBundle} is a template. Its skins name Node3Ds and its clip channels
- * target Node3Ds, so two entities showing the same model cannot share it — the second would drive
- * the first one's joints. What they can share is everything read-only: geometry, materials,
- * inverse-bind matrices and the animation curves themselves, which is why the copy is per-node
- * rather than per-byte.
- */
-export class SceneBundleInstance {
-    /**
-     * @type {Node3D[]}
-     */
-    roots: Node3D[];
-    /**
-     * @type {Skin[]}
-     */
-    skins: Skin[];
-    /**
-     * @type {ShadeAnimationClip[]}
-     */
-    clips: ShadeAnimationClip[];
-    /**
-     * Every node of the instance, by the name the asset gave it — where a socket, an effect anchor
-     * or a projectile spawn is looked up, since all three are authored as names of bones.
-     *
-     * Built here rather than walked per query because the walk is already happening: the tree is
-     * visited once to copy it. A name authored twice keeps the first node the copy reaches, which
-     * is the same answer a search would have returned.
-     *
-     * @type {Map<string,Node3D>}
-     */
-    nodes: Map<string, Node3D>;
-}
-import { Skin } from "../../shade/renderer/animation/Skin.js";
-import { ShadeAnimationClip } from "../../shade/renderer/animation/ShadeAnimationClip.js";
-//# sourceMappingURL=instantiate_scene_bundle.d.ts.map

package/src/engine/graphics3/instantiate_scene_bundle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"instantiate_scene_bundle.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/instantiate_scene_bundle.js"],"names":[],"mappings":"AAiGA;;;;;;;;;;;;;;GAcG;AACH,+DAFa,mBAAmB,CAqD/B;AA7JD;;;;;;;;;GASG;AACH;IACI;;OAEG;IACH,OAFU,QAAQ,CAEP;IAEX;;OAEG;IACH,OAFU,IAAI,EAAE,CAEL;IAEX;;OAEG;IACH,OAFU,kBAAkB,EAAE,CAEnB;IAEX;;;;;;;;;OASG;IACH,OAFU,IAAI,MAAM,SAAQ,CAEV;CACrB;qBAxCoB,wCAAwC;mCAD1B,sDAAsD"}

package/src/engine/graphics3/shade_node_to_entity_composition.d.ts

@@ -1,39 +0,0 @@
-/**
- * Turn a loaded model's node tree into entities.
- *
- * **This is what a hierarchy is in an ECS** (D47). meep has no scene graph to hand a model to: it
- * has entities, `EntityNode` to parent them, and `ShadedGeometry` for the ones that draw. A model
- * file is therefore not a thing an entity *holds* — it is a shape an entity's descendants take, and
- * this function is where the file stops being the renderer's tree and becomes the dataset's.
- *
- * It is `three_object_to_entity_composition` with the source swapped: the same output, built from
- * Shade's `Node3D`s instead of three's `Object3D`s. The two exist side by side for as long as both
- * renderers do.
- *
- * **Geometry and material are shared, not copied.** Two entities placing the same model name the
- * same `MeshletGeometry` and the same `ShadeMaterial`; what is per-entity is the row each one gets
- * in the scene, which is `ShadedGeometrySystem`'s business. That is the whole reason a static model
- * needs no clone of the bundle at all.
- *
- * **A skinned mesh is not expanded, and that is a boundary rather than an omission.** Its vertices
- * are deformed against a skeleton the renderer owns and the GPU poses, and making those joints
- * entities is a design this program does not do (D47). A `SkinnedMesh` node therefore contributes
- * its transform and its name and no geometry, and whatever placed the model keeps drawing it the way
- * Phase 4 built.
- *
- * @param {Node3D} node
- * @returns {EntityNode}
- */
-export function shade_node_to_entity_composition(node: Node3D): EntityNode;
-/**
- * The same, for everything a loader produced.
- *
- * A bundle can carry more than one scene — glTF allows it — and the entity that placed the file owns
- * all of them, so they become children of one root rather than several compositions nobody joins.
- *
- * @param {SceneBundle} bundle
- * @returns {EntityNode}
- */
-export function shade_bundle_to_entity_composition(bundle: SceneBundle): EntityNode;
-import { EntityNode } from "../ecs/parent/EntityNode.js";
-//# sourceMappingURL=shade_node_to_entity_composition.d.ts.map

package/src/engine/graphics3/shade_node_to_entity_composition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shade_node_to_entity_composition.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/shade_node_to_entity_composition.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,gEAFa,UAAU,CA6BtB;AAED;;;;;;;;GAQG;AACH,yEAFa,UAAU,CAmBtB;2BAtF0B,6BAA6B"}

package/src/shade/renderer/animation/compute_skin_world_bounds.d.ts

@@ -1,35 +0,0 @@
-/**
- * World-space bounds of a mesh deformed by `skin`, in the pose the skin's joint nodes currently
- * hold.
- *
- * **The mesh node's own transform does not appear here, and that is the point.** A skinned vertex
- * lands at `mesh.global × inverse(mesh.global) × joint.global × inverse_bind × v` — the skinning
- * pass applies the leftmost inverse (see `chunk_skin_blend_mesh_local`) and the rasterizer
- * re-applies `mesh.global` afterwards, so the two cancel and the vertex is at
- * `joint.global × inverse_bind × v`. Bounding a skinned mesh by putting its rest-pose geometry
- * under `mesh.transform_global` therefore applies a transform the renderer cancels: on an
- * FBX-derived glTF whose root node carries the file's centimetre→metre scale, it comes out 100×
- * too small.
- *
- * The bound is the union over joints of `joint.global × inverse_bind` applied to the mesh-space
- * geometry bounds. Conservative: each joint's product maps the whole geometry rather than the
- * vertices that joint actually weights, and a skinned vertex is a convex combination of those
- * per-joint images, which the enclosing (convex) AABB contains. In the case that matters it is also
- * *tight* — with every joint at its bind pose `joint.global × inverse_bind` collapses to one and
- * the same matrix, the character's placement in the world, so the union is a single exact box.
- *
- * **Pose freshness is the caller's problem.** Joints driven by the GPU pose accumulator are
- * {@link TransformAuthority.GPU}, and their `transform_global` stays at the rest pose the CPU
- * seeded — so for an animated character this is a rest-pose bound that tracks placement, not the
- * deformed silhouette. The per-frame deformed world box lives in the scene database's `meshes` row,
- * published by the skinning pass's bounds-refresh chain, and anything that needs the real thing
- * reads it there.
- *
- * @param {Skin} skin
- * @param {ArrayLike<number>} mesh_box mesh-space AABB, 6 floats — `(low_x, low_y, low_z, high_x, high_y, high_z)`
- * @param {ArrayLike<number>} mesh_sphere mesh-space sphere, 4 floats — `(x, y, z, radius)`
- * @param {Float32Array|number[]} out_box receives the world AABB, 6 floats
- * @param {Float32Array|number[]} out_sphere receives the world sphere, 4 floats
- */
-export function compute_skin_world_bounds(skin: Skin, mesh_box: ArrayLike<number>, mesh_sphere: ArrayLike<number>, out_box: Float32Array | number[], out_sphere: Float32Array | number[]): void;
-//# sourceMappingURL=compute_skin_world_bounds.d.ts.map

package/src/shade/renderer/animation/compute_skin_world_bounds.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compute_skin_world_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/compute_skin_world_bounds.js"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,gEALW,UAAU,MAAM,CAAC,eACjB,UAAU,MAAM,CAAC,WACjB,YAAY,GAAC,MAAM,EAAE,cACrB,YAAY,GAAC,MAAM,EAAE,QAkE/B"}

package/src/shade/renderer/animation/compute_skinned_mesh_clip_bounding_sphere.d.ts

@@ -1,96 +0,0 @@
-/**
- * Inflate a column-major 4×4 matrix `m` into the row-major 3×4 form
- * `mesh_apply_skeletal_vertex_skinning` reads per bone. Writes
- * 12 floats starting at `out[out_offset]`.
- *
- * Mapping: the meep skinner does
- * `sx = b[0]*x + b[1]*y + b[2]*z + b[3]` etc., which is row-major
- * 3×4 (`b[r*4 + c]`). Our `m` is column-major 4×4, so column `c`
- * lives at `m[c*4 + r]`. Hence `b[r*4 + c] = m[c*4 + r]`.
- *
- * Exported (with leading underscore) for direct test coverage.
- *
- * @param {Float32Array} m column-major 4×4
- * @param {Float32Array} out
- * @param {number} out_offset
- */
-export function _pack_mat4_to_bone_3x4(m: Float32Array, out: Float32Array, out_offset: number): void;
-/**
- * CPU skinning + bounding-sphere computation for a single pose.
- *
- * Pure-function sub-step. Takes pre-built `bone_matrices` (already
- * in the row-major 3×4 form `mesh_apply_skeletal_vertex_skinning`
- * expects, with `joint_world × inverse_bind` baked in per bone)
- * plus the bind-pose vertex data, performs CPU skinning into an
- * internal scratch buffer, and writes the resulting tight bounding
- * sphere into `out_sphere` via miniball.
- *
- * Doesn't allocate (beyond the one-time scratch growth on first
- * call with larger-than-seen-before inputs).
- *
- * @param {object} args
- * @param {Float32Array} args.positions       bind-pose vertex positions, flat `3 × vertex_count`
- * @param {Uint32Array|number[]} args.joint_indices flat `4 × vertex_count` joint indices
- * @param {Float32Array} args.joint_weights   flat `4 × vertex_count` weights
- * @param {number} args.vertex_count
- * @param {Float32Array} args.bone_matrices   row-major 3×4 (12 floats) per joint
- * @param {{ set: function(number,number,number,number):void }} out_sphere
- */
-export function compute_skinned_pose_bounding_sphere({ positions, joint_indices, joint_weights, vertex_count, bone_matrices, }: {
-    positions: Float32Array;
-    joint_indices: Uint32Array | number[];
-    joint_weights: Float32Array;
-    vertex_count: number;
-    bone_matrices: Float32Array;
-}, out_sphere: {
-    set: (arg0: number, arg1: number, arg2: number, arg3: number) => void;
-}): void;
-/**
- * Tight-ish bounding sphere over an entire clip's worth of poses.
- * Steps the clip at a fixed `dt`, CPU-skins the bind-pose vertices
- * at each tick, computes a per-tick miniball sphere, and unions
- * them into one final sphere.
- *
- * The output sphere is in the mesh's **local space** — the bone
- * matrices encode `joint_world × inverse_bind` only, with no mesh-
- * node factor. Multiplying the sphere by the SkinnedMesh's runtime
- * `transform_global` produces the world-space sphere a frustum-cull
- * pass can compare against. This matches the rasterizer's
- * convention (clone vertices are mesh-local; world placement comes
- * from `mesh.transform_global` at draw time).
- *
- * Mutates the joint Node3D's `transform_local` while stepping —
- * bind-pose values are saved on entry and restored on exit. Doesn't
- * touch joints not driven by the clip.
- *
- * Allocation: zero per-call. Module-level scratch grows once on
- * first call with a new largest size; subsequent calls reuse it.
- *
- * For the per-clip cost: this is intended for one-time computation
- * at scene-setup time, so the bounding sphere can be uploaded to
- * the GPU for skinning-workload culling. Per-frame use isn't
- * supported (would have to deal with concurrent users of the
- * module-level scratch).
- *
- * @param {object} args
- * @param {Float32Array} args.positions       bind-pose vertex positions, flat `3 × vertex_count`
- * @param {Uint32Array|number[]} args.joint_indices  flat `4 × vertex_count` joint indices
- * @param {Float32Array} args.joint_weights   flat `4 × vertex_count` weights
- * @param {number} args.vertex_count
- * @param {Skin} args.skin                    joints + inverse-bind matrices (column-major, 16 each)
- * @param {ShadeAnimationClip} args.clip
- * @param {number} [args.dt]                  time step in seconds (default `1/60`)
- * @param {{ set: function(number,number,number,number):void }} out_sphere
- */
-export function compute_skinned_mesh_clip_bounding_sphere({ positions, joint_indices, joint_weights, vertex_count, skin, clip, dt, }: {
-    positions: Float32Array;
-    joint_indices: Uint32Array | number[];
-    joint_weights: Float32Array;
-    vertex_count: number;
-    skin: Skin;
-    clip: ShadeAnimationClip;
-    dt?: number;
-}, out_sphere: {
-    set: (arg0: number, arg1: number, arg2: number, arg3: number) => void;
-}): void;
-//# sourceMappingURL=compute_skinned_mesh_clip_bounding_sphere.d.ts.map

package/src/shade/renderer/animation/compute_skinned_mesh_clip_bounding_sphere.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compute_skinned_mesh_clip_bounding_sphere.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/compute_skinned_mesh_clip_bounding_sphere.js"],"names":[],"mappings":"AAsJA;;;;;;;;;;;;;;;GAeG;AACH,0CAJW,YAAY,OACZ,YAAY,cACZ,MAAM,QAehB;AAYD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAP8B,SAAS,EAA5B,YAAY;IACe,aAAa,EAAxC,WAAW,GAAC,MAAM,EAAE;IACD,aAAa,EAAhC,YAAY;IACC,YAAY,EAAzB,MAAM;IACa,aAAa,EAAhC,YAAY;eACZ;IAAE,GAAG,SAAW,MAAM,QAAC,MAAM,QAAC,MAAM,QAAC,MAAM,KAAE,IAAI,CAAA;CAAE,QAwC7D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IAT8B,SAAS,EAA5B,YAAY;IACe,aAAa,EAAxC,WAAW,GAAC,MAAM,EAAE;IACD,aAAa,EAAhC,YAAY;IACC,YAAY,EAAzB,MAAM;IACK,IAAI;IACU,IAAI;IACf,EAAE,GAAhB,MAAM;eACN;IAAE,GAAG,SAAW,MAAM,QAAC,MAAM,QAAC,MAAM,QAAC,MAAM,KAAE,IAAI,CAAA;CAAE,QAmP7D"}

package/src/shade/renderer/animation/pose/pose_evaluate_world.d.ts

@@ -1,20 +0,0 @@
-/**
- * Evaluate a node's **world** pose under a set of playing clips.
- *
- * This is the query gameplay actually asks: where is the muzzle, where does this effect attach,
- * where does the projectile leave from. It walks the node's parent chain, evaluates every ancestor's
- * animated local pose the same way, and composes down — so a socket on a hand follows the arm, the
- * shoulder and the root without any of it having been read back from the GPU.
- *
- * The chain is composed in double precision and every level is evaluated from the same `playbacks`,
- * which is what makes the result a pure function of (clip set, time, weights) rather than of
- * whatever the renderer last happened to write.
- *
- * @param {Transform64} result
- * @param {Node3D} node
- * @param {PosePlayback[]} playbacks
- * @returns {Transform64} `result`
- */
-export function pose_evaluate_world(result: Transform64, node: Node3D, playbacks: PosePlayback[]): Transform64;
-import { Transform64 } from "../../../../engine/ecs/transform/Transform64.js";
-//# sourceMappingURL=pose_evaluate_world.d.ts.map

package/src/shade/renderer/animation/pose/pose_evaluate_world.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pose_evaluate_world.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/pose/pose_evaluate_world.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;GAgBG;AACH,4CALW,WAAW,2BAEX,cAAc,GACZ,WAAW,CA+BvB;4BA1E2B,iDAAiD"}

package/src/shade/renderer/animation/skin_bind_transform.d.ts

@@ -1,25 +0,0 @@
-/**
- * The transform that maps this skin's mesh-space geometry into the world at rest.
- *
- * `compute_skin_world_bounds` already names the thing: *"with every joint at its bind pose
- * `joint.global × inverse_bind` collapses to one and the same matrix, the character's placement in
- * the world"*. This returns that matrix. It is the frame a skinned mesh's vertices belong in, and
- * under {@link skin_normalize_mesh_frame} it becomes the mesh node's transform — see
- * `SKINNING_FRAME_PLAN.md`.
- *
- * **Joint 0's is the one taken.** In a file whose rest pose is its bind pose every joint answers the
- * same matrix, so which one is asked is not a choice; in a file where they differ there is no single
- * answer and no amount of averaging makes one. What matters is not that they agree but that
- * `frame⁻¹ · joint_matrix` comes out rigid for every joint, which is a weaker condition and a
- * different question — {@link skin_frame_defect} is that question, and it is the one to ask.
- *
- * Reads the joints' `transform_global`, so the skeleton has to have been walked
- * ({@link Node3D#updateMatrices}) since it was last moved. Joints under
- * {@link TransformAuthority.GPU} hold the rest pose there, which is what this wants.
- *
- * @param {Float64Array|Float32Array|number[]} out 16 elements, column-major
- * @param {Skin} skin
- * @returns {Float64Array|Float32Array|number[]} `out`
- */
-export function skin_bind_transform(out: Float64Array | Float32Array | number[], skin: Skin): Float64Array | Float32Array | number[];
-//# sourceMappingURL=skin_bind_transform.d.ts.map

package/src/shade/renderer/animation/skin_bind_transform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skin_bind_transform.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/skin_bind_transform.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yCAJW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,eAEhC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,CAQ9C"}

package/src/shade/renderer/animation/skin_frame_defect.d.ts

@@ -1,34 +0,0 @@
-/**
- * Whether a frame is one this skin can be deformed in — and if not, by how much it is not.
- *
- * The skinning pass converts `frame⁻¹ × joint.global × inverse_bind` to a dual quaternion, and a
- * dual quaternion carries a rotation and a translation and nothing else. So that product must be
- * rigid for every joint. This is that condition as a number: zero when the frame works, and growing
- * with whatever the conversion would have to throw away. `SKINNING_FRAME_PLAN.md` §1 is what
- * happens when it does.
- *
- * **This, and not "do the joints agree", is the precondition.** A file whose rest pose is not its
- * bind pose has joints whose skin matrices differ — by *rigid* motions, which cost nothing here.
- * What cannot be absorbed is a scale or a shear, and this sees exactly that.
- *
- * Reads the joints' `transform_global`, so it answers for whatever pose the skeleton is standing in.
- * At rest that is the registration-time question. Handed a posed skeleton it answers the runtime one
- * — a clip that scales a joint, which no frame can fix (§4).
- *
- * @param {Skin} skin
- * @param {ArrayLike<number>} frame 16 elements, column-major — the transform the renderer re-applies
- * @returns {number} the largest {@link m4_rigidity_defect} over the skin's joints; `Infinity` if
- *          `frame` has no inverse, or if any joint's fold comes out a reflection — which scores zero
- *          on the defect and is unrepresentable all the same
- */
-export function skin_frame_defect(skin: Skin, frame: ArrayLike<number>): number;
-/**
- * The same question of one joint, freshly allocated — for a caller that wants to say *which* joint
- * and by how much rather than only the worst of them.
- *
- * @param {Skin} skin
- * @param {ArrayLike<number>} frame
- * @returns {number[]} one defect per joint, in joint order
- */
-export function skin_frame_defect_by_joint(skin: Skin, frame: ArrayLike<number>): number[];
-//# sourceMappingURL=skin_frame_defect.d.ts.map

package/src/shade/renderer/animation/skin_frame_defect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skin_frame_defect.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/skin_frame_defect.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qDALW,UAAU,MAAM,CAAC,GACf,MAAM,CA6ClB;AAiBD;;;;;;;GAOG;AACH,8DAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CA8BpB"}

package/src/shade/renderer/animation/skin_joint_matrix.d.ts

@@ -1,24 +0,0 @@
-/**
- * One joint's skin matrix, in the pose its node currently holds: `joint.global × inverse_bind`.
- *
- * The same quantity `shader_skin_matrix_prep` writes to the GPU's `skin_matrices` buffer, and the
- * same one `compute_skin_world_bounds` composes its box out of — kept here so the CPU-side callers
- * that reason about a skin's geometry all read it from one place rather than three.
- *
- * It maps a vertex from the skin's mesh space into **world** space. The mesh node's own transform
- * does not appear and must not: glTF says a skinned mesh's node transform is ignored, and this
- * engine's arrangement is that the skinning pass folds its inverse in and the rasterizer re-applies
- * it, so the two cancel. See `SKINNING_FRAME_PLAN.md` for what that fold requires of an asset.
- *
- * Not a per-frame path. Joints the pose accumulator drives are {@link TransformAuthority.GPU} and
- * their `transform_global` holds the rest pose the CPU seeded, so what this answers for an animated
- * character is the rest-pose matrix — which is exactly what the frame arithmetic wants, and is not
- * what a renderer wants.
- *
- * @param {Float64Array|Float32Array|number[]} out 16 elements, column-major
- * @param {Skin} skin
- * @param {number} joint_index
- * @returns {Float64Array|Float32Array|number[]} `out`
- */
-export function skin_joint_matrix(out: Float64Array | Float32Array | number[], skin: Skin, joint_index: number): Float64Array | Float32Array | number[];
-//# sourceMappingURL=skin_joint_matrix.d.ts.map

package/src/shade/renderer/animation/skin_joint_matrix.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skin_joint_matrix.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/skin_joint_matrix.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,uCALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,2BAElC,MAAM,GACJ,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,CAsB9C"}

package/src/shade/renderer/animation/skin_normalize_mesh_frame.d.ts

@@ -1,70 +0,0 @@
-/**
- * Put a skin's meshes into the frame the skin actually deforms in.
- *
- * ## What it does and why
- *
- * The skinning pass writes each clone's vertices in `inverse(mesh.global)` space and the rasterizer
- * re-applies `mesh.global`, so `mesh.global` is the *frame* a skinned mesh's vertices live in. The
- * pass gets there by converting `inverse(mesh.global) × joint.global × inverse_bind` to a dual
- * quaternion, which carries a rotation and a translation and **nothing else** — so that product has
- * to be rigid, and whether it is depends entirely on `mesh.global`.
- *
- * glTF says a skinned mesh's node transform is ignored, so it is not the asset's to choose. This
- * makes it the engine's, and sets it to the one frame that is guaranteed to work: the skin's own
- * bind transform, `joint.global × inverse_bind` at rest — see {@link skin_bind_transform}. After
- * this, `inverse(mesh.global) × joint.global × inverse_bind` is the joint's **displacement from
- * bind**, which is rigid whenever the clip rotates and translates and does not scale. That is the
- * honest precondition of dual-quaternion skinning, and it is a property of the animation rather than
- * of the exporter's unit conventions.
- *
- * `SKINNING_FRAME_PLAN.md` is the whole argument, including what a violation looks like on screen.
- *
- * ## Properties worth knowing
- *
- * - **Idempotent.** Afterwards `mesh.global` *is* the bind transform, so a second call computes the
- *   identity and changes nothing. Re-registering a skin is free.
- * - **Placement-invariant.** The correction is `mesh.global⁻¹ × bind`, and anything applied above
- *   both the mesh node and the joints — a placement, a walk cycle moving the character — multiplies
- *   both on the left and cancels. Computed once, correct forever.
- * - **A no-op for an asset that already agrees.** A file whose inverse-bind matrices are authored
- *   before its root's unit conversion has `bind == mesh.global` already and is not touched. That is
- *   the shape this engine's creature models are said to have, and it is what keeps this from being
- *   a change to them.
- *
- * ## What it cannot fix
- *
- * A skin whose *own* bind frame does not work — a rest pose carrying a non-uniform scale or a shear,
- * or joints that disagree about more than a rigid motion. No choice of frame fixes those; a dual
- * quaternion cannot represent them at all. `frame_defect` in the report is that case, and when it
- * fires nothing is written: the mesh is left as the asset had it rather than moved somewhere equally
- * wrong. See `SKINNING_FRAME_PLAN.md` §4 for the ladder out.
- *
- * @param {Skin} skin its joints and meshes must have been walked — this reads `transform_global`,
- *        which is derived. A skin that has never been walked at all is refused rather than
- *        measured; one walked and then moved is the caller's to walk again, and the residual
- *        below is what notices if the mesh half of that was missed
- * @returns {{
- *     frame_defect: number,
- *     absorbed: number,
- *     corrected: number,
- *     unchanged: number,
- *     residual: number,
- *     obstructed: Node3D[],
- *     unwalked: Node3D[],
- * }} `frame_defect` — how far the skin is from being deformable in *any* frame, zero when it is
- *    fine and `NaN` when `unwalked` stopped it being asked; `absorbed` — how far from rigid the largest correction was, which for a violation is the
- *    number the soup was made of; `corrected` and `unchanged` — meshes moved and meshes already
- *    right; `residual` — the worst `|mesh.global − bind|` left afterwards; `obstructed` — corrected
- *    mesh nodes that had children, which have been scaled along with them; `unwalked` — joints or
- *    meshes whose `transform_global` has never been derived, which stops everything else
- */
-export function skin_normalize_mesh_frame(skin: Skin): {
-    frame_defect: number;
-    absorbed: number;
-    corrected: number;
-    unchanged: number;
-    residual: number;
-    obstructed: Node3D[];
-    unwalked: Node3D[];
-};
-//# sourceMappingURL=skin_normalize_mesh_frame.d.ts.map

package/src/shade/renderer/animation/skin_normalize_mesh_frame.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skin_normalize_mesh_frame.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/skin_normalize_mesh_frame.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,uDAfa;IACZ,YAAkB,EAAE,MAAM,CAAC;IAC3B,QAAc,EAAE,MAAM,CAAC;IACvB,SAAe,EAAE,MAAM,CAAC;IACxB,SAAe,EAAE,MAAM,CAAC;IACxB,QAAc,EAAE,MAAM,CAAC;IACvB,UAAgB,EAAE,QAAQ,CAAC;IAC3B,QAAc,EAAE,QAAQ,CAAC;CACtB,CA2GH"}