@woosh/meep-engine 3.51.0 → 3.53.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 = 203.0;
+const PAPER_WHITE_NITS: f32 = ${PAPER_WHITE_NITS};
 `
 );

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js

@@ -82,7 +82,7 @@ import { VSM_SLOT_EMPTY } from "../vsm/VSM_SLOT_STRUCT.js";
  * @typedef {import("../../buffer/table/serde/generate_record_writer.js").GPURecordWriter} GPURecordWriter
  */
 
-const DEFAULT_SHADOWMAP_ATLAS_RESOLUTION = 4096 * 2;
+const DEFAULT_SHADOWMAP_ATLAS_RESOLUTION = 4096;
 
 /**
  * Resolution by cascade.

package/src/shade/renderer/texture/SAMPLER_ANISOTROPIC_CLAMP.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Anisotropic trilinear clamp-to-edge sampler (`magFilter: "linear"`, `minFilter: "linear"`,
+ * `mipmapFilter: "linear"`, `maxAnisotropy: 16`).
+ * Use for mipmapped 3D scene atlases (such as decal and particle atlases) that undergo both
+ * minification and oblique-angle projection in world space.
+ */
+export const SAMPLER_ANISOTROPIC_CLAMP: Readonly<SamplerDescriptor>;
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+//# sourceMappingURL=SAMPLER_ANISOTROPIC_CLAMP.d.ts.map

package/src/shade/renderer/texture/SAMPLER_ANISOTROPIC_CLAMP.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SAMPLER_ANISOTROPIC_CLAMP.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/SAMPLER_ANISOTROPIC_CLAMP.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oEAQI;kCAhB8B,+CAA+C"}

package/src/shade/renderer/texture/SAMPLER_ANISOTROPIC_CLAMP.js

@@ -0,0 +1,17 @@
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+
+/**
+ * Anisotropic trilinear clamp-to-edge sampler (`magFilter: "linear"`, `minFilter: "linear"`,
+ * `mipmapFilter: "linear"`, `maxAnisotropy: 16`).
+ * Use for mipmapped 3D scene atlases (such as decal and particle atlases) that undergo both
+ * minification and oblique-angle projection in world space.
+ */
+export const SAMPLER_ANISOTROPIC_CLAMP = Object.freeze(SamplerDescriptor.from({
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+    addressModeW: "clamp-to-edge",
+    magFilter: "linear",
+    minFilter: "linear",
+    mipmapFilter: "linear",
+    maxAnisotropy: 16,
+}));

package/src/shade/renderer/texture/SAMPLER_LINEAR_UPSCALE.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Magnification-only linear clamp sampler (`magFilter: "linear"`, `minFilter: "nearest"`,
+ * `mipmapFilter: "nearest"`, `maxAnisotropy: 1`).
+ *
+ * Intended ONLY for upscaling single-mip 2D render targets (e.g. post-processing upsampling).
+ * Do NOT use for 3D scene textures, atlases, or mipmapped targets that undergo minification —
+ * use `SAMPLER_TRILINEAR_CLAMP` or `SAMPLER_ANISOTROPIC_CLAMP` instead.
+ */
 export const SAMPLER_LINEAR_UPSCALE: Readonly<SamplerDescriptor>;
 export const SAMPLER_LINEAR_DOWNSCALE: Readonly<SamplerDescriptor>;
 export const SAMPLER_NEAREST: Readonly<SamplerDescriptor>;

package/src/shade/renderer/texture/SAMPLER_LINEAR_UPSCALE.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SAMPLER_LINEAR_UPSCALE.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/SAMPLER_LINEAR_UPSCALE.js"],"names":[],"mappings":"AAEA,iEAKI;AAEJ,mEAIG;AAEH,0DAII;kCAnB8B,+CAA+C"}
+{"version":3,"file":"SAMPLER_LINEAR_UPSCALE.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/SAMPLER_LINEAR_UPSCALE.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,iEAKI;AAEJ,mEAIG;AAEH,0DAII;kCA3B8B,+CAA+C"}

package/src/shade/renderer/texture/SAMPLER_LINEAR_UPSCALE.js

@@ -1,20 +1,28 @@
-import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
-
-export const SAMPLER_LINEAR_UPSCALE = Object.freeze(SamplerDescriptor.from({
-    magFilter: "linear",
-    addressModeU: "clamp-to-edge",
-    addressModeV: "clamp-to-edge",
-    addressModeW: "clamp-to-edge",
-}));
-
-export const SAMPLER_LINEAR_DOWNSCALE = Object.freeze(SamplerDescriptor.from({
-    minFilter: "linear",
-    addressModeU: "clamp-to-edge",
-    addressModeV: "clamp-to-edge"
-}))
-
-export const SAMPLER_NEAREST = Object.freeze(SamplerDescriptor.from({
-    magFilter: "nearest",
-    addressModeU: "clamp-to-edge",
-    addressModeV: "clamp-to-edge"
-}));
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+
+/**
+ * Magnification-only linear clamp sampler (`magFilter: "linear"`, `minFilter: "nearest"`,
+ * `mipmapFilter: "nearest"`, `maxAnisotropy: 1`).
+ *
+ * Intended ONLY for upscaling single-mip 2D render targets (e.g. post-processing upsampling).
+ * Do NOT use for 3D scene textures, atlases, or mipmapped targets that undergo minification —
+ * use `SAMPLER_TRILINEAR_CLAMP` or `SAMPLER_ANISOTROPIC_CLAMP` instead.
+ */
+export const SAMPLER_LINEAR_UPSCALE = Object.freeze(SamplerDescriptor.from({
+    magFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+    addressModeW: "clamp-to-edge",
+}));
+
+export const SAMPLER_LINEAR_DOWNSCALE = Object.freeze(SamplerDescriptor.from({
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+}))
+
+export const SAMPLER_NEAREST = Object.freeze(SamplerDescriptor.from({
+    magFilter: "nearest",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+}));

package/src/shade/renderer/texture/SAMPLER_TRILINEAR_CLAMP.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Trilinear clamp-to-edge sampler (`magFilter: "linear"`, `minFilter: "linear"`, `mipmapFilter: "linear"`).
+ * Use for mipmapped 2D render targets and LUTs where linear filtering is required across both
+ * magnification/minification and mip levels without anisotropic footprint expansion.
+ */
+export const SAMPLER_TRILINEAR_CLAMP: Readonly<SamplerDescriptor>;
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+//# sourceMappingURL=SAMPLER_TRILINEAR_CLAMP.d.ts.map

package/src/shade/renderer/texture/SAMPLER_TRILINEAR_CLAMP.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SAMPLER_TRILINEAR_CLAMP.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/SAMPLER_TRILINEAR_CLAMP.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,kEAOI;kCAd8B,+CAA+C"}

package/src/shade/renderer/texture/SAMPLER_TRILINEAR_CLAMP.js

@@ -0,0 +1,15 @@
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+
+/**
+ * Trilinear clamp-to-edge sampler (`magFilter: "linear"`, `minFilter: "linear"`, `mipmapFilter: "linear"`).
+ * Use for mipmapped 2D render targets and LUTs where linear filtering is required across both
+ * magnification/minification and mip levels without anisotropic footprint expansion.
+ */
+export const SAMPLER_TRILINEAR_CLAMP = Object.freeze(SamplerDescriptor.from({
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+    addressModeW: "clamp-to-edge",
+    magFilter: "linear",
+    minFilter: "linear",
+    mipmapFilter: "linear",
+}));

package/src/shade/renderer/view/chunk_view_mip_bias.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Multiplier applied to screen-space UV derivatives before dividing by `view.upscale_ratio`
+ * to bias texture mip selection for temporal super-sampling (TAAU / NSS).
+ *
+ * @type {number}
+ */
+export const RENDER_MIP_DERIVATIVE_BIAS: number;
+/**
+ * Shared WGSL helpers for biasing screen-space UV derivatives and mip levels according to
+ * the active internal resolution scale (`view.upscale_ratio = output_resolution / internal_resolution`)
+ * and global TAA mip bias ({@link RENDER_GLOBAL_MIP_BIAS}).
+ *
+ * When rendering at reduced internal resolution (`upscale_ratio > 1.0`), raw screen-space
+ * derivatives (`dpdx` / `dpdy` or finite differences across internal pixels) measure the
+ * coarser internal pixel footprint rather than the final output pixel footprint reconstructed
+ * by temporal upscaling. Scaling derivatives by `view_uv_derivative_bias(view.upscale_ratio)`
+ * ensures mip selection and anisotropic filtering match the target output resolution.
+ */
+export const chunk_view_mip_bias: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_view_mip_bias.d.ts.map

package/src/shade/renderer/view/chunk_view_mip_bias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_view_mip_bias.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/view/chunk_view_mip_bias.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,yCAFU,MAAM,CAE2D;AAE3E;;;;;;;;;;GAUG;AACH,4CAqBE;0BA1CwB,iCAAiC"}

package/src/shade/renderer/view/chunk_view_mip_bias.js

@@ -0,0 +1,44 @@
+import { RENDER_GLOBAL_MIP_BIAS } from "../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+
+/**
+ * Multiplier applied to screen-space UV derivatives before dividing by `view.upscale_ratio`
+ * to bias texture mip selection for temporal super-sampling (TAAU / NSS).
+ *
+ * @type {number}
+ */
+export const RENDER_MIP_DERIVATIVE_BIAS = 1 / (1 - RENDER_GLOBAL_MIP_BIAS);
+
+/**
+ * Shared WGSL helpers for biasing screen-space UV derivatives and mip levels according to
+ * the active internal resolution scale (`view.upscale_ratio = output_resolution / internal_resolution`)
+ * and global TAA mip bias ({@link RENDER_GLOBAL_MIP_BIAS}).
+ *
+ * When rendering at reduced internal resolution (`upscale_ratio > 1.0`), raw screen-space
+ * derivatives (`dpdx` / `dpdy` or finite differences across internal pixels) measure the
+ * coarser internal pixel footprint rather than the final output pixel footprint reconstructed
+ * by temporal upscaling. Scaling derivatives by `view_uv_derivative_bias(view.upscale_ratio)`
+ * ensures mip selection and anisotropic filtering match the target output resolution.
+ */
+export const chunk_view_mip_bias = CodeChunk.from(
+    //language=WGSL
+    `
+const RENDER_MIP_DERIVATIVE_BIAS: f32 = ${RENDER_MIP_DERIVATIVE_BIAS.toFixed(8)};
+const RENDER_GLOBAL_MIP_BIAS: f32 = ${RENDER_GLOBAL_MIP_BIAS.toFixed(8)};
+
+/**
+ * Per-axis multiplier for screen-space UV gradients (\`ddx\` by \`.x\`, \`ddy\` by \`.y\`)
+ * that accounts for both temporal upscaling (\`upscale_ratio\`) and global TAA mip bias.
+ */
+fn view_uv_derivative_bias(upscale_ratio: vec2<f32>) -> vec2<f32> {
+    return vec2<f32>(RENDER_MIP_DERIVATIVE_BIAS) / upscale_ratio;
+}
+
+/**
+ * Scalar LOD bias (in mip levels) corresponding to \`upscale_ratio\` and global TAA mip bias.
+ */
+fn view_mip_bias(upscale_ratio: vec2<f32>) -> f32 {
+    return -log2(max(upscale_ratio.x, upscale_ratio.y)) + RENDER_GLOBAL_MIP_BIAS;
+}
+`
+);

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js

@@ -2975,7 +2975,7 @@ function inferBuiltinReturnType(name, args) {
         // the two values; the third argument is the condition
         return commonArgumentType(args.slice(0, 2));
     }
-    if (name === 'textureLoad' || name === 'textureSampleLevel' || name === 'textureSample' || name === 'textureSampleGrad') {
+    if (name === 'textureLoad' || name === 'textureSampleLevel' || name === 'textureSample' || name === 'textureSampleBias' || name === 'textureSampleGrad') {
         return { kind: 'vec', size: 4, scalar: 'f32' };
     }
     // Both gathers return the four texels of a 2x2 footprint. Saying so here matters more than

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IA6jDA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IA4oDA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}