@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/deferred/GBUFFER_RESOURCES.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The G-buffer's PBR material parameters.
+ * @type {ShaderResourceDescriptor}
+ */
+export const GBUFFER_PBR_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The G-buffer's albedo.
+ * @type {ShaderResourceDescriptor}
+ */
+export const GBUFFER_ALBEDO_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The G-buffer's emission, encoded.
+ * @type {ShaderResourceDescriptor}
+ */
+export const GBUFFER_EMISSIVE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The albedo and ambient occlusion.
+ * @type {ShaderResourceDescriptor}
+ */
+export const GBUFFER_ALBEDO_AO_RESOURCE: ShaderResourceDescriptor;
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
+//# sourceMappingURL=GBUFFER_RESOURCES.d.ts.map

package/src/shade/renderer/deferred/GBUFFER_RESOURCES.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GBUFFER_RESOURCES.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/GBUFFER_RESOURCES.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,mCAFU,wBAAwB,CAEiD;AAEnF;;;GAGG;AACH,sCAFU,wBAAwB,CAEuD;AAEzF;;;GAGG;AACH,wCAFU,wBAAwB,CAEmE;AAErG;;;GAGG;AACH,yCAFU,wBAAwB,CAEsD;yCAxB/C,gDAAgD"}

package/src/shade/renderer/deferred/GBUFFER_RESOURCES.js

@@ -0,0 +1,25 @@
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
+
+/**
+ * The G-buffer's PBR material parameters.
+ * @type {ShaderResourceDescriptor}
+ */
+export const GBUFFER_PBR_RESOURCE = ShaderResourceDescriptor.texture("gBufferPBR");
+
+/**
+ * The G-buffer's albedo.
+ * @type {ShaderResourceDescriptor}
+ */
+export const GBUFFER_ALBEDO_RESOURCE = ShaderResourceDescriptor.texture("gBufferAlbedo");
+
+/**
+ * The G-buffer's emission, encoded.
+ * @type {ShaderResourceDescriptor}
+ */
+export const GBUFFER_EMISSIVE_RESOURCE = ShaderResourceDescriptor.texture("gBufferEmissive", "uint");
+
+/**
+ * The albedo and ambient occlusion.
+ * @type {ShaderResourceDescriptor}
+ */
+export const GBUFFER_ALBEDO_AO_RESOURCE = ShaderResourceDescriptor.texture("tAlbedoAO");

package/src/shade/renderer/deferred/LOCAL_LIGHT_SHADING.d.ts

@@ -0,0 +1,12 @@
+/**
+ * How the deferred pass shades local lights ({@link LocalLightShading}), decided by
+ * `chunk_shade_standard_material_direct_deferred`. The forward paths link the clustered chunk
+ * directly and never depend on it.
+ *
+ * The renderer sets this from `feature_restir_di_enabled` in the switch set it hands its passes.
+ *
+ * @type {ShaderSwitch}
+ */
+export const LOCAL_LIGHT_SHADING: ShaderSwitch;
+import { ShaderSwitch } from "../shader/compiler/ShaderSwitch.js";
+//# sourceMappingURL=LOCAL_LIGHT_SHADING.d.ts.map

package/src/shade/renderer/deferred/LOCAL_LIGHT_SHADING.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LOCAL_LIGHT_SHADING.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/LOCAL_LIGHT_SHADING.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,kCAFU,YAAY,CAEyE;6BAZlE,oCAAoC"}

package/src/shade/renderer/deferred/LOCAL_LIGHT_SHADING.js

@@ -0,0 +1,13 @@
+import { ShaderSwitch } from "../shader/compiler/ShaderSwitch.js";
+import { LocalLightShading } from "./LocalLightShading.js";
+
+/**
+ * How the deferred pass shades local lights ({@link LocalLightShading}), decided by
+ * `chunk_shade_standard_material_direct_deferred`. The forward paths link the clustered chunk
+ * directly and never depend on it.
+ *
+ * The renderer sets this from `feature_restir_di_enabled` in the switch set it hands its passes.
+ *
+ * @type {ShaderSwitch}
+ */
+export const LOCAL_LIGHT_SHADING = ShaderSwitch.enum('local light shading', LocalLightShading);

package/src/shade/renderer/deferred/LocalLightShading.d.ts

@@ -0,0 +1,10 @@
+/**
+ * How the deferred pass shades local (point and spot) lights: one way for every light of a renderer,
+ * set by `Renderer.feature_restir_di_enabled`.
+ */
+export type LocalLightShading = number;
+export namespace LocalLightShading {
+    let Clustered: number;
+    let ReSTIR: number;
+}
+//# sourceMappingURL=LocalLightShading.d.ts.map

package/src/shade/renderer/deferred/LocalLightShading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalLightShading.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/LocalLightShading.js"],"names":[],"mappings":";;;;gCAIU,MAAM"}

package/src/shade/renderer/deferred/LocalLightShading.js

@@ -0,0 +1,12 @@
+/**
+ * How the deferred pass shades local (point and spot) lights: one way for every light of a renderer,
+ * set by `Renderer.feature_restir_di_enabled`.
+ *
+ * @enum {number}
+ */
+export const LocalLightShading = {
+    /** Every light of the pixel's froxel cluster, each shadow-mapped. */
+    Clustered: 0,
+    /** ReSTIR DI's resolved radiance, one resampled and ray-traced sample per pixel. */
+    ReSTIR: 1,
+};

package/src/shade/renderer/deferred/SHADING_LIGHT_RESOURCE_GROUP.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SHADING_LIGHT_RESOURCE_GROUP.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/SHADING_LIGHT_RESOURCE_GROUP.js"],"names":[],"mappings":"AAMA,yEAAgF;8CAHlC,qDAAqD"}
+{"version":3,"file":"SHADING_LIGHT_RESOURCE_GROUP.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/SHADING_LIGHT_RESOURCE_GROUP.js"],"names":[],"mappings":"AAUA,yEAAgF;8CAHlC,qDAAqD"}

package/src/shade/renderer/deferred/SHADING_LIGHT_RESOURCE_GROUP.js

@@ -1,18 +1,22 @@
-import { vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { LIGHT_CLUSTER_LOOKUP_STRUCT } from "../light/cluster/shader_cluster_assign_lights.js";
+import {
+    LIGHT_CLUSTER_DATA_RESOURCE,
+    LIGHT_CLUSTER_LOOKUP_RESOURCE,
+    LIGHT_CLUSTER_PARAMETERS_RESOURCE
+} from "../light/cluster/LIGHT_CLUSTER_RESOURCES.js";
+import { ENVIRONMENT_MAP_RESOURCE } from "../light/environment/ENVIRONMENT_MAP_RESOURCE.js";
+import { LIGHT_DATA_RESOURCE } from "../light/LIGHT_DATA_RESOURCE.js";
 import { ShaderResourceGroupDescriptor } from "../shader/resource/ShaderResourceGroupDescriptor.js";
-import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
+import { SHADOWMAP_ATLAS_RESOURCE, SHADOWMAP_COMPARE_SAMPLER_RESOURCE } from "../shadow/map/SHADOWMAP_RESOURCES.js";
 
 export const SHADING_LIGHT_RESOURCE_GROUP = new ShaderResourceGroupDescriptor();
 
 SHADING_LIGHT_RESOURCE_GROUP
-    .addStorageBuffer("light_data", WebGPUArray.u32)
-    .addTexture("tEnvironment")
+    .add(LIGHT_DATA_RESOURCE)
+    .add(ENVIRONMENT_MAP_RESOURCE)
     // clusters
-    .addUniform("cluster_parameters", vec3f)
-    .addStorageBuffer("cluster_lookup", LIGHT_CLUSTER_LOOKUP_STRUCT)
-    .addStorageBuffer("cluster_data", WebGPUArray.u32)
+    .add(LIGHT_CLUSTER_PARAMETERS_RESOURCE)
+    .add(LIGHT_CLUSTER_LOOKUP_RESOURCE)
+    .add(LIGHT_CLUSTER_DATA_RESOURCE)
     // shadows
-    .addTexture("shadowmapAtlas", "depth")
-    .addSampler("sCompareLinear", "comparison", SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR)
+    .add(SHADOWMAP_ATLAS_RESOURCE)
+    .add(SHADOWMAP_COMPARE_SAMPLER_RESOURCE)

package/src/shade/renderer/deferred/TonemapDisplaySettings.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The immediate data every tonemap pass reads: the colour space the canvas actually shows, and the display's peak.
+ *
+ * A pass's immediate struct names only the members it reads. The GT7 passes leave the operator in Rec.2020 and read
+ * `display_from_rec2020_*`; the others work in Rec.709 and read `display_from_rec709_*`; only the HDR passes read
+ * `peak_nits`. So one instance serves whichever pass is current.
+ *
+ * Each matrix is three columns, not a `mat3x3f`: a `mat3x3f` pads each column to 16 bytes and the immediate
+ * serialiser writes its nine floats end to end.
+ */
+export class TonemapDisplaySettings {
+    display_from_rec709_c0: Float32Array;
+    display_from_rec709_c1: Float32Array;
+    display_from_rec709_c2: Float32Array;
+    display_from_rec2020_c0: Float32Array;
+    display_from_rec2020_c1: Float32Array;
+    display_from_rec2020_c2: Float32Array;
+    /**
+     * The display's peak, cd/m². Read by the HDR passes only.
+     * @type {number}
+     */
+    peak_nits: number;
+    /**
+     * Point the passes at the primaries of the canvas they write.
+     *
+     * @param {PredefinedColorSpace|string} color_space what the canvas reports it was configured with, `"srgb"` or
+     *        `"display-p3"`
+     */
+    set_canvas_color_space(color_space: PredefinedColorSpace | string): void;
+}
+/**
+ * Immediate data of a pass that works in Rec.709. Filled by {@link TonemapDisplaySettings}.
+ */
+export const TONEMAP_SETTINGS_REC709: WebGPUStruct;
+/**
+ * Immediate data of a pass that works in Rec.709 and is told the display's peak. Filled by {@link
+ * TonemapDisplaySettings}.
+ */
+export const TONEMAP_SETTINGS_REC709_PEAK: WebGPUStruct;
+/**
+ * Immediate data of a pass that works in Rec.2020. Filled by {@link TonemapDisplaySettings}.
+ */
+export const TONEMAP_SETTINGS_REC2020: WebGPUStruct;
+/**
+ * Immediate data of a pass that works in Rec.2020 and is told the display's peak. Filled by {@link
+ * TonemapDisplaySettings}.
+ */
+export const TONEMAP_SETTINGS_REC2020_PEAK: WebGPUStruct;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=TonemapDisplaySettings.d.ts.map

package/src/shade/renderer/deferred/TonemapDisplaySettings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TonemapDisplaySettings.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/TonemapDisplaySettings.js"],"names":[],"mappings":"AAiDA;;;;;;;;;GASG;AACH;IACI,qCAAqD;IACrD,qCAAqD;IACrD,qCAAqD;IAErD,sCAA8C;IAC9C,sCAA8C;IAC9C,sCAA8C;IAE9C;;;OAGG;IACH,WAFU,MAAM,CAEC;IAMjB;;;;;OAKG;IACH,oCAHW,oBAAoB,GAAC,MAAM,QAkBrC;CACJ;AAqBD;;GAEG;AACH,mDAAqF;AAErF;;;GAGG;AACH,wDAAmG;AAEnG;;GAEG;AACH,oDAAuF;AAEvF;;;GAGG;AACH,yDAAqG;6BAzIxE,gCAAgC"}

package/src/shade/renderer/deferred/TonemapDisplaySettings.js

@@ -0,0 +1,142 @@
+import { m3_rgb_to_xyz_from_primaries } from "../../../core/color/xyz/m3_rgb_to_xyz_from_primaries.js";
+import { m3_invert } from "../../../core/geom/mat3/m3_invert.js";
+import { m3_multiply } from "../../../core/geom/mat3/m3_multiply.js";
+import { f32, vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+
+// chromaticities of red, green and blue; every space here has a D65 white, so none needs chromatic adaptation
+const PRIMARIES_REC709 = [0.640, 0.330, 0.300, 0.600, 0.150, 0.060];
+const PRIMARIES_REC2020 = [0.708, 0.292, 0.170, 0.797, 0.131, 0.046];
+const PRIMARIES_DISPLAY_P3 = [0.680, 0.320, 0.265, 0.690, 0.150, 0.060];
+
+const D65_X = 0.3127;
+const D65_Y = 0.3290;
+
+/**
+ * The primaries of each canvas `colorSpace` the tonemap passes can write. Both share the sRGB transfer curve.
+ * @type {Object<string, number[]>}
+ */
+const CANVAS_PRIMARIES = {
+    "srgb": PRIMARIES_REC709,
+    "display-p3": PRIMARIES_DISPLAY_P3,
+};
+
+const scratch_from_xyz = new Float64Array(9);
+const scratch_to_xyz = new Float64Array(9);
+const scratch_m = new Float64Array(9);
+
+/**
+ * @param {Float32Array} c0
+ * @param {Float32Array} c1
+ * @param {Float32Array} c2
+ * @param {number[]} from
+ * @param {number[]} to
+ */
+function write_columns(c0, c1, c2, from, to) {
+    m3_rgb_to_xyz_from_primaries(scratch_from_xyz, from, D65_X, D65_Y);
+    m3_rgb_to_xyz_from_primaries(scratch_to_xyz, to, D65_X, D65_Y);
+    m3_invert(scratch_to_xyz, scratch_to_xyz);
+
+    // row-major
+    m3_multiply(scratch_m, scratch_to_xyz, scratch_from_xyz);
+
+    for (let row = 0; row < 3; row++) {
+        c0[row] = scratch_m[row * 3];
+        c1[row] = scratch_m[row * 3 + 1];
+        c2[row] = scratch_m[row * 3 + 2];
+    }
+}
+
+/**
+ * The immediate data every tonemap pass reads: the colour space the canvas actually shows, and the display's peak.
+ *
+ * A pass's immediate struct names only the members it reads. The GT7 passes leave the operator in Rec.2020 and read
+ * `display_from_rec2020_*`; the others work in Rec.709 and read `display_from_rec709_*`; only the HDR passes read
+ * `peak_nits`. So one instance serves whichever pass is current.
+ *
+ * Each matrix is three columns, not a `mat3x3f`: a `mat3x3f` pads each column to 16 bytes and the immediate
+ * serialiser writes its nine floats end to end.
+ */
+export class TonemapDisplaySettings {
+    display_from_rec709_c0 = new Float32Array([1, 0, 0]);
+    display_from_rec709_c1 = new Float32Array([0, 1, 0]);
+    display_from_rec709_c2 = new Float32Array([0, 0, 1]);
+
+    display_from_rec2020_c0 = new Float32Array(3);
+    display_from_rec2020_c1 = new Float32Array(3);
+    display_from_rec2020_c2 = new Float32Array(3);
+
+    /**
+     * The display's peak, cd/m². Read by the HDR passes only.
+     * @type {number}
+     */
+    peak_nits = 1000;
+
+    constructor() {
+        this.set_canvas_color_space("srgb");
+    }
+
+    /**
+     * Point the passes at the primaries of the canvas they write.
+     *
+     * @param {PredefinedColorSpace|string} color_space what the canvas reports it was configured with, `"srgb"` or
+     *        `"display-p3"`
+     */
+    set_canvas_color_space(color_space) {
+        const display = CANVAS_PRIMARIES[color_space];
+
+        if (display === undefined) {
+            throw new Error(`Canvas colorSpace '${color_space}' is not one the tonemap passes can write`);
+        }
+
+        write_columns(
+            this.display_from_rec709_c0, this.display_from_rec709_c1, this.display_from_rec709_c2,
+            PRIMARIES_REC709, display
+        );
+        write_columns(
+            this.display_from_rec2020_c0, this.display_from_rec2020_c1, this.display_from_rec2020_c2,
+            PRIMARIES_REC2020, display
+        );
+    }
+}
+
+const display_from_rec709 = {
+    /** column 0 of the matrix from linear Rec.709 to the canvas's linear primaries */
+    display_from_rec709_c0: vec3f,
+    display_from_rec709_c1: vec3f,
+    display_from_rec709_c2: vec3f,
+};
+
+const display_from_rec2020 = {
+    /** column 0 of the matrix from linear Rec.2020 to the canvas's linear primaries */
+    display_from_rec2020_c0: vec3f,
+    display_from_rec2020_c1: vec3f,
+    display_from_rec2020_c2: vec3f,
+};
+
+/**
+ * The display's peak, cd/m². The paper white is not a setting: it is PAPER_WHITE_NITS on both outputs.
+ */
+const peak = { peak_nits: f32 };
+
+/**
+ * Immediate data of a pass that works in Rec.709. Filled by {@link TonemapDisplaySettings}.
+ */
+export const TONEMAP_SETTINGS_REC709 = WebGPUStruct.from({ ...display_from_rec709 });
+
+/**
+ * Immediate data of a pass that works in Rec.709 and is told the display's peak. Filled by {@link
+ * TonemapDisplaySettings}.
+ */
+export const TONEMAP_SETTINGS_REC709_PEAK = WebGPUStruct.from({ ...display_from_rec709, ...peak });
+
+/**
+ * Immediate data of a pass that works in Rec.2020. Filled by {@link TonemapDisplaySettings}.
+ */
+export const TONEMAP_SETTINGS_REC2020 = WebGPUStruct.from({ ...display_from_rec2020 });
+
+/**
+ * Immediate data of a pass that works in Rec.2020 and is told the display's peak. Filled by {@link
+ * TonemapDisplaySettings}.
+ */
+export const TONEMAP_SETTINGS_REC2020_PEAK = WebGPUStruct.from({ ...display_from_rec2020, ...peak });

package/src/shade/renderer/deferred/chunk_read_gBuffer_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_read_gBuffer_material.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_read_gBuffer_material.js"],"names":[],"mappings":"AASA,oDAwDE;0BA1DwB,iCAAiC"}
+{"version":3,"file":"chunk_read_gBuffer_material.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_read_gBuffer_material.js"],"names":[],"mappings":"AAUA,oDAwDE;0BA3DwB,iCAAiC"}

package/src/shade/renderer/deferred/chunk_read_gBuffer_material.js

@@ -6,6 +6,7 @@ import { chunk_decode_g_buffer_roughness } from "../shader/chunk/material/chunk_
 import { chunk_metalness_to_specular_color } from "../shader/chunk/material/chunk_metalness_to_specular_color.js";
 import { MATERIAL_SHADING_INFO_STRUCT } from "../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { GBUFFER_ALBEDO_RESOURCE, GBUFFER_EMISSIVE_RESOURCE, GBUFFER_PBR_RESOURCE } from "./GBUFFER_RESOURCES.js";
 
 export const chunk_read_gBuffer_material = CodeChunk.from(
     //language=WGSL
@@ -63,4 +64,8 @@ fn read_gBuffer_material(
         chunk_decode_g_buffer_metalness,
         chunk_rgbe9995_decode
     ]
-);
+);
+
+chunk_read_gBuffer_material.requireResource(GBUFFER_ALBEDO_RESOURCE);
+chunk_read_gBuffer_material.requireResource(GBUFFER_EMISSIVE_RESOURCE);
+chunk_read_gBuffer_material.requireResource(GBUFFER_PBR_RESOURCE);

package/src/shade/renderer/deferred/chunk_sample_volumetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_sample_volumetrics.js"],"names":[],"mappings":"AAUA,iDAmDO;0BAtDmB,iCAAiC"}
+{"version":3,"file":"chunk_sample_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_sample_volumetrics.js"],"names":[],"mappings":"AAcA,iDAmDO;0BA1DmB,iCAAiC"}

package/src/shade/renderer/deferred/chunk_sample_volumetrics.js

@@ -7,6 +7,10 @@ import { chunk_r3_marty } from "../shader/chunk/noise/r/chunk_r3_marty.js";
 import { chunk_murmur3_vec3u } from "../shader/chunk/random/murmur/chunk_murmur3_vec3u.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { chunk_stbn_sample_vec3 } from "../shader/chunk/noise/chunk_stbn_sample_vec3.js";
+import { CAMERA_RESOURCE } from "../camera/CAMERA_RESOURCE.js";
+import { SAMPLER_LINEAR_RESOURCE } from "../texture/SAMPLER_LINEAR_RESOURCE.js";
+import { VIEW_RESOURCE } from "../view/VIEW_RESOURCE.js";
+import { VOLUMETRICS_METADATA_RESOURCE, VOLUMETRICS_RESOURCE } from "../volumetrics/VOLUMETRICS_RESOURCES.js";
 
 export const chunk_sample_volumetrics = CodeChunk.from(
     //language=WGSL
@@ -59,4 +63,10 @@ fn sample_volumetrics(
         chunk_murmur3_vec3u,
         chunk_r3_marty,
         chunk_cluster_depth_to_z_slice,
-    ]);
+    ]);
+
+chunk_sample_volumetrics.requireResource(CAMERA_RESOURCE);
+chunk_sample_volumetrics.requireResource(SAMPLER_LINEAR_RESOURCE);
+chunk_sample_volumetrics.requireResource(VOLUMETRICS_RESOURCE);
+chunk_sample_volumetrics.requireResource(VIEW_RESOURCE);
+chunk_sample_volumetrics.requireResource(VOLUMETRICS_METADATA_RESOURCE);

package/src/shade/renderer/deferred/chunk_shade_directional_lights.d.ts

@@ -5,8 +5,7 @@
  *
  * Shared by the brute-force deferred shading path and the ReSTIR DI variant —
  * directional lights stay on the cascaded-shadow-map path in both, so the loop
- * lives here once. Relies on the `light_data` storage binding and the shadow
- * atlas bindings being present in the shader's resource set.
+ * lives here once.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/deferred/chunk_shade_directional_lights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_shade_directional_lights.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_directional_lights.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AACH,6CAFU,SAAS,CAuCjB;0BApDwB,iCAAiC"}
+{"version":3,"file":"chunk_shade_directional_lights.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_directional_lights.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AACH,6CAFU,SAAS,CAuCjB;0BApDwB,iCAAiC"}

package/src/shade/renderer/deferred/chunk_shade_directional_lights.js

@@ -10,6 +10,7 @@ import { GEOMETRIC_SHADING_INFO_STRUCT } from "../shader/chunk/material/GEOMETRI
 import { MATERIAL_SHADING_INFO_STRUCT } from "../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { chunk_shadowmap_get_light_visibility } from "../shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
+import { LIGHT_DATA_RESOURCE } from "../light/LIGHT_DATA_RESOURCE.js";
 
 /**
  * Accumulate direct lighting from all occupied directional lights (max 32,
@@ -18,8 +19,7 @@ import { chunk_shadowmap_get_light_visibility } from "../shadow/map/shader/chunk
  *
  * Shared by the brute-force deferred shading path and the ReSTIR DI variant —
  * directional lights stay on the cascaded-shadow-map path in both, so the loop
- * lives here once. Relies on the `light_data` storage binding and the shadow
- * atlas bindings being present in the shader's resource set.
+ * lives here once.
  *
  * @type {CodeChunk}
  */
@@ -61,3 +61,5 @@ fn shade_directional_lights(
         chunk_shadowmap_get_light_visibility,
     ]
 );
+
+chunk_shade_directional_lights.requireResource(LIGHT_DATA_RESOURCE);

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct.d.ts

@@ -4,8 +4,8 @@
  * shadow-mapped.
  *
  * **One chunk, linked by both the deferred and the forward paths.** `shader_deferred_main` links it
- * (through the `_heavy` alias next door) and so do
- * `chunk_forward_shade_standard_fragment_ibl` / `..._brick4`. It used to exist twice under this one
+ * (through the `_heavy` alias next door) and so does
+ * `chunk_forward_shade_standard_fragment`. It used to exist twice under this one
  * WGSL function name, with the cluster metadata lookup, the point loop, the spot loop and the
  * emissive sum character-identical between the two and only the directional half differing: this copy
  * re-inlined `chunk_shade_directional_lights`' body where the other called it. Two files one edit away
@@ -13,7 +13,14 @@
  *
  * The ReSTIR DI variant ({@link chunk_shade_standard_material_direct_restir}) is a genuinely different
  * function — it replaces the cluster loop with one resampled, ray-traced sample — and stays separate.
- * The three are selected as separate compiled shaders, not via a runtime branch.
+ * The deferred pass links one of the two by a shader switch
+ * (`chunk_shade_standard_material_direct_deferred`), not via a runtime branch.
+ *
+ * **Each including pass owns its light budget.** `point_budget` and `spot_budget` are the most point
+ * lights, and separately spot lights, of the pixel's cell this evaluates; the rest of that type's list
+ * goes unshaded. The cell's list is in sorted-light order but for the lane order inside one 32-light
+ * window, so past the budget it drops the highest ids, except within that window (PROPOSAL_HIERARCHICAL,
+ * I.6). The passes linking this one choose their own numbers.
  *
  * A note carried by the inlined copy, kept because it is still true and now has nowhere else to sit:
  * a screen-space ray-trace for directional visibility would be wanted on the deferred path only, and

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_shade_standard_material_direct.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,mDAFU,SAAS,CA0FjB;0BAnHwB,iCAAiC"}
+{"version":3,"file":"chunk_shade_standard_material_direct.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,mDAFU,SAAS,CA8FjB;0BAjIwB,iCAAiC"}

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct.js

@@ -10,6 +10,9 @@ import { MATERIAL_SHADING_INFO_STRUCT } from "../shader/chunk/material/MATERIAL_
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { chunk_shadowmap_get_light_visibility } from "../shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
 import { chunk_shade_directional_lights } from "./chunk_shade_directional_lights.js";
+import { LIGHT_CLUSTER_DATA_RESOURCE } from "../light/cluster/LIGHT_CLUSTER_RESOURCES.js";
+import { LIGHT_DATA_RESOURCE } from "../light/LIGHT_DATA_RESOURCE.js";
+import { VIEW_RESOURCE } from "../view/VIEW_RESOURCE.js";
 
 /**
  * Brute-force direct shading of a standard material: every occupied directional light through the
@@ -17,8 +20,8 @@ import { chunk_shade_directional_lights } from "./chunk_shade_directional_lights
  * shadow-mapped.
  *
  * **One chunk, linked by both the deferred and the forward paths.** `shader_deferred_main` links it
- * (through the `_heavy` alias next door) and so do
- * `chunk_forward_shade_standard_fragment_ibl` / `..._brick4`. It used to exist twice under this one
+ * (through the `_heavy` alias next door) and so does
+ * `chunk_forward_shade_standard_fragment`. It used to exist twice under this one
  * WGSL function name, with the cluster metadata lookup, the point loop, the spot loop and the
  * emissive sum character-identical between the two and only the directional half differing: this copy
  * re-inlined `chunk_shade_directional_lights`' body where the other called it. Two files one edit away
@@ -26,7 +29,14 @@ import { chunk_shade_directional_lights } from "./chunk_shade_directional_lights
  *
  * The ReSTIR DI variant ({@link chunk_shade_standard_material_direct_restir}) is a genuinely different
  * function — it replaces the cluster loop with one resampled, ray-traced sample — and stays separate.
- * The three are selected as separate compiled shaders, not via a runtime branch.
+ * The deferred pass links one of the two by a shader switch
+ * (`chunk_shade_standard_material_direct_deferred`), not via a runtime branch.
+ *
+ * **Each including pass owns its light budget.** `point_budget` and `spot_budget` are the most point
+ * lights, and separately spot lights, of the pixel's cell this evaluates; the rest of that type's list
+ * goes unshaded. The cell's list is in sorted-light order but for the lane order inside one 32-light
+ * window, so past the budget it drops the highest ids, except within that window (PROPOSAL_HIERARCHICAL,
+ * I.6). The passes linking this one choose their own numbers.
  *
  * A note carried by the inlined copy, kept because it is still true and now has nowhere else to sit:
  * a screen-space ray-trace for directional visibility would be wanted on the deferred path only, and
@@ -42,6 +52,8 @@ fn shade_standard_material_direct(
     geometry: ${GEOMETRIC_SHADING_INFO_STRUCT.wgsl_ref},
     coord: vec2<f32>,
     view_depth: f32,
+    point_budget: u32,
+    spot_budget: u32,
 ) -> vec3<f32>{
 
     var reflected_light : ${REFLECTED_LIGHT_STRUCT.wgsl_ref};
@@ -59,7 +71,8 @@ fn shade_standard_material_direct(
     let point_count = light_cluster_count_point(cluster_metadata.counts);
     let spot_count = light_cluster_count_spot(cluster_metadata.counts);
 
-    for (var i = 0u; i < point_count; i++) {
+    // Budget: the including pass's, past it the cell's remaining point lights go unshaded
+    for (var i = 0u; i < min(point_count, point_budget); i++) {
         let light_index = cluster_data[cluster_offset + i];
 
         var direct_light = get_point_light_info_by_index(&light_data, light_index, geometry.position);
@@ -80,7 +93,8 @@ fn shade_standard_material_direct(
         re_direct_physical(direct_light, geometry, material, &reflected_light);
     }
 
-    for (var j = 0u; j < spot_count; j++) {
+    // Budget: the including pass's, past it the cell's remaining spot lights go unshaded
+    for (var j = 0u; j < min(spot_count, spot_budget); j++) {
         let light_index = cluster_data[cluster_offset + point_count + j];
 
         var direct_light = get_spot_light_info_by_index(&light_data, light_index, geometry.position);
@@ -123,3 +137,7 @@ fn shade_standard_material_direct(
         chunk_shadowmap_get_light_visibility,
     ]
 );
+
+chunk_shade_standard_material_direct.requireResource(LIGHT_CLUSTER_DATA_RESOURCE);
+chunk_shade_standard_material_direct.requireResource(LIGHT_DATA_RESOURCE);
+chunk_shade_standard_material_direct.requireResource(VIEW_RESOURCE);

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_deferred.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The deferred pass's direct shading, `shade_standard_material_direct(material, geometry, coord,
+ * view_depth) -> vec3f`, by how the renderer shades local lights ({@link LOCAL_LIGHT_SHADING}):
+ *
+ * - Clustered: every light of the froxel cluster, each shadow-mapped
+ *   ({@link chunk_shade_standard_material_direct}, the chunk the forward paths link directly);
+ * - ReSTIR: ReSTIR DI's resolved radiance in place of the cluster loop
+ *   ({@link chunk_shade_standard_material_direct_restir}), which reads `tRestirRadiance`.
+ *
+ * Directional lights are shaded alike in both.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_shade_standard_material_direct_deferred: CodeChunkChoice;
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_shade_standard_material_direct_deferred.d.ts.map

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_deferred.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_shade_standard_material_direct_deferred.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct_deferred.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AACH,4DAFU,eAAe,CAE8E;gCAnBvE,uCAAuC"}

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_deferred.js

@@ -0,0 +1,23 @@
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+import { chunk_shade_standard_material_direct } from "./chunk_shade_standard_material_direct.js";
+import { chunk_shade_standard_material_direct_restir } from "./chunk_shade_standard_material_direct_restir.js";
+import { LOCAL_LIGHT_SHADING } from "./LOCAL_LIGHT_SHADING.js";
+import { LocalLightShading } from "./LocalLightShading.js";
+
+/**
+ * The deferred pass's direct shading, `shade_standard_material_direct(material, geometry, coord,
+ * view_depth) -> vec3f`, by how the renderer shades local lights ({@link LOCAL_LIGHT_SHADING}):
+ *
+ * - Clustered: every light of the froxel cluster, each shadow-mapped
+ *   ({@link chunk_shade_standard_material_direct}, the chunk the forward paths link directly);
+ * - ReSTIR: ReSTIR DI's resolved radiance in place of the cluster loop
+ *   ({@link chunk_shade_standard_material_direct_restir}), which reads `tRestirRadiance`.
+ *
+ * Directional lights are shaded alike in both.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_shade_standard_material_direct_deferred = CodeChunkChoice.from(LOCAL_LIGHT_SHADING);
+
+chunk_shade_standard_material_direct_deferred.add(LocalLightShading.Clustered, chunk_shade_standard_material_direct);
+chunk_shade_standard_material_direct_deferred.add(LocalLightShading.ReSTIR, chunk_shade_standard_material_direct_restir);

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_heavy.d.ts

@@ -2,12 +2,13 @@
  * Brute-force deferred direct shading: directional lights (shared CSM helper) plus a per-pixel loop
  * over every point/spot light in the froxel cluster, each shadow-mapped. The ReSTIR DI variant
  * ({@link chunk_shade_standard_material_direct_restir}) replaces the cluster loop with one resampled,
- * ray-traced sample; the two are selected as separate compiled shaders, not via a runtime branch.
+ * ray-traced sample; the deferred pass links one of the two by a shader switch
+ * (`chunk_shade_standard_material_direct_deferred`), not via a runtime branch.
  *
  * This *is* {@link chunk_shade_standard_material_direct}. The two were separate chunks declaring one
  * WGSL function name with byte-identical cluster loops, differing only in whether the directional
  * half called `shade_directional_lights` or re-inlined it. The name is kept because it is public
- * surface and because it reads next to `_restir` at the deferred pass's selection site.
+ * surface.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_heavy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_shade_standard_material_direct_heavy.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct_heavy.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,mEAA+F"}
+{"version":3,"file":"chunk_shade_standard_material_direct_heavy.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_shade_standard_material_direct_heavy.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,mEAA+F"}