@woosh/meep-engine 3.65.0 → 3.68.0

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

@@ -0,0 +1,45 @@
+/**
+ * Length of one GPU-side atmosphere spatial unit in world-space metres ($1\text{ km} = 10^3\text{ m}$),
+ * matching Hillaire (2020). Keeping GPU atmosphere geometry and extinction in kilometres and
+ * $\text{km}^{-1}$ keeps planetary squares inside 32-bit integer range, radii and sea-level
+ * scattering coefficients inside normal `f16`, and upper-atmosphere extinction three orders of
+ * magnitude further above division-by-zero epsilon floors while `SceneAtmosphere` remains authored
+ * in world-space metres and $\text{m}^{-1}$ on the CPU.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ * @type {number}
+ */
+export const ATMOSPHERE_UNIT_METERS: number;
+/**
+ * Multiplicative factor converting world-space lengths and positions ($\text{m}$) into GPU
+ * atmosphere units ($\text{km}$): `x_atm = x_meters * METERS_TO_ATMOSPHERE_UNITS`.
+ *
+ * @type {number}
+ */
+export const METERS_TO_ATMOSPHERE_UNITS: number;
+/**
+ * Multiplicative factor converting world-space scattering/extinction/absorption coefficients
+ * ($\text{m}^{-1}$) into inverse GPU atmosphere units ($\text{km}^{-1}$):
+ * `sigma_atm = sigma_per_meter * INVERSE_METERS_TO_ATMOSPHERE_UNITS`, preserving dimensionless
+ * optical depth $\sigma_{\text{atm}} \cdot d_{\text{atm}} = \sigma_m \cdot d_m$.
+ *
+ * @type {number}
+ */
+export const INVERSE_METERS_TO_ATMOSPHERE_UNITS: number;
+/**
+ * Positive lower bound (`1 mm` expressed in GPU atmosphere units) applied to radii and scale
+ * heights so zero or negative inputs cannot divide by zero.
+ *
+ * @type {number}
+ */
+export const MIN_ATMOSPHERE_LENGTH_UNITS: number;
+/**
+ * WGSL compile-time constants mirroring {@link ATMOSPHERE_UNIT_METERS},
+ * {@link METERS_TO_ATMOSPHERE_UNITS}, {@link INVERSE_METERS_TO_ATMOSPHERE_UNITS}, and
+ * {@link MIN_ATMOSPHERE_LENGTH_UNITS}.
+ *
+ * @type {CodeChunk}
+ */
+export const ATMOSPHERE_UNIT_SCALE_DECLARATION: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=ATMOSPHERE_UNIT_SCALE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ATMOSPHERE_UNIT_SCALE.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/ATMOSPHERE_UNIT_SCALE.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,qCAFU,MAAM,CAE4B;AAE5C;;;;;GAKG;AACH,yCAFU,MAAM,CAEqD;AAErE;;;;;;;GAOG;AACH,iDAFU,MAAM,CAEyD;AAEzE;;;;;GAKG;AACH,0CAFU,MAAM,CAE6D;AAE7E;;;;;;GAMG;AACH,gDAFU,SAAS,CAUjB;0BAxDwB,iCAAiC"}

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

@@ -0,0 +1,57 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+
+/**
+ * Length of one GPU-side atmosphere spatial unit in world-space metres ($1\text{ km} = 10^3\text{ m}$),
+ * matching Hillaire (2020). Keeping GPU atmosphere geometry and extinction in kilometres and
+ * $\text{km}^{-1}$ keeps planetary squares inside 32-bit integer range, radii and sea-level
+ * scattering coefficients inside normal `f16`, and upper-atmosphere extinction three orders of
+ * magnitude further above division-by-zero epsilon floors while `SceneAtmosphere` remains authored
+ * in world-space metres and $\text{m}^{-1}$ on the CPU.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ * @type {number}
+ */
+export const ATMOSPHERE_UNIT_METERS = 1_000;
+
+/**
+ * Multiplicative factor converting world-space lengths and positions ($\text{m}$) into GPU
+ * atmosphere units ($\text{km}$): `x_atm = x_meters * METERS_TO_ATMOSPHERE_UNITS`.
+ *
+ * @type {number}
+ */
+export const METERS_TO_ATMOSPHERE_UNITS = 1 / ATMOSPHERE_UNIT_METERS;
+
+/**
+ * Multiplicative factor converting world-space scattering/extinction/absorption coefficients
+ * ($\text{m}^{-1}$) into inverse GPU atmosphere units ($\text{km}^{-1}$):
+ * `sigma_atm = sigma_per_meter * INVERSE_METERS_TO_ATMOSPHERE_UNITS`, preserving dimensionless
+ * optical depth $\sigma_{\text{atm}} \cdot d_{\text{atm}} = \sigma_m \cdot d_m$.
+ *
+ * @type {number}
+ */
+export const INVERSE_METERS_TO_ATMOSPHERE_UNITS = ATMOSPHERE_UNIT_METERS;
+
+/**
+ * Positive lower bound (`1 mm` expressed in GPU atmosphere units) applied to radii and scale
+ * heights so zero or negative inputs cannot divide by zero.
+ *
+ * @type {number}
+ */
+export const MIN_ATMOSPHERE_LENGTH_UNITS = 1e-3 * METERS_TO_ATMOSPHERE_UNITS;
+
+/**
+ * WGSL compile-time constants mirroring {@link ATMOSPHERE_UNIT_METERS},
+ * {@link METERS_TO_ATMOSPHERE_UNITS}, {@link INVERSE_METERS_TO_ATMOSPHERE_UNITS}, and
+ * {@link MIN_ATMOSPHERE_LENGTH_UNITS}.
+ *
+ * @type {CodeChunk}
+ */
+export const ATMOSPHERE_UNIT_SCALE_DECLARATION = CodeChunk.from(
+    //language=WGSL
+    `
+const ATMOSPHERE_UNIT_METERS: f32 = ${ATMOSPHERE_UNIT_METERS.toFixed(1)};
+const METERS_TO_ATMOSPHERE_UNITS: f32 = 1.0 / ATMOSPHERE_UNIT_METERS;
+const INVERSE_METERS_TO_ATMOSPHERE_UNITS: f32 = ATMOSPHERE_UNIT_METERS;
+const MIN_ATMOSPHERE_LENGTH_UNITS: f32 = 1e-3 * METERS_TO_ATMOSPHERE_UNITS;
+    `
+);

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

@@ -1,26 +1,37 @@
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  */
 export class GPUSky {
     /**
-     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
+    /**
      * @param {GraphicsContext} graphics
+     * @param {SceneAtmosphere} [atmosphere]
      */
-    constructor(graphics: GraphicsContext);
+    constructor(graphics: GraphicsContext, atmosphere?: SceneAtmosphere);
     /**
-     *
      * @returns {GPUTextureContext}
      */
     get lut_transmittance(): GPUTextureContext;
     /**
-     *
      * @returns {GPUTextureContext}
      */
     get lut_multiple_scattering(): GPUTextureContext;
     /**
-     * Whether the LUTs still hold nothing a reader could use: true until the first {@link update}.
-     * What reads {@link lut_transmittance} or {@link lut_multiple_scattering} has to see this false,
-     * as a texture nobody wrote reads as zero rather than failing.
+     * @returns {SceneAtmosphere}
+     */
+    get atmosphere(): SceneAtmosphere;
+    /**
+     * GPU uniform buffer holding {@link ATMOSPHERE_PARAMETERS_STRUCT}.
+     * @returns {GPUTypedBuffer}
+     */
+    get parameters_buffer(): GPUTypedBuffer;
+    /**
+     * Whether the LUTs have not yet been built or {@link SceneAtmosphere#version} has advanced
+     * since the last {@link update}.
      *
      * @returns {boolean}
      */
@@ -28,11 +39,15 @@ export class GPUSky {
     destroy(): void;
     debug(): void;
     /**
-     *
+     * Uploads any changed {@link SceneAtmosphere} parameters and rebuilds the transmittance and
+     * multiple-scattering LUTs when {@link needs_update} is true; a no-op on steady frames.
      */
     update(): void;
     #private;
 }
+export type PipelineEnquiry = import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
 import { GPUTextureContext } from "../texture/GPUTextureContext.js";
+import { SceneAtmosphere } from "./SceneAtmosphere.js";
+import { GPUTypedBuffer } from "../buffer/GPUTypedBuffer.js";
 //# sourceMappingURL=GPUSky.d.ts.map

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":"AAUA;;GAEG;AAEH;IAkDI;;;OAGG;IACH,sBAFW,eAAe,EAqBzB;IA7DD;;;OAGG;IACH,2CAEC;IAOD;;;OAGG;IACH,iDAEC;IAQD;;;;;;OAMG;IACH,4BAEC;IA2BD,gBAGC;IAED,cAYC;IAED;;OAEG;IACH,eAiDC;;CAEJ;8BAvJY,OAAO,uBAAuB,EAAE,eAAe;kCAL1B,iCAAiC"}
+{"version":3,"file":"GPUSky.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/GPUSky.js"],"names":[],"mappings":"AAcA;;;GAGG;AAEH;IAEI;;OAEG;IACH,iCAFW,eAAe,QAKzB;IA+ED;;;OAGG;IACH,sBAHW,eAAe,eACf,eAAe,EAgCzB;IA9ED;;OAEG;IACH,2CAEC;IAOD;;OAEG;IACH,iDAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,wCAEC;IAED;;;;;OAKG;IACH,4BAEC;IAsCD,gBAIC;IAED,cAOC;IAED;;;OAGG;IACH,eAwDC;;CAEJ;8BA5MY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;kCAR1B,iCAAiC;gCAEnC,sBAAsB;+BANvB,6BAA6B"}

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

@@ -1,31 +1,66 @@
+import { assert } from "../../../core/assert.js";
 import { FrameGraph } from "../../../engine/graphics/render/frame_graph/FrameGraph.js";
 import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
 import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import { GPUTypedBuffer } from "../buffer/GPUTypedBuffer.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 { ATMOSPHERE_PARAMETERS_STRUCT } from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { SceneAtmosphere } from "./SceneAtmosphere.js";
 import { shader_multiscatter_lut } from "./shader_multiscatter_lut.js";
 import { shader_transmittance_lut } from "./shader_transmittance_lut.js";
 
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  */
 
 export class GPUSky {
 
+    /**
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        enquiry.render.push(shader_transmittance_lut.pipeline);
+        enquiry.compute.push(shader_multiscatter_lut.pipeline);
+    }
+
     /**
      * @type {GraphicsContext}
      */
     #graphics;
 
+    /**
+     * @type {SceneAtmosphere}
+     */
+    #atmosphere;
+
+    /**
+     * @type {GPUTypedBuffer}
+     */
+    #parameters_buffer;
+
+    /**
+     * Reusable POJO target for {@link SceneAtmosphere#write_uniform}.
+     * @type {Record<string, any>}
+     */
+    #uniform_scratch = {};
+
+    /**
+     * Last {@link SceneAtmosphere#version} committed into the LUTs and uniform buffer, or `-1`
+     * before the first {@link update}.
+     * @type {number}
+     */
+    #committed_version = -1;
+
     /**
      * @type {GPUTextureContext}
      */
     #lut_transmittance;
 
     /**
-     *
      * @returns {GPUTextureContext}
      */
     get lut_transmittance() {
@@ -38,7 +73,6 @@ export class GPUSky {
     #lut_multiple_scattering;
 
     /**
-     *
      * @returns {GPUTextureContext}
      */
     get lut_multiple_scattering() {
@@ -46,31 +80,52 @@ export class GPUSky {
     }
 
     /**
-     *
-     * @type {boolean}
+     * @returns {SceneAtmosphere}
+     */
+    get atmosphere() {
+        return this.#atmosphere;
+    }
+
+    /**
+     * GPU uniform buffer holding {@link ATMOSPHERE_PARAMETERS_STRUCT}.
+     * @returns {GPUTypedBuffer}
      */
-    #needs_update = true;
+    get parameters_buffer() {
+        return this.#parameters_buffer;
+    }
 
     /**
-     * Whether the LUTs still hold nothing a reader could use: true until the first {@link update}.
-     * What reads {@link lut_transmittance} or {@link lut_multiple_scattering} has to see this false,
-     * as a texture nobody wrote reads as zero rather than failing.
+     * Whether the LUTs have not yet been built or {@link SceneAtmosphere#version} has advanced
+     * since the last {@link update}.
      *
      * @returns {boolean}
      */
     get needs_update() {
-        return this.#needs_update;
+        return this.#committed_version !== this.#atmosphere.version;
     }
 
     /**
-     *
      * @param {GraphicsContext} graphics
+     * @param {SceneAtmosphere} [atmosphere]
      */
-    constructor(graphics) {
+    constructor(graphics, atmosphere = new SceneAtmosphere()) {
+        assert.defined(graphics, "graphics");
+        assert.defined(atmosphere, "atmosphere");
+        assert.equal(atmosphere.isSceneAtmosphere, true, "atmosphere.isSceneAtmosphere !== true");
+
         this.#graphics = graphics;
+        this.#atmosphere = atmosphere;
 
         const device = graphics.device;
 
+        this.#parameters_buffer = GPUTypedBuffer.create({
+            label: "Sky / Atmosphere Parameters",
+            device,
+            type: ATMOSPHERE_PARAMETERS_STRUCT,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            initial_value: atmosphere.write_uniform(this.#uniform_scratch),
+        });
+
         this.#lut_transmittance = new GPUTextureContext(device);
         this.#lut_transmittance.descriptor.label = "Sky / Transmittance LUT";
         this.#lut_transmittance.descriptor.format = "rgba16float";
@@ -83,37 +138,37 @@ export class GPUSky {
         // 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.#parameters_buffer.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 });
+        debug_draw_texture({ texture: this.#lut_transmittance, x: 50, 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;
-
+        debug_draw_texture({ texture: this.#lut_multiple_scattering, x: 50, y });
     }
 
     /**
-     *
+     * Uploads any changed {@link SceneAtmosphere} parameters and rebuilds the transmittance and
+     * multiple-scattering LUTs when {@link needs_update} is true; a no-op on steady frames.
      */
     update() {
-        if (!this.#needs_update) {
+        if (!this.needs_update) {
             return;
         }
 
+        this.#parameters_buffer.upload(
+            this.#atmosphere.write_uniform(this.#uniform_scratch),
+            this.#graphics.device.queue
+        );
+
         const graph = new FrameGraph("sky update");
 
         const command_ctx = ShadeGPUCommandContext.create(
@@ -121,43 +176,45 @@ export class GPUSky {
             "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);
+        const gr_transmittance = graph.import_resource(
+            "transmittance",
+            TextureResourceDescriptor.fromTexture(this.#lut_transmittance.gpu_texture),
+            this.#lut_transmittance
+        );
+        const gr_multiscatter = graph.import_resource(
+            "multiscatter",
+            TextureResourceDescriptor.fromTexture(this.#lut_multiple_scattering.gpu_texture),
+            this.#lut_multiple_scattering
+        );
 
-        // the handle the write produced, not the one imported: binding the pre-write version below
-        // is a superseded read, which is exactly what `validate()` rejects
         const [gr_transmittance_written] = graph_image_pass({
             graph,
             shader: shader_transmittance_lut,
             inputs: {
+                atmosphere: this.#parameters_buffer.buffer,
                 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: {
+                atmosphere: this.#parameters_buffer.buffer,
                 tSkyLutTransmittance: gr_transmittance_written,
                 tSkyLutMultiscatterOut: gr_multiscatter
             }
         });
 
         command_ctx.encodeGraph(graph);
-
         command_ctx.finish();
 
-
-        this.#needs_update = false;
+        this.#committed_version = this.#atmosphere.version;
     }
 
-}
+}

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

@@ -16,5 +16,22 @@
  * @type {Readonly<SamplerDescriptor>}
  */
 export const SAMPLER_SKY_LUT: Readonly<SamplerDescriptor>;
+/**
+ * Resource declaration for `sSkyLut`, paired with {@link SKY_LUT_TRANSMITTANCE_RESOURCE} and
+ * {@link SKY_LUT_MULTISCATTER_RESOURCE}.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_SAMPLER_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Resource declaration for `tSkyLutTransmittance`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_TRANSMITTANCE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Resource declaration for `tSkyLutMultiscatter`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_MULTISCATTER_RESOURCE: ShaderResourceDescriptor;
 import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
 //# sourceMappingURL=SAMPLER_SKY_LUT.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"SAMPLER_SKY_LUT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/SAMPLER_SKY_LUT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,8BAFU,SAAS,iBAAiB,CAAC,CAOjC;AAEJ;;;;GAIG;AACH,uCAFU,wBAAwB,CAMhC;AAEF;;;GAGG;AACH,6CAFU,wBAAwB,CAKhC;AAEF;;;GAGG;AACH,4CAFU,wBAAwB,CAKhC;kCAtDgC,+CAA+C;yCACxC,gDAAgD"}

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

@@ -1,25 +1,55 @@
-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",
-}));
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.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",
+}));
+
+/**
+ * Resource declaration for `sSkyLut`, paired with {@link SKY_LUT_TRANSMITTANCE_RESOURCE} and
+ * {@link SKY_LUT_MULTISCATTER_RESOURCE}.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler(
+    "sSkyLut",
+    "filtering",
+    SAMPLER_SKY_LUT
+);
+
+/**
+ * Resource declaration for `tSkyLutTransmittance`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_TRANSMITTANCE_RESOURCE = ShaderResourceDescriptor.texture(
+    "tSkyLutTransmittance",
+    "float"
+);
+
+/**
+ * Resource declaration for `tSkyLutMultiscatter`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_MULTISCATTER_RESOURCE = ShaderResourceDescriptor.texture(
+    "tSkyLutMultiscatter",
+    "float"
+);