@woosh/meep-engine 3.40.0 → 3.42.0

package/src/shade/renderer/animation/shader_animation_pose_resolve.js

@@ -1,176 +1,187 @@
-import { atomic_u32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { chunk_scene_database_access_rw } from "../scene/chunk_scene_database_access.js";
-import { SCENE_DATABASE_SPEC } from "../scene/SCENE_DATABASE_SPEC.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_pose_accumulator } from "./chunk_pose_accumulator.js";
-
-const TRANSFORMS_TABLE = SCENE_DATABASE_SPEC.get('transforms');
-
-/**
- * Workgroup size for the resolve pass. Exported so dispatchers can pair
- * it with `transforms.dispatch_group_count(WORKGROUP_SIZE)`.
- */
-export const WORKGROUP_SIZE = 64;
-
-const PG_PREFIX = TRANSFORMS_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
-    .addStorageBuffer('pose_accumulator', WebGPUArray.from(atomic_u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(local_invocation_index) local_id: u32,
-) {
-    if !${PG_PREFIX}_setup(&scene_database, wg_id.x, local_id) {
-        return;
-    }
-
-    let slot_in_page = ${PG_PREFIX}_slot_in_page(local_id);
-
-    if slot_in_page >= ${PG_PREFIX}_ELEMENTS_PER_PAGE {
-        return;
-    }
-    if !${PG_PREFIX}_is_occupied(slot_in_page) {
-        return;
-    }
-
-    // Absolute transforms-table row index. The accumulator is laid out
-    // one slot per row at the same index, so this is also the
-    // accumulator slot.
-    let row = ${PG_PREFIX}_slot_to_index(slot_in_page);
-
-    let slot_base = pose_accumulator_slot_base(row);
-    let dirty_word = slot_base + POSE_OFFSET_DIRTY;
-
-    // Single load of the dirty mask gates the whole resolve. If
-    // nothing was contributed to this row this frame, leave local_*
-    // alone (and the accumulator slot is already zero because the
-    // previous resolve drained it).
-    let dirty = atomicLoad(&pose_accumulator[dirty_word]);
-    if dirty == 0u {
-        return;
-    }
-
-    // ── Translation ───────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_T_MASK) != 0u {
-        let t_base = slot_base + POSE_OFFSET_TRANSLATION;
-        // Per-axis: only overwrite the channels that actually had a
-        // contribution. Read the current local_translation through
-        // the rw helper and patch the dirty channels in-place — the
-        // sibling-axis race that the old direct writer already
-        // tolerated still applies (two threads writing different
-        // axes of the same node), but we now have at most one resolve
-        // thread per row, so it never triggers here.
-        var t = scene_read_node_rw(&scene_database, row).local_translation;
-        if (dirty & POSE_DIRTY_TX) != 0u {
-            t.x = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 0u]));
-            atomicStore(&pose_accumulator[t_base + 0u], 0u);
-        }
-        if (dirty & POSE_DIRTY_TY) != 0u {
-            t.y = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 1u]));
-            atomicStore(&pose_accumulator[t_base + 1u], 0u);
-        }
-        if (dirty & POSE_DIRTY_TZ) != 0u {
-            t.z = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 2u]));
-            atomicStore(&pose_accumulator[t_base + 2u], 0u);
-        }
-        scene_write_node_local_translation(&scene_database, row, t);
-    }
-
-    // ── Rotation ──────────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_R) != 0u {
-        let r_base = slot_base + POSE_OFFSET_ROTATION;
-        let r = vec4<f32>(
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 0u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 1u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 2u])),
-            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 3u])),
-        );
-        atomicStore(&pose_accumulator[r_base + 0u], 0u);
-        atomicStore(&pose_accumulator[r_base + 1u], 0u);
-        atomicStore(&pose_accumulator[r_base + 2u], 0u);
-        atomicStore(&pose_accumulator[r_base + 3u], 0u);
-        // A sum of length zero carries no orientation to recover: every
-        // clip that writes this rotation is playing at weight zero, and
-        // the apply pass contributes to a bound clip whatever its
-        // weight. \`normalize\` answers NaN there, and one NaN local
-        // rotation reaches every skin matrix naming the joint, so the
-        // meshes it drives stop rasterising altogether — a rig loses a
-        // limb because a clip nobody is playing happens to be the only
-        // one that rotates it. Leaving the row alone is the rest pose,
-        // which is the answer the CPU twin gives (\`pose_evaluate_local\`)
-        // and the value the row still holds.
-        //
-        // Otherwise: the weighted-quaternion sum (\`w_i * q_i\`) is the
-        // standard nlerp blend numerator; normalise here, once, after
-        // every contributor has been folded in. The apply pass
-        // canonicalised signs at GLTF load so we don't hit the antipode
-        // case for imported clips.
-        if length(r) > 0.0 {
-            scene_write_node_local_rotation(&scene_database, row, normalize(r));
-        }
-    }
-
-    // ── Scale ─────────────────────────────────────────────────────
-    if (dirty & POSE_DIRTY_S_MASK) != 0u {
-        let s_base = slot_base + POSE_OFFSET_SCALE;
-        var s = scene_read_node_rw(&scene_database, row).local_scale;
-        if (dirty & POSE_DIRTY_SX) != 0u {
-            s.x = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 0u]));
-            atomicStore(&pose_accumulator[s_base + 0u], 0u);
-        }
-        if (dirty & POSE_DIRTY_SY) != 0u {
-            s.y = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 1u]));
-            atomicStore(&pose_accumulator[s_base + 1u], 0u);
-        }
-        if (dirty & POSE_DIRTY_SZ) != 0u {
-            s.z = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 2u]));
-            atomicStore(&pose_accumulator[s_base + 2u], 0u);
-        }
-        scene_write_node_local_scale(&scene_database, row, s);
-    }
-
-    // Clear the dirty mask itself last, so an interrupted resolve
-    // (theoretical — these passes don't yield) would still leave the
-    // dirty bits intact to be redone.
-    atomicStore(&pose_accumulator[dirty_word], 0u);
-}
-`, [
-        TRANSFORMS_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
-        chunk_scene_database_access_rw,
-        chunk_pose_accumulator,
-    ]);
-
-/**
- * Compute shader that drains the pose accumulator into
- * `transforms_table.local_{translation,rotation,scale}`.
- *
- * Walks the transforms table via the read+write page iterator — one
- * thread per slot. For each occupied row whose accumulator slot has
- * any dirty bits set, reads the contributed components (atomic
- * loads, bitcast back to f32), writes them through the per-field
- * scene helpers, normalises rotation, and zeros the slot for next
- * frame.
- *
- * The accumulator buffer must be sized to at least
- * `transforms.dispatch_page_count * elements_per_page` rows —
- * {@link GPUAnimationManager#ensure_pose_accumulator_capacity}
- * handles that.
- *
- * Dispatch via
- * `shader_animation_pose_resolve.dispatch({ group_count_x: transforms.dispatch_group_count(WORKGROUP_SIZE), ... })`.
- */
-export const shader_animation_pose_resolve = ComputeShader.from({
-    label: "Animation/PoseResolve",
-    body,
-    resources,
-});
+import { atomic_u32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { chunk_scene_database_access_rw } from "../scene/chunk_scene_database_access.js";
+import { SCENE_DATABASE_SPEC } from "../scene/SCENE_DATABASE_SPEC.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_pose_accumulator } from "./chunk_pose_accumulator.js";
+
+const TRANSFORMS_TABLE = SCENE_DATABASE_SPEC.get('transforms');
+
+/**
+ * Workgroup size for the resolve pass. Exported so dispatchers can pair
+ * it with `transforms.dispatch_group_count(WORKGROUP_SIZE)`.
+ */
+export const WORKGROUP_SIZE = 64;
+
+const PG_PREFIX = TRANSFORMS_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer('scene_database', WebGPUArray.from(u32), true)
+    .addStorageBuffer('pose_accumulator', WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
+fn main(
+    @builtin(workgroup_id) wg_id: vec3<u32>,
+    @builtin(local_invocation_index) local_id: u32,
+) {
+    if !${PG_PREFIX}_setup(&scene_database, wg_id.x, local_id) {
+        return;
+    }
+
+    let slot_in_page = ${PG_PREFIX}_slot_in_page(local_id);
+
+    if slot_in_page >= ${PG_PREFIX}_ELEMENTS_PER_PAGE {
+        return;
+    }
+    if !${PG_PREFIX}_is_occupied(slot_in_page) {
+        return;
+    }
+
+    // Absolute transforms-table row index. The accumulator is laid out
+    // one slot per row at the same index, so this is also the
+    // accumulator slot.
+    let row = ${PG_PREFIX}_slot_to_index(slot_in_page);
+
+    let slot_base = pose_accumulator_slot_base(row);
+    let dirty_word = slot_base + POSE_OFFSET_DIRTY;
+
+    // Single load of the dirty mask gates the whole resolve. If
+    // nothing was contributed to this row this frame, leave local_*
+    // alone (and the accumulator slot is already zero because the
+    // previous resolve drained it).
+    let dirty = atomicLoad(&pose_accumulator[dirty_word]);
+    if dirty == 0u {
+        return;
+    }
+
+    // ── Translation ───────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_T_MASK) != 0u {
+        let t_base = slot_base + POSE_OFFSET_TRANSLATION;
+        // Per-axis: only overwrite the channels that actually had a
+        // contribution. Read the current local_translation through
+        // the rw helper and patch the dirty channels in-place — the
+        // sibling-axis race that the old direct writer already
+        // tolerated still applies (two threads writing different
+        // axes of the same node), but we now have at most one resolve
+        // thread per row, so it never triggers here.
+        var t = scene_read_node_rw(&scene_database, row).local_translation;
+        if (dirty & POSE_DIRTY_TX) != 0u {
+            t.x = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 0u]));
+            atomicStore(&pose_accumulator[t_base + 0u], 0u);
+        }
+        if (dirty & POSE_DIRTY_TY) != 0u {
+            t.y = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 1u]));
+            atomicStore(&pose_accumulator[t_base + 1u], 0u);
+        }
+        if (dirty & POSE_DIRTY_TZ) != 0u {
+            t.z = bitcast<f32>(atomicLoad(&pose_accumulator[t_base + 2u]));
+            atomicStore(&pose_accumulator[t_base + 2u], 0u);
+        }
+        scene_write_node_local_translation(&scene_database, row, t);
+    }
+
+    // ── Rotation ──────────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_R) != 0u {
+        let r_base = slot_base + POSE_OFFSET_ROTATION;
+        let r = vec4<f32>(
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 0u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 1u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 2u])),
+            bitcast<f32>(atomicLoad(&pose_accumulator[r_base + 3u])),
+        );
+        atomicStore(&pose_accumulator[r_base + 0u], 0u);
+        atomicStore(&pose_accumulator[r_base + 1u], 0u);
+        atomicStore(&pose_accumulator[r_base + 2u], 0u);
+        atomicStore(&pose_accumulator[r_base + 3u], 0u);
+        // The weighted-quaternion sum (\`w_i * q_i\`) is the standard
+        // nlerp blend numerator; normalise here, once, after every
+        // contributor has been folded in. The apply pass canonicalised
+        // signs at GLTF load so we don't hit the antipode case for
+        // imported clips.
+        //
+        // A sum of length zero carries no orientation to recover: every
+        // clip that writes this rotation is playing at weight zero — a
+        // faded-out clip keeps its binding, and the apply pass
+        // contributes to a bound clip whatever its weight — or the
+        // contributions cancelled exactly. \`normalize\` answers NaN there,
+        // and one NaN local rotation reaches every skin matrix naming the
+        // joint, so the meshes it drives stop rasterising altogether. Nor
+        // can the row be left alone: once a clip has written it, it holds
+        // that clip's last pose, not the rest. The answer is the rest
+        // rotation, which every contribution carried into the slot from
+        // its binding — what the CPU twin (\`pose_evaluate_local\`) gives.
+        if length(r) > 0.0 {
+            scene_write_node_local_rotation(&scene_database, row, normalize(r));
+        } else {
+            let rest_base = slot_base + POSE_OFFSET_REST_ROTATION;
+            let rest = vec4<f32>(
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 0u])),
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 1u])),
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 2u])),
+                bitcast<f32>(atomicLoad(&pose_accumulator[rest_base + 3u])),
+            );
+            scene_write_node_local_rotation(&scene_database, row, rest);
+        }
+    }
+
+    // ── Scale ─────────────────────────────────────────────────────
+    if (dirty & POSE_DIRTY_S_MASK) != 0u {
+        let s_base = slot_base + POSE_OFFSET_SCALE;
+        var s = scene_read_node_rw(&scene_database, row).local_scale;
+        if (dirty & POSE_DIRTY_SX) != 0u {
+            s.x = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 0u]));
+            atomicStore(&pose_accumulator[s_base + 0u], 0u);
+        }
+        if (dirty & POSE_DIRTY_SY) != 0u {
+            s.y = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 1u]));
+            atomicStore(&pose_accumulator[s_base + 1u], 0u);
+        }
+        if (dirty & POSE_DIRTY_SZ) != 0u {
+            s.z = bitcast<f32>(atomicLoad(&pose_accumulator[s_base + 2u]));
+            atomicStore(&pose_accumulator[s_base + 2u], 0u);
+        }
+        scene_write_node_local_scale(&scene_database, row, s);
+    }
+
+    // Clear the dirty mask itself last, so an interrupted resolve
+    // (theoretical — these passes don't yield) would still leave the
+    // dirty bits intact to be redone.
+    atomicStore(&pose_accumulator[dirty_word], 0u);
+}
+`, [
+        TRANSFORMS_TABLE.chunk_iterate(WORKGROUP_SIZE, true),
+        chunk_scene_database_access_rw,
+        chunk_pose_accumulator,
+    ]);
+
+/**
+ * Compute shader that drains the pose accumulator into
+ * `transforms_table.local_{translation,rotation,scale}`.
+ *
+ * Walks the transforms table via the read+write page iterator — one
+ * thread per slot. For each occupied row whose accumulator slot has
+ * any dirty bits set, reads the contributed components (atomic
+ * loads, bitcast back to f32), writes them through the per-field
+ * scene helpers, normalises rotation — or, for a rotation summing to
+ * nothing, writes the rest rotation the contributions carried — and
+ * zeros the sums and the dirty mask for next frame.
+ *
+ * The accumulator buffer must be sized to at least
+ * `transforms.dispatch_page_count * elements_per_page` rows —
+ * {@link GPUAnimationManager#ensure_pose_accumulator_capacity}
+ * handles that.
+ *
+ * Dispatch via
+ * `shader_animation_pose_resolve.dispatch({ group_count_x: transforms.dispatch_group_count(WORKGROUP_SIZE), ... })`.
+ */
+export const shader_animation_pose_resolve = ComputeShader.from({
+    label: "Animation/PoseResolve",
+    body,
+    resources,
+});

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA0NnB;IAmXD;;;;;;;OAOG;IACH,gBA+BC;;CACJ;qCA1xCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}
+{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA+NnB;IAmXD;;;;;;;OAOG;IACH,gBA+BC;;CACJ;qCA/xCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js

@@ -711,6 +711,11 @@ export class GPUMeshSkinningContext {
      */
     update(cmd_ctx) {
         if (this.#bindings.length === 0) {
+            if (this.#bindings_dirty) {
+                this.#refresh_bindings_from_records();
+                this.#upload_prev_position_offsets();
+                this.#bindings_dirty = false;
+            }
             return false;
         }
 

package/src/shade/renderer/binding/BufferBinding.js

@@ -61,7 +61,7 @@ export class BufferBinding extends BindingResource {
      * @returns {number}
      */
     get actual_size() {
-        return this.size === -1 ? this.buffer.size : this.size;
+        return this.size === -1 ? this.buffer.size - this.offset : this.size;
     }
 
     /**
@@ -100,4 +100,4 @@ export class BufferBinding extends BindingResource {
  * @readonly
  * @type {boolean}
  */
-BufferBinding.prototype.isBufferBinding = true;
+BufferBinding.prototype.isBufferBinding = true;

package/src/shade/renderer/buffer/table/GPUTypedTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUTypedTable.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTypedTable.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"GPUTypedTable.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTypedTable.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/buffer/table/GPUTypedTable.js

@@ -1214,9 +1214,11 @@ export class GPUTypedTable {
             record_start = tail;
         }
 
-        const upload = this.#upload_words.over(upload_buffer.data);
-
-        writer.write_record(upload.f32, upload.u32, (record_start + u32.size) / WORD_SIZE, value);
+        // A partial writer leaves the row's other fields in the shadow. Publish that whole
+        // record, rather than leaving the upload slot's previous occupant in those fields.
+        new Uint8Array(upload_buffer.data, record_start + u32.size, record_size).set(
+            new Uint8Array(page.cpu_data_buffer, page.cpu_data_address + in_page_index * record_size, record_size)
+        );
     }
 
     /**

package/src/shade/renderer/buffer/table/GPUTypedTableDescriptor.d.ts

@@ -128,9 +128,12 @@ export class GPUTypedTableDescriptor {
      * table's record type.
      *
      * @param {string} field_name
+     * @param {boolean} [rw] When true, the reader takes
+     *     `ptr<storage, ..., read_write>`, for a shader that binds the
+     *     database read+write; see {@link marshalling_method_read_field}.
      * @returns {CodeChunk}
      */
-    chunk_read_field(field_name: string): CodeChunk;
+    chunk_read_field(field_name: string, rw?: boolean): CodeChunk;
     /**
      *
      * @returns {string}
@@ -164,9 +167,11 @@ export class GPUTypedTableDescriptor {
      * Name of the function that reads only one field of a record.
      * Pair with {@link wgsl_gen_read_field_code} to emit the body.
      * @param {string} field_name
+     * @param {boolean} [rw] the variant whose database parameter is
+     *     `ptr<storage, ..., read_write>`
      * @returns {string}
      */
-    marshalling_method_read_field(field_name: string): string;
+    marshalling_method_read_field(field_name: string, rw?: boolean): string;
     /**
      * Name prefix for all WGSL symbols generated by {@link wgsl_gen_iterate_code}
      * for the given workgroup size. Helpers append `_setup`, `_is_occupied`,
@@ -276,9 +281,11 @@ export class GPUTypedTableDescriptor {
      * concept. The field's WGSL type is mirrored in the return type.
      *
      * @param {string} field_name
+     * @param {boolean} [rw] take the database as `ptr<storage, ..., read_write>`:
+     *     WGSL does not coerce access modes across function calls
      * @returns {CodeChunk}
      */
-    wgsl_gen_read_field_code(field_name: string): CodeChunk;
+    wgsl_gen_read_field_code(field_name: string, rw?: boolean): CodeChunk;
     /**
      * Generate a writer that touches only a single struct field of a record.
      *

package/src/shade/renderer/buffer/table/GPUTypedTableDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUTypedTableDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTypedTableDescriptor.js"],"names":[],"mappings":"AAQA;;GAEG;AAGH;IA+FI;;;;;;;OAOG;IACH,kBANW,UAAU,oBACV,MAAM,eACN,MAAM,EA4ChB;IA9ID;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;OAEG;IACH,MAFU,UAAU,CAEf;IAEL;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;;;;OAMG;IACH,2BAFU,MAAM,CAEc;IAE9B;;;;;OAKG;IACH,wBAFU,MAAM,CAEW;IAE3B;;;;;;OAMG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,gCAEC;IAED;;;;;OAKG;IACH,qCAEC;IAED;;;OAGG;IACH,6BAEC;IAkFD;;;OAGG;IACH,4BAKC;IAED;;;;;;;;OAQG;IACH,+BAKC;IAED;;;OAGG;IACH,6BAKC;IAED;;;;;;;;;;;;;;OAcG;IACH,4BARW,MAAM,OACN,OAAO,GAKL,SAAS,CAUrB;IAED;;;;;;OAMG;IACH,6BAHW,MAAM,GACJ,SAAS,CASrB;IAED;;;OAGG;IACH,8BAYC;IAED;;;OAGG;IACH,sCAEC;IAED;;;;;OAKG;IACH,yCAEC;IAED;;;OAGG;IACH,uCAEC;IAED;;;;;OAKG;IACH,2CAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0CAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,0CARW,MAAM,OACN,OAAO,GAKL,MAAM,CAOlB;IAED;;;;;;OAMG;IACH,wBANW,OAAO,GAIL,SAAS,CAyBrB;IAED;;;OAGG;IACH,uBAFa,SAAS,CAqBrB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACH,oCARW,MAAM,OACN,OAAO,GAKL,SAAS,CAwOrB;IAED;;;;;;;;;;;;;OAaG;IACH,qCAHW,MAAM,GACJ,SAAS,CAqCrB;IAED;;;;;;;;;;;;;;;OAeG;IACH,sCAHW,MAAM,GACJ,SAAS,CAmCrB;IAkDD;;;;OAIG;IACH,cAHW,uBAAuB,GACtB,OAAO,CAMlB;IAED,eAEC;IAED,mBAEC;IAGL;;;OAGG;IACH,oCAFU,OAAO,CAE0C;;CAN1D;yBAp2BY,OAAO,iCAAiC,EAAE,UAAU;0BAPvC,oCAAoC"}
+{"version":3,"file":"GPUTypedTableDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTypedTableDescriptor.js"],"names":[],"mappings":"AAQA;;GAEG;AAGH;IA+FI;;;;;;;OAOG;IACH,kBANW,UAAU,oBACV,MAAM,eACN,MAAM,EA4ChB;IA9ID;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;OAEG;IACH,MAFU,UAAU,CAEf;IAEL;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;;;;OAMG;IACH,2BAFU,MAAM,CAEc;IAE9B;;;;;OAKG;IACH,wBAFU,MAAM,CAEW;IAE3B;;;;;;OAMG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,gCAEC;IAED;;;;;OAKG;IACH,qCAEC;IAED;;;OAGG;IACH,6BAEC;IAkFD;;;OAGG;IACH,4BAKC;IAED;;;;;;;;OAQG;IACH,+BAKC;IAED;;;OAGG;IACH,6BAKC;IAED;;;;;;;;;;;;;;OAcG;IACH,4BARW,MAAM,OACN,OAAO,GAKL,SAAS,CAUrB;IAED;;;;;;;;;OASG;IACH,6BANW,MAAM,OACN,OAAO,GAGL,SAAS,CAUrB;IAED;;;OAGG;IACH,8BAYC;IAED;;;OAGG;IACH,sCAEC;IAED;;;;;OAKG;IACH,yCAEC;IAED;;;OAGG;IACH,uCAEC;IAED;;;;;OAKG;IACH,2CAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,0CALW,MAAM,OACN,OAAO,GAEL,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,0CARW,MAAM,OACN,OAAO,GAKL,MAAM,CAOlB;IAED;;;;;;OAMG;IACH,wBANW,OAAO,GAIL,SAAS,CAyBrB;IAED;;;OAGG;IACH,uBAFa,SAAS,CAqBrB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACH,oCARW,MAAM,OACN,OAAO,GAKL,SAAS,CAwOrB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qCALW,MAAM,OACN,OAAO,GAEL,SAAS,CAqCrB;IAED;;;;;;;;;;;;;;;OAeG;IACH,sCAHW,MAAM,GACJ,SAAS,CAmCrB;IAkDD;;;;OAIG;IACH,cAHW,uBAAuB,GACtB,OAAO,CAMlB;IAED,eAEC;IAED,mBAEC;IAGL;;;OAGG;IACH,oCAFU,OAAO,CAE0C;;CAN1D;yBA52BY,OAAO,iCAAiC,EAAE,UAAU;0BAPvC,oCAAoC"}

package/src/shade/renderer/buffer/table/GPUTypedTableDescriptor.js

@@ -254,13 +254,17 @@ export class GPUTypedTableDescriptor {
      * table's record type.
      *
      * @param {string} field_name
+     * @param {boolean} [rw] When true, the reader takes
+     *     `ptr<storage, ..., read_write>`, for a shader that binds the
+     *     database read+write; see {@link marshalling_method_read_field}.
      * @returns {CodeChunk}
      */
-    chunk_read_field(field_name) {
-        let chunk = this.#chunks_read_field.get(field_name);
+    chunk_read_field(field_name, rw = false) {
+        const key = rw ? `${field_name}/rw` : field_name;
+        let chunk = this.#chunks_read_field.get(key);
         if (chunk === undefined) {
-            chunk = this.wgsl_gen_read_field_code(field_name);
-            this.#chunks_read_field.set(field_name, chunk);
+            chunk = this.wgsl_gen_read_field_code(field_name, rw);
+            this.#chunks_read_field.set(key, chunk);
         }
         return chunk;
     }
@@ -323,10 +327,12 @@ export class GPUTypedTableDescriptor {
      * Name of the function that reads only one field of a record.
      * Pair with {@link wgsl_gen_read_field_code} to emit the body.
      * @param {string} field_name
+     * @param {boolean} [rw] the variant whose database parameter is
+     *     `ptr<storage, ..., read_write>`
      * @returns {string}
      */
-    marshalling_method_read_field(field_name) {
-        return `database_read_${this.marshalling_tag}_element_${field_name}`;
+    marshalling_method_read_field(field_name, rw = false) {
+        return `database_read_${rw ? 'rw_' : ''}${this.marshalling_tag}_element_${field_name}`;
     }
 
     /**
@@ -719,9 +725,11 @@ fn ${prefix}_read(
      * concept. The field's WGSL type is mirrored in the return type.
      *
      * @param {string} field_name
+     * @param {boolean} [rw] take the database as `ptr<storage, ..., read_write>`:
+     *     WGSL does not coerce access modes across function calls
      * @returns {CodeChunk}
      */
-    wgsl_gen_read_field_code(field_name) {
+    wgsl_gen_read_field_code(field_name, rw = false) {
         assert.isString(field_name, 'field_name');
 
         /**
@@ -739,9 +747,9 @@ fn ${prefix}_read(
 
         const lines = new LineBuilder();
 
-        const fn_name = this.marshalling_method_read_field(field_name);
+        const fn_name = this.marshalling_method_read_field(field_name, rw);
 
-        lines.add(`fn ${fn_name}(database: ptr<storage, array<${GPU_DATABASE_BUFFER_ELEMENT_TYPE.wgsl_ref}>>, index: u32) -> ${field_type.wgsl_ref} {`);
+        lines.add(`fn ${fn_name}(database: ptr<storage, array<${GPU_DATABASE_BUFFER_ELEMENT_TYPE.wgsl_ref}>${rw ? ', read_write' : ''}>, index: u32) -> ${field_type.wgsl_ref} {`);
         lines.indent();
 
         this.#wgsl_gen_element_offset(lines, `return ${field_type.wgsl_ref}();`);

package/src/shade/renderer/camera/orbital/OrbitalCameraInput.d.ts

@@ -52,6 +52,8 @@ export class OrbitalCameraInput {
     _onDragEnd: any;
     _onWheel: any;
     _onPinch: any;
+    _onCancel: any;
+    _cancelTarget: Element;
     /** Subscribe to device signals. Idempotent. */
     connect(): void;
     /** Unsubscribe. Releases any in-flight gesture so the rig doesn't hang engaged. */
@@ -79,6 +81,7 @@ export class OrbitalCameraInput {
     }): void;
     _handleDragEnd(): void;
     _endGesture(): void;
+    _cancelGesture(): void;
     /** @param {{x:number,y:number,z:number}} delta wheel delta (meep normalizes to signs) */
     _handleWheel(delta: {
         x: number;

package/src/shade/renderer/camera/orbital/OrbitalCameraInput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OrbitalCameraInput.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraInput.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH;IACI;;;;;;;;OAQG;IACH;QAPkE,GAAG,EAA1D,OAAO,uBAAuB,EAAE,gBAAgB;QACgC,OAAO,EAAvF,OAAO,mDAAmD,EAAE,aAAa;QACE,QAAQ,EAAnF,OAAO,oDAAoD,EAAE,OAAO;QACrC,QAAQ,EAAvC;YAAE,YAAY,EAAE,MAAM,CAAA;SAAE;QACF,IAAI,EAA1B;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE;QACF,MAAM,EAAnB,MAAM;OAmBhB;IAhBG,sDAAc;IACd,mFAAsB;IACtB,+EAAwB;IACxB;sBARuB,MAAM;MAQL;IACxB;aARc,MAAM;MAQJ;IAChB,YAAoB;IAEpB,oBAAuB;IACvB,iDAAiD;IACjD,OADW,QAAQ,GAAC,KAAK,GAAC,IAAI,CACb;IAEjB,kBAAoD;IACpD,aAA0C;IAC1C,gBAAgD;IAChD,cAA4C;IAC5C,cAA4C;IAGhD,+CAA+C;IAC/C,gBAaC;IAED,mFAAmF;IACnF,mBAaC;IAED;;;OAGG;IACH,WAFW,MAAM,QAShB;IAID,yBAQC;IAED;;;;OAIG;IACH,sBAJW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,WACnB;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,gBACnB;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAe7B;IAED,uBAEC;IAED,oBAOC;IAID,yFAAyF;IACzF,oBADY;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAmBvC;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAOhB;CACJ"}
+{"version":3,"file":"OrbitalCameraInput.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraInput.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH;IACI;;;;;;;;OAQG;IACH;QAPkE,GAAG,EAA1D,OAAO,uBAAuB,EAAE,gBAAgB;QACgC,OAAO,EAAvF,OAAO,mDAAmD,EAAE,aAAa;QACE,QAAQ,EAAnF,OAAO,oDAAoD,EAAE,OAAO;QACrC,QAAQ,EAAvC;YAAE,YAAY,EAAE,MAAM,CAAA;SAAE;QACF,IAAI,EAA1B;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE;QACF,MAAM,EAAnB,MAAM;OAqBhB;IAlBG,sDAAc;IACd,mFAAsB;IACtB,+EAAwB;IACxB;sBARuB,MAAM;MAQL;IACxB;aARc,MAAM;MAQJ;IAChB,YAAoB;IAEpB,oBAAuB;IACvB,iDAAiD;IACjD,OADW,QAAQ,GAAC,KAAK,GAAC,IAAI,CACb;IAEjB,kBAAoD;IACpD,aAA0C;IAC1C,gBAAgD;IAChD,cAA4C;IAC5C,cAA4C;IAC5C,eAA+C;IAC/C,uBAAyB;IAG7B,+CAA+C;IAC/C,gBAgBC;IAED,mFAAmF;IACnF,mBAgBC;IAED;;;OAGG;IACH,WAFW,MAAM,QAShB;IAID,yBAQC;IAED;;;;OAIG;IACH,sBAJW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,WACnB;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,gBACnB;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAe7B;IAED,uBAEC;IAED,oBAOC;IAED,uBAMC;IAID,yFAAyF;IACzF,oBADY;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAmBvC;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAOhB;CACJ"}

package/src/shade/renderer/camera/orbital/OrbitalCameraInput.js

@@ -39,6 +39,8 @@ export class OrbitalCameraInput {
         this._onDragEnd = this._handleDragEnd.bind(this);
         this._onWheel = this._handleWheel.bind(this);
         this._onPinch = this._handlePinch.bind(this);
+        this._onCancel = this._cancelGesture.bind(this);
+        this._cancelTarget = null;
     }
 
     /** Subscribe to device signals. Idempotent. */
@@ -55,6 +57,9 @@ export class OrbitalCameraInput {
         // meep declares on.pinch but does not yet dispatch it (touch users get
         // single-pointer rotate via drag). Wired so pinch works once it lands.
         this.pointer.on.pinch.add(this._onPinch);
+        this._cancelTarget = this.pointer.domElement;
+        this._cancelTarget.addEventListener("pointercancel", this._onCancel);
+        window.addEventListener("blur", this._onCancel);
     }
 
     /** Unsubscribe. Releases any in-flight gesture so the rig doesn't hang engaged. */
@@ -69,6 +74,9 @@ export class OrbitalCameraInput {
         this.pointer.on.dragEnd.remove(this._onDragEnd);
         this.pointer.on.wheel.remove(this._onWheel);
         this.pointer.on.pinch.remove(this._onPinch);
+        this._cancelTarget.removeEventListener("pointercancel", this._onCancel);
+        this._cancelTarget = null;
+        window.removeEventListener("blur", this._onCancel);
 
         this._endGesture();
     }
@@ -131,6 +139,14 @@ export class OrbitalCameraInput {
         this._mode = null;
     }
 
+    _cancelGesture() {
+        if (this._mode === null) {
+            return;
+        }
+        this.rig.cancelGesture();
+        this._mode = null;
+    }
+
     // ── zoom ─────────────────────────────────────────────────────────────────
 
     /** @param {{x:number,y:number,z:number}} delta wheel delta (meep normalizes to signs) */

package/src/shade/renderer/camera/orbital/OrbitalCameraRig.d.ts

@@ -99,6 +99,8 @@ export class OrbitalCameraRig {
     panScreen(dx: number, dy: number, viewportHeight: number, fov: number): void;
     /** End the pan drag: throw the target with the recent velocity (or stop dead). */
     disengagePan(): void;
+    /** Abort direct control without throwing, retaining the last applied pose. */
+    cancelGesture(): void;
     /**
      * Multiplicative zoom, applied directly. `factor < 1` zooms in, `> 1` out.
      * Scale-uniform and clamped to {@link distanceLimits}.