@woosh/meep-engine 3.15.0 → 3.16.0

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js

@@ -488,6 +488,7 @@ export function graph_avboit_draw({
         const t_color = resources.get(data.color);
         const t_norm = resources.get(data.norm);
         const t_extinction = resources.get(data.extinction);
+        const t_emission = resources.get(data.emission);
 
         const warp_buffer = resources.get(data.warp);
         const t_integral = resources.get(data.integral);
@@ -539,7 +540,7 @@ export function graph_avboit_draw({
             : shader_avboit_draw_ibl;
 
         const pass_encoder = encoder.beginRenderPass(render_pass_descriptor.toGPU({
-            colorTargets: [t_color, t_norm, t_extinction],
+            colorTargets: [t_color, t_norm, t_extinction, t_emission],
             depthTarget: t_depth,
             colorLoadOp: data.clear_targets ? "clear" : "load",
             // depth is only tested, never written
@@ -630,16 +631,15 @@ export function graph_avboit_draw({
         pass_data.norm = pass.write(accumulators.norm);
         pass.read(accumulators.extinction);
         pass_data.extinction = pass.write(accumulators.extinction);
+        pass.read(accumulators.emission);
+        pass_data.emission = pass.write(accumulators.emission);
     } else {
-        const make = label => pass.create(label, TextureResourceDescriptor.from({
-            resolution: view_ctx.resolution,
-            format: 'rgba16float',
-            usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
-        }));
+        const created = avboit_create_accumulators(pass, view_ctx.resolution);
 
-        pass_data.color = make("AVBOIT accumulated color");
-        pass_data.norm = make("AVBOIT accumulated normalization");
-        pass_data.extinction = make("AVBOIT accumulated extinction");
+        pass_data.color = created.color;
+        pass_data.norm = created.norm;
+        pass_data.extinction = created.extinction;
+        pass_data.emission = created.emission;
     }
 
     pass_data.light_cluster_parameters = pass.read(light_cluster_parameters);
@@ -655,6 +655,31 @@ export function graph_avboit_draw({
         color: pass_data.color,
         norm: pass_data.norm,
         extinction: pass_data.extinction,
+        emission: pass_data.emission,
+    };
+}
+
+/**
+ * The four draw accumulators, created by the first pass that writes them — the meshlet draw, or a
+ * side channel's when there are no transparent materials. One place for their format and usage,
+ * so the meshlet draw and a side channel's draw cannot disagree on what they are drawing into.
+ *
+ * @param {FramePassBuilder} pass the pass that first writes them
+ * @param {ArrayLike<number>} resolution internal resolution
+ * @returns {{color: number, norm: number, extinction: number, emission: number}}
+ */
+export function avboit_create_accumulators(pass, resolution) {
+    const make = label => pass.create(label, TextureResourceDescriptor.from({
+        resolution,
+        format: 'rgba16float',
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
+    }));
+
+    return {
+        color: make("AVBOIT accumulated color"),
+        norm: make("AVBOIT accumulated normalization"),
+        extinction: make("AVBOIT accumulated extinction"),
+        emission: make("AVBOIT accumulated emission"),
     };
 }
 
@@ -665,6 +690,13 @@ export function graph_avboit_draw({
  * selects between the two with `transparency_mode` alone. The passes it records are listed in
  * `AVBOIT_PLAN_2026_09_03.md` §3.1.
  *
+ * Fragments that are not meshlets — particles — join through `side_channels`: each is asked for its
+ * occupancy after the buckets have marked theirs, for its extinction after the buckets have
+ * splatted, and for its draw after the buckets have drawn, in that order, with the handles threaded
+ * through it. See `AVBOITSideChannel`. With side channels the frame runs even when no transparent
+ * material is in the scene; the bucket passes then have nothing to do and the channels' fragments
+ * composite against the opaque scene alone.
+ *
  * @param {FrameGraph} graph
  * @param {number} buckets
  * @param {GPUViewContext} view_ctx
@@ -680,6 +712,8 @@ export function graph_avboit_draw({
  * @param {number} volumetrics_metadata
  * @param {ShadeIndirectLightingMode} indirect_lighting_mode
  * @param {AVBOITSettings} [avboit] `Renderer.avboit`; the MBOIT orchestrator ignores it
+ * @param {import("./AVBOITSideChannel.js").AVBOITSideChannel[]} [side_channels] non-meshlet
+ *   sources of transparent fragments; the MBOIT orchestrator ignores them
  * @returns {number} resource ID of the composited color texture
  */
 export function graph_rasterize_meshes_transparent_avboit({
@@ -701,9 +735,11 @@ export function graph_rasterize_meshes_transparent_avboit({
 
                                                               indirect_lighting_mode = ShadeIndirectLightingMode.IBL,
                                                               avboit = DEFAULT_SETTINGS,
+                                                              side_channels = [],
                                                           }) {
 
     assert.isNonNegativeInteger(buckets, 'buckets');
+    assert.isArray(side_channels, 'side_channels');
     assert.isNonNegativeInteger(color_texture, 'color_texture');
     assert.isNonNegativeInteger(depth_texture, 'depth_texture');
 
@@ -748,7 +784,7 @@ export function graph_rasterize_meshes_transparent_avboit({
         scene_materials.length
     );
 
-    if ((material_count_front + material_count_double) === 0) {
+    if ((material_count_front + material_count_double) === 0 && side_channels.length === 0) {
         // nothing to do
         return color_texture;
     }
@@ -825,6 +861,10 @@ export function graph_rasterize_meshes_transparent_avboit({
         occupancy,
     });
 
+    for (const channel of side_channels) {
+        occupancy = channel.avboit_occupancy({ graph, camera: gr_camera, cluster_parameters, occupancy });
+    }
+
     const warp = graph_avboit_build_warp({
         graph,
         occupancy,
@@ -863,6 +903,10 @@ export function graph_rasterize_meshes_transparent_avboit({
         volume,
     });
 
+    for (const channel of side_channels) {
+        volume = channel.avboit_splat({ graph, camera: gr_camera, warp, depth_texture, voxel_resolution, volume });
+    }
+
     // Integrate
     // ======
 
@@ -916,6 +960,20 @@ export function graph_rasterize_meshes_transparent_avboit({
         ...lighting,
     });
 
+    for (const channel of side_channels) {
+        accumulators = channel.avboit_draw({
+            graph,
+            view_ctx,
+            camera: gr_camera,
+            depth_texture,
+            warp,
+            integral,
+            volumetrics_lut,
+            volumetrics_metadata,
+            accumulators,
+        });
+    }
+
     // Resolve
     // ======
 
@@ -928,6 +986,7 @@ export function graph_rasterize_meshes_transparent_avboit({
             tColor: accumulators.color,
             tNorm: accumulators.norm,
             tExtinction: accumulators.extinction,
+            tEmission: accumulators.emission,
         }
     });
 

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js"],"names":[],"mappings":"AAsEA,gDAUE;4BA9E0B,gCAAgC"}
+{"version":3,"file":"shader_avboit_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js"],"names":[],"mappings":"AA4EA,gDAUE;4BApF0B,gCAAgC"}

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js

@@ -10,18 +10,23 @@ resources.createGroup()
     .addTexture("tColor")
     .addTexture("tNorm")
     .addTexture("tExtinction")
+    .addTexture("tEmission")
 
 /**
- * AVBOIT resolve: composites the three draw accumulators over the scene colour (plan §3.9).
+ * AVBOIT resolve: composites the four draw accumulators over the scene colour (plan §3.9).
  *
  * Per channel:
  *
  * ```
  * T_total = exp(-Σ extinction)
  * norm    = Σ norm > ε ? (1 - T_total) / Σ norm : 0
- * out     = scene × T_total + Σ color × norm
+ * out     = scene × T_total + Σ color × norm + Σ emission
  * ```
  *
+ * `emission` is light the draw already attenuated by the transmittance in front of it and that
+ * covers nothing, so it joins as it is — outside the normalization, which only redistributes the
+ * `1 - T_total` the surfaces took from the scene.
+ *
  * The total transmittance is RGB, which fixed-function blending cannot apply to the destination
  * without dual-source blending, so this reads the scene colour and writes a fresh target rather than
  * blending in place. A NaN in any accumulator drops the transparency for that pixel and keeps the
@@ -42,8 +47,9 @@ fn main(
     let accum_color = textureLoad(tColor, coord_u, 0).rgb;
     let accum_norm = textureLoad(tNorm, coord_u, 0).rgb;
     let accum_extinction = textureLoad(tExtinction, coord_u, 0).rgb;
+    let accum_emission = textureLoad(tEmission, coord_u, 0).rgb;
 
-    if (is_nan(accum_color.r) || is_nan(accum_norm.r) || is_nan(accum_extinction.r)) {
+    if (is_nan(accum_color.r) || is_nan(accum_norm.r) || is_nan(accum_extinction.r) || is_nan(accum_emission.r)) {
         // one NaN fragment poisons the whole pixel of an additive accumulator; keeping the opaque
         // scene beats smearing NaN into the frame
         return scene;
@@ -61,7 +67,7 @@ fn main(
 
     let transparent = accum_color * renormalization;
 
-    return vec4<f32>(scene.rgb * total_transmittance + transparent, scene.a);
+    return vec4<f32>(scene.rgb * total_transmittance + transparent + accum_emission, scene.a);
 }
     `, [
         chunk_is_nan

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js"],"names":[],"mappings":"AA4BA;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,yDAAmD;AA6LnD,uDAA8D;qCAzNzB,8CAA8C"}
+{"version":3,"file":"shader_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,yDAAmD;AA4JnD,uDAA8D;qCAtLzB,8CAA8C"}

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js

@@ -19,9 +19,7 @@ import { vertex_shader_chunk } from "../../forward/vertex_shader_chunk.js";
 import { OIT_COVERAGE_MAX } from "../oit/OIT_CONSTANTS.js";
 import { rasterization_primitive_state } from "../rasterization_primitive_state.js";
 import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
-import { chunk_avboit_extinction_to_counts } from "./chunk_avboit_extinction_to_counts.js";
-import { chunk_avboit_overflows } from "./chunk_avboit_overflows.js";
-import { chunk_avboit_pack_counts } from "./chunk_avboit_pack_counts.js";
+import { chunk_avboit_splat_slice } from "./chunk_avboit_splat_slice.js";
 import { chunk_avboit_transmission_tint } from "./chunk_avboit_transmission_tint.js";
 import { chunk_avboit_transmittance_to_extinction } from "./chunk_avboit_transmittance_to_extinction.js";
 import { chunk_avboit_view_depth_to_physical } from "./chunk_avboit_view_depth_to_physical.js";
@@ -74,9 +72,8 @@ const shader_vertex = ShaderDescriptor.from({
  *
  * Depth goes view-space → curve → warp → physical, and the extinction is linear-splat between the
  * two physical slices around it (`c = p - 0.5`) so a surface crossing a slice boundary does not
- * alias. A field that crosses 255 with this add records the slice in the per-channel overflow
- * plane — stored as `P - slice` under `atomicMax`, so the buffer's zero clear reads as "none" and
- * the nearest overflow wins.
+ * alias. The add itself, and the overflow it may record, is `chunk_avboit_splat_slice` — shared
+ * with every side channel's splat, so a particle reaches the volume through the same code.
  *
  * No depth attachment: a splat behind opaque geometry lies deeper than any visible transparent
  * fragment and the integral at a depth only contains what is in front of it. No TAA un-jitter: the
@@ -86,36 +83,6 @@ const shader_vertex = ShaderDescriptor.from({
 const fragment_body = CodeChunk.from(
     //language=WGSL
     `
-fn avboit_splat_slice(column: u32, slice: i32, extinction: vec3<f32>, texel: vec2<u32>) {
-    let physical = i32(warp.physical_count);
-    let s = clamp(slice, 0, physical - 1);
-
-    let counts = avboit_extinction_to_counts(extinction);
-
-    if (all(counts == vec3<u32>(0u))) {
-        return;
-    }
-
-    let previous = atomicAdd(&extinction_volume[column + u32(s)], avboit_pack_counts(counts));
-
-    let overflow = avboit_overflows(previous, counts);
-
-    if (any(overflow)) {
-        let base = (texel.y * warp.voxel_width + texel.x) * 3u;
-        // inverted so that the zero-cleared buffer means "no overflow" and max keeps the nearest
-        let mark = u32(physical - s);
-        if (overflow.x) {
-            atomicMax(&overflow_slice[base], mark);
-        }
-        if (overflow.y) {
-            atomicMax(&overflow_slice[base + 1u], mark);
-        }
-        if (overflow.z) {
-            atomicMax(&overflow_slice[base + 2u], mark);
-        }
-    }
-}
-
 @fragment
 fn main(
     @builtin(front_facing) front_facing : bool,
@@ -174,9 +141,7 @@ fn main(
         chunk_mat4_extract_position,
         chunk_dielectric_specular_color,
         chunk_F_Hauber,
-        chunk_avboit_extinction_to_counts,
-        chunk_avboit_overflows,
-        chunk_avboit_pack_counts,
+        chunk_avboit_splat_slice,
         chunk_avboit_transmission_tint,
         chunk_avboit_transmittance_to_extinction,
         chunk_avboit_view_depth_to_physical,

package/src/shade/renderer/rasterize/standard/graph_rasterize_scene.d.ts

@@ -6,7 +6,12 @@
  * @param {FrameGraph} graph
  * @param {RasterizationJob} job
  * @param {GPUCollectionLimits} limits
- * @returns {number} render buckets buffer resource
+ * @returns {{buckets: number, depth: number, color_targets: number[]}} the render buckets buffer,
+ *   and the depth and colour targets as this pipeline left them
  */
-export function graph_rasterize_scene({ graph, job, limits, }: FrameGraph): number;
+export function graph_rasterize_scene({ graph, job, limits, }: FrameGraph): {
+    buckets: number;
+    depth: number;
+    color_targets: number[];
+};
 //# sourceMappingURL=graph_rasterize_scene.d.ts.map

package/src/shade/renderer/rasterize/standard/graph_rasterize_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_scene.js"],"names":[],"mappings":"AAcA;;;;;;;;;GASG;AACH,4EAFa,MAAM,CA4LlB"}
+{"version":3,"file":"graph_rasterize_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_scene.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AACH,4EAHa;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CA0MrE"}

package/src/shade/renderer/rasterize/standard/graph_rasterize_scene.js

@@ -20,7 +20,8 @@ import { graph_rasterize_remaining_opaque } from "./graph_rasterize_remaining_op
  * @param {FrameGraph} graph
  * @param {RasterizationJob} job
  * @param {GPUCollectionLimits} limits
- * @returns {number} render buckets buffer resource
+ * @returns {{buckets: number, depth: number, color_targets: number[]}} the render buckets buffer,
+ *   and the depth and colour targets as this pipeline left them
  */
 export function graph_rasterize_scene({
                                           graph,
@@ -207,5 +208,18 @@ export function graph_rasterize_scene({
 
     graph.pop_scope();
 
-    return gr_render_buckets;
+    /*
+     The advanced handles come back with the buckets, mirroring
+     `graph_rasterize_scene_fast_raw`. Returning only the buckets left the caller re-importing the
+     same physical textures to read what this wrote — two ResourceEntry chains for one texture, and
+     no dependency edge at all from the rasterization passes to their consumers. It draws correctly
+     today only because writing an imported resource marks a pass a side-effect, so culling cannot
+     touch it and insertion order saves the picture. Make those targets transient — which
+     `Renderer.js` carries a TODO to do — and the whole opaque chain culls itself with no diagnostic.
+    */
+    return {
+        buckets: gr_render_buckets,
+        depth: gr_texture_depth,
+        color_targets: raster_color_targets,
+    };
 }

package/src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.d.ts

@@ -7,9 +7,9 @@
  * Geometries with no detected sharing fall through as `[(IDENTITY, original)]`.
  *
  * @param {GeometryDeduplicateOptions} options
- * @returns {Map<Geometry, [Transform, Geometry][]>}
+ * @returns {Map<Geometry, [Transform64, Geometry][]>}
  */
-export function geometry_deduplicate({ geometries, min_primitives, position_epsilon, seed_budget, }: GeometryDeduplicateOptions): Map<Geometry, [Transform, Geometry][]>;
+export function geometry_deduplicate({ geometries, min_primitives, position_epsilon, seed_budget, }: GeometryDeduplicateOptions): Map<Geometry, [Transform64, Geometry][]>;
 export type PieceGeometryStats = {
     /**
      * A-frame centroid
@@ -41,5 +41,5 @@ export type GeometryDeduplicateOptions = {
      */
     seed_budget?: number;
 };
-import { Transform } from "../../../../../engine/ecs/transform/Transform.js";
+import { Transform64 } from "../../../../../engine/ecs/transform/Transform64.js";
 //# sourceMappingURL=geometry_deduplicate.d.ts.map

package/src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_deduplicate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.js"],"names":[],"mappings":"AA4CA;;;;;;;;;;GAUG;AACH,qGAHW,0BAA0B,GACxB,cAAc,CAAC,SAAS,WAAW,EAAE,CAAC,CAqNlD;;;;;gBA8Ea,MAAM;gBACN,MAAM;gBACN,MAAM;;;;YACN,MAAM;;;gBA1UN,UAAU;;;;qBACV,MAAM;;;;;;;;uBACN,MAAM;;;;kBAKN,MAAM;;0BArBM,kDAAkD"}
+{"version":3,"file":"geometry_deduplicate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;GAUG;AACH,qGAHW,0BAA0B,GACxB,cAAc,CAAC,WAAW,WAAW,EAAE,CAAC,CAqNpD;;;;;gBA8Ea,MAAM;gBACN,MAAM;gBACN,MAAM;;;;YACN,MAAM;;;gBA1UN,UAAU;;;;qBACV,MAAM;;;;;;;;uBACN,MAAM;;;;kBAKN,MAAM;;4BArBQ,oDAAoD"}

package/src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.js

@@ -1,7 +1,8 @@
 import { HashMap } from "../../../../../core/collection/map/HashMap.js";
 import { v3_distance } from "../../../../../core/geom/vec3/v3_distance.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
-import { Transform } from "../../../../../engine/ecs/transform/Transform.js";
+import { v3_quaternion_apply } from "../../../../../core/geom/vec3/v3_quaternion_apply.js";
+import { Transform64 } from "../../../../../engine/ecs/transform/Transform64.js";
 import { StandardAttributes } from "../../../geometry/StandardAttributes.js";
 import { anchor_grow_topological } from "./internal/anchor_grow_topological.js";
 import { cover_greedy } from "./internal/cover_greedy.js";
@@ -51,7 +52,7 @@ const ABSOLUTE_PAIR_EPSILON_FLOOR = 1e-6;
  * Geometries with no detected sharing fall through as `[(IDENTITY, original)]`.
  *
  * @param {GeometryDeduplicateOptions} options
- * @returns {Map<Geometry, [Transform, Geometry][]>}
+ * @returns {Map<Geometry, [Transform64, Geometry][]>}
  */
 export function geometry_deduplicate({
     geometries,
@@ -60,7 +61,7 @@ export function geometry_deduplicate({
     seed_budget = 256,
 }) {
 
-    /** @type {Map<Geometry, [Transform, Geometry][]>} */
+    /** @type {Map<Geometry, [Transform64, Geometry][]>} */
     const result = new Map();
 
     if (geometries.length === 0) {
@@ -196,7 +197,7 @@ export function geometry_deduplicate({
     const decisions = cover_greedy(matches, min_primitives);
 
     // ─────────────── Stage F: assemble output for unique geoms ───────────────
-    /** @type {Map<number, [Transform, Geometry][]>} */
+    /** @type {Map<number, [Transform64, Geometry][]>} */
     const unique_results = new Map();
     /** @type {Map<number, Set<number>>} */
     const removed_faces = new Map();
@@ -207,7 +208,7 @@ export function geometry_deduplicate({
             a_geom, decision.canonical_faces, "_piece" + decision.canonical_piece_id
         );
 
-        get_or_create_array(unique_results, decision.a_geom).push([new Transform(), piece]);
+        get_or_create_array(unique_results, decision.a_geom).push([new Transform64(), piece]);
         const a_removed = get_or_create_set(removed_faces, decision.a_geom);
         for (const f of decision.canonical_faces) a_removed.add(f);
 
@@ -232,7 +233,7 @@ export function geometry_deduplicate({
 
         if (removed === undefined || removed.size === 0) {
             const entries = get_or_create_array(unique_results, idx);
-            if (entries.length === 0) entries.push([new Transform(), geom]);
+            if (entries.length === 0) entries.push([new Transform64(), geom]);
             continue;
         }
 
@@ -245,7 +246,7 @@ export function geometry_deduplicate({
         }
 
         const leftover = geometry_extract_subset(geom, leftover_face_ids, "_leftover");
-        get_or_create_array(unique_results, idx).push([new Transform(), leftover]);
+        get_or_create_array(unique_results, idx).push([new Transform64(), leftover]);
     }
 
     /** @type {Map<Geometry, number>} */
@@ -259,7 +260,7 @@ export function geometry_deduplicate({
     for (const input_geom of geometries) {
         const canonical = input_to_canonical.get(input_geom);
         const idx = unique_idx_by_canonical.get(canonical);
-        const entries = unique_results.get(idx) ?? [[new Transform(), canonical]];
+        const entries = unique_results.get(idx) ?? [[new Transform64(), canonical]];
         result.set(input_geom, entries.map(([t, g]) => [t.clone(), g]));
     }
 
@@ -338,7 +339,7 @@ const OVERSCALE_SAFETY_FACTOR = 2.0;
  */
 const OVERSCALE_MAX_FRACTION = 0.01;
 
-const scratch_centroid_rotated = new Vector3();
+const scratch_centroid_rotated = new Float64Array(3);
 
 /**
  * @typedef PieceGeometryStats
@@ -389,7 +390,7 @@ function compute_piece_geometry_stats(piece) {
 }
 
 /**
- * Build the meep `Transform` for an instance, cloning the fitted match
+ * Build the meep `Transform64` for an instance, cloning the fitted match
  * transform and baking in the per-piece OVERSCALE that absorbs the fit
  * residual into harmless overlap.
  *
@@ -406,10 +407,10 @@ function compute_piece_geometry_stats(piece) {
  * piece's boundary reaches at least the leftover's boundary in any residual
  * direction.
  *
- * @param {Transform} mt              fitted canonical→instance match transform
+ * @param {Transform64} mt              fitted canonical→instance match transform
  * @param {PieceGeometryStats} piece_stats
  * @param {number} max_residual       post-fit residual in B-frame units
- * @returns {Transform}
+ * @returns {Transform64}
  */
 function match_transform_to_meep_transform(mt, piece_stats, max_residual) {
     const t = mt.clone();
@@ -418,7 +419,7 @@ function match_transform_to_meep_transform(mt, piece_stats, max_residual) {
     // actual extent — using the max axis-scale keeps δ a conservative lower
     // bound on the boost needed.
     const max_axis_scale = Math.max(
-        Math.abs(mt.scale.x), Math.abs(mt.scale.y), Math.abs(mt.scale.z)
+        Math.abs(mt.scale_x), Math.abs(mt.scale_y), Math.abs(mt.scale_z)
     );
     const piece_radius_in_b = max_axis_scale * piece_stats.radius;
 
@@ -431,20 +432,25 @@ function match_transform_to_meep_transform(mt, piece_stats, max_residual) {
     if (delta === 0) return t;
 
     const boost = 1 + delta;
-    t.scale.set(t.scale.x * boost, t.scale.y * boost, t.scale.z * boost);
+    t.setScale(t.scale_x * boost, t.scale_y * boost, t.scale_z * boost);
 
     // Adjusted translation = original − δ · R · diag(s) · A_centroid.
-    scratch_centroid_rotated.set(
-        mt.scale.x * piece_stats.centroid_x,
-        mt.scale.y * piece_stats.centroid_y,
-        mt.scale.z * piece_stats.centroid_z
+    v3_quaternion_apply(
+        scratch_centroid_rotated, 0,
+        mt.scale_x * piece_stats.centroid_x,
+        mt.scale_y * piece_stats.centroid_y,
+        mt.scale_z * piece_stats.centroid_z,
+        mt.rotation_x, mt.rotation_y, mt.rotation_z, mt.rotation_w
     );
-    scratch_centroid_rotated.applyQuaternion(mt.rotation);
 
-    t.position.set(
-        mt.position.x - delta * scratch_centroid_rotated.x,
-        mt.position.y - delta * scratch_centroid_rotated.y,
-        mt.position.z - delta * scratch_centroid_rotated.z
+    t.setTranslation(
+        mt.translation_x - delta * scratch_centroid_rotated[0],
+        mt.translation_y - delta * scratch_centroid_rotated[1],
+        mt.translation_z - delta * scratch_centroid_rotated[2]
     );
+
+    // the scale and translation both moved, so the matrix owes an update before anyone reads it
+    t.updateMatrix();
+
     return t;
 }

package/src/shade/renderer/scene/optimization/geometry/internal/anchor_grow_topological.d.ts

@@ -6,7 +6,7 @@
  * @property {number[]} faces_b       face IDs in B that were matched
  * @property {Map<number, number>} vertex_correspondence  vertex_a → vertex_b
  * @property {Map<number, number>} face_correspondence    face_a → face_b
- * @property {import("../../../../../../engine/ecs/transform/Transform.js").Transform} transform   refined transform
+ * @property {import("../../../../../../engine/ecs/transform/Transform64.js").Transform64} transform   refined transform
  */
 /**
  * From a single seed (face_a, face_b) with an established initial vertex
@@ -63,6 +63,6 @@ export type GrownMatch = {
     /**
      * refined transform
      */
-    transform: import("../../../../../../engine/ecs/transform/Transform.js").Transform;
+    transform: import("../../../../../../engine/ecs/transform/Transform64.js").Transform64;
 };
 //# sourceMappingURL=anchor_grow_topological.d.ts.map

package/src/shade/renderer/scene/optimization/geometry/internal/anchor_grow_topological.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anchor_grow_topological.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/anchor_grow_topological.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAX0B,UAAU;IACV,UAAU;IACJ,UAAU;IACV,UAAU;IACL,6BAA6B,EAAvD,IAAI,MAAM,EAAE,MAAM,CAAC;IACN,WAAW,EAAxB,MAAM;IACO,WAAW,EAAxB,MAAM;IACO,gBAAgB,EAA7B,MAAM;IACQ,cAAc,GAA5B,MAAM;IACJ,UAAU,GAAG,IAAI,CA8I7B;;;;;;;;aAxKa,MAAM,EAAE;;;;aACR,MAAM,EAAE;;;;2BACR,IAAI,MAAM,EAAE,MAAM,CAAC;;;;yBACnB,IAAI,MAAM,EAAE,MAAM,CAAC;;;;eACnB,OAAO,qDAAqD,EAAE,SAAS"}
+{"version":3,"file":"anchor_grow_topological.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/anchor_grow_topological.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAX0B,UAAU;IACV,UAAU;IACJ,UAAU;IACV,UAAU;IACL,6BAA6B,EAAvD,IAAI,MAAM,EAAE,MAAM,CAAC;IACN,WAAW,EAAxB,MAAM;IACO,WAAW,EAAxB,MAAM;IACO,gBAAgB,EAA7B,MAAM;IACQ,cAAc,GAA5B,MAAM;IACJ,UAAU,GAAG,IAAI,CA8I7B;;;;;;;;aAxKa,MAAM,EAAE;;;;aACR,MAAM,EAAE;;;;2BACR,IAAI,MAAM,EAAE,MAAM,CAAC;;;;yBACnB,IAAI,MAAM,EAAE,MAAM,CAAC;;;;eACnB,OAAO,uDAAuD,EAAE,WAAW"}

package/src/shade/renderer/scene/optimization/geometry/internal/anchor_grow_topological.js

@@ -3,7 +3,7 @@ import { bt_edge_get } from "../../../../../../core/geom/3d/topology/struct/bina
 import { bt_edge_other_face } from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_edge_other_face.js";
 import { bt_face_third_vertex } from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_third_vertex.js";
 import Vector3 from "../../../../../../core/geom/Vector3.js";
-import { Transform } from "../../../../../../engine/ecs/transform/Transform.js";
+import { Transform64 } from "../../../../../../engine/ecs/transform/Transform64.js";
 import { StandardAttributes } from "../../../../geometry/StandardAttributes.js";
 import { apply_match_transform, match_solve_transform } from "./match_solve_transform.js";
 import { vertex_attribute_pairs, vertex_attributes_match } from "./vertex_attributes_equal.js";
@@ -18,7 +18,7 @@ const scratch_predicted = new Vector3();
  * @property {number[]} faces_b       face IDs in B that were matched
  * @property {Map<number, number>} vertex_correspondence  vertex_a → vertex_b
  * @property {Map<number, number>} face_correspondence    face_a → face_b
- * @property {import("../../../../../../engine/ecs/transform/Transform.js").Transform} transform   refined transform
+ * @property {import("../../../../../../engine/ecs/transform/Transform64.js").Transform64} transform   refined transform
  */
 
 /**
@@ -66,7 +66,7 @@ export function anchor_grow_topological(args) {
 
     f_b_for_a.set(seed_face_a, seed_face_b);
 
-    const transform = new Transform();
+    const transform = new Transform64();
     let needs_refit = true;
 
     // Frontier: edges of matched faces that we haven't tried to grow across yet

package/src/shade/renderer/scene/optimization/geometry/internal/cover_greedy.d.ts

@@ -4,7 +4,7 @@
  * @property {number} b_geom              target/instance geometry index
  * @property {number[]} faces_a
  * @property {number[]} faces_b
- * @property {import("../../../../../../engine/ecs/transform/Transform.js").Transform} transform
+ * @property {import("../../../../../../engine/ecs/transform/Transform64.js").Transform64} transform
  * @property {number} max_residual        Max post-refit residual distance (B-frame units).
  *                                        Used downstream to size a per-piece overscale
  *                                        that absorbs the residual into harmless overlap.
@@ -13,7 +13,7 @@
  * @typedef CoverDecisionInstance
  * @property {number} b_geom
  * @property {number[]} faces_b
- * @property {import("../../../../../../engine/ecs/transform/Transform.js").Transform} transform
+ * @property {import("../../../../../../engine/ecs/transform/Transform64.js").Transform64} transform
  * @property {number} max_residual
  */
 /**
@@ -48,7 +48,7 @@ export type GrownMatchRecord = {
     b_geom: number;
     faces_a: number[];
     faces_b: number[];
-    transform: import("../../../../../../engine/ecs/transform/Transform.js").Transform;
+    transform: import("../../../../../../engine/ecs/transform/Transform64.js").Transform64;
     /**
      * Max post-refit residual distance (B-frame units).
      * Used downstream to size a per-piece overscale
@@ -59,7 +59,7 @@ export type GrownMatchRecord = {
 export type CoverDecisionInstance = {
     b_geom: number;
     faces_b: number[];
-    transform: import("../../../../../../engine/ecs/transform/Transform.js").Transform;
+    transform: import("../../../../../../engine/ecs/transform/Transform64.js").Transform64;
     max_residual: number;
 };
 export type CoverDecision = {

package/src/shade/renderer/scene/optimization/geometry/internal/cover_greedy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cover_greedy.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/cover_greedy.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;GAWG;AACH,sCAJW,gBAAgB,EAAE,kBAClB,MAAM,GACJ,aAAa,EAAE,CA2F3B;;;;;YAhIa,MAAM;;;;YACN,MAAM;aACN,MAAM,EAAE;aACR,MAAM,EAAE;eACR,OAAO,qDAAqD,EAAE,SAAS;;;;;;kBACvE,MAAM;;;YAON,MAAM;aACN,MAAM,EAAE;eACR,OAAO,qDAAqD,EAAE,SAAS;kBACvE,MAAM;;;;;;wBAKN,MAAM;;;;YACN,MAAM;;;;qBACN,MAAM,EAAE;;;;eACR,qBAAqB,EAAE"}
+{"version":3,"file":"cover_greedy.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/cover_greedy.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;GAWG;AACH,sCAJW,gBAAgB,EAAE,kBAClB,MAAM,GACJ,aAAa,EAAE,CA2F3B;;;;;YAhIa,MAAM;;;;YACN,MAAM;aACN,MAAM,EAAE;aACR,MAAM,EAAE;eACR,OAAO,uDAAuD,EAAE,WAAW;;;;;;kBAC3E,MAAM;;;YAON,MAAM;aACN,MAAM,EAAE;eACR,OAAO,uDAAuD,EAAE,WAAW;kBAC3E,MAAM;;;;;;wBAKN,MAAM;;;;YACN,MAAM;;;;qBACN,MAAM,EAAE;;;;eACR,qBAAqB,EAAE"}

package/src/shade/renderer/scene/optimization/geometry/internal/cover_greedy.js

@@ -4,7 +4,7 @@
  * @property {number} b_geom              target/instance geometry index
  * @property {number[]} faces_a
  * @property {number[]} faces_b
- * @property {import("../../../../../../engine/ecs/transform/Transform.js").Transform} transform
+ * @property {import("../../../../../../engine/ecs/transform/Transform64.js").Transform64} transform
  * @property {number} max_residual        Max post-refit residual distance (B-frame units).
  *                                        Used downstream to size a per-piece overscale
  *                                        that absorbs the residual into harmless overlap.
@@ -14,7 +14,7 @@
  * @typedef CoverDecisionInstance
  * @property {number} b_geom
  * @property {number[]} faces_b
- * @property {import("../../../../../../engine/ecs/transform/Transform.js").Transform} transform
+ * @property {import("../../../../../../engine/ecs/transform/Transform64.js").Transform64} transform
  * @property {number} max_residual
  */
 

package/src/shade/renderer/scene/optimization/geometry/internal/match_refit_validate.d.ts

@@ -19,7 +19,7 @@
  * @param {Geometry} args.geometry_a
  * @param {Geometry} args.geometry_b
  * @param {Map<number, number>} args.vertex_correspondence vertex_a → vertex_b
- * @param {import("../../../../../../engine/ecs/transform/Transform.js").Transform} args.transform Updated in place.
+ * @param {import("../../../../../../engine/ecs/transform/Transform64.js").Transform64} args.transform Updated in place.
  * @param {number} args.threshold
  * @returns {ValidationResult}
  */
@@ -27,7 +27,7 @@ export function match_refit_and_validate({ geometry_a, geometry_b, vertex_corres
     geometry_a: Geometry;
     geometry_b: Geometry;
     vertex_correspondence: Map<number, number>;
-    transform: import("../../../../../../engine/ecs/transform/Transform.js").Transform;
+    transform: import("../../../../../../engine/ecs/transform/Transform64.js").Transform64;
     threshold: number;
 }): ValidationResult;
 /**