@woosh/meep-engine 3.11.0 → 3.11.2

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA4FA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,0CAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAE1C;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,sCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAE/B;;;OAGG;IACH,kBAA4B;IAiB5B;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,6BAcC;IA1BD;;;OAGG;IACH,0BAEC;IA4BD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,oBAAkB,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAGD,sCAIC;IAeD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EA0NC;IAED;;OAEG;IACH,gBAGC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8EAJW,MAAM,UACN,iBAAiB,GACf,OAAO,CA62BnB;;CACJ;6BAh5E4B,yBAAyB;0CACZ,gCAAgC;2BAL/C,yCAAyC;6BACvC,4CAA4C;8BAC3C,2CAA2C;4BAc7C,uBAAuB;gCA1BnB,sBAAsB;mBAjDnC,oCAAoC;oBACnC,4BAA4B;kCAuEd,gCAAgC;2BAvCvC,2BAA2B;iCAoCrB,0CAA0C;4CAvB/B,+DAA+D;yBA7BlF,yBAAyB;kCAgDhB,wBAAwB;oBAVtC,0BAA0B;uCAJP,sDAAsD"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA4FA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,0CAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAkB1C,uCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,sCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAE/B;;;OAGG;IACH,kBAA4B;IAiB5B;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,6BAcC;IA1BD;;;OAGG;IACH,0BAEC;IA4BD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,oBAAkB,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAGD,sCAIC;IAeD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EA0NC;IAED;;OAEG;IACH,gBAGC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8EAJW,MAAM,UACN,iBAAiB,GACf,OAAO,CAi3BnB;;CACJ;6BA16E4B,yBAAyB;0CACZ,gCAAgC;2BApB/C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAiC7C,uBAAuB;gCAtCnB,sBAAsB;mBArCnC,oCAAoC;oBACnC,4BAA4B;kCAuEd,gCAAgC;2BApDvC,2BAA2B;iCAkDrB,0CAA0C;4CApC/B,+DAA+D;yBA6BlF,yBAAyB;kCAMhB,wBAAwB;oBAvBtC,0BAA0B;uCAPP,sDAAsD"}

package/src/shade/renderer/Renderer.js

@@ -16,21 +16,8 @@ import { CameraManager } from "./camera/CameraManager.js";
 import { shader_background } from "./deferred/shader_background.js";
 import { shader_composite_volumetrics } from "./deferred/shader_composite_volumetrics.js";
 import { shader_deferred_main, shader_deferred_main_restir } from "./deferred/shader_deferred_main.js";
-import { ReSTIRDI } from "./restir/di/ReSTIRDI.js";
 import { shader_tonemap_HDR } from "./deferred/shader_tonemap_HDR.js";
 import { shader_tonemap_LDR } from "./deferred/shader_tonemap_LDR.js";
-import { G_BUFFER_MIP_LEVELS } from "./gbuffer/G_BUFFER_MIP_LEVELS.js";
-import {
-    graph_rasterize_meshes_transparent_oit
-} from "./rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js";
-import {
-    viz_rasterization_alpha_tested_pass_descriptor
-} from "./rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.js";
-import {
-    viz_rasterization_opaque_pass_descriptor
-} from "./rasterize/native/viz/viz_rasterization_opaque_pass_descriptor.js";
-import { RasterizationJob } from "./rasterize/RasterizationJob.js";
-import { graph_rasterize_scene } from "./rasterize/standard/graph_rasterize_scene.js";
 import { FrameContext } from "./extension/FrameContext.js";
 import { FramePhase } from "./extension/FramePhase.js";
 import { GBufferTextures } from "./extension/GBufferTextures.js";
@@ -38,6 +25,7 @@ import { PresentTarget } from "./extension/PresentTarget.js";
 import { RenderExtensionRegistry } from "./extension/RenderExtensionRegistry.js";
 import { SceneColor } from "./extension/SceneColor.js";
 import { ViewTextures } from "./extension/ViewTextures.js";
+import { G_BUFFER_MIP_LEVELS } from "./gbuffer/G_BUFFER_MIP_LEVELS.js";
 import { shader_brick4_diffuse } from "./global_illumination/brick4/gpu/draw/shader_brick4_diffuse.js";
 import {
     shader_brick4_indirect_lighting
@@ -53,24 +41,36 @@ import { graph_build_light_clusters } from "./light/cluster/graph_build_light_cl
 import { AccumulatingPathTracer } from "./path_tracer/accumulating/AccumulatingPathTracer.js";
 import { graph_postprocess_bloom } from "./postprocess/bloom/graph_postprocess_bloom.js";
 import { shader_ffx_rcas } from "./postprocess/cas/shader_ffx_rcas.js";
+import { DepthOfFieldU } from "./postprocess/dof/gather/DepthOfFieldU.js";
+import { DepthOfField } from "./postprocess/dof/raymarch/DepthOfField.js";
 import { GPUCameraExposureManager } from "./postprocess/eye/GPUCameraExposureManager.js";
+import { MotionBlur } from "./postprocess/motion_blur/MotionBlur.js";
 import { NSS } from "./postprocess/nss/NSS.js";
 import { PostProcess } from "./postprocess/PostProcess.js";
 import { shader_depth_occlusion_clip } from "./postprocess/taa/shader_depth_occlusion_clip.js";
 import { TAA } from "./postprocess/taa/TAA.js";
-import { MotionBlur } from "./postprocess/motion_blur/MotionBlur.js";
-import { DepthOfField } from "./postprocess/dof/raymarch/DepthOfField.js";
-import { DepthOfFieldU } from "./postprocess/dof/gather/DepthOfFieldU.js";
 import { graph_add_per_object_velocity } from "./postprocess/velocity/graph_add_per_object_velocity.js";
+import { shader_debug_velocity } from "./postprocess/velocity/shader_debug_velocity.js";
+import {
+    graph_rasterize_meshes_transparent_oit
+} from "./rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js";
+import {
+    viz_rasterization_alpha_tested_pass_descriptor
+} from "./rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.js";
+import {
+    viz_rasterization_opaque_pass_descriptor
+} from "./rasterize/native/viz/viz_rasterization_opaque_pass_descriptor.js";
+import { RasterizationJob } from "./rasterize/RasterizationJob.js";
+import { graph_rasterize_scene } from "./rasterize/standard/graph_rasterize_scene.js";
+import { ReSTIRDI } from "./restir/di/ReSTIRDI.js";
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
-import { ShadeUpscalerType } from "./ShadeUpscalerType.js";
 import { graph_image_pass } from "./shader/graph/graph_image_pass.js";
 import { graph_import_buffer } from "./shader/graph/graph_import_buffer.js";
 import { graph_import_texture } from "./shader/graph/graph_import_texture.js";
+import { ShadeUpscalerType } from "./ShadeUpscalerType.js";
 import { CascadedSceneSDF } from "./shadow/sdf/cascade/CascadedSceneSDF.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "./STATIC_GRAPHICS_ENGINE_ASSETS.js";
-import { shader_debug_velocity } from "./postprocess/velocity/shader_debug_velocity.js";
 import { GPUTextureContext } from "./texture/GPUTextureContext.js";
 import { RenderTarget } from "./texture/RenderTarget.js";
 import { View } from "./view/View.js";
@@ -187,6 +187,29 @@ export class Renderer {
     feature_bloom_enabled = true;
     feature_automatic_exposure_enabled = true;
 
+    /**
+     * Fixed exposure, in f-stops, used when {@link feature_automatic_exposure_enabled} is off.
+     *
+     * Turning adaptation off without being able to set this leaves the frame at 2 stops, which is
+     * black for any scene the eye would otherwise have opened up for — so the flag alone is not
+     * usable. Anything comparing two renders wants adaptation off and this pinned: eye adaptation
+     * keeps drifting for seconds after a change, which makes two shots of the *same* setting differ
+     * by more than the change being judged.
+     *
+     * @returns {number}
+     */
+    get exposure_compensation() {
+        // the manager is built in initialize(); before that there is no value to report
+        return this.#autoexposure === undefined ? 0 : this.#autoexposure.exposure_compensation;
+    }
+
+    set exposure_compensation(v) {
+        assert.isNumber(v, 'exposure_compensation');
+        assert.defined(this.#autoexposure, 'autoexposure (set exposure_compensation after initialize)');
+
+        this.#autoexposure.exposure_compensation = v;
+    }
+
     /**
      * Virtual texture streaming (opt-in per material via
      * {@link StandardShadeMaterial#vt_stack}). This flag is the system-wide
@@ -2244,6 +2267,8 @@ export class Renderer {
 
         if (this.#feature_enabled_transparencies) {
             // do transparent alpha pass
+            graph.push_scope("transparencies");
+
             current_color_out = graph_rasterize_meshes_transparent_oit({
                 graph,
                 buckets: gr_render_buckets,
@@ -2265,6 +2290,8 @@ export class Renderer {
 
                 indirect_lighting_mode: this.indirect_lighting_mode,
             });
+
+            graph.pop_scope();
         }
 
         frame.phase = FramePhase.AfterTransparency;

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -49,7 +49,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#131@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#132@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_point2.d.ts

@@ -1,19 +1,20 @@
 /**
- * Cone-sampled point shadow PCF. Samples random directions inside a cone around the receiver-
- * to-light vector and re-encodes each one to the octahedral atlas. The cone aperture comes
- * from the GDC bulb-radius scaling in {@link chunk_max_penumbra_percentage}; the factor of 2
- * carries over the texels → tangent-plane conversion an earlier disk-based variant used (1
- * atlas texel ≈ 2/face_dim of Δn.xy near the +Z pole), so the angular footprint stays
- * comparable.
+ * Cone-sampled point shadow PCF: 8 random directions inside a cone around the receiver-to-light
+ * vector, each re-encoded to the light's octahedral map, one `textureLoad` per tap, ending in
+ * {@link chunk_contact_harden_pcf_kernel}. Tap directions come from {@link chunk_random}, which the
+ * calling shader (deferred lighting / volumetrics) initialises per invocation, so neighbouring
+ * pixels decorrelate without a rotation table or a blue-noise disk.
  *
- * No blue-noise disk, no rotation table, no atlas-border clamp. Random tap directions come
- * from {@link chunk_random}, which the calling shader (deferred lighting / volumetrics)
- * initialises per invocation, so neighbours decorrelate naturally. Each tap is one
- * \`textureLoad\` and the loop ends in {@link chunk_contact_harden_pcf_kernel} unchanged.
+ * The aperture is the GDC bulb-radius scaling in {@link chunk_max_penumbra_percentage}; the factor
+ * of 2 carries over the texels → tangent-plane conversion an earlier disk-based variant used (1
+ * atlas texel ≈ 2/face_dim of Δn.xy near the +Z pole), so the angular footprint stays comparable.
  *
- * No clamp on the aperture: the receiver direction is sampled in 3D and re-encoded per tap, so
- * the octahedral encode always lands in [0, 1]² — even a full-sphere aperture stays inside
- * this light's slot.
+ * Addressing: `atlas_aabb` is the INNER octahedral surface, and the cube → octahedral remap
+ * surrounds it with a `SHADOWMAP_ATLAS_BORDER`-texel skirt holding
+ * `inner[texture_octahedral_wrap_texel_coordinates(local)]`. Under the bilinear convention
+ * `uv * size - 0.5` a uv on the edge of the square rounds to -1 or `size` — one texel into that
+ * skirt, which is this light's own wrapped data. The encode always lands in [0, 1]² and the round
+ * can overshoot by at most one texel, so the aperture needs no clamp.
  *
  * @see chunk_cone_sample_direction
  * @type {CodeChunk}

package/src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_point2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_shadowmap_sample_point2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_point2.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4CAFU,SAAS,CA8FjB;0BAvHwB,uCAAuC"}
+{"version":3,"file":"chunk_shadowmap_sample_point2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_point2.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,4CAFU,SAAS,CAiGjB;0BA3HwB,uCAAuC"}

package/src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_point2.js

@@ -1,129 +1,133 @@
-import { LIGHT_DATABASE_SPEC } from "../../../light/LIGHT_DATABASE_SPEC.js";
-import { chunk_cone_sample_direction } from "../../../shader/chunk/geometry/cone/chunk_cone_sample_direction.js";
-import {
-    chunk_uv_octahedral_unit_encode
-} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
-import { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
-import { chunk_random_round_vec2 } from "../../../shader/chunk/random/chunk_random_round_vec2.js";
-import { chunk_random_vec2 } from "../../../shader/chunk/random/chunk_random_vec2.js";
-import { chunk_uv_to_texel_coordinate } from "../../../shader/chunk/texture/chunk_uv_to_texel_coordinate.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { chunk_get_shadow_offsets } from "./chunk_get_shadow_offsets.js";
-import { chunk_contact_harden_pcf_kernel } from "./dpcf/chunk_contact_harden_pcf_kernel.js";
-import { chunk_max_penumbra_percentage } from "./dpcf/chunk_max_penumbra_percentage.js";
-
-const SHADOW_POINT_DESCRIPTOR = LIGHT_DATABASE_SPEC.get('shadow_point');
-
-/**
- * Cone-sampled point shadow PCF. Samples random directions inside a cone around the receiver-
- * to-light vector and re-encodes each one to the octahedral atlas. The cone aperture comes
- * from the GDC bulb-radius scaling in {@link chunk_max_penumbra_percentage}; the factor of 2
- * carries over the texels → tangent-plane conversion an earlier disk-based variant used (1
- * atlas texel ≈ 2/face_dim of Δn.xy near the +Z pole), so the angular footprint stays
- * comparable.
- *
- * No blue-noise disk, no rotation table, no atlas-border clamp. Random tap directions come
- * from {@link chunk_random}, which the calling shader (deferred lighting / volumetrics)
- * initialises per invocation, so neighbours decorrelate naturally. Each tap is one
- * \`textureLoad\` and the loop ends in {@link chunk_contact_harden_pcf_kernel} unchanged.
- *
- * No clamp on the aperture: the receiver direction is sampled in 3D and re-encoded per tap, so
- * the octahedral encode always lands in [0, 1]² — even a full-sphere aperture stays inside
- * this light's slot.
- *
- * @see chunk_cone_sample_direction
- * @type {CodeChunk}
- */
-export const chunk_shadowmap_sample_point2 = CodeChunk.from(
-    //language=WGSL
-    `
-fn shadowmap_sample_point(
-    database: ptr<storage, array<u32>>,
-    shadow_id: u32,
-    position_ws: vec3f,
-    surface_normal_ws: vec3f,
-    light_position_ws: vec3f,
-    light_max_distance: f32,
-    light_radius: f32,
-) -> f32 {
-    const NORMAL_BIAS_SCALE = 2.0;
-    const DEPTH_OFFSET_BIAS = 0.0001;
-
-    let atlas_aabb = ${SHADOW_POINT_DESCRIPTOR.marshalling_method_read}(database, shadow_id);
-
-    // unbiased distance and light direction, used to compute the bias amounts
-    let to_light_unbiased = light_position_ws - position_ws;
-    let dist_to_light_unbiased = length(to_light_unbiased);
-    let light_direction = to_light_unbiased / max(dist_to_light_unbiased, 1e-6);
-
-    let world_pixel_size = 2.0 * dist_to_light_unbiased / max(atlas_aabb.z, 1.0);
-    let shadowmap_bias = get_shadow_offsets(surface_normal_ws, light_direction);
-    let normal_offset = world_pixel_size * shadowmap_bias.x * surface_normal_ws * NORMAL_BIAS_SCALE;
-
-    // re-evaluate direction and distance from the normal-biased position
-    let to_surface = (position_ws + normal_offset) - light_position_ws;
-    let distance_to_center = length(to_surface);
-
-    // Direction the cube faces captured: FROM LIGHT TO SURFACE
-    let dir_light_to_surface = to_surface / max(distance_to_center, 1e-6);
-
-    let face_size = vec2u(atlas_aabb.zw);
-
-    // reverse-Z convention: close to light -> 1, at or beyond light_max_distance -> 0.
-    let radial = distance_to_center / max(light_max_distance, 1e-6);
-    let depth_bias = DEPTH_OFFSET_BIAS * shadowmap_bias.y;
-    let reference_depth = (1.0 - saturate(radial)) + depth_bias;
-
-    // Cone aperture (~ tan of the half-angle). max_penumbra_percentage is the GDC formula
-    // mapping bulb radius to a fraction of the atlas face; the 2× factor is the texels →
-    // tangent-plane conversion. Unclamped: any aperture is valid because the octahedral
-    // re-encode in the loop always stays inside this light's slot.
-    let cone_aperture = 2.0 * max_penumbra_percentage(light_radius, light_radius);
-
-    var occluders: f32 = 0.0;
-    var occluder_dist_sum: f32 = 0.0;
-
-    for (var tap: u32 = 0u; tap < 8u; tap++) {
-
-        let xi = random_vec2();
-
-        let perturbed_dir = cone_sample_direction(dir_light_to_surface, cone_aperture, xi);
-
-        let octahedral_uv = uv_octahedral_unit_encode(perturbed_dir);
-        let local_texel = uv_to_texel_coordinate(octahedral_uv, face_size);
-
-        // instead of doing bilinear, we use stochastic sampling instead
-        let rounded_local_texel = random_round_vec2(local_texel);
-
-        let sample_texel = vec2<u32>(rounded_local_texel) + vec2<u32>(atlas_aabb.xy);
-
-        let stored = textureLoad(shadowmapAtlas, sample_texel, 0);
-        let dist = stored - reference_depth;
-
-        // Per-tap binary compare; reverse-Z + step(0, stored - ref) ⇒ 1 = occluded.
-        let occluded = step(0.0, dist);
-
-        occluders += occluded;
-        occluder_dist_sum += dist * occluded;
-    }
-
-    return contact_harden_pcf_kernel(
-        occluders,
-        occluder_dist_sum,
-        reference_depth,
-
-    );
-}
-    `, [
-        SHADOW_POINT_DESCRIPTOR.chunk_read,
-        chunk_cone_sample_direction,
-        chunk_contact_harden_pcf_kernel,
-        chunk_get_shadow_offsets,
-        chunk_max_penumbra_percentage,
-        chunk_random,
-        chunk_uv_octahedral_unit_encode,
-        chunk_uv_to_texel_coordinate,
-        chunk_random_round_vec2,
-        chunk_random_vec2,
-    ]
-);
+import { LIGHT_DATABASE_SPEC } from "../../../light/LIGHT_DATABASE_SPEC.js";
+import { chunk_cone_sample_direction } from "../../../shader/chunk/geometry/cone/chunk_cone_sample_direction.js";
+import {
+    chunk_uv_octahedral_unit_encode
+} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
+import { chunk_random_round_vec2 } from "../../../shader/chunk/random/chunk_random_round_vec2.js";
+import { chunk_random_vec2 } from "../../../shader/chunk/random/chunk_random_vec2.js";
+import { chunk_uv_to_texel_coordinate } from "../../../shader/chunk/texture/chunk_uv_to_texel_coordinate.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_get_shadow_offsets } from "./chunk_get_shadow_offsets.js";
+import { chunk_contact_harden_pcf_kernel } from "./dpcf/chunk_contact_harden_pcf_kernel.js";
+import { chunk_max_penumbra_percentage } from "./dpcf/chunk_max_penumbra_percentage.js";
+
+const SHADOW_POINT_DESCRIPTOR = LIGHT_DATABASE_SPEC.get('shadow_point');
+
+/**
+ * Cone-sampled point shadow PCF: 8 random directions inside a cone around the receiver-to-light
+ * vector, each re-encoded to the light's octahedral map, one `textureLoad` per tap, ending in
+ * {@link chunk_contact_harden_pcf_kernel}. Tap directions come from {@link chunk_random}, which the
+ * calling shader (deferred lighting / volumetrics) initialises per invocation, so neighbouring
+ * pixels decorrelate without a rotation table or a blue-noise disk.
+ *
+ * The aperture is the GDC bulb-radius scaling in {@link chunk_max_penumbra_percentage}; the factor
+ * of 2 carries over the texels → tangent-plane conversion an earlier disk-based variant used (1
+ * atlas texel ≈ 2/face_dim of Δn.xy near the +Z pole), so the angular footprint stays comparable.
+ *
+ * Addressing: `atlas_aabb` is the INNER octahedral surface, and the cube → octahedral remap
+ * surrounds it with a `SHADOWMAP_ATLAS_BORDER`-texel skirt holding
+ * `inner[texture_octahedral_wrap_texel_coordinates(local)]`. Under the bilinear convention
+ * `uv * size - 0.5` a uv on the edge of the square rounds to -1 or `size` — one texel into that
+ * skirt, which is this light's own wrapped data. The encode always lands in [0, 1]² and the round
+ * can overshoot by at most one texel, so the aperture needs no clamp.
+ *
+ * @see chunk_cone_sample_direction
+ * @type {CodeChunk}
+ */
+export const chunk_shadowmap_sample_point2 = CodeChunk.from(
+    //language=WGSL
+    `
+fn shadowmap_sample_point(
+    database: ptr<storage, array<u32>>,
+    shadow_id: u32,
+    position_ws: vec3f,
+    surface_normal_ws: vec3f,
+    light_position_ws: vec3f,
+    light_max_distance: f32,
+    light_radius: f32,
+) -> f32 {
+    const NORMAL_BIAS_SCALE = 2.0;
+    const DEPTH_OFFSET_BIAS = 0.0001;
+
+    let atlas_aabb = ${SHADOW_POINT_DESCRIPTOR.marshalling_method_read}(database, shadow_id);
+
+    // unbiased distance and light direction, used to compute the bias amounts
+    let to_light_unbiased = light_position_ws - position_ws;
+    let dist_to_light_unbiased = length(to_light_unbiased);
+    let light_direction = to_light_unbiased / max(dist_to_light_unbiased, 1e-6);
+
+    let world_pixel_size = 2.0 * dist_to_light_unbiased / max(atlas_aabb.z, 1.0);
+    let shadowmap_bias = get_shadow_offsets(surface_normal_ws, light_direction);
+    let normal_offset = world_pixel_size * shadowmap_bias.x * surface_normal_ws * NORMAL_BIAS_SCALE;
+
+    // re-evaluate direction and distance from the normal-biased position
+    let to_surface = (position_ws + normal_offset) - light_position_ws;
+    let distance_to_center = length(to_surface);
+
+    // Direction the cube faces captured: FROM LIGHT TO SURFACE
+    let dir_light_to_surface = to_surface / max(distance_to_center, 1e-6);
+
+    let face_size = vec2u(atlas_aabb.zw);
+
+    // reverse-Z convention: close to light -> 1, at or beyond light_max_distance -> 0.
+    let radial = distance_to_center / max(light_max_distance, 1e-6);
+    let depth_bias = DEPTH_OFFSET_BIAS * shadowmap_bias.y;
+    let reference_depth = (1.0 - saturate(radial)) + depth_bias;
+
+    // Cone aperture (~ tan of the half-angle). max_penumbra_percentage is the GDC formula mapping
+    // bulb radius to a fraction of the atlas face; the 2× factor is the texels → tangent-plane
+    // conversion. Unclamped — see the header on why any aperture stays addressable.
+    let cone_aperture = 2.0 * max_penumbra_percentage(light_radius, light_radius);
+
+    var occluders: f32 = 0.0;
+    var occluder_dist_sum: f32 = 0.0;
+
+    for (var tap: u32 = 0u; tap < 8u; tap++) {
+
+        let xi = random_vec2();
+
+        let perturbed_dir = cone_sample_direction(dir_light_to_surface, cone_aperture, xi);
+
+        let octahedral_uv = uv_octahedral_unit_encode(perturbed_dir);
+        let local_texel = uv_to_texel_coordinate(octahedral_uv, face_size);
+
+        // one of the two neighbours at random rather than a blend of them: stochastic bilinear
+        let rounded_local_texel = random_round_vec2(local_texel);
+
+        // Signed: the round reaches -1 at a uv of 0, and the skirt is where that tap belongs. Via
+        // u32 the -1 would be an indeterminate conversion — 0xFFFFFFFF reaches the skirt through
+        // the wrapping add, 0 silently reads the opposite edge of the inner surface. i32 is exact
+        // here, and the inner origin is at least SHADOWMAP_ATLAS_BORDER, so the sum is positive.
+        let sample_texel = vec2<u32>(vec2<i32>(rounded_local_texel) + vec2<i32>(atlas_aabb.xy));
+
+        let stored = textureLoad(shadowmapAtlas, sample_texel, 0);
+        let dist = stored - reference_depth;
+
+        // Per-tap binary compare; reverse-Z + step(0, stored - ref) ⇒ 1 = occluded.
+        let occluded = step(0.0, dist);
+
+        occluders += occluded;
+        occluder_dist_sum += dist * occluded;
+    }
+
+    return contact_harden_pcf_kernel(
+        occluders,
+        occluder_dist_sum,
+        reference_depth,
+
+    );
+}
+    `, [
+        SHADOW_POINT_DESCRIPTOR.chunk_read,
+        chunk_cone_sample_direction,
+        chunk_contact_harden_pcf_kernel,
+        chunk_get_shadow_offsets,
+        chunk_max_penumbra_percentage,
+        chunk_random,
+        chunk_uv_octahedral_unit_encode,
+        chunk_uv_to_texel_coordinate,
+        chunk_random_round_vec2,
+        chunk_random_vec2,
+    ]
+);

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAkBA;IAgFI;;;;OAIG;IACH,qDAqBC;IAtED;;OAEG;IACH,8BAOC;IAjBD;;OAEG;IACH,2BAEC;IA6BD;;OAEG;IACH,4BAEC;IAZD;;OAEG;IACH,yBAEC;IA+CD,gBAWC;IAgGD;;;;;;;OAOG;IACH;;;MAwEC;;CAEJ"}
+{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AA4BA;IAyHI;;;;OAIG;IACH,qDAqBC;IA/GD;;OAEG;IACH,8BAOC;IAjBD;;OAEG;IACH,2BAEC;IA6BD;;OAEG;IACH,4BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IAiND;;;;;;;OAOG;IACH;;;MAyEC;;CAEJ"}