@woosh/meep-engine 3.41.0 → 3.43.0

package/src/shade/renderer/atmosphere/GPUSky.js

@@ -1,148 +1,163 @@
-import { FrameGraph } from "../../../engine/graphics/render/frame_graph/FrameGraph.js";
-import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
-import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
-import { graph_compute_pass } from "../shader/graph/compute/graph_compute_pass.js";
-import { graph_image_pass } from "../shader/graph/graph_image_pass.js";
-import { debug_draw_texture } from "../texture/debug_draw_texture.js";
-import { GPUTextureContext } from "../texture/GPUTextureContext.js";
-import { shader_multiscatter_lut } from "./shader_multiscatter_lut.js";
-import { shader_transmittance_lut } from "./shader_transmittance_lut.js";
-
-export class GPUSky {
-
-    /**
-     * @type {GraphicsContext}
-     */
-    #graphics;
-
-    /**
-     * @type {GPUTextureContext}
-     */
-    #lut_transmittance;
-
-    /**
-     *
-     * @returns {GPUTextureContext}
-     */
-    get lut_transmittance() {
-        return this.#lut_transmittance;
-    }
-
-    /**
-     * @type {GPUTextureContext}
-     */
-    #lut_multiple_scattering;
-
-    /**
-     *
-     * @returns {GPUTextureContext}
-     */
-    get lut_multiple_scattering() {
-        return this.#lut_multiple_scattering;
-    }
-
-    /**
-     *
-     * @type {boolean}
-     */
-    #needs_update = true;
-
-    /**
-     *
-     * @param {GraphicsContext} graphics
-     */
-    constructor(graphics) {
-        this.#graphics = graphics;
-
-        const device = graphics.device;
-
-        this.#lut_transmittance = new GPUTextureContext(device);
-        this.#lut_transmittance.descriptor.label = "Sky / Transmittance LUT";
-        this.#lut_transmittance.descriptor.format = "rgba16float";
-        this.#lut_transmittance.descriptor.usage = GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC;
-        this.#lut_transmittance.resize(256, 64);
-
-        this.#lut_multiple_scattering = new GPUTextureContext(device);
-        this.#lut_multiple_scattering.descriptor.label = "Sky / Multiple Scattering LUT";
-        this.#lut_multiple_scattering.descriptor.format = "rgba16float";
-        // written by a compute shader, so STORAGE_BINDING rather than RENDER_ATTACHMENT
-        this.#lut_multiple_scattering.descriptor.usage = GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC;
-        this.#lut_multiple_scattering.resize(32, 32);
-
-
-    }
-
-    destroy() {
-        this.#lut_transmittance.destroy();
-        this.#lut_multiple_scattering.destroy();
-    }
-
-    debug() {
-
-
-        let y = 50;
-        debug_draw_texture({ texture: this.#lut_transmittance, x: 50, y: y });
-
-        y += this.#lut_transmittance.size[1] + 50;
-
-        debug_draw_texture({ texture: this.#lut_multiple_scattering, x: 50, y: y });
-
-        y += this.#lut_multiple_scattering.size[1] + 50;
-
-    }
-
-    /**
-     *
-     */
-    update() {
-        if (!this.#needs_update) {
-            return;
-        }
-
-        const graph = new FrameGraph("sky update");
-
-        const command_ctx = ShadeGPUCommandContext.create(
-            this.#graphics,
-            "Renderer/main"
-        );
-
-        const gr_transmittance = graph.import_resource("transmittance", TextureResourceDescriptor.fromTexture(this.#lut_transmittance.gpu_texture), this.#lut_transmittance);
-        const gr_multiscatter = graph.import_resource("multiscatter", TextureResourceDescriptor.fromTexture(this.#lut_multiple_scattering.gpu_texture), this.#lut_multiple_scattering);
-
-        // the handle the write produced, not the one imported: binding the pre-write version below
-        // is a superseded read, which is exactly what `validate()` rejects
-        const [gr_transmittance_written] = graph_image_pass({
-            graph,
-            shader: shader_transmittance_lut,
-            inputs: {
-                settings: {
-                    steps: 40,
-                    // read off the texture rather than restated, so the two cannot disagree
-                    resolution: [this.#lut_transmittance.width, this.#lut_transmittance.height],
-                }
-            },
-            output: [gr_transmittance]
-        });
-
-
-        graph_compute_pass({
-            graph,
-            shader: shader_multiscatter_lut,
-            // one workgroup per LUT texel, counted off the texture being written so the
-            // dispatch cannot cover a different area than the shader stores into
-            group_count: [this.#lut_multiple_scattering.width, this.#lut_multiple_scattering.height, 1],
-            bindings: {
-                tSkyLutTransmittance: gr_transmittance_written,
-                tSkyLutMultiscatterOut: gr_multiscatter
-            }
-        });
-
-        command_ctx.encodeGraph(graph);
-
-        command_ctx.finish();
-
-
-        this.#needs_update = false;
-    }
-
+import { FrameGraph } from "../../../engine/graphics/render/frame_graph/FrameGraph.js";
+import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
+import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import { graph_compute_pass } from "../shader/graph/compute/graph_compute_pass.js";
+import { graph_image_pass } from "../shader/graph/graph_image_pass.js";
+import { debug_draw_texture } from "../texture/debug_draw_texture.js";
+import { GPUTextureContext } from "../texture/GPUTextureContext.js";
+import { shader_multiscatter_lut } from "./shader_multiscatter_lut.js";
+import { shader_transmittance_lut } from "./shader_transmittance_lut.js";
+
+/**
+ * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
+ */
+
+export class GPUSky {
+
+    /**
+     * @type {GraphicsContext}
+     */
+    #graphics;
+
+    /**
+     * @type {GPUTextureContext}
+     */
+    #lut_transmittance;
+
+    /**
+     *
+     * @returns {GPUTextureContext}
+     */
+    get lut_transmittance() {
+        return this.#lut_transmittance;
+    }
+
+    /**
+     * @type {GPUTextureContext}
+     */
+    #lut_multiple_scattering;
+
+    /**
+     *
+     * @returns {GPUTextureContext}
+     */
+    get lut_multiple_scattering() {
+        return this.#lut_multiple_scattering;
+    }
+
+    /**
+     *
+     * @type {boolean}
+     */
+    #needs_update = true;
+
+    /**
+     * Whether the LUTs still hold nothing a reader could use: true until the first {@link update}.
+     * What reads {@link lut_transmittance} or {@link lut_multiple_scattering} has to see this false,
+     * as a texture nobody wrote reads as zero rather than failing.
+     *
+     * @returns {boolean}
+     */
+    get needs_update() {
+        return this.#needs_update;
+    }
+
+    /**
+     *
+     * @param {GraphicsContext} graphics
+     */
+    constructor(graphics) {
+        this.#graphics = graphics;
+
+        const device = graphics.device;
+
+        this.#lut_transmittance = new GPUTextureContext(device);
+        this.#lut_transmittance.descriptor.label = "Sky / Transmittance LUT";
+        this.#lut_transmittance.descriptor.format = "rgba16float";
+        this.#lut_transmittance.descriptor.usage = GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC;
+        this.#lut_transmittance.resize(256, 64);
+
+        this.#lut_multiple_scattering = new GPUTextureContext(device);
+        this.#lut_multiple_scattering.descriptor.label = "Sky / Multiple Scattering LUT";
+        this.#lut_multiple_scattering.descriptor.format = "rgba16float";
+        // written by a compute shader, so STORAGE_BINDING rather than RENDER_ATTACHMENT
+        this.#lut_multiple_scattering.descriptor.usage = GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC;
+        this.#lut_multiple_scattering.resize(32, 32);
+
+
+    }
+
+    destroy() {
+        this.#lut_transmittance.destroy();
+        this.#lut_multiple_scattering.destroy();
+    }
+
+    debug() {
+
+
+        let y = 50;
+        debug_draw_texture({ texture: this.#lut_transmittance, x: 50, y: y });
+
+        y += this.#lut_transmittance.size[1] + 50;
+
+        debug_draw_texture({ texture: this.#lut_multiple_scattering, x: 50, y: y });
+
+        y += this.#lut_multiple_scattering.size[1] + 50;
+
+    }
+
+    /**
+     *
+     */
+    update() {
+        if (!this.#needs_update) {
+            return;
+        }
+
+        const graph = new FrameGraph("sky update");
+
+        const command_ctx = ShadeGPUCommandContext.create(
+            this.#graphics,
+            "Renderer/main"
+        );
+
+        const gr_transmittance = graph.import_resource("transmittance", TextureResourceDescriptor.fromTexture(this.#lut_transmittance.gpu_texture), this.#lut_transmittance);
+        const gr_multiscatter = graph.import_resource("multiscatter", TextureResourceDescriptor.fromTexture(this.#lut_multiple_scattering.gpu_texture), this.#lut_multiple_scattering);
+
+        // the handle the write produced, not the one imported: binding the pre-write version below
+        // is a superseded read, which is exactly what `validate()` rejects
+        const [gr_transmittance_written] = graph_image_pass({
+            graph,
+            shader: shader_transmittance_lut,
+            inputs: {
+                settings: {
+                    steps: 40,
+                    // read off the texture rather than restated, so the two cannot disagree
+                    resolution: [this.#lut_transmittance.width, this.#lut_transmittance.height],
+                }
+            },
+            output: [gr_transmittance]
+        });
+
+
+        graph_compute_pass({
+            graph,
+            shader: shader_multiscatter_lut,
+            // one workgroup per LUT texel, counted off the texture being written so the
+            // dispatch cannot cover a different area than the shader stores into
+            group_count: [this.#lut_multiple_scattering.width, this.#lut_multiple_scattering.height, 1],
+            bindings: {
+                tSkyLutTransmittance: gr_transmittance_written,
+                tSkyLutMultiscatterOut: gr_multiscatter
+            }
+        });
+
+        command_ctx.encodeGraph(graph);
+
+        command_ctx.finish();
+
+
+        this.#needs_update = 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"}