@woosh/meep-engine 3.46.0 → 3.49.0

package/src/shade/renderer/restir/di/chunk_restir_resolve.d.ts

@@ -4,9 +4,11 @@
  *   radiance = BRDF·Le·G (full RGB, unshadowed) · W · V
  *
  * where W == reservoir.weightSum after FinalizeResampling (it already folds in
- * 1/p_hat and 1/M) and V is the traced visibility. Because p_hat was the
- * luminance of this same unshadowed BRDF·Le·G, the scalar normalization cancels
- * and the RGB is carried exactly (the RTXDI `f_rgb · weightSum` identity).
+ * 1/p_hat and 1/M) and V is the traced visibility (the RTXDI `f_rgb · weightSum`
+ * identity). p_hat is the luminance of the single-scattering BRDF·Le·G; this
+ * BRDF also carries `re_direct_multiscatter`'s per-pixel scale of the specular,
+ * so f / p_hat is no longer 1 but stays within [1, that scale]. The estimate is
+ * unbiased either way: f and p_hat are positive on the same lights.
  *
  * Visibility is a single opaque shadow ray toward the survivor's sampled emitter
  * point — matching the brute-force NEE reference (`ray_sample_light`), which also

package/src/shade/renderer/restir/di/chunk_restir_resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_restir_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/chunk_restir_resolve.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;GAiBG;AACH,mCAFU,SAAS,CA6DjB;0BAnFwB,oCAAoC"}
+{"version":3,"file":"chunk_restir_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/chunk_restir_resolve.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mCAFU,SAAS,CA+DjB;0BAvFwB,oCAAoC"}

package/src/shade/renderer/restir/di/chunk_restir_resolve.js

@@ -1,4 +1,5 @@
 import { REFLECTED_LIGHT_STRUCT } from "../../shader/chunk/light/REFLECTED_LIGHT_STRUCT.js";
+import { chunk_re_direct_multiscatter } from "../../shader/chunk/material/chunk_re_direct_multiscatter.js";
 import { chunk_re_direct_physical } from "../../shader/chunk/material/chunk_re_direct_physical.js";
 import { GEOMETRIC_SHADING_INFO_STRUCT } from "../../shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
 import { MATERIAL_SHADING_INFO_STRUCT } from "../../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
@@ -15,9 +16,11 @@ import { chunk_restir_trace_visibility } from "./chunk_restir_trace_visibility.j
  *   radiance = BRDF·Le·G (full RGB, unshadowed) · W · V
  *
  * where W == reservoir.weightSum after FinalizeResampling (it already folds in
- * 1/p_hat and 1/M) and V is the traced visibility. Because p_hat was the
- * luminance of this same unshadowed BRDF·Le·G, the scalar normalization cancels
- * and the RGB is carried exactly (the RTXDI `f_rgb · weightSum` identity).
+ * 1/p_hat and 1/M) and V is the traced visibility (the RTXDI `f_rgb · weightSum`
+ * identity). p_hat is the luminance of the single-scattering BRDF·Le·G; this
+ * BRDF also carries `re_direct_multiscatter`'s per-pixel scale of the specular,
+ * so f / p_hat is no longer 1 but stays within [1, that scale]. The estimate is
+ * unbiased either way: f and p_hat are positive on the same lights.
  *
  * Visibility is a single opaque shadow ray toward the survivor's sampled emitter
  * point — matching the brute-force NEE reference (`ray_sample_light`), which also
@@ -48,6 +51,7 @@ fn restir_resolve(
     let incident = restir_get_light_info(light_type, light_index, geometry.position);
     var reflected: ${REFLECTED_LIGHT_STRUCT.wgsl_ref};
     re_direct_physical(incident, geometry, material, &reflected);
+    re_direct_multiscatter(geometry, material, &reflected);
     let radiance = reflected.diffuse + reflected.specular;
 
     if (all(radiance <= vec3<f32>(0.0))) {
@@ -81,6 +85,7 @@ fn restir_resolve(
         GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
         MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
         chunk_re_direct_physical,
+        chunk_re_direct_multiscatter,
         chunk_restir_get_light_info,
         chunk_restir_light_ref,
         chunk_restir_sample_light_record,

package/src/shade/renderer/restir/di/graph_restir_di.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_restir_di.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/graph_restir_di.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+RAFa,MAAM,CAsLlB"}
+{"version":3,"file":"graph_restir_di.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/graph_restir_di.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+RAFa,MAAM,CAuLlB"}

package/src/shade/renderer/restir/di/graph_restir_di.js

@@ -163,6 +163,7 @@ export function graph_restir_di({
                 gBufferEmissive: resources.get(data.emissive).obtainView(),
                 tDepth: resources.get(data.depth).obtainView(),
                 tHZB: resources.get(data.hzb).obtainView(),
+                tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
                 output: out.obtainView(),
                 camera: view.camera.buffer,
                 view: view.uniform_buffer.buffer,

package/src/shade/renderer/restir/di/shader_restir_di_resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_restir_di_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/shader_restir_di_resolve.js"],"names":[],"mappings":"AAgGA,qDAIG;8BA9F2B,+BAA+B"}
+{"version":3,"file":"shader_restir_di_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/shader_restir_di_resolve.js"],"names":[],"mappings":"AAoGA,qDAIG;8BAlG2B,+BAA+B"}

package/src/shade/renderer/restir/di/shader_restir_di_resolve.js

@@ -8,6 +8,7 @@ import { ComputeShader } from "../../shader/ComputeShader.js";
 import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { sr_create_group_RTX } from "../../geometry/sr_create_group_RTX.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
 import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
 import { chunk_restir_reconstruct_surface } from "./chunk_restir_reconstruct_surface.js";
 import { chunk_restir_reservoir_address } from "./chunk_restir_reservoir_address.js";
@@ -43,7 +44,10 @@ resources.createGroup()
     .addTexture("tHZB")
     .addStorageTexture("output", "rgba16float", "2d", "write-only")
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addUniform("view", VIEW_UNIFORM_STRUCT);
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    // the split-sum LUT, for the direct specular's multiple-scattering compensation
+    .addTexture("tSplitSum", "float")
+    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE);
 
 // Local light tables (resolve re-evaluates the selected light; no clusters needed).
 const RESTIR_DI_RESOLVE_LIGHT_GROUP = new ShaderResourceGroupDescriptor();

package/src/shade/renderer/restir/reservoir/shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/reservoir/shader.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,6CAFU,SAAS,CAwBjB;AAEF;;;;GAIG;AACH,8CAFU,SAAS,CA2CjB;0BAlFwB,oCAAoC"}
+{"version":3,"file":"shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/reservoir/shader.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,6CAFU,SAAS,CAwBjB;AAEF;;;;GAIG;AACH,8CAFU,SAAS,CA6CjB;0BApFwB,oCAAoC"}

package/src/shade/renderer/restir/reservoir/shader.js

@@ -1,3 +1,4 @@
+import { F32_MAX_DEFINITION } from "../../shader/chunk/math/F32_MAX_DEFINITION.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { chunk_rtxdi_internal_simple_resample } from "./chunk_rtxdi_internal_simple_resample.js";
 import { RTXDI_Reservoir } from "./RTXDI_Reservoir.js";
@@ -47,9 +48,6 @@ fn RTXDI_FinalizeResampling(
     normalizationNumerator: f32,
     normalizationDenominator: f32
 ){
-    // largest finite f32; both an infinity and a NaN fail the comparison against it
-    const WEIGHT_LIMIT = 3.4028235e38;
-
     let denominator = reservoir.targetPdf * normalizationDenominator;
 
     let weight = (reservoir.weightSum * normalizationNumerator) / denominator;
@@ -74,10 +72,15 @@ fn RTXDI_FinalizeResampling(
 
      Zero is the right answer for all of them: it is what an empty reservoir carries, and it is the
      one value restir_resolve already rejects.
+
+     F32_MAX is the largest finite f32, so both an infinity and a NaN fail the comparison against it.
+     It is spelled below that f32 on purpose: 3.4028235e38, the decimal that names it, is above it,
+     and a device refuses to convert it to f32 at all, so the passes linking this did not compile.
     */
-    reservoir.weightSum = select(0.0, weight, weight > 0.0 && weight < WEIGHT_LIMIT);
+    reservoir.weightSum = select(0.0, weight, weight > 0.0 && weight < F32_MAX);
 }
     `, [
         RTXDI_Reservoir.declaration_chunk,
+        F32_MAX_DEFINITION,
     ]
 );

package/src/shade/renderer/scene/GPUInstancesAccelerationStructure.d.ts

@@ -2,6 +2,12 @@
  * Top-Level Acceleration Structure (TLAS)
  */
 export class GPUInstancesAccelerationStructure {
+    /**
+     * Offer the pipelines the tree is built with — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      *
      * @param {GraphicsContext} graphics
@@ -76,6 +82,7 @@ export class GPUInstancesAccelerationStructure {
     destroy(): void;
     #private;
 }
+export type PipelineEnquiry = import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
 import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
 //# sourceMappingURL=GPUInstancesAccelerationStructure.d.ts.map

package/src/shade/renderer/scene/GPUInstancesAccelerationStructure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUInstancesAccelerationStructure.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUInstancesAccelerationStructure.js"],"names":[],"mappings":"AAmCA;;GAEG;AACH;IA8DI;;;OAGG;IACH,sBAFW,eAAe,EAqBzB;IAzED,cAIC;IAOD;;;OAGG;IACH,wBAEC;IAmED;;;;OAIG;IACH,oBAFW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,uBAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,uBAFW,MAAM,QAOhB;IA8CD;;;;OAIG;IACH;;;OAGG;IACH,mBAEC;IAiGD;;;;;;;;;;;;OAYG;IACH,0BAHW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,GAChC,QAAQ,OAAO,CAAC,CA0C5B;IAED;;;OAGG;IACH,wDAFW,sBAAsB,QAMhC;IAED;;;;;;OAMG;IACH,mDAHW,sBAAsB,QAShC;IAED;;;OAGG;IACH,gBAKC;;CACJ;8BAxZY,OAAO,uBAAuB,EAAE,eAAe;uCARrB,wCAAwC"}
+{"version":3,"file":"GPUInstancesAccelerationStructure.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUInstancesAccelerationStructure.js"],"names":[],"mappings":"AAoCA;;GAEG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAKzB;IA+DD;;;OAGG;IACH,sBAFW,eAAe,EAqBzB;IAzED,cAIC;IAOD;;;OAGG;IACH,wBAEC;IAmED;;;;OAIG;IACH,oBAFW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,uBAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,uBAFW,MAAM,QAOhB;IA8CD;;;;OAIG;IACH;;;OAGG;IACH,mBAEC;IAiGD;;;;;;;;;;;;OAYG;IACH,0BAHW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,GAChC,QAAQ,OAAO,CAAC,CA0C5B;IAED;;;OAGG;IACH,wDAFW,sBAAsB,QAMhC;IAED;;;;;;OAMG;IACH,mDAHW,sBAAsB,QAShC;IAED;;;OAGG;IACH,gBAKC;;CACJ;8BApaY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;uCATrB,wCAAwC"}

package/src/shade/renderer/scene/GPUInstancesAccelerationStructure.js

@@ -5,10 +5,11 @@ import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
 import { ensure_buffer_capacity } from "../geometry/make_temp_gpu_buffer.js";
 import { BVH_HEADER_WORDS, BVH_NODE_STRIDE_WORDS, bvh_buffer_size } from "../gpu_primitive/bvh/BVH_BUFFER_LAYOUT.js";
 import { BVH_NULL_NODE, bvh_tree_views, read_bvh_node } from "../gpu_primitive/bvh/check_bvh_structure.js";
-import { graph_bvh_build_lbvh } from "../gpu_primitive/bvh/graph_bvh_build_lbvh.js";
+import { enquire_bvh_build_lbvh_pipelines, graph_bvh_build_lbvh } from "../gpu_primitive/bvh/graph_bvh_build_lbvh.js";
 import { shader_bvh_extract_instance_leaves } from "./shader_bvh_extract_instance_leaves.js";
 
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  */
 
@@ -38,6 +39,17 @@ const SCENE_BOUNDS_SEED = Uint32Array.from([
  */
 export class GPUInstancesAccelerationStructure {
 
+    /**
+     * Offer the pipelines the tree is built with — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        enquiry.compute.push(shader_bvh_extract_instance_leaves.pipeline);
+        enquire_bvh_build_lbvh_pipelines(enquiry);
+    }
+
+
     /**
      * @type {GraphicsContext}
      */

package/src/shade/renderer/scene/GPUSceneContext.d.ts

@@ -9,6 +9,15 @@
  * local TRS and the row of its parent, through {@link rows}.
  */
 export class GPUSceneContext {
+    /**
+     * Offer the pipelines every scene is updated with each frame — its database's uploads, the
+     * transform hierarchy, mesh bounds, light poses and environment, and the tree over its instances
+     * — see {@link PipelineEnquiry}. What only some scenes have, virtual geometry, volumes, a light
+     * probe volume, waits for the first frame of a scene that has it.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      *
      * @param {GraphicsContext} graphics
@@ -204,6 +213,7 @@ export class GPUSceneContext {
     readonly isGPUSceneContext: boolean;
     #private;
 }
+export type PipelineEnquiry = import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
 export type GPUGeometryManager = import("../geometry/GPUGeometryManager.js").GPUGeometryManager;
 export type GPUMaterialManager = import("../material/GPUMaterialManager.js").GPUMaterialManager;

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAsEA;;;;;;;;;GASG;AACH;IA4JI;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAsCf;IAnMD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAgID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAkBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA9vBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAvBvD,iDAAiD;sBAK1D,YAAY;oCADE,uCAAuC;uBAFpD,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAKrC,wCAAwC;0CAhBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAQrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAfpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAuEA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA4JD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAuCf;IApMD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAiID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAkBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAjxBY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAxBvD,iDAAiD;sBAK1D,YAAY;oCADE,uCAAuC;uBAFpD,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAKrC,wCAAwC;0CAhBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAQrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAfpC,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -28,6 +28,7 @@ import { NODE3D_SCENE_ID, NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
 import { SCENE_DATABASE_SPEC } from "./SCENE_DATABASE_SPEC.js";
 
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  * @typedef {import("../geometry/GPUGeometryManager.js").GPUGeometryManager} GPUGeometryManager
  * @typedef {import("../material/GPUMaterialManager.js").GPUMaterialManager} GPUMaterialManager
@@ -80,6 +81,23 @@ const NO_MATERIALS = Object.freeze([]);
  */
 export class GPUSceneContext {
 
+    /**
+     * Offer the pipelines every scene is updated with each frame — its database's uploads, the
+     * transform hierarchy, mesh bounds, light poses and environment, and the tree over its instances
+     * — see {@link PipelineEnquiry}. What only some scenes have, virtual geometry, volumes, a light
+     * probe volume, waits for the first frame of a scene that has it.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        GPUDatabase.enquirePipelines(enquiry);
+        GPUAnimationManager.enquirePipelines(enquiry);
+        enquiry.compute.push(shader_refresh_all_mesh_bounds.pipeline);
+        GPULightCollection.enquirePipelines(enquiry);
+        GPUInstancesAccelerationStructure.enquirePipelines(enquiry);
+        GPUSceneVolumetrics.enquirePipelines(enquiry);
+    }
+
     /**
      * @readonly
      * @type {number}
@@ -268,6 +286,7 @@ export class GPUSceneContext {
         this.volumetric_light_map = new Brick4LightMap(device);
 
         this.#volumetrics = new GPUSceneVolumetrics(
+            device,
             this.#scene_database.get('participating_media_volumes'),
             scene.volumetrics
         );

package/src/shade/renderer/scene/SceneManager.d.ts

@@ -1,4 +1,5 @@
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  * @typedef {import("./Scene.js").Scene} Scene
  */
@@ -19,6 +20,13 @@ export class SceneManager {
      * @returns {GPUSceneContext}
      */
     obtain(scene: Scene): GPUSceneContext;
+    /**
+     * Offer the pipelines a scene context is updated with — see {@link GPUSceneContext.enquirePipelines}.
+     * Asked before there is a scene to ask about, so it answers for scenes in general.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      * Release every scene context this handed out.
      *
@@ -31,6 +39,7 @@ export class SceneManager {
     destroy(): void;
     #private;
 }
+export type PipelineEnquiry = import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
 export type Scene = import("./Scene.js").Scene;
 import { GPUSceneContext } from "./GPUSceneContext.js";

package/src/shade/renderer/scene/SceneManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SceneManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SceneManager.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;IAaI;;;OAGG;IACH,sBAFW,eAAe,EAIzB;IAjBD;;;OAGG;IACH,gBAFU,IAAI,KAAK,EAAC,eAAe,CAAC,CAET;IA6B3B;;;;OAIG;IACH,cAHW,KAAK,GACH,eAAe,CAY3B;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAQhB;;CAEJ;8BAzEY,OAAO,uBAAuB,EAAE,eAAe;oBAC/C,OAAO,YAAY,EAAE,KAAK;gCAJP,sBAAsB"}
+{"version":3,"file":"SceneManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SceneManager.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;IAaI;;;OAGG;IACH,sBAFW,eAAe,EAIzB;IAjBD;;;OAGG;IACH,gBAFU,IAAI,KAAK,EAAC,eAAe,CAAC,CAET;IA6B3B;;;;OAIG;IACH,cAHW,KAAK,GACH,eAAe,CAY3B;IAED;;;;;OAKG;IACH,0BAFW,eAAe,QAIzB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAQhB;;CAEJ;8BApFY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;oBAC/C,OAAO,YAAY,EAAE,KAAK;gCALP,sBAAsB"}

package/src/shade/renderer/scene/SceneManager.js

@@ -1,6 +1,7 @@
 import { GPUSceneContext } from "./GPUSceneContext.js";
 
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  * @typedef {import("./Scene.js").Scene} Scene
  */
@@ -57,6 +58,16 @@ export class SceneManager {
         return ctx;
     }
 
+    /**
+     * Offer the pipelines a scene context is updated with — see {@link GPUSceneContext.enquirePipelines}.
+     * Asked before there is a scene to ask about, so it answers for scenes in general.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    enquirePipelines(enquiry) {
+        GPUSceneContext.enquirePipelines(enquiry);
+    }
+
     /**
      * Release every scene context this handed out.
      *

package/src/shade/renderer/scene/hierarchy/graph_nodes_update_transform_hierarchy.d.ts

@@ -1,3 +1,13 @@
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+/**
+ * Offer the pipelines {@link graph_nodes_update_transform_hierarchy} dispatches — see
+ * {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_nodes_update_transform_hierarchy_pipelines(enquiry: PipelineEnquiry): void;
 /**
  * FrameGraph harness for the CSDLDF-style scene-graph hierarchy update.
  *
@@ -46,4 +56,5 @@ export function graph_nodes_update_transform_hierarchy({ graph, input, scene_dat
 }): {
     scene_database: number;
 };
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 //# sourceMappingURL=graph_nodes_update_transform_hierarchy.d.ts.map

package/src/shade/renderer/scene/hierarchy/graph_nodes_update_transform_hierarchy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_nodes_update_transform_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/hierarchy/graph_nodes_update_transform_hierarchy.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IAR6B,KAAK;IACL,KAAK,EAAvB,MAAM;IACY,cAAc,EAAhC,MAAM;IACY,aAAa,EAA/B,MAAM;IACY,iBAAiB,GAAnC,MAAM;IAEJ;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAqJtC"}
+{"version":3,"file":"graph_nodes_update_transform_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/hierarchy/graph_nodes_update_transform_hierarchy.js"],"names":[],"mappings":"AAcA;;GAEG;AAEH;;;;;GAKG;AACH,4EAFW,eAAe,QAMzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IAR6B,KAAK;IACL,KAAK,EAAvB,MAAM;IACY,cAAc,EAAhC,MAAM;IACY,aAAa,EAA/B,MAAM;IACY,iBAAiB,GAAnC,MAAM;IAEJ;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAqJtC;8BAzMY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/scene/hierarchy/graph_nodes_update_transform_hierarchy.js

@@ -5,12 +5,29 @@ import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDe
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import {
     build_indirect_compute_dispatch_command,
+    indirect_compute_dispatch_command_pipeline,
     INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
 } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
 import { shader_nodes_record_input_positions } from "./shader_nodes_record_input_positions.js";
 import { shader_nodes_update_transform_hierarchy } from "./shader_nodes_update_transform_hierarchy.js";
 import { TRANSFORM_HIERARCHY_PARTITION_SIZE } from "./TRANSFORM_HIERARCHY_PARTITION_SIZE.js";
 
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+
+/**
+ * Offer the pipelines {@link graph_nodes_update_transform_hierarchy} dispatches — see
+ * {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_nodes_update_transform_hierarchy_pipelines(enquiry) {
+    enquiry.compute.push(indirect_compute_dispatch_command_pipeline(enquiry.device, TRANSFORM_HIERARCHY_PARTITION_SIZE, false));
+    enquiry.compute.push(shader_nodes_record_input_positions.pipeline);
+    enquiry.compute.push(shader_nodes_update_transform_hierarchy.pipeline);
+}
+
 /**
  * FrameGraph harness for the CSDLDF-style scene-graph hierarchy update.
  *

package/src/shade/renderer/scene/hierarchy/graph_scene_update_transform_hierarchy.d.ts

@@ -1,3 +1,13 @@
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+/**
+ * Offer the pipelines {@link graph_scene_update_transform_hierarchy} dispatches — see
+ * {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_scene_update_transform_hierarchy_pipelines(enquiry: PipelineEnquiry): void;
 /**
  * High-level wrapper: refresh `node.global` for *every* node in the
  * scene this frame.
@@ -43,4 +53,5 @@ export function graph_scene_update_transform_hierarchy({ graph, scene, scene_dat
 }): {
     scene_database: number;
 };
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 //# sourceMappingURL=graph_scene_update_transform_hierarchy.d.ts.map

package/src/shade/renderer/scene/hierarchy/graph_scene_update_transform_hierarchy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_scene_update_transform_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/hierarchy/graph_scene_update_transform_hierarchy.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;IAZqC,KAAK;IACL,KAAK;IACL,cAAc,GAAxC,MAAM;IAOJ;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAwFtC"}
+{"version":3,"file":"graph_scene_update_transform_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/hierarchy/graph_scene_update_transform_hierarchy.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH;;;;;GAKG;AACH,4EAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;IAZqC,KAAK;IACL,KAAK;IACL,cAAc,GAAxC,MAAM;IAOJ;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAwFtC;8BAxIY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/scene/hierarchy/graph_scene_update_transform_hierarchy.js

@@ -3,7 +3,24 @@ import { round_up } from "../../../../core/math/round_up.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
-import { graph_nodes_update_transform_hierarchy } from "./graph_nodes_update_transform_hierarchy.js";
+import {
+    enquire_nodes_update_transform_hierarchy_pipelines,
+    graph_nodes_update_transform_hierarchy
+} from "./graph_nodes_update_transform_hierarchy.js";
+
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+
+/**
+ * Offer the pipelines {@link graph_scene_update_transform_hierarchy} dispatches — see
+ * {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_scene_update_transform_hierarchy_pipelines(enquiry) {
+    enquire_nodes_update_transform_hierarchy_pipelines(enquiry);
+}
 
 /**
  * High-level wrapper: refresh `node.global` for *every* node in the

package/src/shade/renderer/shader/ComputeShader.d.ts

@@ -46,6 +46,17 @@ export class ComputeShader {
      * @returns {ShaderDescriptor}
      */
     get descriptor(): ShaderDescriptor;
+    /**
+     * This shader as `set` makes it — see {@link ShaderDescriptor#variant}. Sets that agree on the
+     * descriptor's switches get the one shader, and the set with all of them `0` gets this one.
+     *
+     * Every variant has this shader's `@workgroup_size`: a switch changes what a pass computes, never
+     * how it is dispatched, and a dispatch sized by one variant must fit them all.
+     *
+     * @param {ShaderSwitchSet} set
+     * @returns {ComputeShader}
+     */
+    variant(set: ShaderSwitchSet): ComputeShader;
     /**
      *
      * @param {Object} options
@@ -141,6 +152,7 @@ export class ComputeShader {
     readonly isComputeShader: boolean;
     #private;
 }
+export type ShaderSwitchSet = import("./compiler/ShaderSwitchSet.js").ShaderSwitchSet;
 import { ComputePipelineDescriptor } from "../../descriptor/pipeline/compute/ComputePipelineDescriptor.js";
 import { ShaderDescriptor } from "./ShaderDescriptor.js";
 //# sourceMappingURL=ComputeShader.d.ts.map

package/src/shade/renderer/shader/ComputeShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComputeShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ComputeShader.js"],"names":[],"mappings":"AAMA;IA8FI;;;;;;;;;;OAUG;IACH;QAR4B,KAAK,GAAtB,MAAM;QAC+B,SAAS;QAC3B,IAAI;QACJ,UAAU,GAA7B,MAAM,EAAE;QAGN,aAAa,CAuBzB;IA5DD;;;OAGG;IACH,wBAFW,gBAAgB,EAwB1B;IAhFD;;;OAGG;IACH,0CAEC;IAgBD;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,mCAEC;IAgED;;;;;;OAMG;IACH;QAJ2C,OAAO;QACvB,QAAQ;mCA0BlC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAP2C,OAAO;QACvB,QAAQ;QACP,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;aAgChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACvB,QAAQ;QACR,aAAa,EAA7B,MAAM;aAsBhB;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACvB,QAAQ;QACP,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;aA2ChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACpB,OAAO;QACV,QAAQ;QACP,cAAc,GAA/B,MAAM;aAwChB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;0CA/VyC,gEAAgE;iCACzE,uBAAuB"}
+{"version":3,"file":"ComputeShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ComputeShader.js"],"names":[],"mappings":"AAUA;IA2JI;;;;;;;;;;OAUG;IACH;QAR4B,KAAK,GAAtB,MAAM;QAC+B,SAAS;QAC3B,IAAI;QACJ,UAAU,GAA7B,MAAM,EAAE;QAGN,aAAa,CAuBzB;IA5DD;;;OAGG;IACH,wBAFW,gBAAgB,EAwB1B;IAjID;;;OAGG;IACH,0CAEC;IAgBD;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,mCAEC;IAQD;;;;;;;;;OASG;IACH,aAHW,eAAe,GACb,aAAa,CAiCzB;IAgED;;;;;;OAMG;IACH;QAJ2C,OAAO;QACvB,QAAQ;mCA8BlC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAP2C,OAAO;QACvB,QAAQ;QACP,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;aAgChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACvB,QAAQ;QACR,aAAa,EAA7B,MAAM;aAsBhB;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACvB,QAAQ;QACP,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;aA2ChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACpB,OAAO;QACV,QAAQ;QACP,cAAc,GAA/B,MAAM;aAwChB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;8BAhaY,OAAO,+BAA+B,EAAE,eAAe;0CAJ1B,gEAAgE;iCACzE,uBAAuB"}

package/src/shade/renderer/shader/ComputeShader.js

@@ -2,6 +2,10 @@ import { assert } from "../../../core/assert.js";
 import { ComputePipelineDescriptor } from "../../descriptor/pipeline/compute/ComputePipelineDescriptor.js";
 import { ShaderDescriptor } from "./ShaderDescriptor.js";
 
+/**
+ * @typedef {import("./compiler/ShaderSwitchSet.js").ShaderSwitchSet} ShaderSwitchSet
+ */
+
 const VALIDATION_ENABLED = true;
 
 export class ComputeShader {
@@ -16,6 +20,18 @@ export class ComputeShader {
      */
     #pipeline;
 
+    /**
+     * The device this shader last passed {@link ShaderDescriptor#validate_against_device} on, or null.
+     *
+     * A device's limits and features are fixed for its life, and what this shader asks of them is fixed
+     * once it compiles, at construction. So the check is one per device rather than one per pass, which
+     * was ~400 native reads of `device.limits` and `device.features` a frame. Set only once the check
+     * has passed: a refused device is asked again, and refused again, every time.
+     *
+     * @type {GPUDevice|null}
+     */
+    #validated_device = null;
+
     /**
      *
      * @return {ComputePipelineDescriptor}
@@ -70,6 +86,55 @@ export class ComputeShader {
         return this.#descriptor;
     }
 
+    /**
+     * This shader's variants, by every set asked for and by the descriptor each was built from.
+     * @type {Map<ShaderSwitchSet|ShaderDescriptor, ComputeShader>}
+     */
+    #variants = new Map();
+
+    /**
+     * This shader as `set` makes it — see {@link ShaderDescriptor#variant}. Sets that agree on the
+     * descriptor's switches get the one shader, and the set with all of them `0` gets this one.
+     *
+     * Every variant has this shader's `@workgroup_size`: a switch changes what a pass computes, never
+     * how it is dispatched, and a dispatch sized by one variant must fit them all.
+     *
+     * @param {ShaderSwitchSet} set
+     * @returns {ComputeShader}
+     */
+    variant(set) {
+        let r = this.#variants.get(set);
+
+        if (r !== undefined) {
+            return r;
+        }
+
+        const descriptor = this.#descriptor.variant(set);
+
+        if (descriptor === this.#descriptor) {
+            r = this;
+        } else {
+            r = this.#variants.get(descriptor);
+
+            if (r === undefined) {
+                r = new ComputeShader(descriptor);
+
+                const own = this.#group_size;
+                const theirs = r.#group_size;
+
+                if (own[0] !== theirs[0] || own[1] !== theirs[1] || own[2] !== theirs[2]) {
+                    throw new Error(`ComputeShader '${descriptor.label}' has @workgroup_size(${theirs}), and '${this.#descriptor.label}' has (${own}); the variants of a shader dispatch alike`);
+                }
+
+                this.#variants.set(descriptor, r);
+            }
+        }
+
+        this.#variants.set(set, r);
+
+        return r;
+    }
+
     /**
      *
      * @param {ShaderDescriptor} descriptor
@@ -147,8 +212,12 @@ export class ComputeShader {
         assert.defined(encoder, 'encoder');
         assert.defined(bindings, 'bindings');
 
-        if (VALIDATION_ENABLED) {
-            this.#descriptor.validate_against_device(encoder.device);
+        const device = encoder.device;
+
+        if (VALIDATION_ENABLED && device !== this.#validated_device) {
+            this.#descriptor.validate_against_device(device);
+
+            this.#validated_device = device;
         }
 
         const resources = this.#descriptor.resources;

package/src/shade/renderer/shader/ImageShader.d.ts

@@ -15,13 +15,11 @@ export class ImageShader {
         targets: ColorTargetState[];
         depthStencil?: DepthStencilState;
     }): ImageShader;
-    /**
-     *
-     * @param {ShaderDescriptor} descriptor
-     * @param {(ColorTargetState|{clearValue?:number[]})[]} [targets]
-     * @param {DepthStencilState} [depthStencil]
-     */
-    constructor({ descriptor, targets, depthStencil, }: ShaderDescriptor);
+    constructor({ descriptor, targets, depthStencil, }: {
+        descriptor: any;
+        targets?: any[];
+        depthStencil: any;
+    });
     /**
      *
      * @returns {ShaderDescriptor}
@@ -36,12 +34,31 @@ export class ImageShader {
      *
      * @returns {RenderPipelineDescriptor}
      */
-    get pipeline(): RenderPipelineDescriptor;
+    get pipeline(): import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+    /**
+     * The pipeline {@link draw} uses when it draws into attachments of these formats: {@link pipeline}
+     * itself when they are the formats it declares, otherwise a copy rewritten for them
+     * (rgba8unorm -> bgra8unorm, say). Offer this, not {@link pipeline}, for a pass that draws into
+     * a target it was handed — what an offer compiles is otherwise a variant no frame draws with.
+     *
+     * @param {GPUTextureFormat[]} color_formats one per fragment target
+     * @returns {RenderPipelineDescriptor}
+     */
+    pipeline_for(color_formats: GPUTextureFormat[]): RenderPipelineDescriptor;
     /**
      *
      * @returns {boolean}
      */
     get isImageShader(): boolean;
+    /**
+     * This shader as `set` makes it — see {@link ShaderDescriptor#variant}. The same targets and depth
+     * state, the body specialized. Sets that agree on the descriptor's switches get the one shader, and
+     * the set with all of them `0` gets this one.
+     *
+     * @param {ShaderSwitchSet} set
+     * @returns {ImageShader}
+     */
+    variant(set: ShaderSwitchSet): ImageShader;
     /**
      * Note the absence of depth target, image shader is a full-screen pass, so depth is not used.
      *
@@ -55,4 +72,6 @@ export class ImageShader {
     draw({ encoder, bindings, colorAttachments, depthStencilAttachment, color_formats, viewport }: ShadeGPUCommandContext): void;
     #private;
 }
+export type RenderPipelineDescriptor = import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+export type ShaderSwitchSet = import("./compiler/ShaderSwitchSet.js").ShaderSwitchSet;
 //# sourceMappingURL=ImageShader.d.ts.map