@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/global_illumination/clipmap/shader_debug_clipmap.js

@@ -1,25 +1,40 @@
 import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.js";
 import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
-import { chunk_lut_inferno } from "../../shader/chunk/color/lut/chunk_lut_inferno.js";
+import { chunk_clipmap_select_finest } from "../../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
+import { CLIPMAP_LEVEL_ARRAY } from "../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { chunk_lut_viridis } from "../../shader/chunk/color/lut/chunk_lut_viridis.js";
+import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.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 { chunk_clip_cascade_coord_encode } from "./chunk_clip_cascade_wrap_coord.js";
-import { CLIPMAP_METADATA } from "./CLIPMAP_METADATA.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * What the overlay draws: a clipmap's levels, finest first, and the width of their edge bands.
+ * @type {WebGPUStruct}
+ */
+export const CLIPMAP_DEBUG_STRUCT = WebGPUStruct.from({
+    /**
+     * Levels of {@link levels} in use.
+     */
+    level_count: u32,
+    /**
+     * Cells, positive: how far into a window its edge band reaches.
+     */
+    band_width: f32,
+    levels: CLIPMAP_LEVEL_ARRAY,
+}, "ClipmapDebug");
 
 const resources = new ShaderResourceSetDescriptor();
 resources.createGroup()
     .addTexture("tDepth")
-    .addTexture("gBufferOcclusion")
-    .addUniform("clipmap_info", CLIPMAP_METADATA)
+    .addUniform("clipmap", CLIPMAP_DEBUG_STRUCT)
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
 ;
 
 /**
- *
  * @type {CodeChunk}
  */
 const body = CodeChunk.from(
@@ -33,75 +48,60 @@ fn main(
     let coord_i = vec2<i32>(coord.xy);
 
     let device_depth = textureLoad(tDepth, coord_i, 0).r;
-    
+
     if(is_background(device_depth)){
-        discard ;
+        discard;
     }
 
-    let position_ws = project_position_from_depth(uv, device_depth, camera.view_projection_matrix_inverse );
+    let position_ws = project_position_from_depth(uv, device_depth, camera.view_projection_matrix_inverse);
+
+    let selection = clipmap_select_finest(&clipmap.levels, clipmap.level_count, position_ws, clipmap.band_width);
 
-    var clip_level = clipmap_info.cascade_count;
-    var distance_to_boxel_boundary = 1.0;
-    
-    for(var i=0u; i < clipmap_info.cascade_count; i++){
-        let cascade = clipmap_info.cascades[i];
-    
-        let position_vx = (position_ws / cascade.voxel_size);
-        
-        let position_vx_i = vec3i(position_vx);
-        
-        let center = cascade.offset;
-        
-        if(any(vec3u(abs(position_vx_i - center)) >= vec3(clipmap_info.cascade_resolution/2))){
-            continue;
-        }
-        
-        let voxel_coord = clip_cascade_coord_encode(
-            position_vx_i,
-            clipmap_info.cascade_resolution,
-            center,
-        );
-        
-        let distance_to_boundary = min( fract(position_vx), 1.0 - fract(position_vx) );
-        distance_to_boxel_boundary = min(distance_to_boundary.x, min(distance_to_boundary.y, distance_to_boundary.z));
-        
-        clip_level = i;
-        break;
+    if(selection.level == CLIPMAP_LEVEL_NONE){
+        discard;
     }
-    
-    var color = viridis(1.0 - ( f32(clip_level) + 0.5) / f32(clipmap_info.cascade_count));
-    
-    
-    
-    // check out this https://gamedev.stackexchange.com/questions/183899/how-to-render-a-grid-of-dots-being-exactly-1x1-pixel-wide-using-a-shader
-    // want to draw lines such that they are readable at every distance and don't get larger as we get closer
-    let voxel_boundary = smoothstep(0.0, 0.02/clipmap_info.cascades[clip_level].voxel_size, distance_to_boxel_boundary) ;
-    
-    color = mix(vec3(0.11),color,voxel_boundary);
-    
-    let ao_term = textureLoad(gBufferOcclusion,coord_i, 0).a;
-    
-    color = color * ao_term;
-    
 
-    return vec4(color,1.0);
+    // a colour per level, finest brightest; the edge band shades toward the next level's colour
+    let level_count = f32(clipmap.level_count);
+    let own_color = viridis(1.0 - (f32(selection.level) + 0.5) / level_count);
+    let next_color = viridis(1.0 - (f32(selection.level) + 1.5) / level_count);
+
+    var color = mix(own_color, next_color, selection.edge_weight);
+
+    // lines on the level's cell faces, two centimetres wide in the world
+    let cell_size = clipmap.levels[selection.level].cell_size;
+    let position_cells = position_ws / cell_size;
+    let to_face = min(fract(position_cells), 1.0 - fract(position_cells));
+    let nearest_face = min(to_face.x, min(to_face.y, to_face.z));
+
+    color = mix(vec3(0.11), color, smoothstep(0.0, 0.02 / cell_size, nearest_face));
+
+    return vec4(color, 1.0);
 }
     `, [
         chunk_project_position_from_depth,
-        chunk_clip_cascade_coord_encode,
+        chunk_clipmap_select_finest,
         chunk_lut_viridis,
-        chunk_lut_inferno,
         chunk_is_background,
     ]
 );
 
+/**
+ * A debug overlay for any clipmap of cascades: each surface pixel takes the colour of the finest
+ * level whose window holds it, shaded toward the next level's colour across that window's edge band,
+ * with lines on the level's cell faces. Pixels no level holds, and the background, are discarded.
+ *
+ * Reads the scene depth, a {@link CLIPMAP_DEBUG_STRUCT} and the camera.
+ *
+ * @type {ImageShader}
+ */
 export const shader_debug_clipmap = ImageShader.from({
     descriptor: ShaderDescriptor.from({
-        label: "Clipmap3D Debug",
+        label: "Clipmap Debug",
         resources,
         body
     }),
     targets: [{
         format: "rgba16float"
     }]
-})
+})

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightProbeVolumeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js"],"names":[],"mappings":"AAsBA;;;GAGG;AAEH;IA+GI;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,QAQzB;IAhCD;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,EAgBzB;IAtFD;;;OAGG;IACH,sCAEC;IAdD;;;OAGG;IACH,qCAEC;IAoCD;;;OAGG;IACH,6BAEC;IAYD;;;OAGG;IACH,0CASC;IAyDD;;;OAGG;IACH,gCAFW,MAAM,wEAUhB;IAED;;;;;OAKG;IACH,qBAJW,sBAAsB,gBACtB,MAAM,qBACN,MAAM,QA6ChB;IAED,aAqGC;IAED;;;OAGG;IACH,sCAFW,MAAM,QA8ChB;IAED;;;OAGG;IACH,eAFY,MAAM,CAUjB;IAED,gBACC;;CACJ;8BA/XY,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,mCAAmC,EAAE,eAAe;kCAbtC,uCAAuC;uCAFlC,8CAA8C"}
+{"version":3,"file":"GPULightProbeVolumeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js"],"names":[],"mappings":"AAsBA;;;GAGG;AAEH;IA+GI;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,QAQzB;IAhCD;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,EAgBzB;IAtFD;;;OAGG;IACH,sCAEC;IAdD;;;OAGG;IACH,qCAEC;IAoCD;;;OAGG;IACH,6BAEC;IAYD;;;OAGG;IACH,0CASC;IAyDD;;;OAGG;IACH,gCAFW,MAAM,wEAUhB;IAED;;;;;OAKG;IACH,qBAJW,sBAAsB,gBACtB,MAAM,qBACN,MAAM,QA6ChB;IAED,aAuGC;IAED;;;OAGG;IACH,sCAFW,MAAM,QA8ChB;IAED;;;OAGG;IACH,eAFY,MAAM,CAUjB;IAED,gBACC;;CACJ;8BAjYY,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,mCAAmC,EAAE,eAAe;kCAbtC,uCAAuC;uCAFlC,8CAA8C"}

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js

@@ -304,6 +304,8 @@ export class GPULightProbeVolumeRenderer {
                 tEnvironment: this.#environment.obtainView(),
                 tParticipatingMediaNoise: scene.volumetrics.noise_atlas.texture.obtainView(),
                 sParticipatingMediaNoise: this.#graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
+                wind_field: scene.wind.uniform,
+                wind_field_atlas: scene.wind.atlas.texture,
                 //
                 tlas: scene.tlas.buffer,
                 blas_lookup: blas.buffer_metadata,

package/src/shade/renderer/global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_get_visibility_mask.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.js"],"names":[],"mappings":"AAQA,sDAqDE;0BAvDwB,uCAAuC"}
+{"version":3,"file":"chunk_lpv_get_visibility_mask.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.js"],"names":[],"mappings":"AASA,sDAqDE;0BAxDwB,uCAAuC"}

package/src/shade/renderer/global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.js

@@ -5,6 +5,7 @@ import {
     chunk_lpv_sample_depth_atlas_native
 } from "../../../shader/chunk/light/lpv/depth/chunk_lpv_sample_depth_atlas.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { LPV_PROBES_RESOURCE } from "../../probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_get_visibility_mask = CodeChunk.from(
     //language=WGSL
@@ -61,3 +62,5 @@ fn lpv_get_visibility_mask(
     ]
 );
 
+chunk_lpv_get_visibility_mask.requireResource(LPV_PROBES_RESOURCE);
+

package/src/shade/renderer/global_illumination/lpv/deprecated/probe_trace_compute_shader_code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probe_trace_compute_shader_code.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/deprecated/probe_trace_compute_shader_code.js"],"names":[],"mappings":"AA0BA,sDAIG;AAuKH,4DAIG;6BAvM0B,sCAAsC;8BAiBrC,kCAAkC"}
+{"version":3,"file":"probe_trace_compute_shader_code.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/deprecated/probe_trace_compute_shader_code.js"],"names":[],"mappings":"AA2BA,sDAIG;AAwKH,4DAIG;6BAzM0B,sCAAsC;8BAiBrC,kCAAkC"}

package/src/shade/renderer/global_illumination/lpv/deprecated/probe_trace_compute_shader_code.js

@@ -23,6 +23,7 @@ import { PROBE_RAYS_PER_WORKGROUP } from "../bake/PROBE_RAYS_PER_WORKGROUP.js";
 import { LIGHT_PROBE_STRUCT } from "../LIGHT_PROBE_STRUCT.js";
 import { LIGHT_PROBE_VOLUME_METADATA_STRUCT } from "../LIGHT_PROBE_VOLUME_METADATA_STRUCT.js";
 import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "../../../volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js";
+import { wind_field_add_resources } from "../../../wind/wind_field_add_resources.js";
 
 export const PROBE_BAKE_UNIFORMS_STRUCT = WebGPUStruct.from({
     direction: vec3f,
@@ -36,7 +37,8 @@ export const PROBE_BAKE_UNIFORMS_STRUCT = WebGPUStruct.from({
 // deprecated progressive bake produces radiance only.
 
 const resources = new ShaderResourceSetDescriptor();
-resources.createGroup({ label: 'LPV & scene' })
+// the scene's wind, which carries the fog volumes' noise: one uniform, one texture, one sampler
+wind_field_add_resources(resources.createGroup({ label: 'LPV & scene' })
     .addUniform("lpv_metadata", LIGHT_PROBE_VOLUME_METADATA_STRUCT)
     .addStorageBuffer('lpv_probes', WebGPUArray.from(LIGHT_PROBE_STRUCT), true)
     .addUniform('materials', INDIRECT_MATERIAL_ARRAY_TYPE)
@@ -46,7 +48,7 @@ resources.createGroup({ label: 'LPV & scene' })
     .addTexture('tEnvironment', 'unfilterable-float')
     // the fog volumes' noise, read through participating_media_volume_density_at
     .addTexture("tParticipatingMediaNoise", "float", "3d")
-    .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR)
+    .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR));
 
 sr_create_group_RTX(resources);
 

package/src/shade/renderer/global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.d.ts

@@ -1,3 +1,42 @@
+/**
+ * The light probe volume's BVH over its tetrahedral mesh.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_LOOKUP_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The light probe volume's metadata.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_METADATA_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The light probe volume's tetrahedral mesh.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_MESH_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The light probes.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_PROBES_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The probes' octahedral depth atlas.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_ATLAS_DEPTH_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The probes' octahedral radiance atlas, encoded.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_ATLAS_RADIANCE_RESOURCE: ShaderResourceDescriptor;
 export const LPV_SHADER_RESOURCE_GROUP: ShaderResourceGroupDescriptor;
+/**
+ * The same bindings, each with a default, for a shader that reads the light probe volume under one
+ * indirect lighting mode and is bound under all of them (SSR's resolve, froxel GI): a frame graph pass
+ * given no volume binds transient buffers and a volume of no probes in its place.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS: ShaderResourceGroupDescriptor;
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
 //# sourceMappingURL=LPV_SHADER_RESOURCE_GROUP.d.ts.map

package/src/shade/renderer/global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LPV_SHADER_RESOURCE_GROUP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js"],"names":[],"mappings":"AAOA,sEAA6E;8CAL/B,2DAA2D"}
+{"version":3,"file":"LPV_SHADER_RESOURCE_GROUP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,kCAFU,wBAAwB,CAEkE;AAEpG;;;GAGG;AACH,oCAFU,wBAAwB,CAEwF;AAE1H;;;GAGG;AACH,gCAFU,wBAAwB,CAEkG;AAEpI;;;GAGG;AACH,kCAFU,wBAAwB,CAE4F;AAE9H;;;GAGG;AACH,uCAFU,wBAAwB,CAEmE;AAErG;;;GAGG;AACH,0CAFU,wBAAwB,CAEwE;AAE1G,sEAA6E;AAS7E;;;;;;GAMG;AACH,sDAFU,6BAA6B,CAEoD;yCA1DlD,sDAAsD;8CACjD,2DAA2D"}

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

@@ -1,15 +1,68 @@
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { BVH_STRUCT } from "../../../shader/chunk/bvh/BVH_STRUCT.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
 import { LIGHT_PROBE_STRUCT } from "../../lpv/LIGHT_PROBE_STRUCT.js";
 import { LIGHT_PROBE_VOLUME_METADATA_STRUCT } from "../../lpv/LIGHT_PROBE_VOLUME_METADATA_STRUCT.js";
 import { TETRAHEDRAL_MESH_CELL_STRUCT } from "../../lpv/TETRAHEDRAL_MESH_CELL_STRUCT.js";
 
+/**
+ * The light probe volume's BVH over its tetrahedral mesh.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_LOOKUP_RESOURCE = ShaderResourceDescriptor.storageBuffer("lpv_lookup", BVH_STRUCT);
+
+/**
+ * The light probe volume's metadata.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_METADATA_RESOURCE = ShaderResourceDescriptor.uniform("lpv_metadata", LIGHT_PROBE_VOLUME_METADATA_STRUCT);
+
+/**
+ * The light probe volume's tetrahedral mesh.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_MESH_RESOURCE = ShaderResourceDescriptor.storageBuffer("lpv_mesh", WebGPUArray.from(TETRAHEDRAL_MESH_CELL_STRUCT));
+
+/**
+ * The light probes.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_PROBES_RESOURCE = ShaderResourceDescriptor.storageBuffer("lpv_probes", WebGPUArray.from(LIGHT_PROBE_STRUCT));
+
+/**
+ * The probes' octahedral depth atlas.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_ATLAS_DEPTH_RESOURCE = ShaderResourceDescriptor.texture("lpv_atlas_depth", "float");
+
+/**
+ * The probes' octahedral radiance atlas, encoded.
+ * @type {ShaderResourceDescriptor}
+ */
+export const LPV_ATLAS_RADIANCE_RESOURCE = ShaderResourceDescriptor.texture("lpv_atlas_radiance", "uint");
+
 export const LPV_SHADER_RESOURCE_GROUP = new ShaderResourceGroupDescriptor();
 
 LPV_SHADER_RESOURCE_GROUP
-    .addStorageBuffer("lpv_lookup", BVH_STRUCT)
-    .addUniform("lpv_metadata", LIGHT_PROBE_VOLUME_METADATA_STRUCT)
-    .addStorageBuffer("lpv_mesh", WebGPUArray.from(TETRAHEDRAL_MESH_CELL_STRUCT))
-    .addStorageBuffer("lpv_probes", WebGPUArray.from(LIGHT_PROBE_STRUCT))
+    .add(LPV_LOOKUP_RESOURCE)
+    .add(LPV_METADATA_RESOURCE)
+    .add(LPV_MESH_RESOURCE)
+    .add(LPV_PROBES_RESOURCE)
+;
+
+/**
+ * The same bindings, each with a default, for a shader that reads the light probe volume under one
+ * indirect lighting mode and is bound under all of them (SSR's resolve, froxel GI): a frame graph pass
+ * given no volume binds transient buffers and a volume of no probes in its place.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS = new ShaderResourceGroupDescriptor();
+
+LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS
+    .addStorageBuffer("lpv_lookup", BVH_STRUCT, false, true)
+    .addUniform("lpv_metadata", LIGHT_PROBE_VOLUME_METADATA_STRUCT, { probe_count: 0, probe_resolution: 0 })
+    .addStorageBuffer("lpv_mesh", WebGPUArray.from(TETRAHEDRAL_MESH_CELL_STRUCT), false, true)
+    .addStorageBuffer("lpv_probes", WebGPUArray.from(LIGHT_PROBE_STRUCT), false, true)
 ;

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

@@ -5,7 +5,7 @@ import { chunk_taa_decode_color } from "../../../postprocess/taa/chunk_taa_decod
 import { chunk_taa_encode_color } from "../../../postprocess/taa/chunk_taa_encode_color.js";
 import { chunk_BRDF_GGX } from "../../../shader/chunk/brdf/chunk_BRDF_GGX.js";
 import { chunk_oren_nayar_compensated_diffuse } from "../../../shader/chunk/brdf/diffuse/EON.js";
-import { chunk_F_Hauber } from "../../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
+import { chunk_F_Schlick } from "../../../shader/chunk/brdf/fresnel/chunk_F_Schlick.js";
 import { chunk_rgbe9995_decode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
 import { chunk_rgbe9995_encode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
 import {
@@ -122,7 +122,7 @@ fn lpv_shade_light_record(
 
     let light_irradiance = light_record.emission * NoL;
 
-    let F = F_Hauber(specularF0, specularF90, VoH);
+    let F = F_Schlick(specularF0, specularF90, VoH);
     let kD = (vec3(1.0) - F);
 
     let irradiance_diffuse = light_irradiance * diffuse_color * kD;
@@ -320,7 +320,7 @@ fn main(
         chunk_uv_octahedral_unit_encode,
         chunk_uv_to_texel_coordinate,
         chunk_v2_bilinear_weight,
-        chunk_F_Hauber,
+        chunk_F_Schlick,
     ]
 );
 

package/src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_radiance_sample_reflection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_radiance_sample_reflection.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_radiance_sample_reflection.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,mDAFU,SAAS,CA+ClB;0BAxDyB,0CAA0C"}
+{"version":3,"file":"chunk_lpv_radiance_sample_reflection.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_radiance_sample_reflection.js"],"names":[],"mappings":"AASA;;;GAGG;AACH,mDAFU,SAAS,CA+ClB;0BAzDyB,0CAA0C"}

package/src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_radiance_sample_reflection.js

@@ -4,6 +4,7 @@ import { chunk_lpv_atlas_sample_probe_radiance } from "./chunk_lpv_atlas_sample_
 import {
     chunk_parallax_correct_spherical_probe_iterative
 } from "./chunk_parallax_correct_spherical_probe_iterative.js";
+import { LPV_PROBES_RESOURCE } from "../LPV_SHADER_RESOURCE_GROUP.js";
 
 
 /**
@@ -56,3 +57,5 @@ fn lpv_radiance_sample_reflection(
         chunk_f32_array_as_vec3,
     ]
 )
+
+chunk_lpv_radiance_sample_reflection.requireResource(LPV_PROBES_RESOURCE);

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_DEFINITION.d.ts

@@ -0,0 +1,10 @@
+/**
+ * {@link BVH_REFIT_DEFERRED_LAYOUT} as WGSL constants: the seed a bound word holds until it is
+ * fitted, and the deferred list's layout. One declaration shared by the climb, the repair and the
+ * kernels that seed, for the reason {@link BVH_NODE_LAYOUT_DEFINITION} is one.
+ *
+ * @type {CodeChunk}
+ */
+export const BVH_REFIT_DEFERRED_DEFINITION: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=BVH_REFIT_DEFERRED_DEFINITION.d.ts.map

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_DEFINITION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BVH_REFIT_DEFERRED_DEFINITION.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_DEFINITION.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,4CAFU,SAAS,CAUhB;0BAxBuB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_DEFINITION.js

@@ -0,0 +1,25 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import {
+    BVH_REFIT_DEFERRED_COUNT_WORD,
+    BVH_REFIT_DEFERRED_ENTRIES_WORD,
+    BVH_REFIT_DEFERRED_ENTRY_WORDS,
+    BVH_REFIT_REPAIR_WORKGROUP_SIZE,
+    BVH_UNFITTED
+} from "./BVH_REFIT_DEFERRED_LAYOUT.js";
+
+/**
+ * {@link BVH_REFIT_DEFERRED_LAYOUT} as WGSL constants: the seed a bound word holds until it is
+ * fitted, and the deferred list's layout. One declaration shared by the climb, the repair and the
+ * kernels that seed, for the reason {@link BVH_NODE_LAYOUT_DEFINITION} is one.
+ *
+ * @type {CodeChunk}
+ */
+export const BVH_REFIT_DEFERRED_DEFINITION = CodeChunk.from(
+    //language=WGSL
+    `
+const BVH_UNFITTED = ${BVH_UNFITTED}u;
+const BVH_REFIT_DEFERRED_COUNT = ${BVH_REFIT_DEFERRED_COUNT_WORD}u;
+const BVH_REFIT_DEFERRED_ENTRIES = ${BVH_REFIT_DEFERRED_ENTRIES_WORD}u;
+const BVH_REFIT_DEFERRED_ENTRY_WORDS = ${BVH_REFIT_DEFERRED_ENTRY_WORDS}u;
+const BVH_REFIT_REPAIR_WORKGROUP_SIZE = ${BVH_REFIT_REPAIR_WORKGROUP_SIZE}u;
+`);

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_LAYOUT.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Bytes a deferred list needs for climbs over `internal_node_count` internal nodes. A node is
+ * deferred at most once — only its second arrival reads its children — so that many entries is
+ * the most there can be. Memory, not work: the repair dispatches over the count the climb wrote.
+ *
+ * @param {number} internal_node_count
+ * @returns {number}
+ */
+export function bvh_refit_deferred_byte_size(internal_node_count: number): number;
+/**
+ * The bit pattern a node's bound words hold between being seeded and being fitted: a quiet NaN that
+ * no union of real bounds produces.
+ *
+ * Whatever runs a refit climb ({@link chunk_bvh_refit_climb}) seeds every bound word the climb will
+ * read with this, in an earlier dispatch. The climb hands boxes between invocations through relaxed
+ * atomics, and a store need not have reached the invocation that reads it. A read of a seeded word
+ * then returns either the store or the seed — never a box from before the seed, because the seeding
+ * dispatch ended first. So a box that has not arrived is a box the climb can see is missing.
+ *
+ * @type {number}
+ */
+export const BVH_UNFITTED: number;
+/**
+ * Where a node the climb deferred goes: `[command x, y, z, count, entries...]`, one buffer.
+ *
+ * The first three words are the repair's indirect dispatch command, folded as the engine's command
+ * builders fold one (x filled to the per-dimension limit before y grows), written by the climb as it
+ * defers. Word 3 counts the entries. Each entry is three words: the tree's `node_word_offset`, its
+ * `parents_offset`, and the node — so one repair serves trees that own their buffers and trees that
+ * are tenants in an arena.
+ *
+ * The header must be zero when the climb starts; the entries need not be anything.
+ */
+export const BVH_REFIT_DEFERRED_COUNT_WORD: 3;
+/**
+ * @see BVH_REFIT_DEFERRED_COUNT_WORD
+ */
+export const BVH_REFIT_DEFERRED_ENTRIES_WORD: 4;
+/**
+ * @see BVH_REFIT_DEFERRED_COUNT_WORD
+ */
+export const BVH_REFIT_DEFERRED_ENTRY_WORDS: 3;
+/**
+ * The header, which is all that needs clearing before a climb.
+ *
+ * @type {number}
+ */
+export const BVH_REFIT_DEFERRED_HEADER_BYTES: number;
+/**
+ * Threads per workgroup of the repair, and so entries per workgroup the climb counts into the command.
+ *
+ * @type {number}
+ */
+export const BVH_REFIT_REPAIR_WORKGROUP_SIZE: number;
+//# sourceMappingURL=BVH_REFIT_DEFERRED_LAYOUT.d.ts.map

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_LAYOUT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BVH_REFIT_DEFERRED_LAYOUT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_LAYOUT.js"],"names":[],"mappings":"AAmDA;;;;;;;GAOG;AACH,kEAHW,MAAM,GACJ,MAAM,CAKlB;AA9DD;;;;;;;;;;;GAWG;AACH,2BAFU,MAAM,CAEuB;AAEvC;;;;;;;;;;GAUG;AACH,8CAA+C;AAE/C;;GAEG;AACH,gDAAiD;AAEjD;;GAEG;AACH,+CAAgD;AAEhD;;;;GAIG;AACH,8CAFU,MAAM,CAE+F;AAE/G;;;;GAIG;AACH,8CAFU,MAAM,CAEkC"}

package/src/shade/renderer/gpu_primitive/bvh/BVH_REFIT_DEFERRED_LAYOUT.js

@@ -0,0 +1,63 @@
+/**
+ * The bit pattern a node's bound words hold between being seeded and being fitted: a quiet NaN that
+ * no union of real bounds produces.
+ *
+ * Whatever runs a refit climb ({@link chunk_bvh_refit_climb}) seeds every bound word the climb will
+ * read with this, in an earlier dispatch. The climb hands boxes between invocations through relaxed
+ * atomics, and a store need not have reached the invocation that reads it. A read of a seeded word
+ * then returns either the store or the seed — never a box from before the seed, because the seeding
+ * dispatch ended first. So a box that has not arrived is a box the climb can see is missing.
+ *
+ * @type {number}
+ */
+export const BVH_UNFITTED = 0x7FC0FFEE;
+
+/**
+ * Where a node the climb deferred goes: `[command x, y, z, count, entries...]`, one buffer.
+ *
+ * The first three words are the repair's indirect dispatch command, folded as the engine's command
+ * builders fold one (x filled to the per-dimension limit before y grows), written by the climb as it
+ * defers. Word 3 counts the entries. Each entry is three words: the tree's `node_word_offset`, its
+ * `parents_offset`, and the node — so one repair serves trees that own their buffers and trees that
+ * are tenants in an arena.
+ *
+ * The header must be zero when the climb starts; the entries need not be anything.
+ */
+export const BVH_REFIT_DEFERRED_COUNT_WORD = 3;
+
+/**
+ * @see BVH_REFIT_DEFERRED_COUNT_WORD
+ */
+export const BVH_REFIT_DEFERRED_ENTRIES_WORD = 4;
+
+/**
+ * @see BVH_REFIT_DEFERRED_COUNT_WORD
+ */
+export const BVH_REFIT_DEFERRED_ENTRY_WORDS = 3;
+
+/**
+ * The header, which is all that needs clearing before a climb.
+ *
+ * @type {number}
+ */
+export const BVH_REFIT_DEFERRED_HEADER_BYTES = BVH_REFIT_DEFERRED_ENTRIES_WORD * Uint32Array.BYTES_PER_ELEMENT;
+
+/**
+ * Threads per workgroup of the repair, and so entries per workgroup the climb counts into the command.
+ *
+ * @type {number}
+ */
+export const BVH_REFIT_REPAIR_WORKGROUP_SIZE = 64;
+
+/**
+ * Bytes a deferred list needs for climbs over `internal_node_count` internal nodes. A node is
+ * deferred at most once — only its second arrival reads its children — so that many entries is
+ * the most there can be. Memory, not work: the repair dispatches over the count the climb wrote.
+ *
+ * @param {number} internal_node_count
+ * @returns {number}
+ */
+export function bvh_refit_deferred_byte_size(internal_node_count) {
+    return (BVH_REFIT_DEFERRED_ENTRIES_WORD + internal_node_count * BVH_REFIT_DEFERRED_ENTRY_WORDS)
+        * Uint32Array.BYTES_PER_ELEMENT;
+}