@woosh/meep-engine 3.53.0 → 3.55.0

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

@@ -0,0 +1,191 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { INDIRECT_LIGHT_INTENSITY } from "../../deferred/INDIRECT_LIGHT_INTENSITY.js";
+import { BRICK4_DATA_STRUCT } from "../../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
+import { LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS } from "../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
+import { chunk_light_cluster_counts } from "../../light/cluster/chunk_light_cluster_counts.js";
+import { LIGHT_CLUSTER_LOOKUP_STRUCT } from "../../light/cluster/shader_cluster_assign_lights.js";
+import { ENVIRONMENT_SH_TYPE } from "../../light/environment/shader_project_environment_sh.js";
+import { chunk_world_light_cluster_lookup } from "../../light/world_cluster/chunk_world_light_cluster_lookup.js";
+import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import {
+    chunk_directional_lights_iteration_mask
+} from "../../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
+import {
+    chunk_get_directional_light_info_by_index
+} from "../../shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
+import {
+    METRO_L1_IRRADIANCE_STRUCT
+} from "../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32, i32, u32, vec3i, vec3u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { chunk_shadowmap_get_light_visibility } from "../../shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
+import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
+import { chunk_volumetrics_irradiance_sh } from "../chunk_volumetrics_irradiance_sh.js";
+import { chunk_volumetrics_local_light_shadow } from "../chunk_volumetrics_local_light_shadow.js";
+import { chunk_irradiance_clipmap_gi_sample } from "./chunk_irradiance_clipmap_gi_sample.js";
+import { chunk_irradiance_clipmap_local_light } from "./chunk_irradiance_clipmap_local_light.js";
+import {
+    IRRADIANCE_CLIPMAP_LIGHT_BUDGET,
+    IRRADIANCE_CLIPMAP_TILE_FORMAT,
+} from "./IRRADIANCE_CLIPMAP.js";
+
+export const IRRADIANCE_CLIPMAP_BUILD_GROUP_SIZE = Object.freeze([4, 4, 4]);
+
+export const IRRADIANCE_CLIPMAP_BUILD_STRUCT = WebGPUStruct.from({
+    tile_origin: vec3u,
+    cascade_index: u32,
+    corner: vec3i,
+    cell_size: f32,
+    tile_size: vec3u,
+    border: i32,
+}, "IrradianceClipmapBuild");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("build_settings", IRRADIANCE_CLIPMAP_BUILD_STRUCT)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("environment_sh", ENVIRONMENT_SH_TYPE)
+    .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false, true)
+    .addStorageBuffer("light_data", WebGPUArray.u32, false)
+    .addStorageBuffer("world_cluster_lookup", LIGHT_CLUSTER_LOOKUP_STRUCT, false)
+    .addStorageBuffer("world_cluster_data", WebGPUArray.u32, false)
+    .addTexture("shadowmapAtlas", "depth")
+    .addSampler("sCompareLinear", "comparison", SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR)
+    .addStorageTexture("atlas_y", IRRADIANCE_CLIPMAP_TILE_FORMAT, "3d", "write-only")
+    .addStorageTexture("atlas_cocg", IRRADIANCE_CLIPMAP_TILE_FORMAT, "3d", "write-only");
+
+resources.addGroup(LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${IRRADIANCE_CLIPMAP_BUILD_GROUP_SIZE.join(", ")})
+fn main(@builtin(global_invocation_id) local_texel: vec3<u32>) {
+    let tile_size = build_settings.tile_size;
+    if (any(local_texel >= tile_size)) {
+        return;
+    }
+
+    let local_cell = vec3<i32>(local_texel) - vec3<i32>(build_settings.border);
+    let world_cell = build_settings.corner + local_cell;
+    let position_ws = (vec3<f32>(world_cell) + vec3<f32>(0.5)) * build_settings.cell_size;
+
+    const INDIRECT_INTENSITY: f32 = ${INDIRECT_LIGHT_INTENSITY};
+    let gi_radiance = irradiance_clipmap_gi_sample(position_ws);
+    let scaled_gi = array<vec3<f32>, 4>(
+        gi_radiance[0] * INDIRECT_INTENSITY,
+        gi_radiance[1] * INDIRECT_INTENSITY,
+        gi_radiance[2] * INDIRECT_INTENSITY,
+        gi_radiance[3] * INDIRECT_INTENSITY,
+    );
+
+    var irradiance: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
+    irradiance = volumetrics_irradiance_sh_add_radiance(irradiance, scaled_gi);
+
+    let to_camera = mat4_extract_position(camera.transform) - position_ws;
+    let to_camera_len = max(length(to_camera), 1e-5);
+    let toward_camera = to_camera / to_camera_len;
+
+    var directional_bits = directional_lights_iteration_mask(&light_data);
+    while (directional_bits != 0u) {
+        let directional_index = countTrailingZeros(directional_bits);
+        directional_bits &= ~(1u << directional_index);
+
+        let sun = get_directional_light_info_by_index(&light_data, directional_index);
+
+        let shadow_term = shadowmap_get_directional_light_visibility(
+            &light_data,
+            directional_index,
+            position_ws,
+            toward_camera,
+            sun.direction
+        );
+
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * sun.color, sun.direction);
+    }
+
+    let cluster_meta = world_light_cluster_metadata_by_texel(
+        build_settings.cascade_index,
+        local_texel,
+        tile_size
+    );
+
+    let cluster_offset = cluster_meta.offset;
+    let point_count = light_cluster_count_point(cluster_meta.counts);
+    let spot_count = light_cluster_count_spot(cluster_meta.counts);
+
+    for (var j = 0u; j < min(point_count, ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u); j++) {
+        let light_index = world_cluster_data[cluster_offset + j];
+        let direct_light = irradiance_clipmap_get_point_light_info_by_index(
+            &light_data,
+            light_index,
+            position_ws,
+            build_settings.cell_size
+        );
+
+        if (all(direct_light.color == vec3<f32>(0.0))) {
+            continue;
+        }
+
+        let shadow_term = volumetrics_point_light_shadow(&light_data, light_index, position_ws);
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
+    }
+
+    for (var k = 0u; k < min(spot_count, ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u); k++) {
+        let light_index = world_cluster_data[cluster_offset + point_count + k];
+        let direct_light = irradiance_clipmap_get_spot_light_info_by_index(
+            &light_data,
+            light_index,
+            position_ws,
+            build_settings.cell_size
+        );
+
+        if (all(direct_light.color == vec3<f32>(0.0))) {
+            continue;
+        }
+
+        let shadow_term = volumetrics_spot_light_shadow(&light_data, light_index, position_ws);
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
+    }
+
+    let stored = volumetrics_irradiance_sh_storable(irradiance);
+    let atlas_texel = build_settings.tile_origin + local_texel;
+
+    textureStore(atlas_y, atlas_texel, stored.Y);
+    textureStore(atlas_cocg, atlas_texel, vec4<f32>(stored.CoCg, 0.0, 0.0));
+}
+`, [
+        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
+        chunk_mat4_extract_position,
+        chunk_irradiance_clipmap_gi_sample,
+        chunk_world_light_cluster_lookup,
+        chunk_light_cluster_counts,
+        chunk_directional_lights_iteration_mask,
+        chunk_get_directional_light_info_by_index,
+        chunk_irradiance_clipmap_local_light,
+        chunk_shadowmap_get_light_visibility,
+        chunk_volumetrics_local_light_shadow,
+        chunk_volumetrics_irradiance_sh,
+    ]
+);
+
+/**
+ * Populates one cascade's tile (including its 1-texel trilinear skirt) in the synchronized `Y` and
+ * `CoCg` 3D tile atlases of the world-space irradiance clipmap.
+ *
+ * Evaluates indirect lighting (`INDIRECT_LIGHTING`), directional lights (`SHADOW_DIRECTIONAL_TECHNIQUE`),
+ * and world-space clustered point and spot lights with shadow maps at deterministic world-space
+ * voxel centres.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_irradiance_clipmap_build = ComputeShader.from({
+    label: "Volumetrics / irradiance clipmap build",
+    resources,
+    body,
+});

package/src/shade/renderer/wind/GPUSceneWind.d.ts

@@ -42,7 +42,7 @@ export class GPUSceneWind {
      * @param {number} capacity
      * @returns {GPUTileAtlas3D}
      */
-    static "__#172@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
+    static "__#161@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
     /**
      * @param {GPUDevice} device
      */

package/src/shade/renderer/wind/GPUSceneWind.js

@@ -126,7 +126,7 @@ export class GPUSceneWind {
 
         return new GPUTileAtlas3D({
             device,
-            format: WIND_FIELD_TILE_FORMAT,
+            formats: [WIND_FIELD_TILE_FORMAT],
             // copied by the atlas; made only when the atlas is
             content_size: [content[0], content[1], content[2]],
             border: WIND_FIELD_TILE_BORDER,

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.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/DecalAtlasFill.js

@@ -1,32 +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.
- *
- * @enum {number}
- */
-export const DecalAtlasFill = {
-    /**
-     * Colour weighted by coverage, and a gutter of nothing.
-     *
-     * The patch is stored **premultiplied** and its border is zero. Averaging that pair down a mip
-     * chain gives premultiplied colour times coverage at every level, which is what a decal fading
-     * out at its edge should look like. The same arrangement in *straight* alpha is where dark
-     * halos come from — an edge texel averaged against transparent black keeps its alpha and loses
-     * its colour — and straight alpha beside a zeroed gutter is exactly what the atlas this
-     * replaces has today.
-     */
-    PremultipliedCoverage: 0,
-
-    /**
-     * The nearest content texel, repeated outward.
-     *
-     * For channels that carry no coverage of their own — a normal, a roughness, a metalness — there
-     * is nothing to fade toward, and a zeroed gutter would drag a partially covered mip texel toward
-     * a meaningless value (a zero normal, mirror-smooth roughness). Coverage for these comes from
-     * the albedo's alpha, so their border repeats the edge and lets the mip chain average content
-     * against more of the same.
-     */
-    EdgeExtend: 1,
-};

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"}