@woosh/meep-engine 3.11.2 → 3.12.0

package/src/shade/renderer/animation/skinning/shader_skin_matrix_prep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_skin_matrix_prep.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_skin_matrix_prep.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,gCAAiC;AAiEjC;;;;;;;;;;;;;;;;GAgBG;AACH,oDAKG;8BApG2B,+BAA+B"}
+{"version":3,"file":"shader_skin_matrix_prep.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_skin_matrix_prep.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,gCAAiC;AAiEjC;;;;;;;;;;;;;;;;GAgBG;AACH,oDAIG;8BAnG2B,+BAA+B"}

package/src/shade/renderer/animation/skinning/shader_skin_matrix_prep.js

@@ -1,105 +1,104 @@
-import { mat4x4f, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { ANIMATION_DATABASE_SPEC } from "../ANIMATION_DATABASE_SPEC.js";
-
-const SKIN_JOINT_BLOCK_TABLE = ANIMATION_DATABASE_SPEC.get('animation_skin_joint_blocks');
-
-/**
- * Workgroup size for the skin-matrix-prep pass. Exported so dispatchers
- * can pair it with
- * `animation_skin_joint_blocks.dispatch_group_count(WORKGROUP_SIZE)` —
- * the page iterator's slot-to-workgroup mapping is computed against
- * this value, so the two must agree.
- */
-export const WORKGROUP_SIZE = 64;
-
-const PG_PREFIX = SKIN_JOINT_BLOCK_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE);
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer('animation_database', WebGPUArray.from(u32), false)
-    .addStorageBuffer('scene_database', WebGPUArray.from(u32), false)
-    .addStorageBuffer('skin_matrices', WebGPUArray.from(mat4x4f), true);
-
-// One thread per joint-block slot — page iterator handles allocation/
-// occupancy. Each thread loads its block, then walks its inline joints
-// in a bounded inner loop. The block carries the absolute write
-// offset into `skin_matrices` (baked at registration time), so there's
-// no indirection back through the skin record.
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
-fn main(
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(local_invocation_index) local_id: u32,
-) {
-    if !${PG_PREFIX}_setup(&animation_database, wg_id.x, local_id) {
-        return;
-    }
-
-    let slot_in_page = ${PG_PREFIX}_slot_in_page(local_id);
-
-    if slot_in_page >= ${PG_PREFIX}_ELEMENTS_PER_PAGE {
-        return;
-    }
-    if !${PG_PREFIX}_is_occupied(slot_in_page) {
-        return;
-    }
-
-    let block = ${PG_PREFIX}_read(&animation_database, slot_in_page);
-
-    // Per-joint skin matrix is just joint-world × inverse-bind. The
-    // inverse-bind already takes a vertex from mesh-local space into
-    // joint-bind-local, so joint.global brings the deformed vertex
-    // back into world. The rasterizer then re-applies
-    // mesh.transform_global to the clone vertex (same path used for
-    // every other mesh's vertices, see chunk_mesh_resolve_vertex_
-    // position_world.js) — so any mesh-node factor in this formula
-    // would double-cancel against that re-application and shrink the
-    // rig back to mesh-local coordinates rendered as world. Keeping
-    // the formula minimal lets the SkinnedMesh sit at any transform
-    // in the scene graph and still render correctly via the standard
-    // mesh transform path.
-
-    for(var i = 0u; i < block.count; i++){
-        let joint = block.joints[i];
-        let node = scene_read_node(&scene_database, joint.node);
-
-        skin_matrices[block.skin_matrix_offset + i] =
-            node.global * joint.inverse_bind;
-    }
-}
-`, [
-        SKIN_JOINT_BLOCK_TABLE.chunk_iterate(WORKGROUP_SIZE),
-        chunk_scene_database_access,
-    ]
-);
-
-/**
- * Compute shader that walks the `animation_skin_joint_blocks` table —
- * one thread per joint-block slot via the page iterator — and writes
- * each joint's per-frame skinning matrix `node.global * inverse_bind`
- * to the shared `skin_matrices` scratch buffer at the block's pre-baked
- * absolute offset.
- *
- * Run after `graph_scene_update_transform_hierarchy` (so each joint's
- * `node.global` is up to date) and before any pass that consumes the
- * skin matrices (the pre-skinning compute pass).
- *
- * Dispatch via
- * `shader_skin_matrix_prep.dispatch({ group_count_x: animation_skin_joint_blocks.dispatch_group_count(WORKGROUP_SIZE), ... })`.
- * Skip the dispatch when `group_count_x === 0` — no skins registered
- * means the iterator has no work and `skin_matrices_buffer` may be
- * `null` on the manager.
- */
-export const shader_skin_matrix_prep = ComputeShader.from({
-    label: "Animation/SkinMatrixPrep",
-    body,
-    resources,
-    group_size: [WORKGROUP_SIZE, 1, 1],
-});
+import { mat4x4f, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ANIMATION_DATABASE_SPEC } from "../ANIMATION_DATABASE_SPEC.js";
+
+const SKIN_JOINT_BLOCK_TABLE = ANIMATION_DATABASE_SPEC.get('animation_skin_joint_blocks');
+
+/**
+ * Workgroup size for the skin-matrix-prep pass. Exported so dispatchers
+ * can pair it with
+ * `animation_skin_joint_blocks.dispatch_group_count(WORKGROUP_SIZE)` —
+ * the page iterator's slot-to-workgroup mapping is computed against
+ * this value, so the two must agree.
+ */
+export const WORKGROUP_SIZE = 64;
+
+const PG_PREFIX = SKIN_JOINT_BLOCK_TABLE.page_iterator_symbol_prefix(WORKGROUP_SIZE);
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer('animation_database', WebGPUArray.from(u32), false)
+    .addStorageBuffer('scene_database', WebGPUArray.from(u32), false)
+    .addStorageBuffer('skin_matrices', WebGPUArray.from(mat4x4f), true);
+
+// One thread per joint-block slot — page iterator handles allocation/
+// occupancy. Each thread loads its block, then walks its inline joints
+// in a bounded inner loop. The block carries the absolute write
+// offset into `skin_matrices` (baked at registration time), so there's
+// no indirection back through the skin record.
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${WORKGROUP_SIZE},1,1)
+fn main(
+    @builtin(workgroup_id) wg_id: vec3<u32>,
+    @builtin(local_invocation_index) local_id: u32,
+) {
+    if !${PG_PREFIX}_setup(&animation_database, wg_id.x, local_id) {
+        return;
+    }
+
+    let slot_in_page = ${PG_PREFIX}_slot_in_page(local_id);
+
+    if slot_in_page >= ${PG_PREFIX}_ELEMENTS_PER_PAGE {
+        return;
+    }
+    if !${PG_PREFIX}_is_occupied(slot_in_page) {
+        return;
+    }
+
+    let block = ${PG_PREFIX}_read(&animation_database, slot_in_page);
+
+    // Per-joint skin matrix is just joint-world × inverse-bind. The
+    // inverse-bind already takes a vertex from mesh-local space into
+    // joint-bind-local, so joint.global brings the deformed vertex
+    // back into world. The rasterizer then re-applies
+    // mesh.transform_global to the clone vertex (same path used for
+    // every other mesh's vertices, see chunk_mesh_resolve_vertex_
+    // position_world.js) — so any mesh-node factor in this formula
+    // would double-cancel against that re-application and shrink the
+    // rig back to mesh-local coordinates rendered as world. Keeping
+    // the formula minimal lets the SkinnedMesh sit at any transform
+    // in the scene graph and still render correctly via the standard
+    // mesh transform path.
+
+    for(var i = 0u; i < block.count; i++){
+        let joint = block.joints[i];
+        let node = scene_read_node(&scene_database, joint.node);
+
+        skin_matrices[block.skin_matrix_offset + i] =
+            node.global * joint.inverse_bind;
+    }
+}
+`, [
+        SKIN_JOINT_BLOCK_TABLE.chunk_iterate(WORKGROUP_SIZE),
+        chunk_scene_database_access,
+    ]
+);
+
+/**
+ * Compute shader that walks the `animation_skin_joint_blocks` table —
+ * one thread per joint-block slot via the page iterator — and writes
+ * each joint's per-frame skinning matrix `node.global * inverse_bind`
+ * to the shared `skin_matrices` scratch buffer at the block's pre-baked
+ * absolute offset.
+ *
+ * Run after `graph_scene_update_transform_hierarchy` (so each joint's
+ * `node.global` is up to date) and before any pass that consumes the
+ * skin matrices (the pre-skinning compute pass).
+ *
+ * Dispatch via
+ * `shader_skin_matrix_prep.dispatch({ group_count_x: animation_skin_joint_blocks.dispatch_group_count(WORKGROUP_SIZE), ... })`.
+ * Skip the dispatch when `group_count_x === 0` — no skins registered
+ * means the iterator has no work and `skin_matrices_buffer` may be
+ * `null` on the manager.
+ */
+export const shader_skin_matrix_prep = ComputeShader.from({
+    label: "Animation/SkinMatrixPrep",
+    body,
+    resources,
+});

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",
+}));