@woosh/meep-engine 3.50.0 → 3.52.0

package/src/shade/renderer/light/environment/resample_equirectangular_to_octahedral.js

@@ -3,14 +3,27 @@ import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D
 import { equirectangular_zenith_first_direction_to_uv } from "./equirectangular_zenith_first_direction_to_uv.js";
 import { SAMPLE_OFFSETS, SAMPLE_WEIGHTS, SUPER_SAMPLE_COUNT } from "./octahedral_resample_kernel.js";
 import { octahedral_z_pole_uv_to_direction } from "./octahedral_z_pole_uv_to_direction.js";
+import { sampler2d_octahedral_skirt_fill } from "./sampler2d_octahedral_skirt_fill.js";
 
 /**
+ * With `skirt`, the octahedral square is resampled into the interior `output_resolution - 2` texels and
+ * a one-texel octahedral skirt is written around it — the layout the renderer requires of an
+ * environment map (see `sampler2d_octahedral_skirt_fill`). Without, the square fills the whole output,
+ * which is a map the renderer will refuse.
  *
  * @param {Sampler2D} input must be a float format
- * @param {number} output_resolution
+ * @param {number} output_resolution side of the output, skirt included
+ * @param {boolean} [skirt]
+ * @returns {Sampler2D} float32 RGBA
  */
-export function resample_equirectangular_to_octahedral(input, output_resolution) {
+export function resample_equirectangular_to_octahedral(input, output_resolution, skirt = true) {
     assert.isNonNegativeInteger(output_resolution, "output_resolution");
+    assert.isBoolean(skirt, "skirt");
+
+    const border = skirt ? 1 : 0;
+    const interior = output_resolution - 2 * border;
+
+    assert.greaterThan(interior, 0, "interior resolution");
 
     const output = Sampler2D.float32(4, output_resolution, output_resolution);
 
@@ -22,8 +35,8 @@ export function resample_equirectangular_to_octahedral(input, output_resolution)
 
     const SAMPLE = new Float32Array(SUPER_SAMPLE_COUNT * 3);
 
-    for (let y = 0; y < output_resolution; y++) {
-        for (let x = 0; x < output_resolution; x++) {
+    for (let y = 0; y < interior; y++) {
+        for (let x = 0; x < interior; x++) {
 
             SAMPLE.fill(0);
             let weight_sum = 0;
@@ -36,8 +49,8 @@ export function resample_equirectangular_to_octahedral(input, output_resolution)
                 const sample_x = x + sample_offset_x;
                 const sample_y = y + sample_offset_y;
 
-                const out_u = (sample_x + 0.5) / output_resolution;
-                const out_v = (sample_y + 0.5) / output_resolution;
+                const out_u = (sample_x + 0.5) / interior;
+                const out_v = (sample_y + 0.5) / interior;
 
                 // The direction the GPU will sample this texel for — MUST be the exact inverse of
                 // uv_octahedral_unit_encode (the previous meep Y-pole decode with a negated U
@@ -69,10 +82,14 @@ export function resample_equirectangular_to_octahedral(input, output_resolution)
             for (let i = 0; i < 3; i++) {
                 const input_value = Math.max(0, SAMPLE[i] / weight_sum);
 
-                output.writeChannel(x, y, i, input_value);
+                output.writeChannel(x + border, y + border, i, input_value);
             }
         }
     }
 
+    if (skirt) {
+        sampler2d_octahedral_skirt_fill(output);
+    }
+
     return output;
 }

package/src/shade/renderer/light/environment/sampler2d_octahedral_skirt_fill.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Writes the one-texel octahedral skirt of `sampler` from its interior: every texel of the outer ring
+ * becomes a copy, all channels, of the interior texel the octahedral fold puts next to it.
+ *
+ * Environment maps carry this skirt so the GPU can filter them in hardware (see the WGSL
+ * `texture_octahedral_skirt_uv`). A producer computes the interior, `[1, size - 1)` on both axes,
+ * then calls this.
+ *
+ * @param {import("../../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D} sampler square, at least 3x3
+ */
+export function sampler2d_octahedral_skirt_fill(sampler: import("../../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D): void;
+//# sourceMappingURL=sampler2d_octahedral_skirt_fill.d.ts.map

package/src/shade/renderer/light/environment/sampler2d_octahedral_skirt_fill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler2d_octahedral_skirt_fill.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/sampler2d_octahedral_skirt_fill.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,yDAFW,OAAO,0DAA0D,EAAE,SAAS,QAmBtF"}

package/src/shade/renderer/light/environment/sampler2d_octahedral_skirt_fill.js

@@ -0,0 +1,54 @@
+import { assert } from "../../../../core/assert.js";
+import { octahedral_skirt_source_texel } from "./octahedral_skirt_source_texel.js";
+
+/**
+ * @type {Uint32Array}
+ */
+const SCRATCH_SOURCE = new Uint32Array(2);
+
+/**
+ * Writes the one-texel octahedral skirt of `sampler` from its interior: every texel of the outer ring
+ * becomes a copy, all channels, of the interior texel the octahedral fold puts next to it.
+ *
+ * Environment maps carry this skirt so the GPU can filter them in hardware (see the WGSL
+ * `texture_octahedral_skirt_uv`). A producer computes the interior, `[1, size - 1)` on both axes,
+ * then calls this.
+ *
+ * @param {import("../../../../engine/graphics/texture/sampler/Sampler2D.js").Sampler2D} sampler square, at least 3x3
+ */
+export function sampler2d_octahedral_skirt_fill(sampler) {
+    const size = sampler.width;
+
+    assert.equal(sampler.height, size, 'octahedral map must be square');
+    assert.greaterThanOrEqual(size, 3, 'a skirted map needs an interior');
+
+    const data = sampler.data;
+    const item_size = sampler.itemSize;
+    const last = size - 1;
+
+    for (let i = 0; i < size; i++) {
+        // the four sides; the corners come round twice and are written the same both times
+        copy_from_source(data, item_size, size, i, 0);
+        copy_from_source(data, item_size, size, i, last);
+        copy_from_source(data, item_size, size, 0, i);
+        copy_from_source(data, item_size, size, last, i);
+    }
+}
+
+/**
+ * @param {ArrayLike<number>} data
+ * @param {number} item_size
+ * @param {number} size
+ * @param {number} x
+ * @param {number} y
+ */
+function copy_from_source(data, item_size, size, x, y) {
+    octahedral_skirt_source_texel(SCRATCH_SOURCE, x, y, size);
+
+    const target = (y * size + x) * item_size;
+    const source = (SCRATCH_SOURCE[1] * size + SCRATCH_SOURCE[0]) * item_size;
+
+    for (let c = 0; c < item_size; c++) {
+        data[target + c] = data[source + c];
+    }
+}

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_environment_cells.d.ts

@@ -10,8 +10,8 @@
  */
 export const SH_EXP_MAX_TEXELS_PER_CELL_SIDE: number;
 /**
- * First pass of the SH-exponential encoder: integrates the octahedral environment's level 0 down to a
- * coarse octahedral grid of `cell_resolution²` cells, each a direction and its radiance times solid
+ * First pass of the SH-exponential encoder: integrates the octahedral environment's level 0 — the
+ * square inside its one-texel skirt, so no texel is counted twice — down to a coarse octahedral grid of `cell_resolution²` cells, each a direction and its radiance times solid
  * angle — the quadrature the reference reflectance is integrated over.
  *
  * Writes two `vec4` per cell into `cells`: `(direction, 0)`, then `(radiance * solid_angle, solid_angle)`.

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_environment_cells.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sh_exp_environment_cells.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_environment_cells.js"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEkC;AA0GlD;;;;;;;;;;;;;;;GAeG;AACH,8CAFU,aAAa,CAMpB;8BA/I2B,kCAAkC"}
+{"version":3,"file":"shader_sh_exp_environment_cells.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_environment_cells.js"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEkC;AA2GlD;;;;;;;;;;;;;;;GAeG;AACH,8CAFU,aAAa,CAMpB;8BAhJ2B,kCAAkC"}

package/src/shade/renderer/light/environment/sh_exponential/shader_sh_exp_environment_cells.js

@@ -59,7 +59,8 @@ fn main(
     let cell_x = cell % resolution;
     let cell_y = cell / resolution;
 
-    let source_resolution = textureDimensions(tEnvironment, 0).x;
+    // the octahedral square only: the one-texel skirt around it repeats texels already counted
+    let source_resolution = textureDimensions(tEnvironment, 0).x - 2u;
     let inverse_source_resolution = 1.0 / f32(source_resolution);
 
     // The source texels whose centres fall in this cell. A source coarser than the grid has none in
@@ -97,7 +98,7 @@ fn main(
             let uv = (vec2<f32>(texel) + 0.5) * inverse_source_resolution;
 
             let solid_angle = octahedral_solid_angle(uv, inverse_source_resolution) * f32(block_size.x * block_size.y);
-            let radiance = textureLoad(tEnvironment, texel, 0).rgb;
+            let radiance = textureLoad(tEnvironment, texel + 1u, 0).rgb;
 
             accumulated += vec4<f32>(radiance * solid_angle, solid_angle);
         }
@@ -125,8 +126,8 @@ fn main(
 ]);
 
 /**
- * First pass of the SH-exponential encoder: integrates the octahedral environment's level 0 down to a
- * coarse octahedral grid of `cell_resolution²` cells, each a direction and its radiance times solid
+ * First pass of the SH-exponential encoder: integrates the octahedral environment's level 0 — the
+ * square inside its one-texel skirt, so no texel is counted twice — down to a coarse octahedral grid of `cell_resolution²` cells, each a direction and its radiance times solid
  * angle — the quadrature the reference reflectance is integrated over.
  *
  * Writes two `vec4` per cell into `cells`: `(direction, 0)`, then `(radiance * solid_angle, solid_angle)`.

package/src/shade/renderer/light/environment/shader_convolve_reflection_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_convolve_reflection_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_convolve_reflection_map.js"],"names":[],"mappings":"AA6HA,2DAII;8BA/G0B,+BAA+B"}
+{"version":3,"file":"shader_convolve_reflection_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_convolve_reflection_map.js"],"names":[],"mappings":"AAiIA,2DAII;8BAnH0B,+BAA+B"}

package/src/shade/renderer/light/environment/shader_convolve_reflection_map.js

@@ -11,10 +11,10 @@ import {
 import { chunk_uniform_sample_cone } from "../../shader/chunk/geometry/ray/chunk_uniform_sample_cone.js";
 import { chunk_safe_rcp } from "../../shader/chunk/math/chunk_safe_rcp.js";
 import { chunk_hammersley_2d } from "../../shader/chunk/noise/chunk_hammersley_2d.js";
-import { chunk_texel_coordinate_to_uv } from "../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
 import {
-    chunk_texture_octahedral_sample_bilinear
-} from "../../shader/chunk/texture/octahedral/chunk_texture_octahedral_sample_bilinear.js";
+    chunk_texture_octahedral_skirt_texel_uv
+} from "../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_texel_uv.js";
+import { chunk_texture_octahedral_skirt_uv } from "../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -23,6 +23,7 @@ import { chunk_reflection_sample_weight } from "./chunk_reflection_sample_weight
 import { chunk_roughness_from_relative_mip } from "./chunk_roughness_from_relative_mip.js";
 import { chunk_sphere_probe_lod_to_roughness } from "./chunk_sphere_probe_lod_to_roughness.js";
 import { BSDF_ROUGHNESS_MINIMUM } from "./DEFINES.js";
+import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "./ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
@@ -32,8 +33,9 @@ const resources = new ShaderResourceSetDescriptor();
 resources.setImmediate("read_lod", "u32");
 
 resources.createGroup()
-    .addTexture("input")
+    .addTexture("input", "float")
     .addStorageTexture("output", "rgba16float")
+    .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
 ;
 
 /**
@@ -78,7 +80,8 @@ fn main(
     let mip_roughness_clamped = max(mip_roughness, ${BSDF_ROUGHNESS_MINIMUM});
     let cone_cos = cone_cosine_from_roughness(mip_roughness_clamped);
 
-    let out_uv = texel_coordinate_to_uv(vec2<f32>(output_texel_i), output_size);
+    // the skirt too: a skirt texel takes its interior twin's uv, so it is that texel, computed again
+    let out_uv = texture_octahedral_skirt_texel_uv(output_texel_i, output_size.x);
     let out_direction = uv_octahedral_unit_decode( out_uv );
 
     let basis = build_orthonormal_matrix_n(out_direction);
@@ -88,14 +91,15 @@ fn main(
 
     const sample_count = ${SAMPLE_COUNT};
 
-    let input_size = textureDimensions(input).xy;
+    let input_size = f32(textureDimensions(input).x);
 
     for (var i = 0u; i < sample_count; i++) {
         let rand = hammersley_2d(i, sample_count);
 
         let in_direction = normalize(basis * uniform_sample_cone(rand, cone_cos));
 
-        let radiance = texture_octahedral_sample_bilinear(input, vec2(0u), input_size.x, in_direction, 0);
+        let in_uv = texture_octahedral_skirt_uv(uv_octahedral_unit_encode(in_direction), input_size);
+        let radiance = textureSampleLevel(input, sEnvironment, in_uv, 0.0);
 
         let weight = reflection_sample_weight(out_direction, in_direction, mip_roughness_clamped);
 
@@ -113,10 +117,10 @@ fn main(
         chunk_build_orthonormal_matrix_n,
         chunk_safe_rcp,
         chunk_uniform_sample_cone,
-        chunk_texel_coordinate_to_uv,
+        chunk_texture_octahedral_skirt_texel_uv,
+        chunk_texture_octahedral_skirt_uv,
         chunk_uv_octahedral_unit_decode,
         chunk_uv_octahedral_unit_encode,
-        chunk_texture_octahedral_sample_bilinear,
         chunk_reflection_sample_weight,
         chunk_cone_cosine_from_roughness,
         chunk_roughness_from_relative_mip

package/src/shade/renderer/light/environment/shader_project_environment_sh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_project_environment_sh.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_project_environment_sh.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH,kCAFU,WAAW,CAEyC;AAE9D;;;;;;GAMG;AACH,0CAFU,MAAM,CAE+B;AAuF/C;;;;;;;;;;;;;;GAcG;AACH,4CAFU,aAAa,CAMpB;4BA/HyB,kCAAkC;8BAFhC,+BAA+B"}
+{"version":3,"file":"shader_project_environment_sh.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_project_environment_sh.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH,kCAFU,WAAW,CAEyC;AAE9D;;;;;;GAMG;AACH,0CAFU,MAAM,CAE+B;AAwF/C;;;;;;;;;;;;;;GAcG;AACH,4CAFU,aAAa,CAMpB;4BAjIyB,kCAAkC;8BAFhC,+BAA+B"}

package/src/shade/renderer/light/environment/shader_project_environment_sh.js

@@ -8,6 +8,7 @@ import { ComputeShader } from "../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "./ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
 
 /**
  * The layout {@link shader_project_environment_sh} writes: the environment's radiance as RGB SH2,
@@ -33,7 +34,8 @@ const resources = new ShaderResourceSetDescriptor();
 
 resources.createGroup()
     // read texel by texel (texture_octahedral_sample_bilinear), as the forward path reads it
-    .addTexture("tEnvironment")
+    .addTexture("tEnvironment", "float")
+    .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
     .addStorageBuffer("output", ENVIRONMENT_SH_TYPE, true);
 
 const body = CodeChunk.from(

package/src/shade/renderer/lightmap/bake/shader_lightmap_viz_to_irradiance_flat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_lightmap_viz_to_irradiance_flat.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/lightmap/bake/shader_lightmap_viz_to_irradiance_flat.js"],"names":[],"mappings":"AA4OA,iEASE;4BA3M0B,6BAA6B"}
+{"version":3,"file":"shader_lightmap_viz_to_irradiance_flat.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/lightmap/bake/shader_lightmap_viz_to_irradiance_flat.js"],"names":[],"mappings":"AA8OA,iEASE;4BA7M0B,6BAA6B"}

package/src/shade/renderer/lightmap/bake/shader_lightmap_viz_to_irradiance_flat.js

@@ -47,6 +47,7 @@ import { sr_create_group_RTX } from "../../geometry/sr_create_group_RTX.js";
 import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "../../volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js";
 import { wind_field_add_resources } from "../../wind/wind_field_add_resources.js";
 import { chunk_lightmap_geometry_uv_to_atlas } from "../chunk_lightmap_geometry_uv_to_atlas.js";
+import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
 
 const resources = new ShaderResourceSetDescriptor();
 sr_create_group_RTX(resources);
@@ -60,7 +61,8 @@ resources.createGroup()
 // the scene's wind, which carries the fog volumes' noise: one uniform, one texture, one sampler
 wind_field_add_resources(resources.createGroup()
     .addStorageBuffer("light_data", WebGPUArray.u32)
-    .addTexture("tEnvironment", "unfilterable-float", "2d")
+    .addTexture("tEnvironment", "float", "2d")
+    .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
     // the fog volumes' noise, read through participating_media_volume_density_at
     .addTexture("tParticipatingMediaNoise", "float", "3d")
     .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR));

package/src/shade/renderer/lightmap/bake/shader_lightmap_viz_to_sh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_lightmap_viz_to_sh.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/lightmap/bake/shader_lightmap_viz_to_sh.js"],"names":[],"mappings":"AAyOA,oDAOE;4BAxM0B,6BAA6B"}
+{"version":3,"file":"shader_lightmap_viz_to_sh.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/lightmap/bake/shader_lightmap_viz_to_sh.js"],"names":[],"mappings":"AA2OA,oDAOE;4BA1M0B,6BAA6B"}

package/src/shade/renderer/lightmap/bake/shader_lightmap_viz_to_sh.js

@@ -47,6 +47,7 @@ import { LIGHTMAP_SH_COLOR_TARGETS_DESCRIPTOR } from "./LIGHTMAP_SH_COLOR_TARGET
 import { LIGHTMAP_SH_FRAGMENT_OUTPUT } from "./LIGHTMAP_SH_FRAGMENT_OUTPUT.js";
 import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "../../volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js";
 import { wind_field_add_resources } from "../../wind/wind_field_add_resources.js";
+import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
 
 const resources = new ShaderResourceSetDescriptor();
 sr_create_group_RTX(resources);
@@ -60,7 +61,8 @@ resources.createGroup()
 // the scene's wind, which carries the fog volumes' noise: one uniform, one texture, one sampler
 wind_field_add_resources(resources.createGroup()
     .addStorageBuffer("light_data", WebGPUArray.u32)
-    .addTexture("tEnvironment", "unfilterable-float", "2d")
+    .addTexture("tEnvironment", "float", "2d")
+    .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
     // the fog volumes' noise, read through participating_media_volume_density_at
     .addTexture("tParticipatingMediaNoise", "float", "3d")
     .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR));

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#286@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#287@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_accumulating_path_tracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.js"],"names":[],"mappings":"AAoBA,2DAKG;AAmFH,4DAIG;6BA9G0B,mCAAmC;8BAOlC,+BAA+B"}
+{"version":3,"file":"shader_accumulating_path_tracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.js"],"names":[],"mappings":"AAqBA,2DAKG;AAoFH,4DAIG;6BAhH0B,mCAAmC;8BAOlC,+BAA+B"}

package/src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.js

@@ -15,6 +15,7 @@ import { MEDIA_TABLE_STRUCT } from "../../medium/MEDIA_TABLE_STRUCT.js";
 import { chunk_render_trace_path } from "../shader/chunk_render_trace_path.js";
 import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "../../volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js";
 import { wind_field_add_resources } from "../../wind/wind_field_add_resources.js";
+import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
@@ -39,7 +40,8 @@ resources.createGroup()
 // the scene's wind, which carries the fog volumes' noise: one uniform, one texture, one sampler
 wind_field_add_resources(resources.createGroup()
     .addStorageBuffer("light_data", WebGPUArray.u32)
-    .addTexture("tEnvironment", "unfilterable-float", "2d")
+    .addTexture("tEnvironment", "float", "2d")
+    .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
     // the fog volumes' noise, read through participating_media_volume_density_at
     .addTexture("tParticipatingMediaNoise", "float", "3d")
     .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR));

package/src/shade/renderer/path_tracer/graph_path_trace_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_path_trace_scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/path_tracer/graph_path_trace_scene.js"],"names":[],"mappings":"AAwGA;;;;;;GAMG;AACH;IAJ+B,KAAK;IACD,IAAI;IAC1B,MAAM,CAyFlB"}
+{"version":3,"file":"graph_path_trace_scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/path_tracer/graph_path_trace_scene.js"],"names":[],"mappings":"AA0GA;;;;;;GAMG;AACH;IAJ+B,KAAK;IACD,IAAI;IAC1B,MAAM,CAyFlB"}

package/src/shade/renderer/path_tracer/graph_path_trace_scene.js

@@ -18,6 +18,7 @@ import { MEDIA_TABLE_STRUCT } from "../medium/MEDIA_TABLE_STRUCT.js";
 import { chunk_render_trace_path } from "./shader/chunk_render_trace_path.js";
 import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "../volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js";
 import { wind_field_add_resources } from "../wind/wind_field_add_resources.js";
+import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
 
 const RAY_TRACING_UNIFORMS_STRUCT = WebGPUStruct.from({
     random_seed: u32
@@ -35,7 +36,8 @@ resources.createGroup()
 // the scene's wind, which carries the fog volumes' noise: one uniform, one texture, one sampler
 wind_field_add_resources(resources.createGroup()
     .addStorageBuffer("light_data", WebGPUArray.u32)
-    .addTexture("tEnvironment", "unfilterable-float", "2d")
+    .addTexture("tEnvironment", "float", "2d")
+    .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
     // the fog volumes' noise, read through participating_media_volume_density_at
     .addTexture("tParticipatingMediaNoise", "float", "3d")
     .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR));

package/src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js

@@ -236,7 +236,7 @@ fn render_trace_path(
         if(hit.t <= 0.0){
             // didn't hit anything
             
-            var environment_sample = sample_environment_color(tEnvironment, ray.direction);
+            var environment_sample = sample_environment_color(tEnvironment, sEnvironment, ray.direction);
             
             let env_luma = rgb_to_luminance(environment_sample);
             

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#200@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#201@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr_resolve_shader.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js"],"names":[],"mappings":"AA+VA;;;;;;;GAOG;AACH,iCAFU,WAAW,CAgBlB;4BAlWyB,gCAAgC"}
+{"version":3,"file":"ssr_resolve_shader.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js"],"names":[],"mappings":"AAiWA;;;;;;;GAOG;AACH,iCAFU,WAAW,CAgBlB;4BApWyB,gCAAgC"}

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js

@@ -31,6 +31,7 @@ import { BLACK_PIXEL_TEXTURE } from "../../../texture/util/BLACK_PIXEL_TEXTURE.j
 import { ZERO_UINT_PIXEL_TEXTURE } from "../../../texture/util/ZERO_UINT_PIXEL_TEXTURE.js";
 import { chunk_ssr_add_hit_irradiance } from "./chunk_ssr_add_hit_irradiance.js";
 import { chunk_ssr_sample_radiance } from "./chunk_ssr_sample_radiance.js";
+import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
 
 const RESOLVE_UNIFORMS = WebGPUStruct.from({
     frame_index: u32,
@@ -43,7 +44,8 @@ const resources = new ShaderResourceSetDescriptor();
 // the noise that jitters them, and the light probe volume. The pass binds only the running mode's, and each
 // mode's source has a default for the others: black textures, transient buffers, a volume of no probes.
 resources.createGroup()
-    .addTexture("tEnvironment")
+    .addTexture("tEnvironment", "float")
+    .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
     .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false, true)
     .addTexture("tSTBN_vec2", "unfilterable-float", "3d")
     .addTexture("lpv_atlas_radiance", "uint", "2d", false, ZERO_UINT_PIXEL_TEXTURE)

package/src/shade/renderer/rasterize/native/avboit/AVBOIT_CONSTANTS.d.ts

@@ -77,11 +77,6 @@ export const AVBOIT_EXTINCTION_SCALE: number;
  * @type {number}
  */
 export const AVBOIT_FIELD_BITS: number;
-/**
- * Field mask.
- * @type {number}
- */
-export const AVBOIT_FIELD_MASK: number;
 /**
  * How far toward the camera, in virtual slices, the draw pass samples the integral so that a surface
  * does not occlude itself through its own linear splat. With the exclusive-prefix storage convention

package/src/shade/renderer/rasterize/native/avboit/AVBOIT_CONSTANTS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AVBOIT_CONSTANTS.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOIT_CONSTANTS.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,qCAFU,MAAM,CAE0B;AAE1C;;;;;;;;;;;;;;;;GAgBG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,qCAFU,MAAM,CAEqD;AAErE;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;;;GAMG;AACH,6CAFU,MAAM,CAEkC;AAElD;;;;;;GAMG;AACH,oCAFU,MAAM,CAEmC;AAEnD;;;;;;;;;;;GAWG;AACH,2CAFU,MAAM,CAEoC;AAEpD;;;;GAIG;AACH,sCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,gCAFU,MAAM,CAEoB;AAEpC;;;GAGG;AACH,gCAFU,MAAM,CAE8C;AAE9D;;;;;;;;GAQG;AACH,wCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,sDAAmD;AAEnD;;;GAGG;AACH,8CAFU,MAAM,CAEiC"}
+{"version":3,"file":"AVBOIT_CONSTANTS.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOIT_CONSTANTS.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,qCAFU,MAAM,CAE0B;AAE1C;;;;;;;;;;;;;;;;GAgBG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,qCAFU,MAAM,CAEqD;AAErE;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;;;GAMG;AACH,6CAFU,MAAM,CAEkC;AAElD;;;;;;GAMG;AACH,oCAFU,MAAM,CAEmC;AAEnD;;;;;;;;;;;GAWG;AACH,2CAFU,MAAM,CAEoC;AAEpD;;;;GAIG;AACH,sCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,gCAFU,MAAM,CAEoB;AAEpC;;;;;;;;GAQG;AACH,wCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,sDAAmD;AAEnD;;;GAGG;AACH,8CAFU,MAAM,CAEiC"}

package/src/shade/renderer/rasterize/native/avboit/AVBOIT_CONSTANTS.js

@@ -87,12 +87,6 @@ export const AVBOIT_EXTINCTION_SCALE = 255;
  */
 export const AVBOIT_FIELD_BITS = 10;
 
-/**
- * Field mask.
- * @type {number}
- */
-export const AVBOIT_FIELD_MASK = (1 << AVBOIT_FIELD_BITS) - 1;
-
 /**
  * How far toward the camera, in virtual slices, the draw pass samples the integral so that a surface
  * does not occlude itself through its own linear splat. With the exclusive-prefix storage convention

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_counts_to_extinction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_avboit_counts_to_extinction.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_counts_to_extinction.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,gDAFU,SAAS,CASjB;0BAhBwB,uCAAuC"}
+{"version":3,"file":"chunk_avboit_counts_to_extinction.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_counts_to_extinction.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,gDAFU,SAAS,CASjB;0BAnBwB,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_counts_to_extinction.js

@@ -1,6 +1,9 @@
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { AVBOIT_EXTINCTION_SCALE } from "./AVBOIT_CONSTANTS.js";
 
+
+const AVBOIT_EXTINCTION_SCALE_INV = 1.0 / AVBOIT_EXTINCTION_SCALE;
+
 /**
  * Accumulated counts back to normalized extinction. Not clamped: a field that summed past 255 reads
  * above 1.0 here and saturates in the integration, which is where the running value is kept.
@@ -11,7 +14,7 @@ export const chunk_avboit_counts_to_extinction = CodeChunk.from(
     //language=WGSL
     `
 fn avboit_counts_to_extinction(counts: vec3<u32>) -> vec3<f32> {
-    return vec3<f32>(counts) / ${AVBOIT_EXTINCTION_SCALE}.0;
+    return vec3<f32>(counts) * ${AVBOIT_EXTINCTION_SCALE_INV};
 }
     `
 );

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA2DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8TAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAqM7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IAxB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGC,eAAe,GAAzC,eAAe;IAGU,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAkTlB;+BAz8B8B,qBAAqB;gCAIpB,6CAA6C"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8TAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAuM7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IAxB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGC,eAAe,GAAzC,eAAe;IAGU,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAkTlB;+BA38B8B,qBAAqB;gCAIpB,6CAA6C"}

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js

@@ -13,6 +13,7 @@ import { graph_import_texture } from "../../../shader/graph/graph_import_texture
 import {
     SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR
 } from "../../../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
+import { ENVIRONMENT_MAP_SAMPLER_DESCRIPTOR } from "../../../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../../../STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { rasterization_material_bucket } from "../../expand/bucket/chunk_rasterization_material_bucket.js";
 import { construct_primitive_state } from "../../bucket/construct_primitive_state.js";
@@ -518,12 +519,14 @@ export function graph_avboit_draw({
         ));
 
         const sampler_shadowmap = graphics.samplers.obtain(SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR);
+        const sampler_environment = graphics.samplers.obtain(ENVIRONMENT_MAP_SAMPLER_DESCRIPTOR);
 
         const light_bindings = bind_manager.obtain(BindGroupDescriptor.from(
             FORWARD_LIGHT_LAYOUT,
             [
                 { buffer: view_ctx.scene.lights.buffer_data },
                 view_ctx.scene.lights.environment.obtainView(),
+                sampler_environment,
                 //
                 { buffer: light_cluster_parameters },
                 { buffer: light_cluster_lookup },

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AAuYA;;;;;;;;;;;;;;;;;GAiBG;AACH,gSAFa,MAAM,CAyOlB"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AA0YA;;;;;;;;;;;;;;;;;GAiBG;AACH,gSAFa,MAAM,CAyOlB"}

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js

@@ -11,6 +11,7 @@ import { graph_import_texture } from "../../../shader/graph/graph_import_texture
 import {
     SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR
 } from "../../../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
+import { ENVIRONMENT_MAP_SAMPLER_DESCRIPTOR } from "../../../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../../../STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { rasterization_material_bucket } from "../../expand/bucket/chunk_rasterization_material_bucket.js";
 import { construct_primitive_state } from "../../bucket/construct_primitive_state.js";
@@ -129,12 +130,14 @@ function graph_oit_resolve_moments({
         ));
 
         const sampler_shadowmap = context.graphics.samplers.obtain(SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR);
+        const sampler_environment = context.graphics.samplers.obtain(ENVIRONMENT_MAP_SAMPLER_DESCRIPTOR);
 
         const light_bindings = bind_manager.obtain(BindGroupDescriptor.from(
             FORWARD_LIGHT_LAYOUT,
             [
                 { buffer: view_ctx.scene.lights.buffer_data },
                 view_ctx.scene.lights.environment.obtainView(),
+                sampler_environment,
                 //
                 { buffer: light_cluster_parameters },
                 { buffer: light_cluster_lookup },