@woosh/meep-engine 3.11.2 → 3.11.3

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

@@ -1,4 +1,6 @@
 import { normalize_dynamic_offsets } from "./normalize_dynamic_offsets.js";
+import { pipeline_immediate_size } from "./pipeline_immediate_size.js";
+import { SoftwareGPUImmediateData } from "./SoftwareGPUImmediateData.js";
 import { SoftwareGPUObjectBase } from "./SoftwareGPUObjectBase.js";
 import { write_pass_timestamp } from "./write_pass_timestamp.js";
 
@@ -79,6 +81,14 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
      */
     #scissor = null;
 
+    /**
+     * Immediate data for this pass. Per-encoder state in WebGPU, and a new pass starts over — which
+     * is why it is constructed here rather than carried in from the command encoder.
+     *
+     * @type {SoftwareGPUImmediateData}
+     */
+    #immediates;
+
     #ended = false;
 
     /**
@@ -99,6 +109,7 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
 
         this.#encoder = encoder;
         this.descriptor = descriptor;
+        this.#immediates = new SoftwareGPUImmediateData(encoder.device.limits.maxImmediateSize);
 
         write_pass_timestamp(descriptor, 'beginningOfPassWriteIndex');
     }
@@ -138,6 +149,22 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
         );
     }
 
+    /**
+     * @param {number} range_offset byte offset into the immediate data range
+     * @param {ArrayBuffer|ArrayBufferView} data
+     * @param {number} [data_offset] in elements if `data` is a TypedArray, bytes otherwise
+     * @param {number} [data_size] in elements if `data` is a TypedArray, bytes otherwise
+     */
+    setImmediates(range_offset, data, data_offset = 0, data_size) {
+        this.#assert_encoding();
+
+        const message = this.#immediates.write(range_offset, data, data_offset, data_size);
+
+        if (message !== null) {
+            this.#encoder.notify_pass_validation_error(message);
+        }
+    }
+
     /**
      * @param {number} slot
      * @param {GPUBuffer} buffer
@@ -206,6 +233,24 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
         this.stencil_reference = reference;
     }
 
+    /**
+     * WebGPU's *Validate immediate data*: every slot the pipeline's immediate range covers must have
+     * been written before a command reads it. The bytes default to zero but the slots do not default
+     * to set, so a forgotten `setImmediates` is a refused draw on a real device rather than a shader
+     * quietly reading zeroes. Catching it here is the whole reason the slot bookkeeping exists.
+     *
+     * @returns {void}
+     */
+    #validate_immediates() {
+        const size = pipeline_immediate_size(this.#pipeline);
+
+        if (size > 0 && !this.#immediates.isRangeSet(0, size)) {
+            this.#encoder.notify_pass_validation_error(
+                `draw: pipeline declares ${size} bytes of immediate data, and not all of it was set by setImmediates`
+            );
+        }
+    }
+
     /**
      * The state a draw would run under, copied so later state changes do not rewrite a draw already
      * recorded.
@@ -221,6 +266,7 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
             index_buffer: this.#index_buffer,
             viewport: this.#viewport,
             scissor: this.#scissor,
+            immediates: this.#immediates.snapshot(),
         };
     }
 
@@ -230,6 +276,7 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
      */
     draw(vertex_count, instance_count = 1) {
         this.#assert_encoding();
+        this.#validate_immediates();
 
         this.draws.push({
             ...this.#snapshot(),
@@ -246,6 +293,7 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
      */
     drawIndexed(index_count, instance_count = 1) {
         this.#assert_encoding();
+        this.#validate_immediates();
 
         this.draws.push({
             ...this.#snapshot(),
@@ -262,6 +310,7 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
      */
     drawIndirect(indirect_buffer, indirect_offset) {
         this.#assert_encoding();
+        this.#validate_immediates();
 
         this.draws.push({
             ...this.#snapshot(),
@@ -281,6 +330,7 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
      */
     drawIndexedIndirect(indirect_buffer, indirect_offset) {
         this.#assert_encoding();
+        this.#validate_immediates();
 
         this.draws.push({
             ...this.#snapshot(),

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

@@ -0,0 +1,11 @@
+/**
+ * Bytes of immediate data a pipeline's layout declares, or 0 when it declares none.
+ *
+ * A pipeline built with `layout: "auto"` reports 0 rather than deriving a size: deriving one would
+ * mean reading the WGSL, and nothing in this folder compiles WGSL.
+ *
+ * @param {GPUPipelineBase|null} pipeline
+ * @returns {number}
+ */
+export function pipeline_immediate_size(pipeline: GPUPipelineBase | null): number;
+//# sourceMappingURL=pipeline_immediate_size.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline_immediate_size.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/pipeline_immediate_size.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,kDAHW,kBAAgB,IAAI,GAClB,MAAM,CAUlB"}

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

@@ -0,0 +1,18 @@
+/**
+ * Bytes of immediate data a pipeline's layout declares, or 0 when it declares none.
+ *
+ * A pipeline built with `layout: "auto"` reports 0 rather than deriving a size: deriving one would
+ * mean reading the WGSL, and nothing in this folder compiles WGSL.
+ *
+ * @param {GPUPipelineBase|null} pipeline
+ * @returns {number}
+ */
+export function pipeline_immediate_size(pipeline) {
+    const layout = pipeline?.descriptor?.layout;
+
+    if (layout === undefined || layout === null || layout === "auto") {
+        return 0;
+    }
+
+    return layout.immediateSize ?? 0;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"PipelineLayoutManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/pipeline/PipelineLayoutManager.js"],"names":[],"mappings":"AAGA;IAMI;;;OAGG;IACH,+BAEC;IAoBD;;;;OAIG;IACH,2DAFa,4BAA0B,SAAS,CAI/C;IAgBD;;;;OAIG;IACH,iFAKC;IAED;;;;OAIG;IACH,8EAEC;;CAkBJ"}
+{"version":3,"file":"PipelineLayoutManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/pipeline/PipelineLayoutManager.js"],"names":[],"mappings":"AAGA;IAMI;;;OAGG;IACH,+BAEC;IAoBD;;;;OAIG;IACH,2DAFa,4BAA0B,SAAS,CAI/C;IAgBD;;;;OAIG;IACH,iFAKC;IAED;;;;OAIG;IACH,8EAEC;;CAmBJ"}

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

@@ -89,6 +89,7 @@ export class PipelineLayoutManager {
         return this.#device.createPipelineLayout({
             label: descriptor.label,
             bindGroupLayouts,
+            immediateSize: descriptor.immediateSize,
         });
 
     }

package/src/shade/renderer/GraphicsContext.d.ts

@@ -89,8 +89,15 @@ export class GraphicsContext {
      * @param {GPUBindingCommandsMixin} pass
      * @param {PipelineDescriptorBase} pipeline
      * @param {GPUBindingResource[][]} [bindings]
-     */
-    setPipelineBindings(pass: GPUBindingCommandsMixin, pipeline: PipelineDescriptorBase, bindings?: GPUBindingResource[][]): void;
+     * @param {{buffer: BinaryBuffer, offset: number, size: number}} [immediate] bytes to hand the
+     *        pass through `setImmediates`, when the pipeline declares immediate data. Optional so
+     *        that every caller predating immediates keeps working unchanged.
+     */
+    setPipelineBindings(pass: GPUBindingCommandsMixin, pipeline: PipelineDescriptorBase, bindings?: GPUBindingResource[][], immediate?: {
+        buffer: BinaryBuffer;
+        offset: number;
+        size: number;
+    }): void;
     /**
      *
      * @param {BufferDescriptor} buffer_descriptor

package/src/shade/renderer/GraphicsContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAwBA;IAoJI,yBA8BC;IAjLD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;OAGG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAkCD;;;;;OAKG;IACH,gGAFW,oBAAoB,EAAE,QAwDhC;IAED;;;;OAIG;IACH,mDAFa,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAcC;IAED,4BAEC;IAED,eAmBC;IAED,gBAcC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;mCAlUkC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAXzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAchD,6BAA6B;sCACtB,4CAA4C;iCAbjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAErC,uCAAuC;oCAO7C,kCAAkC;iCARtB,8BAA8B"}
+{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAwBA;IAoJI,yBA8BC;IAjLD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;OAGG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAkCD;;;;;;;;OAQG;IACH,gGALW,oBAAoB,EAAE,cACtB;QAAC,MAAM,eAAe;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,mDAFa,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAcC;IAED,4BAEC;IAED,eAmBC;IAED,gBAcC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;mCA9UkC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAXzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAchD,6BAA6B;sCACtB,4CAA4C;iCAbjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAErC,uCAAuC;oCAO7C,kCAAkC;iCARtB,8BAA8B"}

package/src/shade/renderer/GraphicsContext.js

@@ -207,14 +207,26 @@ export class GraphicsContext {
      * @param {GPUBindingCommandsMixin} pass
      * @param {PipelineDescriptorBase} pipeline
      * @param {GPUBindingResource[][]} [bindings]
+     * @param {{buffer: BinaryBuffer, offset: number, size: number}} [immediate] bytes to hand the
+     *        pass through `setImmediates`, when the pipeline declares immediate data. Optional so
+     *        that every caller predating immediates keeps working unchanged.
      */
     setPipelineBindings(
         pass,
         pipeline,
-        bindings
+        bindings,
+        immediate
     ) {
         assert.isArray(bindings, 'bindings');
 
+        if (immediate !== undefined) {
+            // `raw_bytes` is read here rather than cached by the caller: BinaryBuffer rebinds it
+            // when the backing store grows, so a reference taken earlier can be stale. It is also a
+            // Uint8Array, for which `setImmediates` counts offset and size in elements — and its
+            // elements are bytes, so the range passes through unchanged.
+            pass.setImmediates(0, immediate.buffer.raw_bytes, immediate.offset, immediate.size);
+        }
+
         const bind_group_descriptors = pipeline.layout.bindGroupLayouts;
 
         const bind_group_count = bindings.length;

package/src/shade/renderer/atmosphere/GPUSky.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSky.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/GPUSky.js"],"names":[],"mappings":"AASA;IAuCI;;;OAGG;IACH,uCAkBC;IAjDD;;;OAGG;IACH,2CAEC;IAOD;;;OAGG;IACH,iDAEC;IAgCD,gBAGC;IAED,cAYC;IAED;;OAEG;IACH,eA8CC;;CAEJ;kCAzIiC,iCAAiC"}
+{"version":3,"file":"GPUSky.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/GPUSky.js"],"names":[],"mappings":"AAUA;IAuCI;;;OAGG;IACH,uCAmBC;IAlDD;;;OAGG;IACH,2CAEC;IAOD;;;OAGG;IACH,iDAEC;IAiCD,gBAGC;IAED,cAYC;IAED;;OAEG;IACH,eA+CC;;CAEJ;kCA3IiC,iCAAiC"}

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

@@ -1,143 +1,146 @@
-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_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";
-        this.#lut_multiple_scattering.descriptor.usage = GPUTextureUsage.RENDER_ATTACHMENT | 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);
-
-        graph_image_pass({
-            graph,
-            shader: shader_transmittance_lut,
-            inputs: {
-                settings: {
-                    steps: 40,
-                }
-            },
-            output: [gr_transmittance]
-        });
-
-
-        graph_image_pass({
-            graph,
-            shader: shader_multiscatter_lut,
-            inputs: {
-                settings: {
-                    steps: 20,
-                    sqrt_samples: 8,
-                },
-                tSkyLutTransmittance: gr_transmittance
-            },
-            output: [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";
+
+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);
+
+        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,
+                tSkyLutMultiscatterOut: gr_multiscatter
+            }
+        });
+
+        command_ctx.encodeGraph(graph);
+
+        command_ctx.finish();
+
+
+        this.#needs_update = false;
+    }
+
 }

package/src/shade/renderer/atmosphere/MULTISCATTER_LUT_CONFIG.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Directions are drawn on an 8x8 grid, stratified in azimuth and in the cosine of the polar
+ * angle. Matches Hillaire's `SQRTSAMPLECOUNT`.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_SQRT_SAMPLES: number;
+/**
+ * One thread integrates one direction, so this is also the workgroup size.
+ *
+ * 64 is Hillaire's `[numthreads(1,1,64)]` count. It is a multiple of every legal subgroup
+ * size up to 64, and the reduction handles a subgroup wider than the workgroup, so no
+ * hardware needs a different number here.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_DIRECTION_COUNT: number;
+/**
+ * Ray-march steps per direction. Hillaire's `SampleCountIni` for this LUT; the comment there
+ * reads "a minimum set of step is required for accuracy unfortunately".
+ *
+ * Compile-time on purpose: as a uniform the inner loop cannot be unrolled and the trip count
+ * has to be re-tested against an f32 every iteration.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_STEPS: number;
+/**
+ * Upper bound on the number of subgroups in one workgroup, which is how many partial sums
+ * the cross-subgroup reduction has to combine.
+ *
+ * WGSL pins the subgroup size to a power of two in [4, 128], so the worst case is
+ * {@link MULTISCATTER_LUT_DIRECTION_COUNT} / 4.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS: number;
+//# sourceMappingURL=MULTISCATTER_LUT_CONFIG.d.ts.map

package/src/shade/renderer/atmosphere/MULTISCATTER_LUT_CONFIG.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MULTISCATTER_LUT_CONFIG.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/MULTISCATTER_LUT_CONFIG.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;;;;;GAOG;AACH,+CAFU,MAAM,CAE8F;AAE9G;;;;;;;GAOG;AACH,qCAFU,MAAM,CAEyB;AAEzC;;;;;;;GAOG;AACH,qDAFU,MAAM,CAE2E"}

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

@@ -0,0 +1,36 @@
+/**
+ * Directions are drawn on an 8x8 grid, stratified in azimuth and in the cosine of the polar
+ * angle. Matches Hillaire's `SQRTSAMPLECOUNT`.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_SQRT_SAMPLES = 8;
+
+/**
+ * One thread integrates one direction, so this is also the workgroup size.
+ *
+ * 64 is Hillaire's `[numthreads(1,1,64)]` count. It is a multiple of every legal subgroup
+ * size up to 64, and the reduction handles a subgroup wider than the workgroup, so no
+ * hardware needs a different number here.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_DIRECTION_COUNT = MULTISCATTER_LUT_SQRT_SAMPLES * MULTISCATTER_LUT_SQRT_SAMPLES;
+
+/**
+ * Ray-march steps per direction. Hillaire's `SampleCountIni` for this LUT; the comment there
+ * reads "a minimum set of step is required for accuracy unfortunately".
+ *
+ * Compile-time on purpose: as a uniform the inner loop cannot be unrolled and the trip count
+ * has to be re-tested against an f32 every iteration.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_STEPS = 20;
+
+/**
+ * Upper bound on the number of subgroups in one workgroup, which is how many partial sums
+ * the cross-subgroup reduction has to combine.
+ *
+ * WGSL pins the subgroup size to a power of two in [4, 128], so the worst case is
+ * {@link MULTISCATTER_LUT_DIRECTION_COUNT} / 4.
+ * @type {number}
+ */
+export const MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS = MULTISCATTER_LUT_DIRECTION_COUNT / 4;

package/src/shade/renderer/atmosphere/SAMPLER_SKY_LUT.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Filtering sampler for the sky LUTs (transmittance, multiple-scattering).
+ *
+ * Both LUTs are `rgba16float`, which is filterable in core WebGPU — only the 32-bit float
+ * formats need the `float32-filterable` feature — so these can go through the texture unit
+ * instead of the 4-tap manual bilinear in `texture_sample_bilinear_uv`.
+ *
+ * `min` and `mag` are both set: the LUTs are single-mip and sampled with an explicit LOD of
+ * 0, which selects the magnification filter, but relying on that alone would silently fall
+ * back to point sampling if either LUT ever grew mips.
+ *
+ * Clamp-to-edge reproduces the manual filter's per-corner clamping exactly: `uv` is
+ * saturated by `sky_lut_uv`, and at the edges both bilinear taps collapse onto the edge
+ * texel.
+ *
+ * @type {Readonly<SamplerDescriptor>}
+ */
+export const SAMPLER_SKY_LUT: Readonly<SamplerDescriptor>;
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+//# sourceMappingURL=SAMPLER_SKY_LUT.d.ts.map

package/src/shade/renderer/atmosphere/SAMPLER_SKY_LUT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SAMPLER_SKY_LUT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/SAMPLER_SKY_LUT.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,8BAFU,SAAS,iBAAiB,CAAC,CAOjC;kCAxB8B,+CAA+C"}

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

@@ -0,0 +1,25 @@
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+
+/**
+ * Filtering sampler for the sky LUTs (transmittance, multiple-scattering).
+ *
+ * Both LUTs are `rgba16float`, which is filterable in core WebGPU — only the 32-bit float
+ * formats need the `float32-filterable` feature — so these can go through the texture unit
+ * instead of the 4-tap manual bilinear in `texture_sample_bilinear_uv`.
+ *
+ * `min` and `mag` are both set: the LUTs are single-mip and sampled with an explicit LOD of
+ * 0, which selects the magnification filter, but relying on that alone would silently fall
+ * back to point sampling if either LUT ever grew mips.
+ *
+ * Clamp-to-edge reproduces the manual filter's per-corner clamping exactly: `uv` is
+ * saturated by `sky_lut_uv`, and at the edges both bilinear taps collapse onto the edge
+ * texel.
+ *
+ * @type {Readonly<SamplerDescriptor>}
+ */
+export const SAMPLER_SKY_LUT = Object.freeze(SamplerDescriptor.from({
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+}));