@woosh/meep-engine 3.67.0 → 3.68.0

package/src/shade/renderer/atmosphere/shader_sky_view_lut.js

@@ -0,0 +1,111 @@
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_mat4_extract_position } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+import { u32, vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { ATMOSPHERE_PARAMETERS_STRUCT } from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_raymarch_sky_scattering } from "./chunk_raymarch_sky_scattering.js";
+import { chunk_sky_irradiance_lut_encode_uv } from "./chunk_sky_irradiance_lut_encode_uv.js";
+import {
+    SKY_LUT_MULTISCATTER_RESOURCE,
+    SKY_LUT_SAMPLER_RESOURCE,
+    SKY_LUT_TRANSMITTANCE_RESOURCE
+} from "./SAMPLER_SKY_LUT.js";
+
+export const SKY_VIEW_LUT_WIDTH = 192;
+export const SKY_VIEW_LUT_HEIGHT = 108;
+
+export const SKY_VIEW_LUT_SETTINGS_STRUCT = WebGPUStruct.from({
+    sun_direction: vec3f,
+    resolution_x: u32,
+    sun_irradiance: vec3f,
+    resolution_y: u32,
+}, "SkyViewLutSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", SKY_VIEW_LUT_SETTINGS_STRUCT);
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("atmosphere", ATMOSPHERE_PARAMETERS_STRUCT)
+    .add(SKY_LUT_TRANSMITTANCE_RESOURCE)
+    .add(SKY_LUT_MULTISCATTER_RESOURCE)
+    .add(SKY_LUT_SAMPLER_RESOURCE);
+
+/**
+ * Per-view $192 \times 108$ horizon-warped Sky-View LUT generator (Hillaire 2020, §5.3).
+ *
+ * Evaluates scattering in the camera's local planet-up frame where `up = +Y` and the sun lies in
+ * the `+X/+Y` half-plane, matching {@link chunk_sky_irradiance_lut_encode_uv}.
+ *
+ * @type {CodeChunk}
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> @location(0) vec4<f32> {
+    let sun_len_sq = dot(settings.sun_direction, settings.sun_direction);
+    if (sun_len_sq <= 1e-12 || all(settings.sun_irradiance <= vec3<f32>(0.0))) {
+        return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+    }
+
+    let sun_dir_world = settings.sun_direction * inverseSqrt(sun_len_sq);
+
+    let view_pos = mat4_extract_position(camera.transform);
+    let view_rel_world = atmosphere_clamped_observer_relative(atmosphere, view_pos);
+    let observer_radius = length(view_rel_world);
+    let up_world = view_rel_world / observer_radius;
+
+    let resolution = vec2<f32>(f32(settings.resolution_x), f32(settings.resolution_y));
+    let decoded = sky_view_lut_decode_texel(
+        atmosphere.planet_radius,
+        observer_radius,
+        floor(coord.xy),
+        resolution
+    );
+
+    let sun_cos_zenith = clamp(dot(sun_dir_world, up_world), -1.0, 1.0);
+    let sun_sin_zenith = sqrt(max(1.0 - sun_cos_zenith * sun_cos_zenith, 0.0));
+    let sun_local = vec3<f32>(sun_sin_zenith, sun_cos_zenith, 0.0);
+
+    let view_rel_local = vec3<f32>(0.0, observer_radius, 0.0);
+    let bounds = atmosphere_ray_bounds_for(atmosphere, view_rel_local, decoded.ray_local);
+
+    let lum = raymarch_sky_scattering(
+        atmosphere,
+        view_rel_local,
+        decoded.ray_local,
+        sun_local,
+        bounds.t_max,
+        decoded.hits_ground && bounds.hits_ground
+    );
+
+    return vec4<f32>(lum * settings.sun_irradiance, 1.0);
+}
+    `, [
+        chunk_mat4_extract_position,
+        chunk_sky_irradiance_lut_encode_uv,
+        chunk_raymarch_sky_scattering,
+    ]
+);
+
+export const shader_sky_view_lut = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Sky / sky-view LUT",
+        resources,
+        body,
+    }),
+    targets: [
+        {
+            label: "sky_view_lut",
+            format: "rgba16float",
+        }
+    ]
+});

package/src/shade/renderer/atmosphere/shader_transmittance_lut.d.ts

@@ -1,5 +1,4 @@
 /**
- * @see https://www.shadertoy.com/view/slSXRW
  * @type {ImageShader}
  */
 export const shader_transmittance_lut: ImageShader;

package/src/shade/renderer/atmosphere/shader_transmittance_lut.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_transmittance_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/shader_transmittance_lut.js"],"names":[],"mappings":"AAgEA;;;GAGG;AACH,uCAFU,WAAW,CAWlB;4BAtEyB,0BAA0B"}
+{"version":3,"file":"shader_transmittance_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/shader_transmittance_lut.js"],"names":[],"mappings":"AAuDA;;GAEG;AACH,uCAFU,WAAW,CAWlB;4BAhEyB,0BAA0B"}

package/src/shade/renderer/atmosphere/shader_transmittance_lut.js

@@ -1,79 +1,68 @@
-import { u32, vec2u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-import { ATMOSPHERE_HEIGHT_DECLARATION } from "../shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js";
-import { chunk_get_sun_transmittance } from "../shader/chunk/atmosphere/chunk_get_sun_transmittance.js";
-import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
-import { chunk_sky_lut_texel_to_unit } from "./chunk_sky_lut_texel_to_unit.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ImageShader } from "../shader/ImageShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
-
-const TRANSMITTANCE_LUT_SETTINGS_STRUCT = WebGPUStruct.from({
-    // how many ray-marching steps to take per pixel of LUT, more steps = higher accuracy but lower performance
-    steps: u32,
-    // size of the target being written, which a fragment shader cannot ask for. Needed to
-    // know which point of the parameter range each texel stands for -- see
-    // chunk_sky_lut_texel_to_unit. Pass the dimensions of the texture actually being drawn
-    // into: a mismatch silently skews the whole LUT.
-    resolution: vec2u,
-});
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-pass, 16 bytes, read-only: immediate data rather than a uniform buffer
-resources.setImmediate("settings", TRANSMITTANCE_LUT_SETTINGS_STRUCT);
-
-/**
- * @see https://www.shadertoy.com/view/slSXRW
- * @type {CodeChunk}
- */
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-
-@fragment
-fn main(
-    @builtin(position) coord: vec4<f32>,
-) -> @location(0) vec4<f32> {
-
-    // coord.xy is the fragment centre, so flooring it gives this texel's index. The point of
-    // each range the texel stands for then comes from sky_lut_texel_to_unit, whose inverse
-    // sky_lut_uv every lookup goes through -- a generator that skipped it would write a LUT
-    // addressed half a texel off at both ends.
-    let unit = sky_lut_texel_to_unit(floor(coord.xy), vec2<f32>(settings.resolution));
-
-    let sunCosTheta = 2.0*unit.x - 1.0;
-    let sunTheta = safe_acos(sunCosTheta);
-
-    let height = ATMOSPHERE_HEIGHT*unit.y;
-    
-    let pos = vec3(0.0, height, 0.0); 
-    let sunDir = normalize(vec3(0.0, sunCosTheta, -sin(sunTheta)));
-    
-    return vec4(get_sun_transmittance(pos, sunDir, f32(settings.steps)), 1.0);
-
-}
-    `, [
-        chunk_get_sun_transmittance,
-        chunk_safe_acos,
-        chunk_sky_lut_texel_to_unit,
-        ATMOSPHERE_HEIGHT_DECLARATION,
-    ]
-);
-
-/**
- * @see https://www.shadertoy.com/view/slSXRW
- * @type {ImageShader}
- */
-export const shader_transmittance_lut = new ImageShader({
-    descriptor: ShaderDescriptor.from({
-        label: "Sky / transmittance LUT",
-        resources,
-        body
-    }),
-    targets: [{
-        format: "rgba16float",
-    }]
-});
-
+import { chunk_get_sun_transmittance } from "../shader/chunk/atmosphere/chunk_get_sun_transmittance.js";
+import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+import { u32, vec2u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { ATMOSPHERE_PARAMETERS_STRUCT } from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_sky_lut_texel_to_unit } from "./chunk_sky_lut_texel_to_unit.js";
+
+const TRANSMITTANCE_LUT_SETTINGS_STRUCT = WebGPUStruct.from({
+    steps: u32,
+    resolution: vec2u,
+}, "TransmittanceLutSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", TRANSMITTANCE_LUT_SETTINGS_STRUCT);
+resources.createGroup()
+    .addUniform("atmosphere", ATMOSPHERE_PARAMETERS_STRUCT);
+
+/**
+ * Transmittance LUT generator (`256×64` `rgba16float`), parameterised by `(sunCosTheta, altitude)`
+ * and driven by the scene's {@link ATMOSPHERE_PARAMETERS_STRUCT} uniform.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ * @type {CodeChunk}
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> @location(0) vec4<f32> {
+    let unit = sky_lut_texel_to_unit(floor(coord.xy), vec2<f32>(settings.resolution));
+
+    let sunCosTheta = 2.0 * unit.x - 1.0;
+    let sunTheta = safe_acos(sunCosTheta);
+
+    let height = atmosphere.atmosphere_height * unit.y;
+
+    let origin_rel = vec3<f32>(0.0, atmosphere.planet_radius + height, 0.0);
+    let sunDir = normalize(vec3<f32>(0.0, sunCosTheta, -sin(sunTheta)));
+
+    return vec4<f32>(get_sun_transmittance_rel_for(atmosphere, origin_rel, sunDir, f32(settings.steps)), 1.0);
+}
+    `, [
+        chunk_get_sun_transmittance,
+        chunk_safe_acos,
+        chunk_sky_lut_texel_to_unit,
+    ]
+);
+
+/**
+ * @type {ImageShader}
+ */
+export const shader_transmittance_lut = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Sky / transmittance LUT",
+        resources,
+        body
+    }),
+    targets: [{
+        format: "rgba16float",
+    }]
+});

package/src/shade/renderer/deferred/shader_background.js

@@ -1,6 +1,6 @@
 import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
 import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_sample_environment_color } from "../atmosphere/chunk_sample_environment_color.js";
+import { chunk_sample_environment_color } from "../light/environment/chunk_sample_environment_color.js";
 import { chunk_uv_to_ndc } from "../shader/chunk/texture/chunk_uv_to_ndc.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../shader/ImageShader.js";

package/src/shade/renderer/deferred/shader_background_sky.d.ts

@@ -0,0 +1,5 @@
+export const SKY_BACKGROUND_SETTINGS_STRUCT: WebGPUStruct;
+export const shader_background_sky: ImageShader;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { ImageShader } from "../shader/ImageShader.js";
+//# sourceMappingURL=shader_background_sky.d.ts.map

package/src/shade/renderer/deferred/shader_background_sky.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_background_sky.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_background_sky.js"],"names":[],"mappings":"AAeA,0DAK4B;AA6F5B,gDAgBG;6BApH0B,gCAAgC;4BAJjC,0BAA0B"}

package/src/shade/renderer/deferred/shader_background_sky.js

@@ -0,0 +1,130 @@
+import { ATMOSPHERE_PARAMETERS_STRUCT } from "../atmosphere/ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_sample_transmittance_lut_params_for } from "../atmosphere/chunk_sample_transmittance_lut.js";
+import { chunk_sky_irradiance_lut_encode_uv } from "../atmosphere/chunk_sky_irradiance_lut_encode_uv.js";
+import { SKY_LUT_SAMPLER_RESOURCE, SKY_LUT_TRANSMITTANCE_RESOURCE } from "../atmosphere/SAMPLER_SKY_LUT.js";
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_mat4_extract_position } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
+import { chunk_uv_to_ndc } from "../shader/chunk/texture/chunk_uv_to_ndc.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+import { f32, u32, vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+
+export const SKY_BACKGROUND_SETTINGS_STRUCT = WebGPUStruct.from({
+    sun_direction: vec3f,
+    sun_disk_radius: f32,
+    sun_irradiance: vec3f,
+    sun_has_disc: u32,
+}, "SkyBackgroundSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", SKY_BACKGROUND_SETTINGS_STRUCT);
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("atmosphere", ATMOSPHERE_PARAMETERS_STRUCT)
+    .addTexture("tSkyViewLut", "float")
+    .add(SKY_LUT_TRANSMITTANCE_RESOURCE)
+    .add(SKY_LUT_SAMPLER_RESOURCE);
+
+/**
+ * Full-screen atmospheric sky background shader sampling Hillaire's $192 \times 108$ Sky-View LUT
+ * and compositing a transmittance-attenuated, limb-darkened solar disc when the ray misses the
+ * planet sphere.
+ *
+ * @type {CodeChunk}
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+// Clamp pre-bloom f16 sky-disc radiance well inside rgba16float range (max 65504) to prevent Inf/NaN.
+const MAX_SOLAR_DISC_RADIANCE = 16384.0;
+
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+) -> @location(0) vec4<f32> {
+    let clip_pos = vec4<f32>(uv_to_ndc(uv), 0.0, 1.0);
+    let world_dir_h = camera.view_projection_matrix_inverse * clip_pos;
+    let view_direction = normalize(world_dir_h.xyz);
+    let view_position = mat4_extract_position(camera.transform);
+
+    let sun_len_sq = dot(settings.sun_direction, settings.sun_direction);
+    if (sun_len_sq <= 1e-12 || all(settings.sun_irradiance <= vec3<f32>(0.0))) {
+        return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+    }
+    let sun_dir = settings.sun_direction * inverseSqrt(sun_len_sq);
+
+    let lut_res = vec2<f32>(textureDimensions(tSkyViewLut));
+    let sky_uv = sky_view_lut_uv_for(atmosphere, view_position, view_direction, sun_dir, lut_res);
+    var result = textureSampleLevel(tSkyViewLut, sSkyLut, sky_uv, 0.0).rgb;
+
+    if (settings.sun_has_disc != 0u && settings.sun_disk_radius > 0.0) {
+        let view_rel = atmosphere_clamped_observer_relative(atmosphere, view_position);
+        let bounds = atmosphere_ray_bounds_for(atmosphere, view_rel, view_direction);
+
+        if (!bounds.hits_ground) {
+            let angular_radius = max(settings.sun_disk_radius, 0.0045);
+            let cos_outer = cos(angular_radius * 1.06);
+            let cos_inner = cos(angular_radius * 0.88);
+            let cos_angle = dot(view_direction, sun_dir);
+            let disc_mask = smoothstep(cos_outer, cos_inner, cos_angle);
+
+            if (disc_mask > 0.0) {
+                let cos_radius = cos(angular_radius);
+                let mu = sqrt(saturate((cos_angle - cos_outer) / max(1.0 - cos_outer, 1e-6)));
+                // Eddington solar limb darkening (mean over disc = 0.8)
+                let limb = (0.4 + 0.6 * mu) * (1.0 / 0.8);
+                let solid_angle = max(2.0 * PI * (1.0 - cos_radius), 1e-6);
+
+                let observer_radius = length(view_rel);
+                let up = view_rel / observer_radius;
+                let altitude = observer_radius - atmosphere.planet_radius;
+                let sun_transmittance = sample_transmittance_lut_params_for(
+                    atmosphere,
+                    altitude,
+                    dot(view_direction, up)
+                );
+
+                let raw_disc_radiance = (settings.sun_irradiance / solid_angle) * limb * sun_transmittance;
+                let max_channel = max(max(raw_disc_radiance.r, raw_disc_radiance.g), max(raw_disc_radiance.b, 1e-6));
+                let disc_radiance = raw_disc_radiance * min(1.0, MAX_SOLAR_DISC_RADIANCE / max_channel);
+
+                result += disc_radiance * disc_mask;
+            }
+        }
+    }
+
+    return vec4<f32>(result, 1.0);
+}
+    `, [
+        PI_DECLARATION,
+        chunk_uv_to_ndc,
+        chunk_mat4_extract_position,
+        chunk_sky_irradiance_lut_encode_uv,
+        chunk_sample_transmittance_lut_params_for,
+    ]
+);
+
+export const shader_background_sky = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "Scene Background / Atmosphere Sky",
+        resources,
+        body
+    }),
+    depthStencil: {
+        format: "depth32float",
+        depthCompare: "equal"
+    },
+    targets: [
+        {
+            label: "shaded",
+            format: "rgba16float"
+        }
+    ]
+});

package/src/shade/renderer/deferred/tonemap/chunk_tonemap_purkinje.d.ts

@@ -13,7 +13,8 @@ export const TONEMAP_ADAPTATION_RESOURCE: ShaderResourceDescriptor;
  * ```
  *
  * - `false`, the default: the colour as it is.
- * - `true`: the colour through `apply_purkinje_shift` at the view's adaptation, {@link TONEMAP_ADAPTATION_RESOURCE}.
+ * - `true`: the colour through `apply_purkinje_shift` at the view's adaptation, {@link TONEMAP_ADAPTATION_RESOURCE},
+ *   across CIE 191's mesopic range.
  *
  * The shift is linear in the colour, so the function may be applied ahead of the exposure or after it.
  *

package/src/shade/renderer/deferred/tonemap/chunk_tonemap_purkinje.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_tonemap_purkinje.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/chunk_tonemap_purkinje.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,0CAFU,wBAAwB,CAE8E;AAEhH;;;;;;;;;;;;;GAaG;AACH,qCAFU,eAAe,CAE0D;yCA1B1C,mDAAmD;gCAD5D,0CAA0C"}
+{"version":3,"file":"chunk_tonemap_purkinje.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/chunk_tonemap_purkinje.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,0CAFU,wBAAwB,CAE8E;AAEhH;;;;;;;;;;;;;;GAcG;AACH,qCAFU,eAAe,CAE0D;yCA3B1C,mDAAmD;gCAD5D,0CAA0C"}

package/src/shade/renderer/deferred/tonemap/chunk_tonemap_purkinje.js

@@ -21,7 +21,8 @@ export const TONEMAP_ADAPTATION_RESOURCE = ShaderResourceDescriptor.uniform("ada
  * ```
  *
  * - `false`, the default: the colour as it is.
- * - `true`: the colour through `apply_purkinje_shift` at the view's adaptation, {@link TONEMAP_ADAPTATION_RESOURCE}.
+ * - `true`: the colour through `apply_purkinje_shift` at the view's adaptation, {@link TONEMAP_ADAPTATION_RESOURCE},
+ *   across CIE 191's mesopic range.
  *
  * The shift is linear in the colour, so the function may be applied ahead of the exposure or after it.
  *
@@ -41,7 +42,10 @@ const shifted = CodeChunk.from(
     //language=WGSL
     `
 fn tonemap_purkinje(color: vec3<f32>) -> vec3<f32> {
-    return apply_purkinje_shift(color, adaptation.value);
+    return apply_purkinje_shift(
+        color,
+        purkinje_rod_share(adaptation.value, PURKINJE_MESOPIC_MIN_NITS, PURKINJE_MESOPIC_MAX_NITS)
+    );
 }
 `, [chunk_apply_purkinje_shift]);
 

package/src/shade/renderer/extension/ViewTextures.d.ts

@@ -41,8 +41,9 @@ export class ViewTextures extends FrameRecord {
     get visible_meshlets(): number;
     set velocity(handle: number);
     /**
-     * How far each pixel's surface moved on screen since the last frame: `rg16float`, in pixels, this
-     * frame's place less last frame's, free of the sub-pixel jitter. The renderer fills it from depth and
+     * How far each pixel's surface moved since the last frame, `VELOCITY_FORMAT`: in xy the pixels from last
+     * frame's place to this frame's, in z the view depth now less then, free of the sub-pixel jitter
+     * (`chunk_velocity_texel` makes the texel). The renderer fills it from depth and
      * {@link visibility} before {@link FramePhase.AfterGBuffer}; an extension that draws surfaces the
      * visibility buffer cannot describe writes their pixels' motion over it at that phase and publishes
      * the handle it wrote. What is published later than that phase reaches nothing the renderer runs.

package/src/shade/renderer/extension/ViewTextures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH;IAOI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAgBD,mCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAiBD,+BAEC;IAbD;;;;;;OAMG;IACH,yBAEC;IAiBD,qCAEC;IAbD;;;;;;OAMG;IACH,+BAEC;IAmBD,6BAEC;IAfD;;;;;;;;OAQG;IACH,uBAEC;;CAKJ;4BA/F2B,kBAAkB"}
+{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH;IAOI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAgBD,mCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAiBD,+BAEC;IAbD;;;;;;OAMG;IACH,yBAEC;IAiBD,qCAEC;IAbD;;;;;;OAMG;IACH,+BAEC;IAoBD,6BAEC;IAhBD;;;;;;;;;OASG;IACH,uBAEC;;CAKJ;4BAhG2B,kBAAkB"}

package/src/shade/renderer/extension/ViewTextures.js

@@ -79,8 +79,9 @@ export class ViewTextures extends FrameRecord {
     }
 
     /**
-     * How far each pixel's surface moved on screen since the last frame: `rg16float`, in pixels, this
-     * frame's place less last frame's, free of the sub-pixel jitter. The renderer fills it from depth and
+     * How far each pixel's surface moved since the last frame, `VELOCITY_FORMAT`: in xy the pixels from last
+     * frame's place to this frame's, in z the view depth now less then, free of the sub-pixel jitter
+     * (`chunk_velocity_texel` makes the texel). The renderer fills it from depth and
      * {@link visibility} before {@link FramePhase.AfterGBuffer}; an extension that draws surfaces the
      * visibility buffer cannot describe writes their pixels' motion over it at that phase and publishes
      * the handle it wrote. What is published later than that phase reaches nothing the renderer runs.

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -143,7 +143,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#289@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#292@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -151,7 +151,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#289@#execute_fill"(record: object, _resources: any, context: {
+    static "__#292@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -159,7 +159,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#289@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#292@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts

@@ -63,7 +63,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#291@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#294@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -90,19 +90,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#292@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#295@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#292@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#295@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#292@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#292@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#292@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#292@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#295@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#295@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#295@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#295@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -41,7 +41,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#288@#execute"(data: {
+    static "__#291@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

package/src/shade/renderer/fluid/query/GPUFluidQueries.d.ts

@@ -49,7 +49,7 @@ export class GPUFluidQueries {
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#293@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#296@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/global_illumination/probe/octahedral/shader_lpv_build_gbuffer.js

@@ -1,7 +1,7 @@
 import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { chunk_sample_environment_color } from "../../../atmosphere/chunk_sample_environment_color.js";
+import { chunk_sample_environment_color } from "../../../light/environment/chunk_sample_environment_color.js";
 import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../../../material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
 import { chunk_indirect_sample_texture } from "../../../path_tracer/shader/chunk_indirect_sample_texture.js";
 

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts

@@ -34,7 +34,7 @@ export class GPUProbeClipmapGI {
      * @param {ProbeClipmapSettings} settings
      * @returns {boolean} whether it is what the settings' world cache describes, in their frustum's windows
      */
-    static "__#214@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
+    static "__#215@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
     /**
      * @param {GraphicsContext} graphics
      */
@@ -55,6 +55,24 @@ export class GPUProbeClipmapGI {
      * @returns {ProbeClipmapSceneHolds|undefined} undefined while the mode is not running
      */
     get holds(): ProbeClipmapSceneHolds;
+    /**
+     * @returns {GPUBrickMaterial|undefined} the bricks' surface material, which a ray's hit reads; undefined while the
+     *   mode is not running
+     */
+    get material(): GPUBrickMaterial;
+    /**
+     * @returns {number} the graph handle of the brick clipmap's last write in this frame's {@link graph_update}, which a
+     *   pass tracing the bricks after it reads
+     */
+    get bricks(): number;
+    /**
+     * @returns {{lookup: number, data: number}} graph handles of the world light clusters this frame's
+     *   {@link graph_update} built over the bricks' cascades, where a ray's hit finds its local lights
+     */
+    get clusters(): {
+        lookup: number;
+        data: number;
+    };
     /**
      * Take a frame of the mode: make the clipmaps for `view` and the structure `settings` describe,
      * unless they already are, hold the scene's geometry caches and record their bake. Allocates nothing
@@ -201,4 +219,5 @@ export type BrickProvider = import("./brick/GPUBrickClipmap.js").BrickProvider;
 import { GPUBrickClipmap } from "./brick/GPUBrickClipmap.js";
 import { GPUProbeClipmap } from "./probe/GPUProbeClipmap.js";
 import { ProbeClipmapSceneHolds } from "./ProbeClipmapSceneHolds.js";
+import { GPUBrickMaterial } from "./material/GPUBrickMaterial.js";
 //# sourceMappingURL=GPUProbeClipmapGI.d.ts.map