@woosh/meep-engine 3.47.0 → 3.50.0

package/src/engine/physics/narrowphase/rigid_subject_pose.js

@@ -1,54 +1,14 @@
-import { m4_decompose_array } from "../../../core/geom/3d/mat4/m4_decompose_array.js";
+import { m4_decompose_rigid_array } from "../../../core/geom/3d/mat4/m4_decompose_rigid_array.js";
 import { quat3_multiply } from "../../../core/geom/3d/quaternion/quat3_multiply.js";
 import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
 
-/**
- * How far a TransformedShape3D's matrix may be from a rigid motion — column lengths off 1, columns off
- * perpendicular — and still be treated as one. A matrix handed over in float32 arrives rounded at
- * about 1e-7, an exact rotation included.
- * @type {number}
- */
-const RIGID_TOLERANCE = 1e-5;
-
-/** Translation / rotation / scale of the wrapper matrix last passed to {@link decompose_rigid}. */
+/** Translation / rotation of the wrapper matrix last passed to {@link m4_decompose_rigid_array}. */
 const wrapper_translation = new Float64Array(3);
 const wrapper_rotation = new Float64Array(4);
-const wrapper_scale = new Float64Array(3);
 
 /** The wrapper's translation rotated into the world, by {@link rigid_subject_pose}. */
 const wrapper_offset = new Float64Array(3);
 
-/**
- * Whether an affine matrix (column-major) is a rigid motion, leaving its translation and rotation in
- * {@link wrapper_translation} / {@link wrapper_rotation}.
- *
- * @param {ArrayLike<number>} m
- * @returns {boolean}
- */
-function decompose_rigid(m) {
-    if (m[3] !== 0 || m[7] !== 0 || m[11] !== 0 || m[15] !== 1) {
-        return false;
-    }
-
-    // a reflection comes back as a negative x scale, so it fails here too
-    m4_decompose_array(m, wrapper_translation, 0, wrapper_rotation, 0, wrapper_scale, 0);
-
-    if (Math.abs(wrapper_scale[0] - 1) > RIGID_TOLERANCE
-        || Math.abs(wrapper_scale[1] - 1) > RIGID_TOLERANCE
-        || Math.abs(wrapper_scale[2] - 1) > RIGID_TOLERANCE) {
-        return false;
-    }
-
-    // the decomposition assumes no shear; a sheared matrix has unit columns that are not perpendicular
-    const d01 = m[0] * m[4] + m[1] * m[5] + m[2] * m[6];
-    const d02 = m[0] * m[8] + m[1] * m[9] + m[2] * m[10];
-    const d12 = m[4] * m[8] + m[5] * m[9] + m[6] * m[10];
-
-    return Math.abs(d01) <= RIGID_TOLERANCE
-        && Math.abs(d02) <= RIGID_TOLERANCE
-        && Math.abs(d12) <= RIGID_TOLERANCE;
-}
-
 /**
  * The world pose of what a rigid `TransformedShape3D` wraps, given the wrapper's own world pose.
  *
@@ -75,7 +35,7 @@ function decompose_rigid(m) {
  *   is untouched when it is not
  */
 export function rigid_subject_pose(out, shape, px, py, pz, qx, qy, qz, qw) {
-    if (shape.isTransformedShape3D !== true || shape.subject === null || !decompose_rigid(shape.transform)) {
+    if (shape.isTransformedShape3D !== true || shape.subject === null || !m4_decompose_rigid_array(shape.transform, wrapper_translation, 0, wrapper_rotation, 0)) {
         return false;
     }
 

package/src/generation/markers/actions/terrain/MarkerNodeActionPaintTerrain.js

@@ -247,16 +247,16 @@ export class MarkerNodeActionPaintTerrain extends MarkerNodeAction {
 
     initialize(grid, ecd, seed) {
         // find layer index
-        const terrain = ecd.getAnyComponent(Terrain);
+        const terrain = ecd.getAnyComponentInstance(Terrain);
 
-        if (terrain.component === null) {
+        if (terrain === null) {
             throw new Error('No terrain present');
         }
 
-        this._terrain = terrain.component;
+        this._terrain = terrain;
 
         // bind splats
-        this._splat_map = terrain.component.splat;
+        this._splat_map = terrain.splat;
 
         this._layer_index = -1;
 

package/src/shade/device/ShadeGPUCommandContext.d.ts

@@ -163,6 +163,26 @@ export class ShadeGPUCommandContext {
             size: number;
         };
     }): ShadeGPUComputePassEncoder;
+    /**
+     * Set `pipeline` and its bindings on a compute pass that is already open, so that several
+     * pipelines can dispatch in one pass.
+     *
+     * @param {Object} options
+     * @param {ShadeGPUComputePassEncoder} options.pass
+     * @param {ComputePipelineDescriptor} options.pipeline
+     * @param {GPUBindingResource[][]} [options.bindings]
+     * @param {{buffer: BinaryBuffer, offset: number, size: number}} [options.immediate] see {@link constructComputePass}
+     */
+    bindComputePipeline({ pass, pipeline, bindings, immediate }: {
+        pass: ShadeGPUComputePassEncoder;
+        pipeline: ComputePipelineDescriptor;
+        bindings?: GPUBindingResource[][];
+        immediate?: {
+            buffer: BinaryBuffer;
+            offset: number;
+            size: number;
+        };
+    }): void;
     /**
      * Begins a labeled debug group containing subsequent commands.
      * @see https://gpuweb.github.io/gpuweb/#debug-markers

package/src/shade/device/ShadeGPUCommandContext.d.ts.map

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

package/src/shade/device/ShadeGPUCommandContext.js

@@ -450,21 +450,38 @@ export class ShadeGPUCommandContext {
             pass_descriptor.label = pipeline.label;
         }
 
-        const graphics = this.#graphics;
-
         const pass = this.beginComputePass(pass_descriptor);
 
-        const gpu_pipeline = graphics.compute_pipelines.obtain(pipeline);
+        this.bindComputePipeline({ pass, pipeline, bindings, immediate });
 
-        pass.setPipeline(gpu_pipeline);
+        // console.warn(`cmd.constructComputePass(${pass_descriptor.label})`)
 
-        pass.record_pipeline(pipeline);
+        return pass;
+    }
 
-        graphics.setPipelineBindings(pass, pipeline, bindings, immediate);
+    /**
+     * Set `pipeline` and its bindings on a compute pass that is already open, so that several
+     * pipelines can dispatch in one pass.
+     *
+     * @param {Object} options
+     * @param {ShadeGPUComputePassEncoder} options.pass
+     * @param {ComputePipelineDescriptor} options.pipeline
+     * @param {GPUBindingResource[][]} [options.bindings]
+     * @param {{buffer: BinaryBuffer, offset: number, size: number}} [options.immediate] see {@link constructComputePass}
+     */
+    bindComputePipeline({
+                            pass,
+                            pipeline,
+                            bindings = [],
+                            immediate
+                        }) {
+        const graphics = this.#graphics;
 
-        // console.warn(`cmd.constructComputePass(${pass_descriptor.label})`)
+        pass.setPipeline(graphics.compute_pipelines.obtain(pipeline));
 
-        return pass;
+        pass.record_pipeline(pipeline);
+
+        graphics.setPipelineBindings(pass, pipeline, bindings, immediate);
     }
 
     /**

package/src/shade/device/mock/SoftwareGPUComputePassEncoder.d.ts

@@ -19,15 +19,19 @@ export class SoftwareGPUComputePassEncoder extends SoftwareGPUObjectBase impleme
      */
     constructor(encoder: SoftwareGPUCommandEncoder, descriptor?: GPUComputePassDescriptor);
     /**
-     * One entry per {@link dispatchWorkgroups}, in encode order.
+     * One entry per {@link dispatchWorkgroups} or {@link dispatchWorkgroupsIndirect}, in encode order.
+     * An indirect one's `group_counts` is `[-1, -1, -1]`, and it carries the `indirect_buffer` and
+     * `indirect_offset` its counts are read from.
      *
-     * @type {{pipeline: GPUComputePipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], group_counts: [number, number, number]}[]}
+     * @type {{pipeline: GPUComputePipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], group_counts: [number, number, number], indirect_buffer?: GPUBuffer, indirect_offset?: number}[]}
      */
     dispatches: {
         pipeline: GPUComputePipeline | null;
         bind_groups: GPUBindGroup[];
         dynamic_offsets: number[][];
         group_counts: [number, number, number];
+        indirect_buffer?: GPUBuffer;
+        indirect_offset?: number;
     }[];
     /**
      * The descriptor this pass was begun with, retained so a test can read what the host asked for —

package/src/shade/device/mock/SoftwareGPUComputePassEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUComputePassEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUComputePassEncoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,oFAFgB,qBAAqB;IA6DjC;;;OAGG;IACH,uFAQC;IAtED;;;;OAIG;IACH,YAFU;QAAC,QAAQ,EAAE,qBAAmB,IAAI,CAAC;QAAC,WAAW,EAAE,cAAc,CAAC;QAAC,eAAe,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAC,EAAE,CAEjI;IAEhB;;;;;OAKG;IACH,qCAAW;IAoCX;;;;OAIG;IACH,uBAEC;IAsBD;;OAEG;IACH,gDAIC;IAED;;;;;;;;;OASG;IACH,oBANW,MAAM,8CAEN,MAAM,EAAE,GAAC,WAAW,0BACpB,MAAM,2BACN,MAAM,QA0BhB;IAED;;;;;OAKG;IACH,4BALW,MAAM,QACN,WAAW,GAAC,eAAe,gBAC3B,MAAM,cACN,MAAM,QAUhB;IA4DD;;;;OAIG;IACH,sBAJW,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,wEAFW,MAAM,QAsBhB;IAED;;OAEG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAED,YAQC;IAGL;;;OAGG;IACH,0CAFU,OAAO,CAEsD;;CANtE;sCA7RqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUComputePassEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUComputePassEncoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,oFAFgB,qBAAqB;IA+DjC;;;OAGG;IACH,uFAQC;IAxED;;;;;;OAMG;IACH,YAFU;QAAC,QAAQ,EAAE,qBAAmB,IAAI,CAAC;QAAC,WAAW,EAAE,cAAc,CAAC;QAAC,eAAe,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,eAAe,CAAC,YAAY;QAAC,eAAe,CAAC,EAAE,MAAM,CAAA;KAAC,EAAE,CAExL;IAEhB;;;;;OAKG;IACH,qCAAW;IAoCX;;;;OAIG;IACH,uBAEC;IAsBD;;OAEG;IACH,gDAIC;IAED;;;;;;;;;OASG;IACH,oBANW,MAAM,8CAEN,MAAM,EAAE,GAAC,WAAW,0BACpB,MAAM,2BACN,MAAM,QA0BhB;IAED;;;;;OAKG;IACH,4BALW,MAAM,QACN,WAAW,GAAC,eAAe,gBAC3B,MAAM,cACN,MAAM,QAUhB;IA4DD;;;;OAIG;IACH,sBAJW,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,wEAFW,MAAM,QAwBhB;IAED;;OAEG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAED,YAQC;IAGL;;;OAGG;IACH,0CAFU,OAAO,CAEsD;;CANtE;sCAjSqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUComputePassEncoder.js

@@ -20,9 +20,11 @@ import { write_pass_timestamp } from "./write_pass_timestamp.js";
  */
 export class SoftwareGPUComputePassEncoder extends SoftwareGPUObjectBase {
     /**
-     * One entry per {@link dispatchWorkgroups}, in encode order.
+     * One entry per {@link dispatchWorkgroups} or {@link dispatchWorkgroupsIndirect}, in encode order.
+     * An indirect one's `group_counts` is `[-1, -1, -1]`, and it carries the `indirect_buffer` and
+     * `indirect_offset` its counts are read from.
      *
-     * @type {{pipeline: GPUComputePipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], group_counts: [number, number, number]}[]}
+     * @type {{pipeline: GPUComputePipeline|null, bind_groups: GPUBindGroup[], dynamic_offsets: number[][], group_counts: [number, number, number], indirect_buffer?: GPUBuffer, indirect_offset?: number}[]}
      */
     dispatches = [];
 
@@ -251,11 +253,13 @@ export class SoftwareGPUComputePassEncoder extends SoftwareGPUObjectBase {
         this.#encoder.notify_pass_uses([indirect_buffer]);
 
         // The group counts live in a buffer a shader wrote, which nothing here executed — recording
-        // a count read out of it would be fiction, so the entry says what it is.
+        // a count read out of it would be fiction, so the entry says what it is, and where they live.
         this.dispatches.push({
             pipeline: this.#pipeline,
             ...this.#snapshot_bindings(),
             group_counts: [-1, -1, -1],
+            indirect_buffer,
+            indirect_offset,
         });
     }
 

package/src/shade/device/mock/SoftwareGPUDevice.d.ts

@@ -230,6 +230,21 @@ export class SoftwareGPUDevice extends SoftwareGPUObjectBase implements GPUDevic
      * @returns {GPUComputePipeline}
      */
     createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline;
+    /**
+     * The asynchronous form of {@link createRenderPipeline}. There is nothing to compile here, so the
+     * handle is already made when the promise is returned, and the promise is already resolved.
+     *
+     * @param {GPURenderPipelineDescriptor} descriptor
+     * @returns {Promise<GPURenderPipeline>}
+     */
+    createRenderPipelineAsync(descriptor: GPURenderPipelineDescriptor): Promise<GPURenderPipeline>;
+    /**
+     * The asynchronous form of {@link createComputePipeline} — see {@link createRenderPipelineAsync}.
+     *
+     * @param {GPUComputePipelineDescriptor} descriptor
+     * @returns {Promise<GPUComputePipeline>}
+     */
+    createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise<GPUComputePipeline>;
     /**
      * The next tick. Shared by every query set this device made, so two of them still order against
      * each other.

package/src/shade/device/mock/SoftwareGPUDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AA+QA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;OAQG;IACH;QAP+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAuBrC;IAvDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAiCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAmJD;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;;;;;OAOG;IACH,kEAUC;IAkCD;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WA7sBa,mBAAiB,IAAI;;sCA9QG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}
+{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AA+QA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;OAQG;IACH;QAP+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAuBrC;IAvDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAiCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAmJD;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;;;;;OAOG;IACH,kEAUC;IAkCD;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAED;;;;;;OAMG;IACH,oEAFa,0BAA0B,CAItC;IAED;;;;;OAKG;IACH,sEAFa,2BAA2B,CAIvC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WAluBa,mBAAiB,IAAI;;sCA9QG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}

package/src/shade/device/mock/SoftwareGPUDevice.js

@@ -924,6 +924,27 @@ export class SoftwareGPUDevice extends SoftwareGPUObjectBase {
         return new SoftwareGPUComputePipeline(descriptor);
     }
 
+    /**
+     * The asynchronous form of {@link createRenderPipeline}. There is nothing to compile here, so the
+     * handle is already made when the promise is returned, and the promise is already resolved.
+     *
+     * @param {GPURenderPipelineDescriptor} descriptor
+     * @returns {Promise<GPURenderPipeline>}
+     */
+    createRenderPipelineAsync(descriptor) {
+        return Promise.resolve(new SoftwareGPURenderPipeline(descriptor));
+    }
+
+    /**
+     * The asynchronous form of {@link createComputePipeline} — see {@link createRenderPipelineAsync}.
+     *
+     * @param {GPUComputePipelineDescriptor} descriptor
+     * @returns {Promise<GPUComputePipeline>}
+     */
+    createComputePipelineAsync(descriptor) {
+        return Promise.resolve(new SoftwareGPUComputePipeline(descriptor));
+    }
+
     /**
      * The device's monotonic counter, which is what a timestamp query records here. See
      * {@link SoftwareGPUQuerySet} for why these are not measurements.

package/src/shade/device/pipeline/ComputePipelineManager.d.ts

@@ -2,6 +2,7 @@
  * @typedef {import("../../descriptor/pipeline/compute/ComputePipelineDescriptor.js").ComputePipelineDescriptor} ComputePipelineDescriptor
  * @typedef {import("../shader/ShaderModuleCompiler.js").ShaderModuleCompiler} ShaderModuleCompiler
  * @typedef {import("./PipelineLayoutManager.js").PipelineLayoutManager} PipelineLayoutManager
+ * @typedef {import("./PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  */
 export class ComputePipelineManager {
     /**
@@ -16,15 +17,34 @@ export class ComputePipelineManager {
      * @returns {PipelineLayoutManager}
      */
     get layouts(): import("./PipelineLayoutManager.js").PipelineLayoutManager;
+    /**
+     * How many pipelines {@link prepare} is still compiling.
+     *
+     * @returns {number}
+     */
+    get pending_count(): number;
     /**
      *
      * @param {ComputePipelineDescriptor} descriptor
      * @returns {GPUComputePipeline}
      */
     obtain(descriptor: ComputePipelineDescriptor): GPUComputePipeline;
+    /**
+     * Compile the pipeline for `descriptor` off the thread that presents frames, into the cache
+     * {@link obtain} reads — see {@link PipelineEnquiry} for why.
+     *
+     * Nothing new starts for a descriptor that is cached or already compiling. A pipeline that fails
+     * is reported and left out of the cache, so `obtain` makes it again the old way. If `obtain`
+     * makes it while it is still compiling here, the one `obtain` made is kept.
+     *
+     * @param {ComputePipelineDescriptor} descriptor
+     * @returns {Promise<void>} settles once the pipeline is cached or has failed; never rejects
+     */
+    prepare(descriptor: ComputePipelineDescriptor): Promise<void>;
     #private;
 }
 export type ComputePipelineDescriptor = import("../../descriptor/pipeline/compute/ComputePipelineDescriptor.js").ComputePipelineDescriptor;
 export type ShaderModuleCompiler = import("../shader/ShaderModuleCompiler.js").ShaderModuleCompiler;
 export type PipelineLayoutManager = import("./PipelineLayoutManager.js").PipelineLayoutManager;
+export type PipelineEnquiry = import("./PipelineEnquiry.js").PipelineEnquiry;
 //# sourceMappingURL=ComputePipelineManager.d.ts.map

package/src/shade/device/pipeline/ComputePipelineManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComputePipelineManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/pipeline/ComputePipelineManager.js"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH;IA+BI;;;;;OAKG;IACH,wCAHW,qBAAqB,WACrB,oBAAoB,EAc9B;IAtCD;;;OAGG;IACH,0EAEC;IA8DD;;;;OAIG;IACH,mBAHW,yBAAyB,sBAQnC;;CAEJ;wCAhGY,OAAO,gEAAgE,EAAE,yBAAyB;mCAClG,OAAO,mCAAmC,EAAE,oBAAoB;oCAChE,OAAO,4BAA4B,EAAE,qBAAqB"}
+{"version":3,"file":"ComputePipelineManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/pipeline/ComputePipelineManager.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH;IA+CI;;;;;OAKG;IACH,wCAHW,qBAAqB,WACrB,oBAAoB,EAc9B;IAtDD;;;OAGG;IACH,0EAEC;IAoBD;;;;OAIG;IACH,4BAEC;IAyDD;;;;OAIG;IACH,mBAHW,yBAAyB,sBAQnC;IAED;;;;;;;;;;OAUG;IACH,oBAHW,yBAAyB,GACvB,QAAQ,IAAI,CAAC,CAwCzB;;CAEJ;wCA1KY,OAAO,gEAAgE,EAAE,yBAAyB;mCAClG,OAAO,mCAAmC,EAAE,oBAAoB;oCAChE,OAAO,4BAA4B,EAAE,qBAAqB;8BAC1D,OAAO,sBAAsB,EAAE,eAAe"}

package/src/shade/device/pipeline/ComputePipelineManager.js

@@ -5,6 +5,7 @@ import { HashMap } from "../../../core/collection/map/HashMap.js";
  * @typedef {import("../../descriptor/pipeline/compute/ComputePipelineDescriptor.js").ComputePipelineDescriptor} ComputePipelineDescriptor
  * @typedef {import("../shader/ShaderModuleCompiler.js").ShaderModuleCompiler} ShaderModuleCompiler
  * @typedef {import("./PipelineLayoutManager.js").PipelineLayoutManager} PipelineLayoutManager
+ * @typedef {import("./PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  */
 
 export class ComputePipelineManager {
@@ -37,6 +38,22 @@ export class ComputePipelineManager {
      */
     #cache = new HashMap();
 
+    /**
+     * Compilations {@link prepare} started that have not finished.
+     *
+     * @type {HashMap<ComputePipelineDescriptor, Promise<void>>}
+     */
+    #pending = new HashMap();
+
+    /**
+     * How many pipelines {@link prepare} is still compiling.
+     *
+     * @returns {number}
+     */
+    get pending_count() {
+        return this.#pending.size;
+    }
+
 
     /**
      *
@@ -62,18 +79,17 @@ export class ComputePipelineManager {
     /**
      *
      * @param {ComputePipelineDescriptor} descriptor
-     * @returns {GPUComputePipeline}
+     * @returns {GPUComputePipelineDescriptor}
      */
-    #create(descriptor) {
+    #gpu_descriptor(descriptor) {
 
         const shaders = this.#shaders;
 
         const layouts = this.#layouts;
-        const device = this.#device;
 
         const stage = descriptor.compute;
 
-        const gpu_descriptor = {
+        return {
             label: descriptor.label,
             layout: layouts.obtainPipelineLayout(descriptor.layout),
             compute: {
@@ -82,8 +98,15 @@ export class ComputePipelineManager {
                 constants: stage.constants
             },
         };
+    }
 
-        return device.createComputePipeline(gpu_descriptor);
+    /**
+     *
+     * @param {ComputePipelineDescriptor} descriptor
+     * @returns {GPUComputePipeline}
+     */
+    #create(descriptor) {
+        return this.#device.createComputePipeline(this.#gpu_descriptor(descriptor));
     }
 
     /**
@@ -98,4 +121,55 @@ export class ComputePipelineManager {
         return this.#cache.getOrCompute(descriptor, this.#create, this);
     }
 
-}
+    /**
+     * Compile the pipeline for `descriptor` off the thread that presents frames, into the cache
+     * {@link obtain} reads — see {@link PipelineEnquiry} for why.
+     *
+     * Nothing new starts for a descriptor that is cached or already compiling. A pipeline that fails
+     * is reported and left out of the cache, so `obtain` makes it again the old way. If `obtain`
+     * makes it while it is still compiling here, the one `obtain` made is kept.
+     *
+     * @param {ComputePipelineDescriptor} descriptor
+     * @returns {Promise<void>} settles once the pipeline is cached or has failed; never rejects
+     */
+    prepare(descriptor) {
+        assert.defined(descriptor, 'descriptor');
+        assert.equal(descriptor.isComputePipelineDescriptor, true, 'descriptor.isComputePipelineDescriptor !== true');
+
+        const cache = this.#cache;
+
+        if (cache.has(descriptor)) {
+            return Promise.resolve();
+        }
+
+        const pending = this.#pending;
+
+        const existing = pending.get(descriptor);
+
+        if (existing !== undefined) {
+            return existing;
+        }
+
+        const gpu_descriptor = this.#gpu_descriptor(descriptor);
+
+        const compilation = this.#device.createComputePipelineAsync(gpu_descriptor).then(
+            (pipeline) => {
+                pending.delete(descriptor);
+
+                if (!cache.has(descriptor)) {
+                    cache.set(descriptor, pipeline);
+                }
+            },
+            (error) => {
+                pending.delete(descriptor);
+
+                console.error(`Failed to create "${descriptor.label}" pipeline: `, error.message, gpu_descriptor);
+            }
+        );
+
+        pending.set(descriptor, compilation);
+
+        return compilation;
+    }
+
+}

package/src/shade/device/pipeline/PipelineEnquiry.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @typedef {import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} RenderPipelineDescriptor
+ * @typedef {import("../../descriptor/pipeline/compute/ComputePipelineDescriptor.js").ComputePipelineDescriptor} ComputePipelineDescriptor
+ */
+/**
+ * The pipelines a renderer is about to draw with, gathered before it draws, so that they can be
+ * compiled all at once and off the thread that presents frames.
+ *
+ * Left to themselves, pipelines are made the first time a frame obtains them, and a browser compiles
+ * a pipeline made that way on the GPU process's main thread, one after another — the thread that also
+ * presents the page. A cold first frame of a single lit cube spent 3.4 s there on 54 pipelines. Made
+ * asynchronously, the same 54 compiled on the browser's worker pool in ~1.0 s, as long as the
+ * slowest of them took.
+ *
+ * Whoever owns a pass puts into this the descriptor that pass will hand to `obtain` — the same
+ * object, or one equal to it — for the configuration it is in now. An offer is speculative: one that
+ * turns out not to be drawn with costs a compile on a worker and nothing more, and a pipeline that
+ * nobody offered is still made the old way, the first time a frame obtains it. Offering the same
+ * pipeline twice is harmless; it compiles once.
+ *
+ * Who answers, and how:
+ * - a `graph_*` pass exports `enquire_<pass>_pipelines(enquiry)` beside itself, offering what it
+ *   dispatches and asking the passes it calls, so each list sits next to the code it predicts;
+ * - an object the renderer already holds when it asks answers through its own `enquirePipelines`;
+ * - a class whose instances come later — one per scene or per view — answers through a static
+ *   `enquirePipelines`, for all of them.
+ */
+export class PipelineEnquiry {
+    /**
+     * @param {GPUDevice} device
+     * @returns {PipelineEnquiry}
+     */
+    static from(device: GPUDevice): PipelineEnquiry;
+    /**
+     * The device the pipelines are for. Some descriptors are built from its limits, which is how an
+     * offer comes out equal to the descriptor the pass builds for itself.
+     *
+     * @type {GPUDevice}
+     */
+    device: GPUDevice;
+    /**
+     * @type {RenderPipelineDescriptor[]}
+     */
+    render: RenderPipelineDescriptor[];
+    /**
+     * @type {ComputePipelineDescriptor[]}
+     */
+    compute: ComputePipelineDescriptor[];
+}
+export type RenderPipelineDescriptor = import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+export type ComputePipelineDescriptor = import("../../descriptor/pipeline/compute/ComputePipelineDescriptor.js").ComputePipelineDescriptor;
+//# sourceMappingURL=PipelineEnquiry.d.ts.map

package/src/shade/device/pipeline/PipelineEnquiry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PipelineEnquiry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/pipeline/PipelineEnquiry.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAmBI;;;OAGG;IACH,gCAFa,eAAe,CAU3B;IA9BD;;;;;OAKG;IACH,kBAAO;IAEP;;OAEG;IACH,QAFU,wBAAwB,EAAE,CAExB;IAEZ;;OAEG;IACH,SAFU,yBAAyB,EAAE,CAExB;CAehB;uCA3DY,OAAO,8DAA8D,EAAE,wBAAwB;wCAC/F,OAAO,gEAAgE,EAAE,yBAAyB"}

package/src/shade/device/pipeline/PipelineEnquiry.js

@@ -0,0 +1,63 @@
+import { assert } from "../../../core/assert.js";
+
+/**
+ * @typedef {import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} RenderPipelineDescriptor
+ * @typedef {import("../../descriptor/pipeline/compute/ComputePipelineDescriptor.js").ComputePipelineDescriptor} ComputePipelineDescriptor
+ */
+
+/**
+ * The pipelines a renderer is about to draw with, gathered before it draws, so that they can be
+ * compiled all at once and off the thread that presents frames.
+ *
+ * Left to themselves, pipelines are made the first time a frame obtains them, and a browser compiles
+ * a pipeline made that way on the GPU process's main thread, one after another — the thread that also
+ * presents the page. A cold first frame of a single lit cube spent 3.4 s there on 54 pipelines. Made
+ * asynchronously, the same 54 compiled on the browser's worker pool in ~1.0 s, as long as the
+ * slowest of them took.
+ *
+ * Whoever owns a pass puts into this the descriptor that pass will hand to `obtain` — the same
+ * object, or one equal to it — for the configuration it is in now. An offer is speculative: one that
+ * turns out not to be drawn with costs a compile on a worker and nothing more, and a pipeline that
+ * nobody offered is still made the old way, the first time a frame obtains it. Offering the same
+ * pipeline twice is harmless; it compiles once.
+ *
+ * Who answers, and how:
+ * - a `graph_*` pass exports `enquire_<pass>_pipelines(enquiry)` beside itself, offering what it
+ *   dispatches and asking the passes it calls, so each list sits next to the code it predicts;
+ * - an object the renderer already holds when it asks answers through its own `enquirePipelines`;
+ * - a class whose instances come later — one per scene or per view — answers through a static
+ *   `enquirePipelines`, for all of them.
+ */
+export class PipelineEnquiry {
+    /**
+     * The device the pipelines are for. Some descriptors are built from its limits, which is how an
+     * offer comes out equal to the descriptor the pass builds for itself.
+     *
+     * @type {GPUDevice}
+     */
+    device;
+
+    /**
+     * @type {RenderPipelineDescriptor[]}
+     */
+    render = [];
+
+    /**
+     * @type {ComputePipelineDescriptor[]}
+     */
+    compute = [];
+
+    /**
+     * @param {GPUDevice} device
+     * @returns {PipelineEnquiry}
+     */
+    static from(device) {
+        assert.defined(device, 'device');
+
+        const r = new PipelineEnquiry();
+
+        r.device = device;
+
+        return r;
+    }
+}

package/src/shade/device/pipeline/RenderPipelineManager.d.ts

@@ -1,6 +1,7 @@
 /**
  * @typedef {import("../shader/ShaderModuleCompiler.js").ShaderModuleCompiler} ShaderModuleCompiler
  * @typedef {import("./PipelineLayoutManager.js").PipelineLayoutManager} PipelineLayoutManager
+ * @typedef {import("./PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  */
 export class RenderPipelineManager {
     /**
@@ -15,6 +16,12 @@ export class RenderPipelineManager {
      * @returns {PipelineLayoutManager}
      */
     get layouts(): import("./PipelineLayoutManager.js").PipelineLayoutManager;
+    /**
+     * How many pipelines {@link prepare} is still compiling.
+     *
+     * @returns {number}
+     */
+    get pending_count(): number;
     /**
      *
      * @param {RenderPipelineDescriptor} descriptor
@@ -22,9 +29,23 @@ export class RenderPipelineManager {
      * @returns {GPURenderPipeline}
      */
     obtain(descriptor: RenderPipelineDescriptor, actual_color_attachments?: GPUTextureFormat[]): GPURenderPipeline;
+    /**
+     * Compile the pipeline for `descriptor` off the thread that presents frames, into the cache
+     * {@link obtain} reads — see {@link PipelineEnquiry} for why.
+     *
+     * Nothing new starts for a descriptor that is cached or already compiling. A pipeline that fails
+     * is reported and left out of the cache, so `obtain` makes it again the old way and reports it
+     * again. If `obtain` makes it while it is still compiling here, the one `obtain` made is kept.
+     *
+     * @param {RenderPipelineDescriptor} descriptor exactly as {@link obtain} will be asked for it:
+     * after any rewrite for the attachments it is drawn into
+     * @returns {Promise<void>} settles once the pipeline is cached or has failed; never rejects
+     */
+    prepare(descriptor: RenderPipelineDescriptor): Promise<void>;
     #private;
 }
 export type ShaderModuleCompiler = import("../shader/ShaderModuleCompiler.js").ShaderModuleCompiler;
 export type PipelineLayoutManager = import("./PipelineLayoutManager.js").PipelineLayoutManager;
+export type PipelineEnquiry = import("./PipelineEnquiry.js").PipelineEnquiry;
 import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 //# sourceMappingURL=RenderPipelineManager.d.ts.map

package/src/shade/device/pipeline/RenderPipelineManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderPipelineManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/pipeline/RenderPipelineManager.js"],"names":[],"mappings":"AAKA;;;GAGG;AAGH;IA8BI;;;;;OAKG;IACH,wCAHW,qBAAqB,WACrB,oBAAoB,EAc9B;IArCD;;;OAGG;IACH,0EAEC;IA2FD;;;;;OAKG;IACH,mBAJW,wBAAwB,6BACxB,kBAAkB,qBAgB5B;;CAEJ;mCAtIY,OAAO,mCAAmC,EAAE,oBAAoB;oCAChE,OAAO,4BAA4B,EAAE,qBAAqB;yCAL9B,8DAA8D"}
+{"version":3,"file":"RenderPipelineManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/pipeline/RenderPipelineManager.js"],"names":[],"mappings":"AAKA;;;;GAIG;AAGH;IA8CI;;;;;OAKG;IACH,wCAHW,qBAAqB,WACrB,oBAAoB,EAc9B;IArDD;;;OAGG;IACH,0EAEC;IAoBD;;;;OAIG;IACH,4BAEC;IA4FD;;;;;OAKG;IACH,mBAJW,wBAAwB,6BACxB,kBAAkB,qBAgB5B;IAED;;;;;;;;;;;OAWG;IACH,oBAJW,wBAAwB,GAEtB,QAAQ,IAAI,CAAC,CAuCzB;;CAEJ;mCAtNY,OAAO,mCAAmC,EAAE,oBAAoB;oCAChE,OAAO,4BAA4B,EAAE,qBAAqB;8BAC1D,OAAO,sBAAsB,EAAE,eAAe;yCANlB,8DAA8D"}