@woosh/meep-engine 3.50.0 → 3.52.0

package/src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_tonemap_ue_filmic.js

@@ -0,0 +1,163 @@
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+import { chunk_aces_ue_matrices } from "./chunk_aces_ue_matrices.js";
+
+/**
+ * Unreal Engine's default SDR tone mapping, "Filmic", with every setting at its default.
+ *
+ * A line-for-line port of UE 5.4's `CombineLUTsCommon` (PostProcessCombineLUTs.usf) for the sRGB output device and
+ * `FilmToneMap` (TonemapCommon.ush), as UE evaluates them into its colour grading LUT, here evaluated per pixel:
+ *
+ * 1. into ACEScg (AP1) from UE's default sRGB working space;
+ * 2. Expand Gamut at its default 1.0, which pushes bright saturated colours toward wider primaries;
+ * 3. the colour corrections at their defaults, which only clamp AP1 at zero;
+ * 4. Blue Correction at its default 0.6, a matrix that turns bright blue toward cyan rather than violet, before the
+ *    curve, and its inverse after;
+ * 5. `FilmToneMap` with Slope 0.88, Toe 0.55, Shoulder 0.26, Black Clip 0 and White Clip 0.04 (`FPostProcessSettings`'
+ *    defaults, Scene.cpp). It is the ACES reference rendering's glow and red modifier and its 0.96 desaturation, then a
+ *    parametric toe-straight-shoulder curve on log10 of each AP1 channel, solved so that 0.18 comes out at 0.18, then a
+ *    0.93 desaturation;
+ * 6. back to the working space, clamped at zero, and clipped at 1 as the sRGB target clips it.
+ *
+ * UE 5.8 keeps Filmic as its default method and its SDR output unchanged. What it does on an HDR display is in
+ * shader_tonemap_HDR_aces.
+ *
+ * Where UE divides 0 by 0 (gamut expansion of black) or takes log10(0), this takes the limit, so black stays black.
+ * UE's LUT also limits its input to 43.7, the top of its log encoding; this does not, which moves a few saturated
+ * highlights over 43.7 by a few codes.
+ *
+ * Input: exposed linear Rec.709. Output: display-linear Rec.709 in [0, 1].
+ *
+ * @see "Color Grading and the Filmic Tonemapper in Unreal Engine", Epic Games
+ * @type {CodeChunk}
+ */
+export const chunk_tonemap_ue_filmic = CodeChunk.from(
+    //language=WGSL
+    `
+const UE_FILM_SLOPE: f32 = 0.88;
+const UE_FILM_TOE: f32 = 0.55;
+const UE_FILM_SHOULDER: f32 = 0.26;
+const UE_FILM_BLACK_CLIP: f32 = 0.0;
+const UE_FILM_WHITE_CLIP: f32 = 0.04;
+const UE_BLUE_CORRECTION: f32 = 0.6;
+const UE_EXPAND_GAMUT_AMOUNT: f32 = 1.0;
+
+fn ue_film_saturation(rgb: vec3<f32>) -> f32 {
+    let lowest = min(rgb.r, min(rgb.g, rgb.b));
+    let highest = max(rgb.r, max(rgb.g, rgb.b));
+    return (max(highest, 1e-10) - max(lowest, 1e-10)) / max(highest, 1e-2);
+}
+
+// a luminance proxy for the glow: Y plus 1.75 of the chroma
+fn ue_film_yc(rgb: vec3<f32>) -> f32 {
+    let chroma = sqrt(max(rgb.b * (rgb.b - rgb.g) + rgb.g * (rgb.g - rgb.r) + rgb.r * (rgb.r - rgb.b), 0.0));
+    return (rgb.b + rgb.g + rgb.r + 1.75 * chroma) / 3.0;
+}
+
+fn ue_film_glow(yc: f32, gain: f32, mid: f32) -> f32 {
+    if (yc <= 2.0 / 3.0 * mid) {
+        return gain;
+    }
+    if (yc >= 2.0 * mid) {
+        return 0.0;
+    }
+    return gain * (mid / yc - 0.5);
+}
+
+fn ue_film_sigmoid(x: f32) -> f32 {
+    let t = max(1.0 - abs(0.5 * x), 0.0);
+    return 0.5 * (1.0 + sign(x) * (1.0 - t * t));
+}
+
+// geometric hue in degrees, [0, 360]; 0 for a neutral
+fn ue_film_hue(rgb: vec3<f32>) -> f32 {
+    if (rgb.r == rgb.g && rgb.g == rgb.b) {
+        return 0.0;
+    }
+    var hue = atan2(1.7320508075688772 * (rgb.g - rgb.b), 2.0 * rgb.r - rgb.g - rgb.b) * 57.29577951308232;
+    if (hue < 0.0) {
+        hue += 360.0;
+    }
+    return clamp(hue, 0.0, 360.0);
+}
+
+// FilmToneMap: AP1 in, AP1 out
+fn ue_film_tone_map(color_ap1: vec3<f32>) -> vec3<f32> {
+    var aces = UE_AP1_TO_AP0 * color_ap1;
+
+    // the reference rendering's glow
+    let saturation = ue_film_saturation(aces);
+    let yc = ue_film_yc(aces);
+    let s = ue_film_sigmoid((saturation - 0.4) / 0.2);
+    aces *= 1.0 + ue_film_glow(yc, 0.05 * s, 0.08);
+
+    // and its red modifier
+    var centered_hue = ue_film_hue(aces);
+    if (centered_hue > 180.0) {
+        centered_hue -= 360.0;
+    }
+    let hue_weight = smoothstep(0.0, 1.0, 1.0 - abs(2.0 * centered_hue / 135.0));
+    aces.r += hue_weight * hue_weight * saturation * (0.03 - aces.r) * (1.0 - 0.82);
+
+    var color = max(vec3<f32>(0.0), UE_AP0_TO_AP1 * aces);
+
+    // pre-desaturate
+    color = mix(vec3<f32>(dot(color, UE_AP1_LUMINANCE)), color, 0.96);
+
+    let toe_scale = 1.0 + UE_FILM_BLACK_CLIP - UE_FILM_TOE;
+    let shoulder_scale = 1.0 + UE_FILM_WHITE_CLIP - UE_FILM_SHOULDER;
+
+    // 0.18 in, 0.18 out, on the toe because the toe is under 0.8
+    let bt = (0.18 + UE_FILM_BLACK_CLIP) / toe_scale - 1.0;
+    let toe_match = log2(0.18) * 0.30102999566398120 - 0.5 * log((1.0 + bt) / (1.0 - bt)) * (toe_scale / UE_FILM_SLOPE);
+    let straight_match = (1.0 - UE_FILM_TOE) / UE_FILM_SLOPE - toe_match;
+    let shoulder_match = UE_FILM_SHOULDER / UE_FILM_SLOPE - straight_match;
+
+    // log10; the floor stands in for log10(0) = -inf, which the toe takes to 0 either way
+    let log_color = log2(max(color, vec3<f32>(1e-10))) * 0.30102999566398120;
+
+    let straight = UE_FILM_SLOPE * (log_color + straight_match);
+
+    var toe = -UE_FILM_BLACK_CLIP + (2.0 * toe_scale) / (1.0 + exp((-2.0 * UE_FILM_SLOPE / toe_scale) * (log_color - toe_match)));
+    var shoulder = (1.0 + UE_FILM_WHITE_CLIP) - (2.0 * shoulder_scale) / (1.0 + exp((2.0 * UE_FILM_SLOPE / shoulder_scale) * (log_color - shoulder_match)));
+
+    toe = select(straight, toe, log_color < vec3<f32>(toe_match));
+    shoulder = select(straight, shoulder, log_color > vec3<f32>(shoulder_match));
+
+    var t = saturate((log_color - toe_match) / (shoulder_match - toe_match));
+    if (shoulder_match < toe_match) {
+        t = 1.0 - t;
+    }
+    t = (3.0 - 2.0 * t) * t * t;
+
+    var tone = mix(toe, shoulder, t);
+
+    // post-desaturate
+    tone = mix(vec3<f32>(dot(tone, UE_AP1_LUMINANCE)), tone, 0.93);
+
+    return max(vec3<f32>(0.0), tone);
+}
+
+fn tonemap_ue_filmic(color_rec709: vec3<f32>) -> vec3<f32> {
+    // the scene from zero up, as UE's LUT encodes it
+    var color = UE_REC709_TO_AP1 * max(color_rec709, vec3<f32>(0.0));
+
+    // Expand Gamut. Black has no chroma to expand, and UE's 0 / 0 there comes out as black too
+    let luma = dot(color, UE_AP1_LUMINANCE);
+    if (luma > 0.0) {
+        let chroma = color / luma - 1.0;
+        let amount = (1.0 - exp2(-4.0 * dot(chroma, chroma))) * (1.0 - exp2(-4.0 * UE_EXPAND_GAMUT_AMOUNT * luma * luma));
+        color = mix(color, UE_EXPAND_GAMUT * color, amount);
+    }
+
+    // the colour corrections at their defaults
+    color = max(color, vec3<f32>(0.0));
+
+    color = mix(color, UE_BLUE_CORRECT * color, UE_BLUE_CORRECTION);
+    color = ue_film_tone_map(color);
+    color = mix(color, UE_BLUE_CORRECT_INVERSE * color, UE_BLUE_CORRECTION);
+
+    return min(max(vec3<f32>(0.0), UE_AP1_TO_REC709 * color), vec3<f32>(1.0));
+}
+`,
+    [chunk_aces_ue_matrices]
+);

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.d.ts

@@ -1,11 +1,18 @@
+/**
+ * The paper white, cd/m², for the CPU side of a pass that needs it: {@link chunk_PAPER_WHITE_NITS} is this number in
+ * WGSL.
+ *
+ * @type {number}
+ */
+export const PAPER_WHITE_NITS: number;
 /**
  * The luminance an exposed scene value of 1.0 is shown at, in cd/m², on every display and in every tone mapping mode.
  * It is where the canvas puts SDR white: 1.0 on an SDR output, and 1.0 of extended Display P3 on an HDR one, so an HDR
  * pass's headroom is the display's peak over this.
  *
- * The value is the SDR paper white of GT7's sample code, `GRAN_TURISMO_SDR_PAPER_WHITE`. Polyphony tuned the curve's
- * parameters under this assumption; their sample code accepts no HDR peak below it. The GT7 passes give it to
- * `tonemap_gt7` as the paper white, and the SDR pass also as the peak, which is the sample code's SDR mode.
+ * The value is ITU-R BT.2408's graphics white, 203. GT7's sample code assumes 250 (`GRAN_TURISMO_SDR_PAPER_WHITE`) and
+ * accepts no HDR peak below that. The GT7 passes give this to `tonemap_gt7` as the paper white, and the SDR pass also as
+ * the peak, which is the sample code's SDR mode. The ACES HDR pass expands its SDR picture by the headroom over it.
  *
  * It is one constant rather than an argument for each pass, so the SDR and HDR outputs cannot drift apart.
  *

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_PAPER_WHITE_NITS.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,qCAFU,SAAS,CAOjB;0BArBwB,gCAAgC"}
+{"version":3,"file":"chunk_PAPER_WHITE_NITS.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,+BAFU,MAAM,CAEoB;AAEpC;;;;;;;;;;;;;GAaG;AACH,qCAFU,SAAS,CAOjB;0BA7BwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js

@@ -1,13 +1,21 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 
+/**
+ * The paper white, cd/m², for the CPU side of a pass that needs it: {@link chunk_PAPER_WHITE_NITS} is this number in
+ * WGSL.
+ *
+ * @type {number}
+ */
+export const PAPER_WHITE_NITS = 203;
+
 /**
  * The luminance an exposed scene value of 1.0 is shown at, in cd/m², on every display and in every tone mapping mode.
  * It is where the canvas puts SDR white: 1.0 on an SDR output, and 1.0 of extended Display P3 on an HDR one, so an HDR
  * pass's headroom is the display's peak over this.
  *
- * The value is the SDR paper white of GT7's sample code, `GRAN_TURISMO_SDR_PAPER_WHITE`. Polyphony tuned the curve's
- * parameters under this assumption; their sample code accepts no HDR peak below it. The GT7 passes give it to
- * `tonemap_gt7` as the paper white, and the SDR pass also as the peak, which is the sample code's SDR mode.
+ * The value is ITU-R BT.2408's graphics white, 203. GT7's sample code assumes 250 (`GRAN_TURISMO_SDR_PAPER_WHITE`) and
+ * accepts no HDR peak below that. The GT7 passes give this to `tonemap_gt7` as the paper white, and the SDR pass also as
+ * the peak, which is the sample code's SDR mode. The ACES HDR pass expands its SDR picture by the headroom over it.
  *
  * It is one constant rather than an argument for each pass, so the SDR and HDR outputs cannot drift apart.
  *
@@ -17,6 +25,6 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
 export const chunk_PAPER_WHITE_NITS = CodeChunk.from(
     //language=WGSL
     `
-const PAPER_WHITE_NITS: f32 = 250.0;
+const PAPER_WHITE_NITS: f32 = ${PAPER_WHITE_NITS};
 `
 );

package/src/shade/renderer/shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_texel_uv.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The octahedral uv a texel of a skirted level carries: its own centre for an interior texel, and
+ * for a skirt texel the centre of the interior texel the octahedral fold mirrors it onto.
+ *
+ * A pass that writes a skirted level computes every texel, skirt included, from this uv. A skirt
+ * texel then runs the exact computation its interior twin runs, so the two are bit-identical rather
+ * than equal to rounding — which is what lets a hardware bilinear sample across the edge match a
+ * manual wrap.
+ *
+ * @see chunk_texture_octahedral_skirt_uv for the layout
+ * @type {CodeChunk}
+ */
+export const chunk_texture_octahedral_skirt_texel_uv: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_texture_octahedral_skirt_texel_uv.d.ts.map

package/src/shade/renderer/shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_texel_uv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_texture_octahedral_skirt_texel_uv.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_texel_uv.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,sDAFU,SAAS,CAahB;0BA1BuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_texel_uv.js

@@ -0,0 +1,27 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_texture_octahedral_wrap_texel_coordinates } from "./chunk_texture_octahedral_wrap_texel_coordinates.js";
+
+/**
+ * The octahedral uv a texel of a skirted level carries: its own centre for an interior texel, and
+ * for a skirt texel the centre of the interior texel the octahedral fold mirrors it onto.
+ *
+ * A pass that writes a skirted level computes every texel, skirt included, from this uv. A skirt
+ * texel then runs the exact computation its interior twin runs, so the two are bit-identical rather
+ * than equal to rounding — which is what lets a hardware bilinear sample across the edge match a
+ * manual wrap.
+ *
+ * @see chunk_texture_octahedral_skirt_uv for the layout
+ * @type {CodeChunk}
+ */
+export const chunk_texture_octahedral_skirt_texel_uv = CodeChunk.from(
+    //language=WGSL
+    `
+fn texture_octahedral_skirt_texel_uv(texel: vec2<u32>, texture_size: u32) -> vec2<f32> {
+    let interior = i32(texture_size) - 2;
+    let source = texture_octahedral_wrap_texel_coordinates(vec2<i32>(texel) - 1, interior);
+
+    return (vec2<f32>(source) + 0.5) / f32(interior);
+}
+`, [
+    chunk_texture_octahedral_wrap_texel_coordinates,
+]);

package/src/shade/renderer/shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Where an octahedral uv lands in one level of a skirted octahedral texture.
+ *
+ * A skirted level of side `texture_size` holds the octahedral square in its interior texels
+ * `[1, texture_size - 1)` and a one-texel skirt around it, each skirt texel a copy of the interior
+ * texel the octahedral fold puts next to it. With the skirt there, the hardware's bilinear footprint
+ * at the edge of the square reads exactly the texels a manual wrap would, so one filtered sample
+ * replaces four loads and their wraps.
+ *
+ * The interior is `texture_size - 2` texels, not half of the level above's, so a level's uv is its
+ * own: sample each level through its own size.
+ *
+ * @see chunk_texture_octahedral_skirt_texel_uv for the inverse, from a skirted texel to the uv it carries
+ * @type {CodeChunk}
+ */
+export const chunk_texture_octahedral_skirt_uv: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_texture_octahedral_skirt_uv.d.ts.map

package/src/shade/renderer/shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_texture_octahedral_skirt_uv.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,gDAFU,SAAS,CAQhB;0BAvBuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js

@@ -0,0 +1,24 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Where an octahedral uv lands in one level of a skirted octahedral texture.
+ *
+ * A skirted level of side `texture_size` holds the octahedral square in its interior texels
+ * `[1, texture_size - 1)` and a one-texel skirt around it, each skirt texel a copy of the interior
+ * texel the octahedral fold puts next to it. With the skirt there, the hardware's bilinear footprint
+ * at the edge of the square reads exactly the texels a manual wrap would, so one filtered sample
+ * replaces four loads and their wraps.
+ *
+ * The interior is `texture_size - 2` texels, not half of the level above's, so a level's uv is its
+ * own: sample each level through its own size.
+ *
+ * @see chunk_texture_octahedral_skirt_texel_uv for the inverse, from a skirted texel to the uv it carries
+ * @type {CodeChunk}
+ */
+export const chunk_texture_octahedral_skirt_uv = CodeChunk.from(
+    //language=WGSL
+    `
+fn texture_octahedral_skirt_uv(octahedral_uv: vec2<f32>, texture_size: f32) -> vec2<f32> {
+    return (octahedral_uv * (texture_size - 2.0) + 1.0) / texture_size;
+}
+`);

package/src/shade/renderer/shader/chunk/texture/sample/chunk_sample_environment_map.d.ts

@@ -1,5 +1,22 @@
 /**
- * Works on ann octahedral-encoded pre-filtered environment map
+ * Works on an octahedral-encoded pre-filtered environment map with a one-texel octahedral skirt on
+ * every level it reads (see `texture_octahedral_skirt_uv`).
+ *
+ * Trilinear as two hardware bilinear taps, one per level, blended here: each level's interior is its
+ * own size less the skirt, so one uv cannot address two levels and the sampler's own mip blend would
+ * read the coarser one up to a texel off. Most texture units filter trilinear at half the bilinear
+ * rate anyway, so the second tap costs about what the hardware blend would.
+ *
+ * Measured against the manual form this replaces (8 loads, 4 octahedral wraps a level, each wrap
+ * two integer divisions and remainders), radiance + irradiance over 1920x1080: 88 → 17 µs on an RTX
+ * 4090, 15.4 → 1.3 ms on an RDNA2 iGPU, whose integer division is emulated.
+ *
+ * Every level the roughness mapping reaches (0 to `SPHERE_PROBE_MIPMAP_LEVELS - 1`) must be at least
+ * 3 texels wide to have an interior. A level's size is the texture's halved and kept at 1 or more, as
+ * a level's extent is, so a smaller map (the renderer's 1x1 black stand-in, a test's constant) still
+ * samples at a finite uv. At the roughest level the second tap reads the level past it at weight 0; a
+ * texture without one clamps to the last level, which the weight discards just the same.
+ *
  * @see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/samples/hybridreflections/shaders/Common.hlsl#L118
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/texture/sample/chunk_sample_environment_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/texture/sample/chunk_sample_environment_map.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,2CAFU,SAAS,CAyCjB;0BA/CwB,gCAAgC"}
+{"version":3,"file":"chunk_sample_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/texture/sample/chunk_sample_environment_map.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,2CAFU,SAAS,CAyCjB;0BAjEwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/texture/sample/chunk_sample_environment_map.js

@@ -2,10 +2,28 @@ import {
     chunk_sphere_probe_roughness_to_lod
 } from "../../../../light/environment/chunk_sphere_probe_roughness_to_lod.js";
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_texture_octahedral_sample_bilinear } from "../octahedral/chunk_texture_octahedral_sample_bilinear.js";
+import { chunk_uv_octahedral_unit_encode } from "../../geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import { chunk_texture_octahedral_skirt_uv } from "../octahedral/chunk_texture_octahedral_skirt_uv.js";
 
 /**
- * Works on ann octahedral-encoded pre-filtered environment map
+ * Works on an octahedral-encoded pre-filtered environment map with a one-texel octahedral skirt on
+ * every level it reads (see `texture_octahedral_skirt_uv`).
+ *
+ * Trilinear as two hardware bilinear taps, one per level, blended here: each level's interior is its
+ * own size less the skirt, so one uv cannot address two levels and the sampler's own mip blend would
+ * read the coarser one up to a texel off. Most texture units filter trilinear at half the bilinear
+ * rate anyway, so the second tap costs about what the hardware blend would.
+ *
+ * Measured against the manual form this replaces (8 loads, 4 octahedral wraps a level, each wrap
+ * two integer divisions and remainders), radiance + irradiance over 1920x1080: 88 → 17 µs on an RTX
+ * 4090, 15.4 → 1.3 ms on an RDNA2 iGPU, whose integer division is emulated.
+ *
+ * Every level the roughness mapping reaches (0 to `SPHERE_PROBE_MIPMAP_LEVELS - 1`) must be at least
+ * 3 texels wide to have an interior. A level's size is the texture's halved and kept at 1 or more, as
+ * a level's extent is, so a smaller map (the renderer's 1x1 black stand-in, a test's constant) still
+ * samples at a finite uv. At the roughest level the second tap reads the level past it at weight 0; a
+ * texture without one clamps to the last level, which the weight discards just the same.
+ *
  * @see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/samples/hybridreflections/shaders/Common.hlsl#L118
  * @type {CodeChunk}
  */
@@ -13,39 +31,39 @@ export const chunk_sample_environment_map = CodeChunk.from(
     //language=WGSL
     `
 fn sample_environment_map(
-    tEnvironment:texture_2d<f32>, 
-    direction: vec3<f32>, 
+    tEnvironment: texture_2d<f32>,
+    sEnvironment: sampler,
+    direction: vec3<f32>,
     roughness: f32
 ) -> vec3<f32> {
-    
+
     let lod = sphere_probe_roughness_to_lod(roughness);
-        
-    let lod_0 = u32(floor(lod));
-    let f = fract(lod);
-    
-    let color_0 = texture_octahedral_sample_bilinear(
+
+    let lod_0 = floor(lod);
+    let level_0 = u32(lod_0);
+
+    let octahedral_uv = uv_octahedral_unit_encode(direction);
+    let size = textureDimensions(tEnvironment).x;
+
+    let color_0 = textureSampleLevel(
         tEnvironment,
-        vec2(0u),
-        textureDimensions(tEnvironment, lod_0).x,
-        direction,
+        sEnvironment,
+        texture_octahedral_skirt_uv(octahedral_uv, f32(max(size >> level_0, 1u))),
         lod_0
-    ).rgb;  
-     
-    let lod_1 = lod_0 + 1u;
-    
-    let color_1 = texture_octahedral_sample_bilinear(
+    ).rgb;
+
+    let color_1 = textureSampleLevel(
         tEnvironment,
-        vec2(0u),
-        textureDimensions(tEnvironment, lod_1).x,
-        direction,
-        lod_1
+        sEnvironment,
+        texture_octahedral_skirt_uv(octahedral_uv, f32(max(size >> (level_0 + 1u), 1u))),
+        lod_0 + 1.0
     ).rgb;
-    
-    
-    return mix(color_0, color_1, f);
+
+    return mix(color_0, color_1, lod - lod_0);
 }
     `, [
         chunk_sphere_probe_roughness_to_lod,
-        chunk_texture_octahedral_sample_bilinear,
+        chunk_uv_octahedral_unit_encode,
+        chunk_texture_octahedral_skirt_uv,
     ]
-);
+);