@woosh/meep-engine 3.54.0 → 3.55.0

package/src/shade/renderer/postprocess/ssr/prefilter/NOTES.md

@@ -37,10 +37,3 @@ It has drifted against the live pipeline in one way that a reader will not notic
 directory: the à-trous path grew `chunk_ssr_metadata`, and the variance/metadata contract the
 prefilter expects predates it. Reconcile those before wiring the pass in, rather than after.
 
-## Sibling trap, same territory
-
-`graph_build_depth_max_pyramid.js` (also one directory up, also unreferenced) builds a
-**single-channel `r32float`** max-depth chain, while the live `HierarchicalZBuffer` the SSR trace
-actually reads is **two-channel** — `chunk_ffx_sssr_load_depth` reads its `.y`. The two are not
-interchangeable, and swapping one in for the other gives a silently zero `.y` rather than an error.
-That file's own header says the same thing.

package/src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_local_light.d.ts

@@ -18,11 +18,16 @@
  *
  * To match brightness across cascades without introducing axis-aligned cubic plateaus or directional
  * distortion:
- * - `result.direction` is always the true Euclidean radial unit vector `L / length(L)`.
- * - `irradiance_clipmap_regularize_light_distance(d, cell_size)` depends purely on Euclidean radial
- *   distance `d = length(L)`, applying a strictly monotonic, radially isotropic `C^1` shift inside
- *   `d < 1.75 * h` bounded below by `0.35 * h`, and equalling `d` identically in the far field
- *   (`d >= 1.75 * h`).
+ * - `result.direction` is `L / max(d_center, max(light.radius, 0.5 * cell_size))`: exact Euclidean
+ *   radial unit vector outside the half-voxel / source sphere, and decaying smoothly (`C^1`) through
+ *   `0` as `L -> 0` so L1 directional SH coefficients never flip sign across `180°` when a light
+ *   crosses a voxel centre.
+ * - `irradiance_clipmap_regularize_light_distance(d, cell_size)` evaluates a `C^1`-smooth, strictly
+ *   monotonic quartic polynomial on `t = d / (1.75 * h) in [0, 1]` with `f(0) = 0.35 * h`,
+ *   `f'(0) = 0` (differentiable across `L = 0`), `f(1) = 1.75 * h`, and `f'(1) = 1.0`, equalling `d`
+ *   identically in the far field (`d >= 1.75 * h`) with zero `max()` slope kink.
+ * - When `light.radius > cell_size` (fine cascades already resolving a large area sphere), the
+ *   sub-voxel pull blends smoothly toward `d_center` so the sphere cap is not artificially widened.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_local_light.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_irradiance_clipmap_local_light.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_local_light.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mDAFU,SAAS,CAyEjB;0BA/GwB,oCAAoC"}
+{"version":3,"file":"chunk_irradiance_clipmap_local_light.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_local_light.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,mDAFU,SAAS,CAoFjB;0BA/HwB,oCAAoC"}

package/src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_local_light.js

@@ -31,11 +31,16 @@ const SPOT_DESCRIPTOR = LIGHT_DATABASE_SPEC.get("light_spot");
  *
  * To match brightness across cascades without introducing axis-aligned cubic plateaus or directional
  * distortion:
- * - `result.direction` is always the true Euclidean radial unit vector `L / length(L)`.
- * - `irradiance_clipmap_regularize_light_distance(d, cell_size)` depends purely on Euclidean radial
- *   distance `d = length(L)`, applying a strictly monotonic, radially isotropic `C^1` shift inside
- *   `d < 1.75 * h` bounded below by `0.35 * h`, and equalling `d` identically in the far field
- *   (`d >= 1.75 * h`).
+ * - `result.direction` is `L / max(d_center, max(light.radius, 0.5 * cell_size))`: exact Euclidean
+ *   radial unit vector outside the half-voxel / source sphere, and decaying smoothly (`C^1`) through
+ *   `0` as `L -> 0` so L1 directional SH coefficients never flip sign across `180°` when a light
+ *   crosses a voxel centre.
+ * - `irradiance_clipmap_regularize_light_distance(d, cell_size)` evaluates a `C^1`-smooth, strictly
+ *   monotonic quartic polynomial on `t = d / (1.75 * h) in [0, 1]` with `f(0) = 0.35 * h`,
+ *   `f'(0) = 0` (differentiable across `L = 0`), `f(1) = 1.75 * h`, and `f'(1) = 1.0`, equalling `d`
+ *   identically in the far field (`d >= 1.75 * h`) with zero `max()` slope kink.
+ * - When `light.radius > cell_size` (fine cascades already resolving a large area sphere), the
+ *   sub-voxel pull blends smoothly toward `d_center` so the sphere cap is not artificially widened.
  *
  * @type {CodeChunk}
  */
@@ -43,14 +48,18 @@ export const chunk_irradiance_clipmap_local_light = CodeChunk.from(
     //language=WGSL
     `
 const IRRADIANCE_CLIPMAP_VOXEL_FOOTPRINT_RADIUS: f32 = 0.35;
-const IRRADIANCE_CLIPMAP_VOXEL_RADIAL_SHIFT: f32 = 0.45;
 const IRRADIANCE_CLIPMAP_VOXEL_RADIAL_SUPPORT: f32 = 1.75;
 
 fn irradiance_clipmap_regularize_light_distance(distance: f32, cell_size: f32) -> f32 {
     let h = max(cell_size, 1e-5);
-    let s = smoothstep(0.0, IRRADIANCE_CLIPMAP_VOXEL_RADIAL_SUPPORT * h, distance);
-    let shifted = distance - IRRADIANCE_CLIPMAP_VOXEL_RADIAL_SHIFT * h * (1.0 - s);
-    return max(shifted, IRRADIANCE_CLIPMAP_VOXEL_FOOTPRINT_RADIUS * h);
+    let support = IRRADIANCE_CLIPMAP_VOXEL_RADIAL_SUPPORT * h;
+    if (distance >= support) {
+        return distance;
+    }
+
+    let t = max(0.0, distance / support);
+    let t2 = t * t;
+    return h * (IRRADIANCE_CLIPMAP_VOXEL_FOOTPRINT_RADIUS + t2 * (0.45 + t * (2.95 - 2.00 * t)));
 }
 
 fn irradiance_clipmap_get_point_light_info_by_index(
@@ -62,10 +71,13 @@ fn irradiance_clipmap_get_point_light_info_by_index(
     let light = ${POINT_DESCRIPTOR.marshalling_method_read}(database, index);
     let L = light.position.xyz - position_ws;
     let d_center = max(length(L), 1e-5);
-    let d_eval = irradiance_clipmap_regularize_light_distance(d_center, cell_size);
+    let d_reg = irradiance_clipmap_regularize_light_distance(d_center, cell_size);
+    let resolved_blend = saturate(light.radius / max(cell_size, 1e-5) - 1.0);
+    let d_eval = mix(d_reg, d_center, resolved_blend);
 
     var result: ${INCIDENT_LIGHT_STRUCT.wgsl_ref};
-    result.direction = L / d_center;
+    let dir_radius = max(max(light.radius, 0.5 * cell_size), 1e-5);
+    result.direction = L / max(d_center, dir_radius);
 
     let attenuation = light_sphere_distance_attenuation(d_eval, light.radius, light.distance);
     result.color = light.color * attenuation;
@@ -84,14 +96,18 @@ fn irradiance_clipmap_get_spot_light_info_by_index(
     let light = ${SPOT_DESCRIPTOR.marshalling_method_read}(database, index);
     let L = light.position - position_ws;
     let d_center = max(length(L), 1e-5);
-    let d_eval = irradiance_clipmap_regularize_light_distance(d_center, cell_size);
+    let d_reg = irradiance_clipmap_regularize_light_distance(d_center, cell_size);
+    let resolved_blend = saturate(light.radius / max(cell_size, 1e-5) - 1.0);
+    let d_eval = mix(d_reg, d_center, resolved_blend);
+    let unit_dir = L / d_center;
 
     var result: ${INCIDENT_LIGHT_STRUCT.wgsl_ref};
-    result.direction = L / d_center;
+    let dir_radius = max(max(light.radius, 0.5 * cell_size), 1e-5);
+    result.direction = L / max(d_center, dir_radius);
     result.distance = max(0.0, d_center - light.radius);
     result.radius = light.radius / d_center;
 
-    let angle_cos = dot(result.direction, -light.direction);
+    let angle_cos = dot(unit_dir, -light.direction);
     let spot_attenuation = light_get_spot_attenuation(light.coneCos, light.penumbraCos, angle_cos);
 
     if (spot_attenuation > 0.0) {

package/src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_sample.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_irradiance_clipmap_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_sample.js"],"names":[],"mappings":"AAsDA;;;;;;;GAOG;AACH,wDALW,OAAO,wDAAwD,EAAE,6BAA6B;IAE5E,iBAAiB,GAAnC,OAAO;IACL,OAAO,wDAAwD,EAAE,6BAA6B,CAc1G;AA3DD;;;GAGG;AACH,kDAFU,wBAAwB,CAKhC;AAEF;;;GAGG;AACH,kDAFU,wBAAwB,CAMhC;AAEF;;;GAGG;AACH,qDAFU,wBAAwB,CAMhC;AAEF;;;GAGG;AACH,kDAFU,wBAAwB,CAMhC;AAwBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,8CAFU,SAAS,CAwJjB;AAOF;;;;;;;;;;;;;;GAcG;AACH,6DAFU,SAAS,CAoCjB;yCAxVuC,mDAAmD;0BADlE,oCAAoC"}
+{"version":3,"file":"chunk_irradiance_clipmap_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_sample.js"],"names":[],"mappings":"AAsDA;;;;;;;GAOG;AACH,wDALW,OAAO,wDAAwD,EAAE,6BAA6B;IAE5E,iBAAiB,GAAnC,OAAO;IACL,OAAO,wDAAwD,EAAE,6BAA6B,CAc1G;AA3DD;;;GAGG;AACH,kDAFU,wBAAwB,CAKhC;AAEF;;;GAGG;AACH,kDAFU,wBAAwB,CAMhC;AAEF;;;GAGG;AACH,qDAFU,wBAAwB,CAMhC;AAEF;;;GAGG;AACH,kDAFU,wBAAwB,CAMhC;AAwBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,8CAFU,SAAS,CAsKjB;AAOF;;;;;;;;;;;;;;GAcG;AACH,6DAFU,SAAS,CAoCjB;yCAtWuC,mDAAmD;0BADlE,oCAAoC"}

package/src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_sample.js

@@ -176,7 +176,11 @@ fn irradiance_clipmap_select_finest(
             all(abs(anchor_cells - level_center) <= vec3<f32>(0.501))
         );
 
-        let radius = min(half_size.x, min(half_size.y, half_size.z));
+        // Subtract 0.5 cells from half_size so that even when anchor_cells is offset by up to
+        // +/-0.5 cells from level_center, the selection sphere stays strictly inside [0, size]^3
+        // and the +/-0.5 voxel B_2 jitter taps stay strictly inside the 1-texel border
+        // [-0.5, size + 0.5]^3 without hitting the border clamp.
+        let radius = max(0.5, min(half_size.x, min(half_size.y, half_size.z)) - 0.5);
         let edge = radius - length(position_cells - center_cells);
 
         if (edge <= 0.0) {
@@ -238,8 +242,18 @@ fn irradiance_clipmap_cascade_read_stochastic(
 }
 
 fn irradiance_clipmap_cascade_read(c: u32, position_ws: vec3<f32>) -> ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref} {
-    var u = 0.5;
-    return irradiance_clipmap_cascade_read_stochastic(c, position_ws, &u);
+    let level = irradiance_clipmap.levels[c];
+    let cascade = irradiance_clipmap.cascades[c];
+    let local = position_ws / level.cell_size - vec3<f32>(level.corner);
+    let center = cascade.content_origin + local;
+    let t_min = cascade.content_origin - vec3<f32>(0.5);
+    let t_max = cascade.content_origin + vec3<f32>(level.size) + vec3<f32>(0.5);
+    let uvw = clamp(center, t_min, t_max) * irradiance_clipmap.inverse_atlas_size;
+
+    return ${METRO_L1_IRRADIANCE_STRUCT.make({
+        CoCg: "textureSampleLevel(irradiance_clipmap_atlas_cocg, irradiance_clipmap_sampler, uvw, 0.0).xy",
+        Y: "textureSampleLevel(irradiance_clipmap_atlas_y, irradiance_clipmap_sampler, uvw, 0.0)",
+    })};
 }
 
 fn irradiance_clipmap_mix_sh(

package/src/engine/graphics3/decal/DecalAtlas.d.ts

@@ -1,43 +0,0 @@
-/**
- * A texture atlas whose patches can be **mipmapped without bleeding into each other**.
- *
- * The atlas this replaces generates mipmaps and reserves padding, and still bleeds: nothing ever
- * fills the padding, so the gutter is zeros and every level past the first averages a patch against
- * whatever lies beyond it. The workarounds are visible in the shader that reads it — a negative LOD
- * bias, and a switch to turn mipmapping off when a scene has many overlapping decals.
- *
- * Three things fix it, and all three are here: a border sized in proportion to the patch
- * ({@link decal_atlas_border}), a border that is actually **filled**, by a rule that suits what the
- * channel means ({@link DecalAtlasFill}), and a per-patch bound on how deep the mip chain may be
- * sampled ({@link decal_atlas_max_lod}), because no finite border protects every level.
- *
- * Packing, growth, repacking and uv bookkeeping are the base class's and are untouched — it already
- * places content at `packing + padding`, which is the whole geometry of a bordered patch.
- */
-export class DecalAtlas extends TextureAtlas {
-    /**
-     * @param {DecalAtlasFill} fill
-     * @param {number} [size] initial edge length; the atlas grows on demand
-     */
-    constructor(fill: DecalAtlasFill, size?: number);
-    /**
-     * @returns {DecalAtlasFill}
-     */
-    get fill(): number;
-    /**
-     * The border is the patch's own size, not the caller's choice — every patch in one atlas has to
-     * obey the same rule for {@link decal_atlas_max_lod}'s "+1 from the neighbour" to hold.
-     *
-     * @param {Sampler2D} sampler
-     * @returns {AtlasPatch}
-     */
-    add(sampler: Sampler2D): AtlasPatch;
-    /**
-     * @param {AtlasPatch} patch
-     */
-    paintPatch(patch: AtlasPatch): void;
-    #private;
-}
-import { TextureAtlas } from "../../graphics/texture/atlas/TextureAtlas.js";
-import { DecalAtlasFill } from "./DecalAtlasFill.js";
-//# sourceMappingURL=DecalAtlas.d.ts.map

package/src/engine/graphics3/decal/DecalAtlas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DecalAtlas.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/DecalAtlas.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;GAeG;AACH;IAMI;;;OAGG;IACH,kBAHW,cAAc,SACd,MAAM,EAQhB;IAED;;OAEG;IACH,mBAEC;IAED;;;;;;OAMG;IACH,oCAIC;IAED;;OAEG;IACH,oCAoDC;;CA6EJ;6BA/L4B,8CAA8C;+BAG5C,qBAAqB"}

package/src/engine/graphics3/decal/DecalAtlasFill.d.ts

@@ -1,12 +0,0 @@
-/**
- * How a decal atlas fills the border around a patch.
- *
- * Two rules rather than one, because the correct fill depends on what the channel means and getting
- * it wrong shows up only once the mip chain is built.
- */
-export type DecalAtlasFill = number;
-export namespace DecalAtlasFill {
-    let PremultipliedCoverage: number;
-    let EdgeExtend: number;
-}
-//# sourceMappingURL=DecalAtlasFill.d.ts.map

package/src/engine/graphics3/decal/DecalAtlasFill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DecalAtlasFill.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/DecalAtlasFill.js"],"names":[],"mappings":";;;;;;6BAMU,MAAM"}

package/src/engine/graphics3/decal/decal_atlas_border.d.ts

@@ -1,52 +0,0 @@
-/**
- * Border, in texels, for a patch of this size.
- *
- * Driven by the longer side, because one border value protects both axes and the atlas halves both
- * together when it builds its mip chain.
- *
- * @param {number} width
- * @param {number} height
- * @returns {number}
- */
-export function decal_atlas_border(width: number, height: number): number;
-/**
- * The deepest mip level a patch with this border can be sampled at without reading a neighbour.
- *
- * **A patch's own border is not the whole guard.** Every patch in the atlas has a border of at least
- * {@link DECAL_ATLAS_BORDER_MINIMUM}, so whatever sits next to this one contributes at least one
- * more texel of separation: content is `border + 1` texels apart at worst. At mip level `L` that
- * separation is `(border + 1) / 2^L` texels, and it has to survive down to one — which is also what
- * pays for patches not landing on power-of-two boundaries, so alignment is not claimed on top of it.
- *
- * Past this level the sampler is clamped rather than allowed to keep minifying, so a decal seen from
- * very far away aliases instead of bleeding. That is the trade, and it is the right way round: a
- * shimmering decal is a decal, a bleeding one is somebody else's texture.
- *
- * @param {number} border
- * @returns {number}
- */
-export function decal_atlas_max_lod(border: number): number;
-/**
- * How much of a patch's own size is spent on its border.
- *
- * A **proportional** border rather than a fixed one, and that is the point of it: the border is what
- * decides how far a patch can be minified before its neighbours bleed into it, so sizing it in
- * proportion makes that limit the same for every decal whatever its resolution. At 1/64 every patch
- * stops minifying at roughly the same ~64 px screen footprint, for a flat ~6.3% of atlas area.
- *
- * A fixed border does the opposite: generous for small patches and useless for large ones.
- *
- * @type {number}
- */
-export const DECAL_ATLAS_BORDER_RATIO: number;
-/**
- * The smallest border a patch may have, in texels.
- *
- * One, not more. A 64x64 decal is common and needs four texels at the very most; eight would spend a
- * tenth of the texture on gutter to protect mip levels at which the decal is a handful of pixels on
- * screen. One texel is also not really one — see {@link decal_atlas_max_lod}.
- *
- * @type {number}
- */
-export const DECAL_ATLAS_BORDER_MINIMUM: number;
-//# sourceMappingURL=decal_atlas_border.d.ts.map

package/src/engine/graphics3/decal/decal_atlas_border.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"decal_atlas_border.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/decal_atlas_border.js"],"names":[],"mappings":"AA2BA;;;;;;;;;GASG;AACH,0CAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,4CAHW,MAAM,GACJ,MAAM,CAOlB;AAlED;;;;;;;;;;;GAWG;AACH,uCAFU,MAAM,CAE+B;AAE/C;;;;;;;;GAQG;AACH,yCAFU,MAAM,CAE4B"}

package/src/shade/renderer/postprocess/gtao/graph_build_depth_mipmap.d.ts

@@ -1,26 +0,0 @@
-/**
- * @param {GraphicsContext} graphics
- * @param {GPUCommandEncoder} encoder
- * @param {GPUTextureContext} output_depth
- * @param {GPUTextureView} source_view
- * @param {GPUBuffer} camera
- */
-export function render_mip0(graphics: GraphicsContext, encoder: GPUCommandEncoder, output_depth: GPUTextureContext, source_view: GPUTextureView, camera: GPUBuffer): any;
-/**
- * NOTE: was written for GTAO, currently not being used
- * @param {Object} options
- * @param {FrameGraph} options.graph
- * @param {number} options.depth
- * @param {number[]} options.resolution
- * @param {number} [options.max_mips]
- * @param {number} options.camera camera buffer
- * @returns {number} mip-mapped linear z-buffer
- */
-export function graph_build_depth_mipmap({ graph, depth, resolution, max_mips, camera }: {
-    graph: FrameGraph;
-    depth: number;
-    resolution: number[];
-    max_mips?: number;
-    camera: number;
-}): number;
-//# sourceMappingURL=graph_build_depth_mipmap.d.ts.map

package/src/shade/renderer/postprocess/gtao/graph_build_depth_mipmap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graph_build_depth_mipmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/graph_build_depth_mipmap.js"],"names":[],"mappings":"AA0HA;;;;;;GAMG;AACH,yKAoCC;AAED;;;;;;;;;GASG;AACH;IAP+B,KAAK;IACT,KAAK,EAArB,MAAM;IACY,UAAU,EAA5B,MAAM,EAAE;IACS,QAAQ,GAAzB,MAAM;IACU,MAAM,EAAtB,MAAM;IACJ,MAAM,CA4FlB"}

package/src/shade/renderer/postprocess/gtao/graph_build_depth_mipmap.js

@@ -1,268 +0,0 @@
-import { BufferBindingLayout } from "../../../descriptor/binding/BufferBindingLayout.js";
-import { TextureBindingLayout } from "../../../descriptor/binding/TextureBindingLayout.js";
-import { PipelineLayoutDescriptor } from "../../../descriptor/pipeline/PipelineLayoutDescriptor.js";
-import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
-import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
-import { BindGroupDescriptor } from "../../binding/BindGroupDescriptor.js";
-import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { create_full_quad_pipeline_descriptor } from "../../shader/fullscreen/create_full_quad_pipeline_descriptor.js";
-import { chunk_linearize_depth } from "../../shader/chunk/depth/chunk_linearize_depth.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { GTAO_EFFECT_FALLOFF_RANGE, GTAO_EFFECT_RADIUS } from "./fragment_shader_gtao.js";
-
-//
-
-//language=WGSL
-const shader_reduce = `
-
-      @group(0) @binding(0) var source : texture_2d<f32>;
-            
-      const EffectRadius = ${GTAO_EFFECT_RADIUS};
-      const EffectFalloffRange = ${GTAO_EFFECT_FALLOFF_RANGE};
-      
-      fn DepthMIPFilter( depth0:f32, depth1:f32, depth2:f32, depth3:f32 ) -> f32
-        {
-            let maxDepth = max( max( depth0, depth1 ), max( depth2, depth3 ) );
-        
-            const depthRangeScaleFactor = 0.75; // found empirically :)
-            
-            const effectRadius              = depthRangeScaleFactor * EffectRadius;
-            const falloffRange              =  EffectFalloffRange * effectRadius;
-
-            const falloffFrom       = effectRadius * (1-EffectFalloffRange);
-            
-            // fadeout precompute optimisation
-            const falloffMul        = -1.0 / ( falloffRange );
-            const falloffAdd        = falloffFrom / ( falloffRange ) + 1.0;
-        
-            let weight0 = saturate( (maxDepth-depth0) * falloffMul + falloffAdd );
-            let weight1 = saturate( (maxDepth-depth1) * falloffMul + falloffAdd );
-            let weight2 = saturate( (maxDepth-depth2) * falloffMul + falloffAdd );
-            let weight3 = saturate( (maxDepth-depth3) * falloffMul + falloffAdd );
-        
-            let weightSum = weight0 + weight1 + weight2 + weight3;
-            
-            return (weight0 * depth0 + weight1 * depth1 + weight2 * depth2 + weight3 * depth3) / weightSum;
-        }
-        
-      @fragment
-      fn main(@builtin(position) coord : vec4<f32>) -> @location(0) f32 {
-            
-            
-            let source_size = textureDimensions(source, 0);
-            let limit =  vec2u(source_size - 1u);
-            
-            let p0 = min( vec2u( u32(coord.x) << 1,  u32(coord.y) << 1), limit);
-            let p1 = min( p0 + vec2u(1,0), limit );
-            let p2 = min( p0 + vec2u(0,1), limit );
-            let p3 = min( p0 + vec2u(1,1), limit );
-           
-            let depth0 = textureLoad(source, p0, 0).r;
-            let depth1 = textureLoad(source, p1, 0).r;
-            let depth2 = textureLoad(source, p2, 0).r;
-            let depth3 = textureLoad(source, p3, 0).r;
-            
-            let depth = DepthMIPFilter(depth0, depth1, depth2, depth3);
-            
-            return depth;
-      }
-`;
-
-const render_pipeline_descriptor_reduce = create_full_quad_pipeline_descriptor({
-    fragment_code: shader_reduce,
-    layout: PipelineLayoutDescriptor.forStage(GPUShaderStage.FRAGMENT, [
-        [
-            TextureBindingLayout.unfilterableFloat
-        ]
-    ]),
-    targets: [
-        {
-            format: "r32float",
-        }
-    ]
-});
-
-
-//language=WGSL
-const shader_mip0 = CodeChunk.from(`
-
-@group(0) @binding(0) var source : texture_2d<f32>;
-@group(0) @binding(1) var<uniform> camera: ${CAMERA_UNIFORM_STRUCT.wgsl_ref};
-      
-@fragment
-fn main(@builtin(position) coord : vec4<f32>) -> @location(0) f32 {
-    
-    let depth_raw = textureLoad(source,vec2u(coord.xy), 0).r;
-    
-    let depth = linearize_depth(camera.projection_matrix, depth_raw);
-    
-    return depth;
-}
-      
-`,[
-    CAMERA_UNIFORM_STRUCT.declaration_chunk,
-    chunk_linearize_depth,
-]).compile().text;
-
-const render_pipeline_descriptor_mip0 = create_full_quad_pipeline_descriptor({
-    fragment_code: shader_mip0,
-    layout: PipelineLayoutDescriptor.forStage(GPUShaderStage.FRAGMENT, [
-        [
-            TextureBindingLayout.unfilterableFloat,
-            BufferBindingLayout.uniform
-        ]
-    ]),
-    targets: [
-        {
-            format: "r32float",
-        }
-    ]
-});
-
-
-/**
- * @param {GraphicsContext} graphics
- * @param {GPUCommandEncoder} encoder
- * @param {GPUTextureContext} output_depth
- * @param {GPUTextureView} source_view
- * @param {GPUBuffer} camera
- */
-export function render_mip0(
-    graphics,
-    encoder,
-    output_depth,
-    source_view,
-    camera
-) {
-    const pipeline = graphics.render_pipelines.obtain(render_pipeline_descriptor_mip0);
-
-    const output_view = output_depth.obtainView(TextureViewDescriptor.from({
-        baseMipLevel: 0,
-        mipLevelCount: 1
-    }));
-
-    const pass = encoder.beginRenderPass({
-        colorAttachments: [
-            {
-                view: output_view,
-                loadOp: "clear",
-                storeOp: "store"
-            }
-        ]
-    });
-
-
-    const bind_group = graphics.bind_groups.obtain(BindGroupDescriptor.from(render_pipeline_descriptor_mip0.layout.bindGroupLayouts[0], [
-        source_view,
-        { buffer: camera }
-    ]));
-
-    pass.setPipeline(pipeline);
-    pass.setBindGroup(0, bind_group);
-    pass.draw(3);
-    pass.end();
-
-    return output_view;
-}
-
-/**
- * NOTE: was written for GTAO, currently not being used
- * @param {Object} options
- * @param {FrameGraph} options.graph
- * @param {number} options.depth
- * @param {number[]} options.resolution
- * @param {number} [options.max_mips]
- * @param {number} options.camera camera buffer
- * @returns {number} mip-mapped linear z-buffer
- */
-export function graph_build_depth_mipmap(
-    {
-        graph,
-        depth,
-        resolution,
-        max_mips = Number.POSITIVE_INFINITY,
-        camera
-    }
-) {
-    const data = {};
-
-
-    /**
-     *
-     * @param data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute(data, resources, context) {
-        /**
-         * @type {GPUTextureContext}
-         */
-        const input_depth = resources.get(data.input_depth);
-        const output_depth = resources.get(data.output_depth);
-        const camera = resources.get(data.camera);
-
-        const graphics = context.graphics;
-
-        const reduction_pipeline = graphics.render_pipelines.obtain(render_pipeline_descriptor_reduce);
-
-        const mip_limit = Math.min(max_mips, output_depth.gpu_texture.mipLevelCount);
-
-
-        const encoder = context.encoder;
-
-        // mip 0
-        let source_view = input_depth.obtainView();
-
-        source_view = render_mip0(graphics, encoder, output_depth, source_view, camera);
-
-        // inspect_gpu_buffer_typed({
-        //     buffer: camera,
-        //     device: graphics.device,
-        //     type: CAMERA_UNIFORM_STRUCT,
-        //     count:1
-        // }).then(console.warn);
-
-
-        for (let i = 1; i < mip_limit; i++) {
-            const destination_view = output_depth.obtainView(TextureViewDescriptor.from({
-                baseMipLevel: i,
-                mipLevelCount: 1,
-            }));
-
-            const pass = encoder.beginRenderPass({
-                colorAttachments: [
-                    {
-                        view: destination_view,
-                        loadOp: "clear",
-                        storeOp: "store"
-                    }
-                ]
-            });
-
-            const bind_group = graphics.bind_groups.obtain(BindGroupDescriptor.from(render_pipeline_descriptor_reduce.layout.bindGroupLayouts[0], [
-                source_view
-            ]));
-
-            pass.setPipeline(reduction_pipeline);
-            pass.setBindGroup(0, bind_group);
-            pass.draw(3);
-            pass.end();
-
-            source_view = destination_view;
-        }
-
-    }
-
-    const builder = graph.add('depth mipmap', data, execute);
-
-    data.input_depth = builder.read(depth);
-    data.camera = builder.read(camera);
-    data.output_depth = builder.create("mipmap", TextureResourceDescriptor.from({
-        resolution: resolution,
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_DST,
-        format: "r32float",
-        enableMips: true
-    }));
-
-    return data.output_depth;
-}

package/src/shade/renderer/postprocess/ssr/copy_shader_f32.d.ts

@@ -1,3 +0,0 @@
-export const copy_shader_f32: ImageShader;
-import { ImageShader } from "../../shader/ImageShader.js";
-//# sourceMappingURL=copy_shader_f32.d.ts.map

package/src/shade/renderer/postprocess/ssr/copy_shader_f32.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"copy_shader_f32.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/copy_shader_f32.js"],"names":[],"mappings":"AAsBA,0CASE;4BA9B0B,6BAA6B"}

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

@@ -1,32 +0,0 @@
-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 resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addTexture("tInput");
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@fragment
-fn main(
-    @builtin(position) coord : vec4<f32>,
-    @location(0) uv: vec2<f32>,
-) -> @location(0) f32 {
-    return textureLoad(tInput, vec2<i32>(coord.xy), 0).r;
-}
-    `
-)
-
-export const copy_shader_f32 = new ImageShader({
-    descriptor: ShaderDescriptor.from({
-        label: "Copy r32",
-        resources,
-        body
-    }),
-    targets: [
-        { format: "r32float" }
-    ]
-})

package/src/shade/renderer/postprocess/ssr/depth_max_shader.d.ts

@@ -1,17 +0,0 @@
-/**
- * Inclusive source-texel window one output texel of the reduction reads: `(min.xy, max.xy)`.
- *
- * The windows of one step tile the source exactly — every source texel belongs to one output texel,
- * none twice and none missed — which is what makes the result a max over the whole level rather than a
- * max over an arbitrary stencil. Pinned by `depth_max_source_bounds.spec`.
- *
- * The stride is `ceil(source / output)`, not a hardcoded 2, and the upper bound is
- * `min + stride - 1` because the loops that read it are inclusive. It used to be `target * 2` for the
- * origin and `min + stride` for the bound, which at a halving step is three texels per axis: nine
- * reads for a 2x2 footprint, overlapping its neighbours on both sides.
- */
-export const chunk_depth_max_source_bounds: CodeChunk;
-export const depth_max_shader: ImageShader;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ImageShader } from "../../shader/ImageShader.js";
-//# sourceMappingURL=depth_max_shader.d.ts.map

package/src/shade/renderer/postprocess/ssr/depth_max_shader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"depth_max_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/depth_max_shader.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;GAWG;AACH,sDAyBE;AAkCF,2CAWG;0BAhGuB,oCAAoC;4BAClC,6BAA6B"}