@woosh/meep-engine 3.41.0 → 3.42.0

package/src/shade/playground/water_surface/world.js

@@ -0,0 +1,160 @@
+import { Color } from "../../../core/color/Color.js";
+import { Entity } from "../../../engine/ecs/Entity.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { ShadedGeometry } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import Water from "../../../engine/graphics/ecs/water/Water.js";
+import WaterWaves from "../../../engine/graphics/ecs/water/WaterWaves.js";
+import { Attribute } from "../../renderer/geometry/Attribute.js";
+import { Geometry } from "../../renderer/geometry/Geometry.js";
+import { MeshoptClusterizer } from "../../renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.js";
+import { meshlet_geometry_build_from_geometry } from "../../renderer/geometry/meshlet_geometry_build_from_geometry.js";
+import { MeshletGeometry } from "../../renderer/geometry/MeshletGeometry.js";
+import { make_box_geometry } from "../../renderer/geometry/primitives/make_box_geometry.js";
+import { make_cylinder_geometry } from "../../renderer/geometry/primitives/make_cylinder_geometry.js";
+import { StandardAttributes } from "../../renderer/geometry/StandardAttributes.js";
+import { ShadeDrawSide } from "../../renderer/material/ShadeDrawSide.js";
+import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
+import { water_medium_preset } from "../../renderer/medium/water/water_presets.js";
+import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
+import { ColorSpace } from "../../renderer/texture/ColorSpace.js";
+import { ShadeTexture } from "../../renderer/texture/ShadeTexture.js";
+import { ShadeImage } from "../../renderer/texture/source/ShadeImage.js";
+
+function pose(x, y, z) {
+    const transform = new Transform64();
+    transform.setTranslation(x, y, z);
+    transform.updateMatrix();
+    return transform;
+}
+
+let checker_texture = null;
+/** Sharp light and dark squares, one per UV unit: what refraction bends shows the slopes without a sky. */
+function checker() {
+    if (checker_texture !== null) { return checker_texture; }
+    const size = 512, data = Sampler2D.uint8(4, size, size);
+    for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
+        const bright = ((x >> 8) + (y >> 8)) % 2 === 0;
+        data.data.set(bright ? [215, 220, 200, 255] : [42, 66, 84, 255], (y * size + x) * 4);
+    }
+    const image = ShadeImage.fromSampler2D(data); image.color_space = ColorSpace.SRGB;
+    return checker_texture = ShadeTexture.from(image);
+}
+
+function material(rgb, roughness = 0.8, textured = false) {
+    const m = new StandardShadeMaterial();
+    m.diffuse_color.copy(new Color(...rgb, 1));
+    m.metallic_factor = 0; m.roughness_factor = roughness; m.draw_side = ShadeDrawSide.Double;
+    if (textured) { m.texture_albedo = checker(); }
+    return m;
+}
+
+function meshlets(geometry) {
+    const result = new MeshletGeometry();
+    meshlet_geometry_build_from_geometry(geometry, result);
+    return result;
+}
+
+/**
+ * A polar mesh in local xz, wound to face +y: rings of `segments` vertices at radii `radius(theta, t)` for
+ * t from 0 to 1, at heights `height(theta, t)`. A disk has a centre vertex for t = 0; with `hole`, t = 0 is a
+ * ring, and the mesh an annulus. Texture coordinates are local xz over `texel` metres: two checker squares.
+ */
+function polar_geometry({ segments, rings, radius, height = () => 0, hole = false, texel = 1 }) {
+    const positions = [], normals = [], uvs = [], index = [];
+    const centre = !hole;
+    if (centre) { positions.push(0, height(0, 0), 0); normals.push(0, 1, 0); uvs.push(0, 0); }
+    const first = centre ? 1 : 0;
+    const ring_count = centre ? rings : rings + 1;
+    for (let r = 0; r < ring_count; r++) {
+        const t = centre ? (r + 1) / rings : r / rings;
+        for (let s = 0; s < segments; s++) {
+            const theta = 2 * Math.PI * s / segments;
+            const rho = radius(theta, t);
+            positions.push(Math.cos(theta) * rho, height(theta, t), Math.sin(theta) * rho);
+            normals.push(0, 1, 0);
+            uvs.push(Math.cos(theta) * rho / texel, Math.sin(theta) * rho / texel);
+        }
+    }
+    const vertex = (r, s) => first + r * segments + (s % segments);
+    const triangle = (a, b, c) => {
+        const p = i => [positions[3 * i], positions[3 * i + 1], positions[3 * i + 2]];
+        const [pa, pb, pc] = [p(a), p(b), p(c)];
+        const ny = (pb[2] - pa[2]) * (pc[0] - pa[0]) - (pb[0] - pa[0]) * (pc[2] - pa[2]);
+        if (ny >= 0) { index.push(a, b, c); } else { index.push(a, c, b); }
+    };
+    if (centre) { for (let s = 0; s < segments; s++) { triangle(0, vertex(0, s), vertex(0, s + 1)); } }
+    for (let r = 0; r + 1 < ring_count; r++) {
+        for (let s = 0; s < segments; s++) {
+            triangle(vertex(r, s), vertex(r + 1, s), vertex(r + 1, s + 1));
+            triangle(vertex(r, s), vertex(r + 1, s + 1), vertex(r, s + 1));
+        }
+    }
+    const geometry = new Geometry();
+    geometry.index = Attribute.from(new Uint32Array(index), 1, 'index');
+    geometry.addAttribute(Attribute.from(new Float32Array(positions), 3, StandardAttributes.Position));
+    geometry.addAttribute(Attribute.from(new Float32Array(normals), 3, StandardAttributes.Normal));
+    geometry.addAttribute(Attribute.from(new Float32Array(uvs), 2, StandardAttributes.TextureCoordinates0));
+    return geometry;
+}
+
+/** A wobbly outline of mean radius one, the same for the water and the ground around it. */
+const wobble = (seed, amount) => theta => 1 + amount * (0.6 * Math.sin(3 * theta + seed) + 0.4 * Math.sin(5 * theta + 2 * seed));
+
+/**
+ * Four bodies of water, from a cup to an ocean, each a `Water` + `WaterWaves` entity whose mesh authors
+ * only its outline: the surface's detail comes from the waves, at any scale.
+ */
+export async function build_world(dataset) {
+    await MeshoptClusterizer.ready;
+    const build = builder => { builder.build(dataset); return builder.id; };
+    const solid = (geometry, m, x, y, z) => {
+        const shaded = new ShadedGeometry(); shaded.geometry = meshlets(geometry); shaded.material = m;
+        return build(new Entity().add(pose(x, y, z)).add(shaded));
+    };
+    const water_body = ({ geometry, x, y, z, preset, wind, upwind = 0, reflection = 0.5, roughness = 0.02 }) => {
+        const water = new Water();
+        water.medium = water_medium_preset({ preset });
+        water.roughness.set(roughness);
+        const waves = new WaterWaves();
+        waves.windSpeed.set(wind); waves.upwindFetch.set(upwind); waves.shoreReflection.set(reflection);
+        const transform = pose(x, y, z);
+        const entity = build(new Entity().add(water).add(waves).add(meshlets(geometry)).add(transform));
+        return { entity, water, waves, transform, level: y, base_wind: wind };
+    };
+
+    // a floor for the cup's table and the puddle
+    solid(polar_geometry({ segments: 48, rings: 6, radius: (theta, t) => 40 * t, texel: 0.5 }), material([1, 1, 1], 0.8, true), 0, 0, 0);
+
+    // a cup of tea on a table: 4 cm across, 7 cm deep
+    solid(make_box_geometry(1.2, 0.75, 0.8), material([0.45, 0.28, 0.16], 0.5), 0, 0.375, 0);
+    solid(make_cylinder_geometry(0.045, 0.04, 0.095, 32, 1, true), material([0.92, 0.92, 0.9], 0.3), 0, 0.75 + 0.0475, 0);
+    solid(polar_geometry({ segments: 32, rings: 1, radius: (theta, t) => 0.04 * t, texel: 0.02 }), material([1, 1, 1], 0.3, true), 0, 0.751, 0);
+    const cup = water_body({ geometry: polar_geometry({ segments: 32, rings: 2, radius: (theta, t) => 0.0435 * t }),
+        x: 0, y: 0.83, z: 0, preset: 'swimming_pool', wind: 2, reflection: 0.9 });
+
+    // a puddle on the floor: a centimetre deep, two metres across
+    const puddle_outline = wobble(1.3, 0.25);
+    const puddle = water_body({ geometry: polar_geometry({ segments: 64, rings: 3, radius: (theta, t) => 1.0 * t * puddle_outline(theta) }),
+        x: 4, y: 0.01, z: 1, preset: 'swimming_pool', wind: 4, reflection: 0.2 });
+
+    // a mountain lake, 120 × 60 m, in a basin whose shore is its outline
+    const lake_outline = wobble(0.4, 0.15);
+    const lake_radius = (theta, t) => t * lake_outline(theta) * (60 - 30 * Math.sin(theta) ** 2);
+    const lake = water_body({ geometry: polar_geometry({ segments: 96, rings: 6, radius: lake_radius }),
+        x: 0, y: 0, z: 160, preset: 'tropical_lagoon', wind: 6, reflection: 0.3 });
+    solid(polar_geometry({ segments: 96, rings: 24, radius: (theta, t) => lake_radius(theta, 3 * t),
+        height: (theta, t) => { const f = 3 * t; return f < 1 ? -4 * (1 - f * f) : 18 * ((f - 1) / 2) ** 2; }, texel: 4 }),
+        material([0.75, 0.85, 0.65], 0.8, true), 0, 0, 160);
+
+    // an open ocean disk, 5 km across, around an island the mesh leaves a hole for; the sea runs on for 200 km upwind
+    const ocean_x = 0, ocean_z = 5000;
+    const island = wobble(2.1, 0.12);
+    const ocean = water_body({ geometry: polar_geometry({ segments: 128, rings: 24, hole: true,
+        radius: (theta, t) => { const rim = 130 * island(theta); return rim * (2500 / rim) ** t; } }),
+        x: ocean_x, y: 0, z: ocean_z, preset: 'clear_ocean', wind: 10, upwind: 200000, reflection: 0.6 });
+    solid(polar_geometry({ segments: 128, rings: 48, radius: (theta, t) => 2600 * t * t,
+        height: (theta, t) => { const r = 2600 * t * t / (220 * island(theta)); return r < 1 ? 60 - 100 * r ** 1.2 : -40; }, texel: 16 }),
+        material([0.95, 0.9, 0.75], 0.8, true), ocean_x, 0, ocean_z);
+
+    return { bodies: { cup, puddle, lake, ocean } };
+}

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

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

@@ -1 +1 @@
-{"version":3,"file":"OrbitalCameraRig.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraRig.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;;OAKG;IACH;QAJkE,MAAM,GAA7D,WAAW,gCAAgC,CAAC;QAClB,cAAc,GAAxC,eAAe;QACE,kBAAkB,GAAnC,MAAM;OA4BhB;IAzBG;;;;kCAPJ;;;;;WAKG;;;;;;;;;OAEqB;IACpB,gCAAsE;IACtE,2BAA4C;IAG5C,mBAAyC;IACzC,qBAAiC;IACjC,kBAA8B;IAC9B,kBAA8B;IAC9B,kBAA8B;IAG9B,iBAAiB;IAIjB,sBAAyB;IAGzB;;;;;;;;;;;;;;MAAgB;IAGhB,6BAAwC;IACxC,+BAA0C;IAC1C,wBAAmC;IAOvC,0FAA0F;IAC1F,qBAIC;IAED;;;;;OAKG;IACH,aAHW,MAAM,UACN,MAAM,QAKhB;IAED,4FAA4F;IAC5F,wBAGC;IAMD,mDAAmD;IACnD,kBAKC;IAED;;;;;;;OAOG;IACH,cALW,MAAM,MACN,MAAM,kBACN,MAAM,OACN,MAAM,QAsBhB;IAED,kFAAkF;IAClF,qBAMC;IAMD;;;;OAIG;IACH,cAFW,MAAM,QAQhB;IAED,6DAA6D;IAC7D,iCAGC;IAED;;;;;;;OAOG;IACH,cAJW,MAAM,KACN,MAAM,MACN,MAAM,QAuBhB;IAMD;;;;;;;OAOG;IACH,cALW,OAAO,MACP,OAAO;QAEQ,OAAO,GAAtB,OAAO;aAyBjB;IAMD;;;;;OAKG;IACH,WAHW,MAAM,GACJ,OAAO,CAoCnB;IAED;;;;;OAKG;IACH,4CASC;IAID,kBAAqC;IACrC,oBAAyC;IACzC,yDAAyD;IACzD,wBAQC;IAED;;;;;OAKG;IACH,gBAHW,OAAO,GACL,OAAO,CAMnB;IAMD,8BAiBC;IAED;;;;MAaC;IAED,0BAGC;IAED,yEAAyE;IACzE,oCAOC;IAED,iFAYC;IAED,yEAAyE;IACzE,iDAIC;CACJ;gCA3Y+B,mDAAmD;6BAGtD,mBAAmB;4BADpB,iDAAiD;oBADzD,kCAAkC;0CAGZ,0BAA0B"}
+{"version":3,"file":"OrbitalCameraRig.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraRig.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;;OAKG;IACH;QAJkE,MAAM,GAA7D,WAAW,gCAAgC,CAAC;QAClB,cAAc,GAAxC,eAAe;QACE,kBAAkB,GAAnC,MAAM;OA4BhB;IAzBG;;;;kCAPJ;;;;;WAKG;;;;;;;;;OAEqB;IACpB,gCAAsE;IACtE,2BAA4C;IAG5C,mBAAyC;IACzC,qBAAiC;IACjC,kBAA8B;IAC9B,kBAA8B;IAC9B,kBAA8B;IAG9B,iBAAiB;IAIjB,sBAAyB;IAGzB;;;;;;;;;;;;;;MAAgB;IAGhB,6BAAwC;IACxC,+BAA0C;IAC1C,wBAAmC;IAOvC,0FAA0F;IAC1F,qBAIC;IAED;;;;;OAKG;IACH,aAHW,MAAM,UACN,MAAM,QAKhB;IAED,4FAA4F;IAC5F,wBAGC;IAMD,mDAAmD;IACnD,kBAKC;IAED;;;;;;;OAOG;IACH,cALW,MAAM,MACN,MAAM,kBACN,MAAM,OACN,MAAM,QAsBhB;IAED,kFAAkF;IAClF,qBAMC;IAED,8EAA8E;IAC9E,sBAQC;IAMD;;;;OAIG;IACH,cAFW,MAAM,QAQhB;IAED,6DAA6D;IAC7D,iCAGC;IAED;;;;;;;OAOG;IACH,cAJW,MAAM,KACN,MAAM,MACN,MAAM,QAuBhB;IAMD;;;;;;;OAOG;IACH,cALW,OAAO,MACP,OAAO;QAEQ,OAAO,GAAtB,OAAO;aAyBjB;IAMD;;;;;OAKG;IACH,WAHW,MAAM,GACJ,OAAO,CAoCnB;IAED;;;;;OAKG;IACH,4CASC;IAID,kBAAqC;IACrC,oBAAyC;IACzC,yDAAyD;IACzD,wBAQC;IAED;;;;;OAKG;IACH,gBAHW,OAAO,GACL,OAAO,CAMnB;IAMD,8BAiBC;IAED;;;;MAaC;IAED,0BAGC;IAED,yEAAyE;IACzE,oCAOC;IAED,iFAYC;IAED,yEAAyE;IACzE,iDAIC;CACJ;gCAtZ+B,mDAAmD;6BAGtD,mBAAmB;4BADpB,iDAAiD;oBADzD,kCAAkC;0CAGZ,0BAA0B"}

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

@@ -143,6 +143,17 @@ export class OrbitalCameraRig {
         this._tz.release(w, m);
     }
 
+    /** Abort direct control without throwing, retaining the last applied pose. */
+    cancelGesture() {
+        this._phi.settle(this._phi.value);
+        this._theta.settle(this._theta.value);
+        this._tx.settle(this._tx.value);
+        this._ty.settle(this._ty.value);
+        this._tz.settle(this._tz.value);
+        // The last drag may not have reached the facade's next frame yet.
+        this._directDirty = true;
+    }
+
     // ─────────────────────────────────────────────────────────────────────────
     //  Zoom + keyboard (direct, no momentum)
     // ─────────────────────────────────────────────────────────────────────────

package/src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.d.ts

@@ -7,7 +7,7 @@
  * @param {RowFirstTable} result_metadata
  * @param {BinaryBuffer} result_data
  * @param {number[]} input_index Index array
- * @param {number} input_index_count
+ * @param {number} input_index_count Number of active indices at the start of input_index
  * @param {number} vertex_count Number of vertices in the geometry
  * @param {Float32Array} vertex_positions
  * @param {number} [meshlet_vertex_limit]

package/src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_to_meshlets_meshoptimizer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;GAcG;AACH,2HAPW,MAAM,EAAE,qBACR,MAAM,gBACN,MAAM,oBACN,YAAY,yBACZ,MAAM,2BACN,MAAM,QAmDhB"}
+{"version":3,"file":"geometry_to_meshlets_meshoptimizer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;GAcG;AACH,2HAPW,MAAM,EAAE,qBACR,MAAM,gBACN,MAAM,oBACN,YAAY,yBACZ,MAAM,2BACN,MAAM,QAyDhB"}

package/src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.js

@@ -23,7 +23,7 @@ MeshoptClusterizer.ready?.then(() => {
  * @param {RowFirstTable} result_metadata
  * @param {BinaryBuffer} result_data
  * @param {number[]} input_index Index array
- * @param {number} input_index_count
+ * @param {number} input_index_count Number of active indices at the start of input_index
  * @param {number} vertex_count Number of vertices in the geometry
  * @param {Float32Array} vertex_positions
  * @param {number} [meshlet_vertex_limit]
@@ -41,7 +41,13 @@ export function geometry_to_meshlets_meshoptimizer(
 ) {
     assert.ok(clusterizer_ready, 'meshoptimizer is not ready; await MeshoptClusterizer.ready');
 
-    const meshlets = MeshoptClusterizer.buildMeshlets(input_index, vertex_positions, 3, meshlet_vertex_limit, meshlet_triangle_limit, 0.0);
+    const active_index = input_index_count === input_index.length
+        ? input_index
+        : Array.isArray(input_index)
+            ? input_index.slice(0, input_index_count)
+            : input_index.subarray(0, input_index_count);
+
+    const meshlets = MeshoptClusterizer.buildMeshlets(active_index, vertex_positions, 3, meshlet_vertex_limit, meshlet_triangle_limit, 0.0);
 
     result_metadata.setCapacity(result_metadata.length + meshlets.meshletCount);
 
@@ -78,4 +84,4 @@ export function geometry_to_meshlets_meshoptimizer(
         result_data.writeUint32Array(meshlets.triangles, triangle_offset, triangle_count * 3);
 
     }
-}
+}

package/src/shade/renderer/geometry/util/geometry_simplify_redundant_topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_simplify_redundant_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/util/geometry_simplify_redundant_topology.js"],"names":[],"mappings":"AAWA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6DAJW,QAAQ,YACR,uBAAuB,GACrB,QAAQ,CAsCpB;;;;;8BA/Da,MAAM;;;;0BACN,MAAM;;;;;;oBAkEN,MAAM,EAAE,EAAE;;;;gBACV,IAAI,MAAM,CAAC,EAAE;;yBA7EF,gBAAgB"}
+{"version":3,"file":"geometry_simplify_redundant_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/util/geometry_simplify_redundant_topology.js"],"names":[],"mappings":"AAWA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6DAJW,QAAQ,YACR,uBAAuB,GACrB,QAAQ,CAsCpB;;;;;8BA/Da,MAAM;;;;0BACN,MAAM;;;;;;oBAkEN,MAAM,EAAE,EAAE;;;;gBACV,IAAI,MAAM,CAAC,EAAE;;yBA7Ea,gBAAgB"}

package/src/shade/renderer/geometry/util/geometry_simplify_redundant_topology.js

@@ -2,7 +2,7 @@ import { v3_array_normalize } from "../../../../core/geom/vec3/v3_array_normaliz
 import { v3_cross_array } from "../../../../core/geom/vec3/v3_cross_array.js";
 import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
 import { Attribute } from "../Attribute.js";
-import { Geometry } from "../Geometry.js";
+import { Geometry, GeometryFlags } from "../Geometry.js";
 import { geometry_deduplicate_vertices } from "../geometry_deduplicate_vertices.js";
 import { StandardAttributes } from "../StandardAttributes.js";
 
@@ -363,7 +363,7 @@ function apply_remap_and_compact(source, remap) {
     // Build new geometry with compacted attribute arrays
     const result = new Geometry();
     result.name = source.name;
-    result.flags = source.flags;
+    result.flags = source.flags | GeometryFlags.BoundsNeedUpdate;
 
     for (const src_attr of source.attributes) {
         const stride = src_attr.spec.itemSize;

package/src/shade/renderer/geometry/virtual/format/vgeo_validate_container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_validate_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_validate_container.js"],"names":[],"mappings":"AA+xDA;;;;;;;;;GASG;AACH,gDAHW,YAAY,GACV,QAAQ,UAAU,EAAE,CAAC,CAqFjC;6BA53D4B,4CAA4C;2BAoD9C,iBAAiB"}
+{"version":3,"file":"vgeo_validate_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_validate_container.js"],"names":[],"mappings":"AAk3DA;;;;;;;;;GASG;AACH,gDAHW,YAAY,GACV,QAAQ,UAAU,EAAE,CAAC,CAuFjC;6BAj9D4B,4CAA4C;2BAoD9C,iBAAiB"}