@woosh/meep-engine 3.38.0 → 3.40.0

package/src/shade/renderer/postprocess/ssr/ssr_spatial_denoise_shader.js

@@ -1,167 +1,177 @@
-import { chunk_ssr_spatial_variance } from "./chunk_ssr_spatial_variance.js";
-import { chunk_ssr_metadata } from "./chunk_ssr_metadata.js";
-import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
-import { chunk_rgb_to_YCoCg } from "../../shader/chunk/color/YCoCg/chunk_rgb_to_YCoCg.js";
-import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
-import { chunk_safe_sqrt } from "../../shader/chunk/math/chunk_safe_sqrt.js";
-import {
-    chunk_texture_channel_gaussian_3x3
-} from "../../shader/chunk/texture/chunk_texture_channel_gaussian_3x3.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_luma_edge_stopping_weight } from "../../shader/chunk/filter/chunk_compute_edge_stopping_weight.js";
-import { ATORUS_UNIFORMS_STRUCT } from "../denoise/fragment_shader_denoise_ao.js";
-import {
-    chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight
-} from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight.js";
-import {
-    chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight
-} from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight.js";
-
-function create_spatial_shader(with_metadata) {
-    const resources = new ShaderResourceSetDescriptor();
-
-    // per-pass, four bytes, read-only: immediate data rather than a uniform buffer
-    resources.setImmediate("settings", ATORUS_UNIFORMS_STRUCT);
-    const group = resources.createGroup()
-        .addTexture("tInput")
-        .addTexture("tDepth")
-        .addTexture("tNormal", "uint");
-    if (with_metadata) { group.addTexture("tMetadata", "unfilterable-float"); }
-
-    const body = CodeChunk.from(
-        //language=WGSL
-    `
-const phi_visibility = 10.0;
-const phi_normal = 32.0;
-const sigma_depth = 1.0;
- 
-@fragment
-fn main(
-    @builtin(position) coord: vec4<f32>,
-) -> ${with_metadata ? "SSRResolveOutput" : "@location(0) vec4f"}{
-    let ipos = vec2<i32>(coord.xy);
-    let screen_size = vec2<i32>(textureDimensions(tInput));
-    
-    const eps_variance      = 1e-10;
-    const kernel_weights = array<f32,3>( 1.0, 2.0 / 3.0, 1.0 / 6.0 );
-    
-    // constant samplers to prevent the compiler from generating code which
-    // fetches the sampler descriptor from memory for each texture access
-    let center_color = textureLoad(tInput, ipos, 0);
-    
-    let center_color_luma = rgb_to_luminance(center_color.rgb);
-
-    // variance for direct and indirect, filtered using 3x3 gaussin blur
-    let input_variance = max(0.0, texture_channel_gaussian_3x3(ipos, tInput, 3));
-${with_metadata ? `    let bootstrap_variance = ssr_spatial_variance(tInput,tDepth,tNormal,ipos);
-    let variance = max(input_variance,bootstrap_variance);
-    var sum_squared_weights = 1.0;` : `    let variance = input_variance;`}
-            
-    // explicitly store/accumulate center pixel with weight 1 to prevent issues
-    // with the edge-stopping functions
-    var sum_weight = 1.0;
-    var sum_color   = center_color;
-${with_metadata ? `    let center_metadata = textureLoad(tMetadata, ipos, 0).rg;
-    var distance_moments = ssr_distance_moments(center_metadata.x, center_metadata.y, 1.0);` : ""}
-    
-    
-    let current_normal = decode_g_buffer_normal( textureLoad(tNormal, ipos, 0).xy );
-    let center_depth   = textureLoad(tDepth, ipos, 0).r;
-    
-    const offsets = array< vec2<i32>,8>(
-      vec2( -1, -1 ),
-      vec2(  0, -1 ) ,
-      vec2(  1, -1 ), 
-      vec2( -1,  0 ), 
-      vec2(  1,  0 ), 
-      vec2( -1,  1 ),
-      vec2(  0,  1 ), 
-      vec2(  1,  1 ), 
-   );
-    
-    const num_samples = 8;
-    
-    let std_dev =  safe_sqrt(variance);
-    
-    for(var i = 0; i < num_samples; i++){
-        let offset: vec2i = offsets[i];
-                
-        let p      = ipos + offset * settings.step_size;
-        let inside = all(p >= vec2(0, 0)) && all(p < screen_size);
-        
-        if(!inside){
-            // off-screen
-            continue;
-        }
-        
-        let kernel = kernel_weights[ abs(offset.x) ] * kernel_weights[ abs(offset.y) ];
-        
-        let sample_color = textureLoad(tInput, p, 0);
-        let sample_color_luma = rgb_to_luminance(sample_color.rgb);
-
-        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
-        let sample_depth  = textureLoad(tDepth, p, 0).r;
-
-        // compute the edge-stopping functions
-        var weight = 1.0;
-        
-        let phi_luma = max(0.001,std_dev * phi_visibility);
-
-        weight *= ffx_dnsr_reflections_get_edge_stopping_normal_weight(current_normal, sample_normal);
-        weight *= ffx_dnsr_reflections_get_edge_stopping_depth_weight(center_depth, sample_depth);
-        weight *= exp(-luma_edge_stopping_weight(center_color_luma,sample_color_luma,phi_luma));
-        
-        let w_visibility = weight * kernel;
-${with_metadata ? `        let metadata = textureLoad(tMetadata, p, 0).rg;
-        distance_moments += ssr_distance_moments(metadata.x, metadata.y, w_visibility);` : ""}
-
-        // alpha channel contains the variance, therefore the weights need to be squared, see paper for the formula
-        sum_weight += w_visibility;
-${with_metadata ? `        sum_squared_weights += w_visibility*w_visibility;` : ""}
-        sum_color += vec4(vec3(w_visibility), w_visibility * w_visibility) * sample_color;
-    }
-    
-    var out_visibility = sum_color / vec4(vec3(sum_weight), sum_weight * sum_weight);
-${with_metadata ? `    // Carry bootstrap uncertainty forward so the next passes do not freeze again.
-    out_visibility.w = max(out_visibility.w,bootstrap_variance*sum_squared_weights/(sum_weight*sum_weight));` : ""}
-    
-${with_metadata ? `    var output: SSRResolveOutput;
-    output.radiance = out_visibility;
-    output.metadata = ssr_resolve_metadata(distance_moments, 1.0);
-    return output;` : "    return out_visibility;"}
-}
-        `,
-        [
-            chunk_ssr_metadata,
-            ...(with_metadata ? [chunk_ssr_spatial_variance] : []),
-            ATORUS_UNIFORMS_STRUCT.declaration_chunk,
-            chunk_texture_channel_gaussian_3x3,
-            chunk_decode_g_buffer_normal,
-            chunk_rgb_to_luminance,
-            chunk_rgb_to_YCoCg,
-            chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight,
-            chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight,
-            chunk_luma_edge_stopping_weight,
-            chunk_safe_sqrt,
-        ]);
-
-    return new ImageShader({
-        descriptor: ShaderDescriptor.from({
-            label: with_metadata ? "SSR / spatial denoise with metadata" : "SSR / spatial denoise",
-            body,
-            resources
-        }),
-        targets: [
-            {
-                format: "rgba16float"
-            },
-            ...(with_metadata ? [{ format: "rg32float" }] : [])
-        ]
-    })
-}
-
-export const ssr_spatial_denoise_shader = create_spatial_shader(false);
-export const ssr_spatial_denoise_metadata_shader = create_spatial_shader(true);
+import { chunk_ssr_spatial_variance } from "./chunk_ssr_spatial_variance.js";
+import { chunk_ssr_metadata } from "./chunk_ssr_metadata.js";
+import { SSR_DENOISE_TILE_SIZE } from "./SSR_DENOISE_TILE_SIZE.js";
+import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_rgb_to_YCoCg } from "../../shader/chunk/color/YCoCg/chunk_rgb_to_YCoCg.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_safe_sqrt } from "../../shader/chunk/math/chunk_safe_sqrt.js";
+import {
+    chunk_texture_channel_gaussian_3x3
+} from "../../shader/chunk/texture/chunk_texture_channel_gaussian_3x3.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_luma_edge_stopping_weight } from "../../shader/chunk/filter/chunk_compute_edge_stopping_weight.js";
+import { ATORUS_UNIFORMS_STRUCT } from "../denoise/fragment_shader_denoise_ao.js";
+import {
+    chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight
+} from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight.js";
+import {
+    chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight
+} from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight.js";
+
+function create_spatial_shader(with_metadata, tiled = false) {
+    const resources = new ShaderResourceSetDescriptor();
+
+    // per-pass, four bytes, read-only: immediate data rather than a uniform buffer
+    resources.setImmediate("settings", ATORUS_UNIFORMS_STRUCT);
+    const group = resources.createGroup()
+        .addTexture("tInput")
+        .addTexture("tDepth")
+        .addTexture("tNormal", "uint");
+    if (with_metadata) { group.addTexture("tMetadata", "unfilterable-float"); }
+    if (tiled) { group.addTexture("tDenoiseTiles", "uint"); }
+
+    const body = CodeChunk.from(
+        //language=WGSL
+    `
+const phi_visibility = 10.0;
+const phi_normal = 32.0;
+const sigma_depth = 1.0;
+ 
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> ${with_metadata ? "SSRResolveOutput" : "@location(0) vec4f"}{
+    let ipos = vec2<i32>(coord.xy);
+    let screen_size = vec2<i32>(textureDimensions(tInput));
+${tiled ? `    if (textureLoad(tDenoiseTiles, ipos / ${SSR_DENOISE_TILE_SIZE}, 0).r == 0u) {
+${with_metadata ? `        var output: SSRResolveOutput;
+        output.radiance = textureLoad(tInput, ipos, 0);
+        output.metadata = textureLoad(tMetadata, ipos, 0).rg;
+        return output;` : `        return textureLoad(tInput, ipos, 0);`}
+    }` : ""}
+    
+    const eps_variance      = 1e-10;
+    const kernel_weights = array<f32,3>( 1.0, 2.0 / 3.0, 1.0 / 6.0 );
+    
+    // constant samplers to prevent the compiler from generating code which
+    // fetches the sampler descriptor from memory for each texture access
+    let center_color = textureLoad(tInput, ipos, 0);
+    
+    let center_color_luma = rgb_to_luminance(center_color.rgb);
+
+    // variance for direct and indirect, filtered using 3x3 gaussin blur
+    let input_variance = max(0.0, texture_channel_gaussian_3x3(ipos, tInput, 3));
+${with_metadata ? `    let bootstrap_variance = ssr_spatial_variance(tInput,tDepth,tNormal,ipos);
+    let variance = max(input_variance,bootstrap_variance);
+    var sum_squared_weights = 1.0;` : `    let variance = input_variance;`}
+            
+    // explicitly store/accumulate center pixel with weight 1 to prevent issues
+    // with the edge-stopping functions
+    var sum_weight = 1.0;
+    var sum_color   = center_color;
+${with_metadata ? `    let center_metadata = textureLoad(tMetadata, ipos, 0).rg;
+    var distance_moments = ssr_distance_moments(center_metadata.x, center_metadata.y, 1.0);` : ""}
+    
+    
+    let current_normal = decode_g_buffer_normal( textureLoad(tNormal, ipos, 0).xy );
+    let center_depth   = textureLoad(tDepth, ipos, 0).r;
+    
+    const offsets = array< vec2<i32>,8>(
+      vec2( -1, -1 ),
+      vec2(  0, -1 ) ,
+      vec2(  1, -1 ), 
+      vec2( -1,  0 ), 
+      vec2(  1,  0 ), 
+      vec2( -1,  1 ),
+      vec2(  0,  1 ), 
+      vec2(  1,  1 ), 
+   );
+    
+    const num_samples = 8;
+    
+    let std_dev =  safe_sqrt(variance);
+    
+    for(var i = 0; i < num_samples; i++){
+        let offset: vec2i = offsets[i];
+                
+        let p      = ipos + offset * settings.step_size;
+        let inside = all(p >= vec2(0, 0)) && all(p < screen_size);
+        
+        if(!inside){
+            // off-screen
+            continue;
+        }
+        
+        let kernel = kernel_weights[ abs(offset.x) ] * kernel_weights[ abs(offset.y) ];
+        
+        let sample_color = textureLoad(tInput, p, 0);
+        let sample_color_luma = rgb_to_luminance(sample_color.rgb);
+
+        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
+        let sample_depth  = textureLoad(tDepth, p, 0).r;
+
+        // compute the edge-stopping functions
+        var weight = 1.0;
+        
+        let phi_luma = max(0.001,std_dev * phi_visibility);
+
+        weight *= ffx_dnsr_reflections_get_edge_stopping_normal_weight(current_normal, sample_normal);
+        weight *= ffx_dnsr_reflections_get_edge_stopping_depth_weight(center_depth, sample_depth);
+        weight *= exp(-luma_edge_stopping_weight(center_color_luma,sample_color_luma,phi_luma));
+        
+        let w_visibility = weight * kernel;
+${with_metadata ? `        let metadata = textureLoad(tMetadata, p, 0).rg;
+        distance_moments += ssr_distance_moments(metadata.x, metadata.y, w_visibility);` : ""}
+
+        // alpha channel contains the variance, therefore the weights need to be squared, see paper for the formula
+        sum_weight += w_visibility;
+${with_metadata ? `        sum_squared_weights += w_visibility*w_visibility;` : ""}
+        sum_color += vec4(vec3(w_visibility), w_visibility * w_visibility) * sample_color;
+    }
+    
+    var out_visibility = sum_color / vec4(vec3(sum_weight), sum_weight * sum_weight);
+${with_metadata ? `    // Carry bootstrap uncertainty forward so the next passes do not freeze again.
+    out_visibility.w = max(out_visibility.w,bootstrap_variance*sum_squared_weights/(sum_weight*sum_weight));` : ""}
+    
+${with_metadata ? `    var output: SSRResolveOutput;
+    output.radiance = out_visibility;
+    output.metadata = ssr_resolve_metadata(distance_moments, 1.0);
+    return output;` : "    return out_visibility;"}
+}
+        `,
+        [
+            chunk_ssr_metadata,
+            ...(with_metadata ? [chunk_ssr_spatial_variance] : []),
+            ATORUS_UNIFORMS_STRUCT.declaration_chunk,
+            chunk_texture_channel_gaussian_3x3,
+            chunk_decode_g_buffer_normal,
+            chunk_rgb_to_luminance,
+            chunk_rgb_to_YCoCg,
+            chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight,
+            chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight,
+            chunk_luma_edge_stopping_weight,
+            chunk_safe_sqrt,
+        ]);
+
+    return new ImageShader({
+        descriptor: ShaderDescriptor.from({
+            label: (with_metadata ? "SSR / spatial denoise with metadata" : "SSR / spatial denoise") + (tiled ? " / tiles" : ""),
+            body,
+            resources
+        }),
+        targets: [
+            {
+                format: "rgba16float"
+            },
+            ...(with_metadata ? [{ format: "rg32float" }] : [])
+        ]
+    })
+}
+
+export const ssr_spatial_denoise_shader = create_spatial_shader(false);
+export const ssr_spatial_denoise_metadata_shader = create_spatial_shader(true);
+export const ssr_spatial_denoise_tile_shader = create_spatial_shader(false, true);
+export const ssr_spatial_denoise_metadata_tile_shader = create_spatial_shader(true, true);

package/src/shade/renderer/rasterize/DEPTH_STENCIL_STATE_SHADOW.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DEPTH_STENCIL_STATE_SHADOW.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/DEPTH_STENCIL_STATE_SHADOW.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,yCAFU,SAAS,iBAAiB,CAAC,CAiBjC;kCArB8B,uDAAuD"}
+{"version":3,"file":"DEPTH_STENCIL_STATE_SHADOW.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/DEPTH_STENCIL_STATE_SHADOW.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,yCAFU,SAAS,iBAAiB,CAAC,CA2BjC;kCA/B8B,uDAAuD"}

package/src/shade/renderer/rasterize/DEPTH_STENCIL_STATE_SHADOW.js

@@ -17,6 +17,16 @@ export const DEPTH_STENCIL_STATE_SHADOW = Object.freeze(DepthStencilState.from({
     /**
      * Combat shadow acne.
      * negative, because of reversed Z.
+     *
+     * A point light's cube faces need all of it at concave corners. Where a wall stands farther from
+     * the light than the light is above the ground, the ground in front of it is steep to the side
+     * cube face that sees it, and this pushes that ground back far enough that the wall's base does not
+     * read it as an occluder; at -1, as at 0, the bottom centimetres of the wall shadow themselves in
+     * scallops. The same push leaves a point light's shadow a seam on the cone 45° from straight down,
+     * where the ground stops being square-on to the -Y face: an occluder a little above a receiver stops
+     * shadowing it as the receiver's direction crosses into a side face (at 128 texels, from about
+     * 14 cm above to 22 cm). Measured 2026-10-04 and kept: a `depthBiasClamp` limits it by distance,
+     * not by angle, and no bias tried closed the seam without opening the corners.
      */
     depthBiasSlopeScale: -2.0,
 }));

package/src/shade/renderer/rasterize/RasterizationJob.d.ts

@@ -6,8 +6,7 @@ export class RasterizationJob {
     pipeline_type: number;
     /**
      * Side-to-cullMode lookup applied per material bucket. Default {@link CullPolicy.Standard}
-     * matches main-pass culling. Shadow callers set {@link CullPolicy.Reversed} so the back
-     * face of sided geometry is what gets written into the shadow map.
+     * matches main-pass culling, which shadow casters use too.
      * @type {Readonly<Record<number, GPUCullMode>>}
      */
     cull_policy: Readonly<Record<number, GPUCullMode>>;

package/src/shade/renderer/rasterize/RasterizationJob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RasterizationJob.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/RasterizationJob.js"],"names":[],"mappings":";;;;AAcA;IACI,sBAAmD;IAEnD;;;;;OAKG;IACH,aAFU,SAAS,OAAO,MAAM,cAAc,CAAC,CAEb;IAElC;;OAEG;IACH,kCAAW;IACX;;;;OAIG;IACH,0CAAiB;IAEjB;;OAEG;IACH,4BAAa;IAEb;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEV;IAER;;OAEG;IACH,yBAAQ;IAER;;;OAGG;IACH,gBAAyB;IAEzB;;;OAGG;IACH,sBAA+B;CAClC"}
+{"version":3,"file":"RasterizationJob.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/RasterizationJob.js"],"names":[],"mappings":";;;;AAcA;IACI,sBAAmD;IAEnD;;;;OAIG;IACH,aAFU,SAAS,OAAO,MAAM,cAAc,CAAC,CAEb;IAElC;;OAEG;IACH,kCAAW;IACX;;;;OAIG;IACH,0CAAiB;IAEjB;;OAEG;IACH,4BAAa;IAEb;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEV;IAER;;OAEG;IACH,yBAAQ;IAER;;;OAGG;IACH,gBAAyB;IAEzB;;;OAGG;IACH,sBAA+B;CAClC"}

package/src/shade/renderer/rasterize/RasterizationJob.js

@@ -17,8 +17,7 @@ export class RasterizationJob {
 
     /**
      * Side-to-cullMode lookup applied per material bucket. Default {@link CullPolicy.Standard}
-     * matches main-pass culling. Shadow callers set {@link CullPolicy.Reversed} so the back
-     * face of sided geometry is what gets written into the shadow map.
+     * matches main-pass culling, which shadow casters use too.
      * @type {Readonly<Record<number, GPUCullMode>>}
      */
     cull_policy = CullPolicy.Standard;

package/src/shade/renderer/rasterize/bucket/construct_primitive_state.d.ts

@@ -16,12 +16,11 @@ export function construct_primitive_state(draw_mode: ShadeDrawMode, side: ShadeD
  *
  *  - `Standard` is the main-pass mapping: a one-sided material renders the face its winding
  *    presents (cull back), `Double` renders both.
- *  - `Reversed` culls the other way, so the *back* face is what gets drawn. This is the
- *    standard "back-face shadow casting" / "front-face culling for shadow casters"
- *    technique — shadow callers select this policy so the surface written into the shadow
- *    map sits behind the lit surface, eliminating self-shadow acne on the lit side and
- *    keeping shadow casting consistent with the user's view of one-sided geometry.
- *    `Double` has no opposite and stays at `none`.
+ *  - `Reversed` culls the other way, so the *back* face is what gets drawn — "back-face
+ *    shadow casting". Shadow casters do not use it: they cull as the main view does, and the
+ *    shared rasterizer slope bias keeps acne off; back faces on top of that bias left a gap of
+ *    a shadow texel or so where a caster meets the ground. `Double` has no opposite and stays
+ *    at `none`.
  */
 export type CullPolicy = Readonly<Record<number, GPUCullMode>>;
 export namespace CullPolicy {

package/src/shade/renderer/rasterize/bucket/construct_primitive_state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"construct_primitive_state.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/construct_primitive_state.js"],"names":[],"mappings":"AA4DA;;;;;;GAMG;AACH,qDALW,aAAa,QACb,aAAa,gBACb,SAAS,OAAO,MAAM,cAAc,CAAC,GACnC,cAAc,CA2B1B;;;;;;;;;;;;;;;;;;yBA5DS,SAAS,OAAO,MAAM,cAAc,CAAC;;;;;;;;;AAe/C;;;;;;;GAOG;AACH,yCAFU,cAAc,aAAa,CAAC,CAKnC;8BAzD2B,iCAAiC;8BACjC,iCAAiC;+BAFhC,uDAAuD"}
+{"version":3,"file":"construct_primitive_state.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/construct_primitive_state.js"],"names":[],"mappings":"AA2DA;;;;;;GAMG;AACH,qDALW,aAAa,QACb,aAAa,gBACb,SAAS,OAAO,MAAM,cAAc,CAAC,GACnC,cAAc,CA2B1B;;;;;;;;;;;;;;;;;yBA5DS,SAAS,OAAO,MAAM,cAAc,CAAC;;;;;;;;;AAe/C;;;;;;;GAOG;AACH,yCAFU,cAAc,aAAa,CAAC,CAKnC;8BAxD2B,iCAAiC;8BACjC,iCAAiC;+BAFhC,uDAAuD"}

package/src/shade/renderer/rasterize/bucket/construct_primitive_state.js

@@ -23,12 +23,11 @@ const lut_topology = {
  *
  *  - `Standard` is the main-pass mapping: a one-sided material renders the face its winding
  *    presents (cull back), `Double` renders both.
- *  - `Reversed` culls the other way, so the *back* face is what gets drawn. This is the
- *    standard "back-face shadow casting" / "front-face culling for shadow casters"
- *    technique — shadow callers select this policy so the surface written into the shadow
- *    map sits behind the lit surface, eliminating self-shadow acne on the lit side and
- *    keeping shadow casting consistent with the user's view of one-sided geometry.
- *    `Double` has no opposite and stays at `none`.
+ *  - `Reversed` culls the other way, so the *back* face is what gets drawn — "back-face
+ *    shadow casting". Shadow casters do not use it: they cull as the main view does, and the
+ *    shared rasterizer slope bias keeps acne off; back faces on top of that bias left a gap of
+ *    a shadow texel or so where a caster meets the ground. `Double` has no opposite and stays
+ *    at `none`.
  *
  * @enum {Readonly<Record<number, GPUCullMode>>}
  */

package/src/shade/renderer/rasterize/native/avboit/AVBOITSettings.d.ts

@@ -23,5 +23,13 @@ export class AVBOITSettings {
      * @type {boolean}
      */
     transmission_tint_from_base_color: boolean;
+    /**
+     * Virtual resolutions the warp tries per octave when the occupied slices do not fit the physical
+     * budget. `1` halves, as the deck does; `4` adds three steps between each octave and the next, so the
+     * occupied count lands closer to the budget (`shader_avboit_build_warp`, AVBOIT ledger entry 27), for
+     * about a microsecond per resolution tried on an RTX 4090 (entry 28).
+     * @type {number}
+     */
+    warp_steps_per_octave: number;
 }
 //# sourceMappingURL=AVBOITSettings.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/AVBOITSettings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSettings.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSettings.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH;IAEI;;;;;;;;;;;;;OAaG;IACH,mCAFU,OAAO,CAEyB;CAC7C"}
+{"version":3,"file":"AVBOITSettings.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSettings.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH;IAEI;;;;;;;;;;;;;OAaG;IACH,mCAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,uBAFU,MAAM,CAEU;CAC7B"}

package/src/shade/renderer/rasterize/native/avboit/AVBOITSettings.js

@@ -24,4 +24,13 @@ export class AVBOITSettings {
      * @type {boolean}
      */
     transmission_tint_from_base_color = false;
+
+    /**
+     * Virtual resolutions the warp tries per octave when the occupied slices do not fit the physical
+     * budget. `1` halves, as the deck does; `4` adds three steps between each octave and the next, so the
+     * occupied count lands closer to the budget (`shader_avboit_build_warp`, AVBOIT ledger entry 27), for
+     * about a microsecond per resolution tried on an RTX 4090 (entry 28).
+     * @type {number}
+     */
+    warp_steps_per_octave = 4;
 }

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts

@@ -36,7 +36,8 @@
 export type AVBOITSideChannel = {
     /**
      * Optional optics preparation before occupancy; at most one producer per view. Inputs are
-     * immutable opaque resources. The returned background is read by the one shared resolve.
+     * immutable opaque resources; the light clusters, the shadow atlas and the GI mode are the ones
+     * the transparent meshes are lit by. The returned background is read by the one shared resolve.
      * Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
      */
     avboit_prepare?: (args: {
@@ -48,6 +49,11 @@ export type AVBOITSideChannel = {
         normal_texture: number;
         hzb_texture: number;
         environment_texture: number;
+        light_cluster_parameters: number;
+        light_cluster_lookup: number;
+        light_cluster_data: number;
+        shadowmap_atlas: number;
+        indirect_lighting_mode: import("../../../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode;
     }) => {
         background_color?: number;
     };
@@ -86,7 +92,11 @@ export type AVBOITSideChannel = {
     };
     /**
      * draw the
-     * channel's fragments into the accumulators; returns their handles after the draw.
+     * channel's fragments into the accumulators; returns their handles after the draw. A channel
+     * whose fragments splat into the volume adds `avboit_footprint_bias` (of `fwidth` of the fragment's
+     * virtual slice coordinate, taken in uniform control flow) to its lookup, as the mesh draw does, or
+     * a surface it draws at an angle occludes itself in an 8-pixel pattern; one whose fragments write
+     * nothing into the volume passes `0`.
      * `volumetrics_irradiance` is what a fragment standing in a froxel is lit by
      * (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
      * indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by
@@ -118,10 +128,10 @@ export type AVBOITSideChannel = {
         emission: number;
     };
     /**
-     * whether the channel would add nothing this frame;
+     * whether the channel would add nothing for this view;
      * asked before the orchestrator records, and a channel that answers `true` is not asked for
      * anything else in that frame.
      */
-    avboit_is_empty?: () => boolean;
+    avboit_is_empty?: (view: import("../../../view/GPUViewContext.js").GPUViewContext) => boolean;
 };
 //# sourceMappingURL=AVBOITSideChannel.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAC,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAI1E,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAM9D,MAAM,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,sBAA4B,EAAE,OAAO,uCAAuC,EAAE,yBAAyB,CAAC;KACrG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAU9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js

@@ -37,9 +37,14 @@
  * @property {(args: {graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
  *     view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext, camera: number,
  *     color_texture: number, depth_texture: number, normal_texture: number,
- *     hzb_texture: number, environment_texture: number}) => {background_color?: number}} [avboit_prepare]
+ *     hzb_texture: number, environment_texture: number,
+ *     light_cluster_parameters: number, light_cluster_lookup: number, light_cluster_data: number,
+ *     shadowmap_atlas: number,
+ *     indirect_lighting_mode: import("../../../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode,
+ * }) => {background_color?: number}} [avboit_prepare]
  *     Optional optics preparation before occupancy; at most one producer per view. Inputs are
- *     immutable opaque resources. The returned background is read by the one shared resolve.
+ *     immutable opaque resources; the light clusters, the shadow atlas and the GI mode are the ones
+ *     the transparent meshes are lit by. The returned background is read by the one shared resolve.
  *     Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
  * @property {(args: {
  *     graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
@@ -72,12 +77,16 @@
  *     volumetrics_irradiance: {Y: number, CoCg: number},
  *     accumulators: {color: number, norm: number, extinction: number, emission: number},
  * }) => {color: number, norm: number, extinction: number, emission: number}} avboit_draw draw the
- *     channel's fragments into the accumulators; returns their handles after the draw.
+ *     channel's fragments into the accumulators; returns their handles after the draw. A channel
+ *     whose fragments splat into the volume adds `avboit_footprint_bias` (of `fwidth` of the fragment's
+ *     virtual slice coordinate, taken in uniform control flow) to its lookup, as the mesh draw does, or
+ *     a surface it draws at an angle occludes itself in an 8-pixel pattern; one whose fragments write
+ *     nothing into the volume passes `0`.
  *     `volumetrics_irradiance` is what a fragment standing in a froxel is lit by
  *     (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
  *     indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by
  *     the fog, written by the pass that lights the fog.
- * @property {() => boolean} [avboit_is_empty] whether the channel would add nothing this frame;
+ * @property {(view: import("../../../view/GPUViewContext.js").GPUViewContext) => boolean} [avboit_is_empty] whether the channel would add nothing for this view;
  *     asked before the orchestrator records, and a channel that answers `true` is not asked for
  *     anything else in that frame.
  */