@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_mask_weights_by_visibility.js

@@ -3,6 +3,7 @@ import {
 } from "../../../../../global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.js";
 import { CodeChunk } from "../../../../compiler/CodeChunk.js";
 import { chunk_lpv_mesh_get_vertices } from "../chunk_lpv_mesh_get_vertices.js";
+import { LPV_PROBES_RESOURCE } from "../../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_mask_weights_by_visibility = CodeChunk.from(
     //language=WGSL
@@ -107,6 +108,8 @@ fn lpv_mask_weights_by_visibility(
         chunk_lpv_get_visibility_mask
     ]);
 
+chunk_lpv_mask_weights_by_visibility.requireResource(LPV_PROBES_RESOURCE);
+
 
 export const chunk_lpv_mask_weights_by_visibility_no_depth = CodeChunk.from(
     //language=WGSL
@@ -187,4 +190,6 @@ fn lpv_mask_weights_by_visibility(
 `, [
         chunk_lpv_mesh_get_vertices,
         chunk_lpv_get_visibility_mask
-    ]);
+    ]);
+
+chunk_lpv_mask_weights_by_visibility_no_depth.requireResource(LPV_PROBES_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_sample_depth_atlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_sample_depth_atlas.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_sample_depth_atlas.js"],"names":[],"mappings":"AAUA,qDA4CC;AAGD,4DA2BC;0BApFyB,mCAAmC"}
+{"version":3,"file":"chunk_lpv_sample_depth_atlas.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_sample_depth_atlas.js"],"names":[],"mappings":"AAeA,qDA4CC;AAMD,4DA2BC;0BA5FyB,mCAAmC"}

package/src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_sample_depth_atlas.js

@@ -7,6 +7,11 @@ import {
     chunk_texture_octahedral_wrap_texel_coordinates
 } from "../../../texture/octahedral/chunk_texture_octahedral_wrap_texel_coordinates.js";
 import { chunk_get_bilinear_weights } from "../../../texture/sample/chunk_get_bilinear_weights.js";
+import {
+    LPV_ATLAS_DEPTH_RESOURCE,
+    LPV_METADATA_RESOURCE
+} from "../../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
+import { SAMPLER_LINEAR_RESOURCE } from "../../../../../texture/SAMPLER_LINEAR_RESOURCE.js";
 
 export const chunk_lpv_sample_depth_atlas = CodeChunk.from(
     //language=WGSL
@@ -54,6 +59,9 @@ fn lpv_sample_depth_atlas( direction: vec3<f32>, probe_index: u32 ) -> vec2<f32>
     ]
 )
 
+chunk_lpv_sample_depth_atlas.requireResource(LPV_ATLAS_DEPTH_RESOURCE);
+chunk_lpv_sample_depth_atlas.requireResource(LPV_METADATA_RESOURCE);
+
 
 export const chunk_lpv_sample_depth_atlas_native = CodeChunk.from(
     //language=WGSL
@@ -82,4 +90,8 @@ fn lpv_sample_depth_atlas( direction: vec3<f32>, probe_index: u32 ) -> vec2<f32>
         chunk_uv_to_texel_coordinate,
         chunk_index_to_grid2d,
     ]
-)
+)
+
+chunk_lpv_sample_depth_atlas_native.requireResource(LPV_ATLAS_DEPTH_RESOURCE);
+chunk_lpv_sample_depth_atlas_native.requireResource(LPV_METADATA_RESOURCE);
+chunk_lpv_sample_depth_atlas_native.requireResource(SAMPLER_LINEAR_RESOURCE);

package/src/shade/renderer/shader/chunk/material/MULTISCATTER.md

@@ -15,6 +15,9 @@ paths now restore it with Turquin's compensation (2019, eq. 16), from the split-
 
 It uses the material's roughness, not the roughness a sphere light widens it to in `re_direct_physical`.
 
+The same call scales the direct diffuse by what the dielectric's specular leaves, from the same fetch; see
+[Direct diffuse under the specular](#direct-diffuse-under-the-specular).
+
 ## Why GI does not already cover it
 
 The indirect path's compensation scales the environment's light. The sun and local lights reach a pixel
@@ -53,23 +56,69 @@ Measured against applying the term at the blended F0 (`deferred/white_furnace.sp
 metalness 0.5): the direct specular came up to 0.157 of the sky short, the indirect resolve up to 0.33.
 Split, the direct is within 0.0028 of the blend and the indirect is the blend to one f32 ulp.
 
+## Direct diffuse under the specular
+
+`re_direct_physical` adds the EON diffuse on top of the GGX specular, and the light the specular reflected reached
+the diffuse as well: under a uniform sky a white dielectric returned 1.01 – 1.40 of it through direct light, the
+most at low roughness and grazing view. `re_direct_multiscatter` now scales the accumulated direct diffuse by
+1 − the dielectric's specular albedo at N·V: `compute_multiscattering_specular` at `specularF0_dielectric`, on the
+`f_ab` it already fetched. That is the indirect path's factor, "albedo scaling"; UE 5.4 does the same for direct
+light (`ComputeEnergyPreservation`, by luminance: always under Substrate, in legacy shading only with the project's
+energy-conservation setting on), as do EEVEE Next (by the RGB maximum) and OpenPBR / MaterialX
+(`throughput = 1 − dirAlbedo`). Filament leaves direct diffuse uncoupled (a TODO in
+`surface_shading_model_standard.fs`); three.js since #33985 scales it per light by 1 − F(V·H).
+
+The candidates, measured through `shader_deferred_main` on a white dielectric (roughness 0.26 – 0.99, N·V 0.10 –
+0.99, the spec's grid), and their cost on "Shade From G-Buffer" in Sponza (RTX 4090, 1898 × 982, inside the
+atrium, 16 unshadowed point lights added so that a per-light term shows; with the one sun all were within noise).
+The furnace is to ±0.005, the sky sampled coarsely; under a finer one the taken coupling reads 0.932 – 1.000 and
+Kulla–Conty's at most 1.002. These were measured with the direct lobe on F_Hauber and the LUT on Schlick's fourth
+power; with both on Schlick's fifth (`brdf/FRESNEL_BRIEF_2026_10_16.md`) the LUT's dielectric albedo is the direct
+lobe's own and the taken coupling reads 1.000 – 1.001 under the spec's sky:
+
+| coupling | furnace | cost, 16 point lights |
+|---|---|---|
+| none (before) | 1.01 – 1.40 | 427.6 µs |
+| 1 − E(N·V), per pixel (taken) | 0.93 – 1.00 | +0.1 – 0.2% (copy twin 0.998 – 1.002) |
+| 1 − F(V·H), per light (three.js) | 0.97 – 1.34 | +1.3% |
+| Kulla–Conty, (1 − E(N·L))(1 − E(N·V)) / (1 − E_avg), per light | 0.93 – 1.00 | +1.5% |
+| the same without 1 / (1 − E_avg) | 0.86 – 0.98 | |
+
+Per light, the Fresnel at V·H does not hold the furnace at grazing view. Kulla–Conty's does, is reciprocal, and adds
+the light's side of the interface, at a `tSplitSum` fetch per light, an E_avg it would need from a fit or a third
+LUT channel, and `tSplitSum` in the two ReSTIR passes that reach `re_direct_physical` through the target function
+(resample, whose candidates and temporal reuse call it, and spatial reuse).
+
+The ReSTIR target function stays uncoupled: it is a resampling weight, and the coupling is a per-pixel scale.
+
+Shipped: "Shade From G-Buffer" 80.2 against 80.2 µs and 88.6 against 87.8 µs without the coupling's line (Sponza
+with its sun, the views above; copy twin 0.991 – 1.010), and the pass's mean output 3% lower. On a grid of
+dielectric spheres under a sun, the change is at the lit rims and falls with roughness.
+
 ## What the furnace holds
 
 `deferred/white_furnace.spec.js` lights one texel through the real passes: `shader_deferred_main` (a
-uniform sky as directional lights from GGX visible-normal sampling, or one point light through the cluster)
-and `shader_resolve_indirect_lighting`. It holds:
+uniform sky as directional lights from GGX visible-normal sampling, with cosine samples beside them where a
+diffuse is lit, or one point light through the cluster) and `shader_resolve_indirect_lighting`. It holds:
 
-1. a white metal's direct light is the sky less only `F_Hauber`'s dip over the half vectors that view can
-   reach, a floor derived per N·V (0.32 – 0.99 before, 0.93 – 1.00 now);
+1. a white metal's direct light is the sky, to the sampling and the LUT's error (0.32 – 0.99 before the
+   compensation, 0.93 – 1.00 while the direct lobe was F_Hauber, whose dip the LUT did not hold, 0.997 – 1.000
+   now);
 2. the direct specular at any metalness is the blend of the pure dielectric's and the pure metal's, white
-   and gold, every channel, to the 0.0028 the Fresnel offset leaves (1.7e-5 without it);
+   and gold, every channel, to 1.3e-5 (0.0028 under F_Hauber's offset);
 3. the indirect resolve is that blend to float rounding (0.67 – 0.90 of the sky at metalness 0.25 – 0.75
    before);
-4. for a pure dielectric and a pure gold, the indirect specular exceeds the direct by no less than 0 and no
-   more than the Fresnel dip the LUT drops: this, not the white furnace, is what sees where the LUT is read;
+4. for a pure dielectric and a pure gold, the indirect specular is the direct, to the sampling and the LUT's
+   error (up to 0.068 above it under F_Hauber): this, not the white furnace, is what sees where the LUT is read;
 5. a point light is compensated as a directional light is;
 6. the ReSTIR twin shades its directional lights as the brute-force pass does;
-7. each channel is shaded by its own colour alone.
+7. each channel is shaded by its own colour alone;
+8. a white dielectric's direct light is at most the sky (1.01 – 1.40 before, 0.932 – 1.000 with the coupling
+   under F_Hauber, 1.000 – 1.001 now);
+9. a white dielectric's direct and indirect totals agree, to the sampling and the LUT's and EON's errors;
+10. the direct diffuse keeps the share of the sky the indirect diffuse keeps, to EON's own albedo error and
+    the sampling's, 0.0015: this sees the coupling's strength more sharply than the totals, which carry EON's
+    albedo and the sampling of both lobes as well.
 
 Every mutant of the adversarial review is killed — the call doubled or moved ahead of the cluster loop, F0
 for the variance, the variance's sign or half of it, either path's LUT read with its coordinates swapped or at
@@ -78,10 +127,13 @@ roughness², the guard at 1e-1, the diffuse coupled to the blend, a dielectric F
 channel's ratio for all or none for blue, the ReSTIR twin's call removed — but one: `restir_resolve`'s own
 call. That pass needs the ray-tracing group and is not run at this tier.
 
+So is every mutant of the diffuse coupling: removed, doubled, put on the specular, taken from the blend's albedo,
+without the dielectric's multiple scattering, at 0.9, 0.97, 1.03 or 1.1 of itself, at F0 0.08, by F0 alone, with
+F90 = 0, by the white lobe's albedo, or read at N·V = 1, with its coordinates swapped, at roughness² or at 0.8 N·V.
+The multiple-scattering and ±3% ones die only by item 10.
+
 What is left on purpose:
 
-- **The direct lobe's Fresnel dip.** `F_Hauber(1, 1, VoH) = 1 − VoH (1 − VoH)⁴` is below 1, least at
-  VoH = 1/5 (1 − 256/3125); the compensation does not hide it. That is the 0.93 at low roughness, grazing.
 - **The LUT's edge.** Texel centres are (i + 0.5) / 64, so roughness 1 reads 0.992's albedo: 3% at
   roughness 1, N·V 1.
 - **The resolve's horizon occlusion.** Its bent-normal specular occlusion cuts a lobe reaching under the
@@ -96,12 +148,11 @@ view): 79.8 against 74.6 µs and 89.6 against 83.0 µs, +7%, ~0.2% of the frame.
 
 ## Measured and not changed here
 
-- **Direct diffuse is not coupled to the specular.** EON's albedo is the base colour, and the direct
-  path adds the specular on top, so a white dielectric returns 1.01 – 1.49 of a uniform sky through direct
-  light (the most at low roughness, grazing). The indirect path couples them.
-- **Direct and indirect Fresnel differ.** The LUT splits `F_Hauber` into `f0 · A + f90 · B` and drops its
-  `− VoH (1 − VoH)⁴` term, so the indirect specular is up to 0.068 of the sky above the direct for the same
-  dielectric (0.288 against 0.220 at roughness 0.26, N·V 0.26).
+- **The direct diffuse is coupled on the view's side only.** It keeps 1 − E(N·V) whatever the light's
+  angle, so a smooth dielectric's diffuse under a grazing light is not dimmed by the Fresnel the light meets on
+  the way in: at roughness 0.26, N·V 0.9, it keeps 0.96 of the uncoupled diffuse at every N·L, where
+  Kulla–Conty's keeps 0.57 at N·L 0.1 and 1.02 at N·L 1 (within 7% of each other at roughness 0.99). Under a
+  uniform sky the two agree within 0.007 of it; the cost of Kulla–Conty's is in the section above.
 - **Light the LPV injects is single-scattering.** `graph_lpv_shade.js` shades a probe ray's hit with its own
   `BRDF_GGX` and (1 − F) diffuse, so in LPV mode a rough metal bounces its uncompensated direct light.
 - **The path tracer is single-scattering**, so for rough metals it is not the reference: it reflects what

package/src/shade/renderer/shader/chunk/material/chunk_compute_indirect_specular.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_compute_indirect_specular.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_compute_indirect_specular.js"],"names":[],"mappings":"AAKA,wDAsEC;0BA3EyB,6BAA6B"}
+{"version":3,"file":"chunk_compute_indirect_specular.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_compute_indirect_specular.js"],"names":[],"mappings":"AAOA,wDAsEC;0BA7EyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_compute_indirect_specular.js

@@ -2,6 +2,8 @@ import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { chunk_max_v3 } from "../geometry/vec3/chunk_max_v3.js";
 import { chunk_compute_multiscattering_specular } from "../light/chunk_compute_multiscattering_specular.js";
 import { RECIPROCAL_PI_DECLARATION } from "../math/RECIPROCAL_PI_DECLARATION.js";
+import { SPLIT_SUM_LUT_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import { SAMPLER_LINEAR_RESOURCE } from "../../../texture/SAMPLER_LINEAR_RESOURCE.js";
 
 export const chunk_compute_indirect_specular = CodeChunk.from(
     //language=WGSL
@@ -73,4 +75,7 @@ fn compute_indirect_specular(
         RECIPROCAL_PI_DECLARATION,
         chunk_max_v3,
     ]
-)
+)
+
+chunk_compute_indirect_specular.requireResource(SAMPLER_LINEAR_RESOURCE);
+chunk_compute_indirect_specular.requireResource(SPLIT_SUM_LUT_RESOURCE);

package/src/shade/renderer/shader/chunk/material/chunk_re_direct_multiscatter.d.ts

@@ -1,5 +1,6 @@
 /**
- * Multiple-scattering compensation for the direct specular, once per pixel after the last light.
+ * Multiple-scattering compensation for the direct specular, and the direct diffuse's share of what the
+ * specular leaves, once per pixel after the last light.
  *
  * `re_direct_physical` evaluates single-scattering GGX per light, which loses the energy that bounces
  * between microfacets more than once: a rough white metal reflects 0.31 of a uniform sky. Turquin's
@@ -9,6 +10,11 @@
  * accumulated, and the indirect path's `compute_multiscattering_specular` supplies it, so the two paths cannot
  * disagree.
  *
+ * `re_direct_physical` also adds its diffuse on top of the specular, and a white dielectric returned up to 1.4
+ * of a uniform sky that way. The diffuse is scaled here by 1 − the dielectric's specular albedo at N·V, from the
+ * same fetch: the indirect path's factor, and what UE5, EEVEE and OpenPBR apply ("albedo scaling"). It is
+ * the view's side of the interface only; the light's (Kulla–Conty's 1 − E(N·L)) would cost a fetch per light.
+ *
  * Requires `tSplitSum` and `sLinear` in the shader's resources. See `MULTISCATTER.md` beside this chunk.
  *
  * @type {CodeChunk}

package/src/shade/renderer/shader/chunk/material/chunk_re_direct_multiscatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_re_direct_multiscatter.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_re_direct_multiscatter.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,2CAFU,SAAS,CAoCjB;0BAvDwB,6BAA6B"}
+{"version":3,"file":"chunk_re_direct_multiscatter.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_re_direct_multiscatter.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2CAFU,SAAS,CAqDjB;0BAhFwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_re_direct_multiscatter.js

@@ -3,9 +3,12 @@ import { chunk_compute_multiscattering_specular } from "../light/chunk_compute_m
 import { REFLECTED_LIGHT_STRUCT } from "../light/REFLECTED_LIGHT_STRUCT.js";
 import { GEOMETRIC_SHADING_INFO_STRUCT } from "./GEOMETRIC_SHADING_INFO_STRUCT.js";
 import { MATERIAL_SHADING_INFO_STRUCT } from "./MATERIAL_SHADING_INFO_STRUCT.js";
+import { SPLIT_SUM_LUT_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import { SAMPLER_LINEAR_RESOURCE } from "../../../texture/SAMPLER_LINEAR_RESOURCE.js";
 
 /**
- * Multiple-scattering compensation for the direct specular, once per pixel after the last light.
+ * Multiple-scattering compensation for the direct specular, and the direct diffuse's share of what the
+ * specular leaves, once per pixel after the last light.
  *
  * `re_direct_physical` evaluates single-scattering GGX per light, which loses the energy that bounces
  * between microfacets more than once: a rough white metal reflects 0.31 of a uniform sky. Turquin's
@@ -15,6 +18,11 @@ import { MATERIAL_SHADING_INFO_STRUCT } from "./MATERIAL_SHADING_INFO_STRUCT.js"
  * accumulated, and the indirect path's `compute_multiscattering_specular` supplies it, so the two paths cannot
  * disagree.
  *
+ * `re_direct_physical` also adds its diffuse on top of the specular, and a white dielectric returned up to 1.4
+ * of a uniform sky that way. The diffuse is scaled here by 1 − the dielectric's specular albedo at N·V, from the
+ * same fetch: the indirect path's factor, and what UE5, EEVEE and OpenPBR apply ("albedo scaling"). It is
+ * the view's side of the interface only; the light's (Kulla–Conty's 1 − E(N·L)) would cost a fetch per light.
+ *
  * Requires `tSplitSum` and `sLinear` in the shader's resources. See `MULTISCATTER.md` beside this chunk.
  *
  * @type {CodeChunk}
@@ -46,6 +54,23 @@ fn re_direct_multiscatter(
 
     // single scattering is at least F0 * A, so this guards only an F0 of 0, whose multiple scattering is 0 too
     (*reflectedLight).specular *= 1.0 + multi_scattering / max( single_scattering, vec3<f32>( 1e-4 ) );
+
+    // the diffuse lies under the dielectric part of the surface only (material.diffuse carries its 1 - metalness),
+    // so it keeps what the dielectric's specular leaves, as the indirect path's does
+    var single_scattering_dielectric = vec3<f32>( 0.0 );
+    var multi_scattering_dielectric = vec3<f32>( 0.0 );
+
+    compute_multiscattering_specular(
+        f_ab,
+        material.specularF0_dielectric,
+        material.specularF0_dielectric,
+        material.specularF0_dielectric,
+        material.specularF90,
+        &single_scattering_dielectric,
+        &multi_scattering_dielectric
+    );
+
+    (*reflectedLight).diffuse *= saturate( vec3<f32>( 1.0 ) - ( single_scattering_dielectric + multi_scattering_dielectric ) );
 }
     `, [
         GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
@@ -54,3 +79,6 @@ fn re_direct_multiscatter(
         chunk_compute_multiscattering_specular,
     ]
 );
+
+chunk_re_direct_multiscatter.requireResource(SAMPLER_LINEAR_RESOURCE);
+chunk_re_direct_multiscatter.requireResource(SPLIT_SUM_LUT_RESOURCE);

package/src/shade/renderer/shader/chunk/math/chunk_falloff_quadratic.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Quadratic falloff of a normalised distance: `(1 − t)²` inside the support, `t < 1`, and 0 from its
+ * edge on. 1 at the centre, 0 with zero slope at the edge. `t` is `d / R`, ≥ 0.
+ *
+ * The WGSL twin of `falloff_quadratic` (`core/math/falloff_quadratic.js`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_falloff_quadratic: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_falloff_quadratic.d.ts.map

package/src/shade/renderer/shader/chunk/math/chunk_falloff_quadratic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_falloff_quadratic.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/chunk_falloff_quadratic.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,sCAFU,SAAS,CAWjB;0BAnBwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/math/chunk_falloff_quadratic.js

@@ -0,0 +1,20 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Quadratic falloff of a normalised distance: `(1 − t)²` inside the support, `t < 1`, and 0 from its
+ * edge on. 1 at the centre, 0 with zero slope at the edge. `t` is `d / R`, ≥ 0.
+ *
+ * The WGSL twin of `falloff_quadratic` (`core/math/falloff_quadratic.js`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_falloff_quadratic = CodeChunk.from(
+    //language=WGSL
+    `
+fn falloff_quadratic(t: f32) -> f32 {
+    let s = 1.0 - t;
+
+    return select(0.0, s * s, t < 1.0);
+}
+    `
+);

package/src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_stbn_sample_vec2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec2.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qCAFU,SAAS,CAYlB;0BAhByB,6BAA6B"}
+{"version":3,"file":"chunk_stbn_sample_vec2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec2.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,qCAFU,SAAS,CAYlB;0BAjByB,6BAA6B"}

package/src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec2.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 
 /**
  * Sampling "Spatio-Temoral Blue Noise" texture (see STBN paper by NVIDIA)
@@ -14,4 +15,6 @@ fn stbn_sample_vec2(index: vec3<u32> ) -> vec2<f32>{
     return textureLoad(tSTBN_vec2, noise_coord, 0).rg;
 }
     `
-)
+)
+
+chunk_stbn_sample_vec2.requireResource(STBN_VEC2_RESOURCE);

package/src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_stbn_sample_vec3.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec3.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qCAFU,SAAS,CAYlB;0BAhByB,6BAA6B"}
+{"version":3,"file":"chunk_stbn_sample_vec3.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec3.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,qCAFU,SAAS,CAYlB;0BAjByB,6BAA6B"}

package/src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec3.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { STBN_VEC3_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 
 /**
  * Sampling "Spatio-Temoral Blue Noise" texture (see STBN paper by NVIDIA)
@@ -16,3 +17,5 @@ fn stbn_sample_vec3(index: vec3<u32> ) -> vec3<f32>{
     `
 )
 
+chunk_stbn_sample_vec3.requireResource(STBN_VEC3_RESOURCE);
+

package/src/shade/renderer/shader/chunk/physics/fluid/chunk_vortex_swirl.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The tangential push about an axis, along a segment of it:
+ *
+ *     swirl(x) = strength · (27/4) · (â × r⊥)/R · (1 − d/R)²,   0 from d = R on
+ *
+ * The segment runs from `position` along the unit `axis` (`â`) for `segment_length`, ≥ 0.
+ * `r⊥ = x − c(x)`, `c(x)` the point on the segment closest to `x`, `d = ‖r⊥‖`, `R = radius`. Zero on
+ * the axis and at `R`; `strength` at `d = R/3` beside the segment; right-handed about the axis. The
+ * cross product turns only the part of `r⊥` across the axis, so a segment of no length is a point
+ * vortex about the axis line through `position`. `r⊥` is never normalised, so the swirl is finite
+ * everywhere for `R > 0`.
+ *
+ * The WGSL twin of `vortex_swirl` (`core/math/physics/fluid/vortex_swirl.js`), whose header has the
+ * derivation.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_vortex_swirl: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_vortex_swirl.d.ts.map

package/src/shade/renderer/shader/chunk/physics/fluid/chunk_vortex_swirl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_vortex_swirl.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/physics/fluid/chunk_vortex_swirl.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,iCAFU,SAAS,CAmBjB;0BAtCwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/physics/fluid/chunk_vortex_swirl.js

@@ -0,0 +1,39 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_point_closest_on_line } from "../../geometry/chunk_point_closest_on_line.js";
+import { chunk_falloff_quadratic } from "../../math/chunk_falloff_quadratic.js";
+
+/**
+ * The tangential push about an axis, along a segment of it:
+ *
+ *     swirl(x) = strength · (27/4) · (â × r⊥)/R · (1 − d/R)²,   0 from d = R on
+ *
+ * The segment runs from `position` along the unit `axis` (`â`) for `segment_length`, ≥ 0.
+ * `r⊥ = x − c(x)`, `c(x)` the point on the segment closest to `x`, `d = ‖r⊥‖`, `R = radius`. Zero on
+ * the axis and at `R`; `strength` at `d = R/3` beside the segment; right-handed about the axis. The
+ * cross product turns only the part of `r⊥` across the axis, so a segment of no length is a point
+ * vortex about the axis line through `position`. `r⊥` is never normalised, so the swirl is finite
+ * everywhere for `R > 0`.
+ *
+ * The WGSL twin of `vortex_swirl` (`core/math/physics/fluid/vortex_swirl.js`), whose header has the
+ * derivation.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_vortex_swirl = CodeChunk.from(
+    //language=WGSL
+    `
+fn vortex_swirl(
+    x: vec3<f32>, position: vec3<f32>, axis: vec3<f32>, segment_length: f32, radius: f32, strength: f32
+) -> vec3<f32> {
+    let r_perp = x - point_closest_on_line(x, position, position + axis * segment_length);
+
+    let weight = falloff_quadratic(length(r_perp) / radius);
+
+    // 27/4 lifts the peak of s (1 - s)^2, which is 4/27 at s = 1/3, to 1
+    return cross(axis, r_perp) * (strength * (27.0 / 4.0) * weight / radius);
+}
+    `, [
+        chunk_point_closest_on_line,
+        chunk_falloff_quadratic,
+    ]
+);

package/src/shade/renderer/shader/chunk/physics/kinematics/chunk_rigid_velocity_at_point.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Velocity of a point `p` carried by a rigid body: `v + ω × (p − c)`. The body moves at
+ * `linear_velocity` at the point `origin` it turns about, and spins at `angular_velocity` radians per
+ * second about it.
+ *
+ * The WGSL twin of `rigid_velocity_at_point` (`core/math/physics/kinematics/rigid_velocity_at_point.js`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_rigid_velocity_at_point: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_rigid_velocity_at_point.d.ts.map

package/src/shade/renderer/shader/chunk/physics/kinematics/chunk_rigid_velocity_at_point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_rigid_velocity_at_point.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/physics/kinematics/chunk_rigid_velocity_at_point.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,4CAFU,SAAS,CAWjB;0BApBwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/physics/kinematics/chunk_rigid_velocity_at_point.js

@@ -0,0 +1,21 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Velocity of a point `p` carried by a rigid body: `v + ω × (p − c)`. The body moves at
+ * `linear_velocity` at the point `origin` it turns about, and spins at `angular_velocity` radians per
+ * second about it.
+ *
+ * The WGSL twin of `rigid_velocity_at_point` (`core/math/physics/kinematics/rigid_velocity_at_point.js`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_rigid_velocity_at_point = CodeChunk.from(
+    //language=WGSL
+    `
+fn rigid_velocity_at_point(
+    linear_velocity: vec3<f32>, angular_velocity: vec3<f32>, origin: vec3<f32>, p: vec3<f32>
+) -> vec3<f32> {
+    return linear_velocity + cross(angular_velocity, p - origin);
+}
+    `
+);

package/src/shade/renderer/shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The scene's depth, as the screen-space marches read it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SCREEN_DEPTH_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The hierarchical Z buffer, starting at mip 1.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SCREEN_HZB_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The scene's normals, encoded.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SCREEN_NORMAL_RESOURCE: ShaderResourceDescriptor;
+import { ShaderResourceDescriptor } from "../../resource/ShaderResourceDescriptor.js";
+//# sourceMappingURL=SCREEN_SPACE_RESOURCES.d.ts.map

package/src/shade/renderer/shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SCREEN_SPACE_RESOURCES.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oCAFU,wBAAwB,CAE8C;AAEhF;;;GAGG;AACH,kCAFU,wBAAwB,CAE0C;AAE5E;;;GAGG;AACH,qCAFU,wBAAwB,CAEwD;yCAlBjD,4CAA4C"}

package/src/shade/renderer/shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.js

@@ -0,0 +1,19 @@
+import { ShaderResourceDescriptor } from "../../resource/ShaderResourceDescriptor.js";
+
+/**
+ * The scene's depth, as the screen-space marches read it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SCREEN_DEPTH_RESOURCE = ShaderResourceDescriptor.texture("tDepth");
+
+/**
+ * The hierarchical Z buffer, starting at mip 1.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SCREEN_HZB_RESOURCE = ShaderResourceDescriptor.texture("tHZB");
+
+/**
+ * The scene's normals, encoded.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SCREEN_NORMAL_RESOURCE = ShaderResourceDescriptor.texture("tNormal", "uint");

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_load_depth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ffx_sssr_load_depth.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_load_depth.js"],"names":[],"mappings":"AAEA,kDAYE;0BAdwB,6BAA6B"}
+{"version":3,"file":"chunk_ffx_sssr_load_depth.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_load_depth.js"],"names":[],"mappings":"AAGA,kDAYE;0BAfwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_load_depth.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { SCREEN_DEPTH_RESOURCE, SCREEN_HZB_RESOURCE } from "./SCREEN_SPACE_RESOURCES.js";
 
 export const chunk_ffx_sssr_load_depth = CodeChunk.from(
 //language=WGSL
@@ -12,4 +13,7 @@ fn ffx_sssr_load_depth(pixel_coordinate:vec2<i32>, mip:i32) -> f32{
     }
 }
     `
-);
+);
+
+chunk_ffx_sssr_load_depth.requireResource(SCREEN_DEPTH_RESOURCE);
+chunk_ffx_sssr_load_depth.requireResource(SCREEN_HZB_RESOURCE);

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_load_world_space_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ffx_sssr_load_world_space_normal.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_load_world_space_normal.js"],"names":[],"mappings":"AAGA,+DAUE;0BAbwB,6BAA6B"}
+{"version":3,"file":"chunk_ffx_sssr_load_world_space_normal.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_load_world_space_normal.js"],"names":[],"mappings":"AAIA,+DAUE;0BAdwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_load_world_space_normal.js

@@ -1,5 +1,6 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { chunk_decode_g_buffer_normal } from "../geometry/normal/chunk_decode_g_buffer_normal.js";
+import { SCREEN_NORMAL_RESOURCE } from "./SCREEN_SPACE_RESOURCES.js";
 
 export const chunk_ffx_sssr_load_world_space_normal = CodeChunk.from(
     //language=WGSL
@@ -11,4 +12,6 @@ fn ffx_sssr_load_world_space_normal(texel_coord: vec2<i32>)-> vec3<f32>{
     `, [
         chunk_decode_g_buffer_normal
     ]
-);
+);
+
+chunk_ffx_sssr_load_world_space_normal.requireResource(SCREEN_NORMAL_RESOURCE);

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_screen_space_to_view_space.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ffx_sssr_screen_space_to_view_space.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_screen_space_to_view_space.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wDAFU,SAAS,CAWlB;0BAhByB,6BAA6B"}
+{"version":3,"file":"chunk_ffx_sssr_screen_space_to_view_space.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_screen_space_to_view_space.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wDAFU,SAAS,CAWlB;0BAjByB,6BAA6B"}

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_screen_space_to_view_space.js

@@ -1,5 +1,6 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { chunk_inv_project_position } from "./chunk_inv_project_position.js";
+import { CAMERA_RESOURCE } from "../../../camera/CAMERA_RESOURCE.js";
 
 /**
  * TODO replace with {@link chunk_get_view_space_depth} / {@link chunk_get_view_space_position_uv}
@@ -14,4 +15,6 @@ fn ffx_sssr_screen_space_to_view_space(screen_space_position_uv: vec3<f32>) -> v
     `, [
         chunk_inv_project_position
     ]
-)
+)
+
+chunk_ffx_sssr_screen_space_to_view_space.requireResource(CAMERA_RESOURCE);

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_validate_hit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ffx_sssr_validate_hit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_validate_hit.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,gDAFU,SAAS,CAmBhB;AAEH,oEAoBC;AAGD;;;;;GAKG;AACH,gDAFU,SAAS,CAyDlB;AAED;;;;GAIG;AACH,0CAFU,SAAS,CAyBjB;0BA/IwB,6BAA6B"}
+{"version":3,"file":"chunk_ffx_sssr_validate_hit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_validate_hit.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,gDAFU,SAAS,CAmBhB;AAEH,oEAoBC;AAGD;;;;;GAKG;AACH,gDAFU,SAAS,CAyDlB;AAID;;;;GAIG;AACH,0CAFU,SAAS,CAyBjB;0BAlJwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_validate_hit.js

@@ -4,6 +4,7 @@ import { chunk_ffx_sssr_load_depth } from "./chunk_ffx_sssr_load_depth.js";
 import { chunk_ffx_sssr_load_world_space_normal } from "./chunk_ffx_sssr_load_world_space_normal.js";
 import { chunk_ffx_sssr_screen_space_to_view_space } from "./chunk_ffx_sssr_screen_space_to_view_space.js";
 import { chunk_uv_is_out_of_bounds } from "./chunk_uv_is_out_of_bounds.js";
+import { CAMERA_RESOURCE } from "../../../camera/CAMERA_RESOURCE.js";
 
 /**
  * @see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/samples/hybridreflections/shaders/ffx_sssr_intersect.h#L163
@@ -114,6 +115,8 @@ fn ffx_validate_screen_ray_hit(
     ]
 )
 
+chunk_ffx_validate_screen_ray_hit.requireResource(CAMERA_RESOURCE);
+
 /**
  * NOTE: default thickness from FFX is 0.015, see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/samples/sssr/sssrrendermodule.h#L72
  * @see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/samples/hybridreflections/shaders/ffx_sssr_intersect.h#L163

package/src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_scene_sdf_raymarch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.js"],"names":[],"mappings":"AAoBA,iDAiGE;0BAjHwB,6BAA6B"}
+{"version":3,"file":"chunk_scene_sdf_raymarch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.js"],"names":[],"mappings":"AAkBA,iDAiGE;0BAjHwB,6BAA6B"}