@woosh/meep-engine 3.58.0 → 3.59.0

package/src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_mask_weights_by_visibility.js

@@ -2,6 +2,7 @@ import {
     chunk_lpv_get_visibility_mask
 } from "../../../../../global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.js";
 import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+import { chunk_probe_visibility_weight } from "../../probe/chunk_probe_visibility_weight.js";
 import { chunk_lpv_mesh_get_vertices } from "../chunk_lpv_mesh_get_vertices.js";
 import { LPV_PROBES_RESOURCE } from "../../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
@@ -23,70 +24,34 @@ fn lpv_mask_weights_by_visibility(
 
     for (var i = 0u; i < 4u; i++) {
 
-        var weight = 1.0;
-
         let probe_index = vertices[i];
 
         let probe = lpv_probes[probe_index];
-        
-        let probe_position = lpv_probe_get_position(probe_index);
-
-        // Smooth backface test
-        {
-
-            // Computed without the biasing applied to the "dir" variable.
-            // This test can cause reflection-map looking errors in the image
-            // (stuff looks shiny) if the transition is poor.
-            let direction_to_probe = normalize(probe_position - position);
-
-            // The naive soft backface weight would ignore a probe when
-            // it is behind the surface. That's good for walls. But for small details inside of a
-            // room, the normals on the details might rule out all of the probes that have mutual
-            // visibility to the point. So, we instead use a "wrap shading" test below inspired by
-            // NPR work.
-//            let backface_term = max(0.0001, dot(direction_to_probe, normal));
-
-            // The small offset at the end reduces the "going to zero" impact
-            // where this is really close to exactly opposite
-            let backface_term = max(0.0001, (dot(direction_to_probe, normal) + 1.0) * 0.5);
-            weight *= backface_term * backface_term + 0.2;
-
-        }
-
-        // Moment visibility test (depth)
-        {
-            // Bias the position at which visibility is computed; this
-            // avoids performing a shadow test *at* a surface, which is a
-            // dangerous location because that is exactly the line between
-            // shadowed and unshadowed. If the normal bias is too small,
-            // there will be light and dark leaks. If it is too large,
-            // then samples can pass through thin occluders to the other
-            // side (this can only happen if there are MULTIPLE occluders
-            // near each other, a wall surface won't pass through itself.)
-            
-            // see "Scaling Probe-Based Real-Time Dynamic Global Illumunation for Production" by Zander Majercik et al 
-            const TUNABLE_BIAS = 0.05;
-            let bias_scale = max(probe.distance_max * TUNABLE_BIAS, 1e-7);
-            let bias_vector = mix(normal, view_direction, 0.2) * bias_scale;
-                
-            let lookup_position = position + bias_vector;
-            
-            weight *= lpv_get_visibility_mask(lookup_position, probe_index);
-
-        }
-
-        // Avoid zero weight
-        weight = max(1e-6, weight);
 
+        let probe_position = lpv_probe_get_position(probe_index);
 
-        // A tiny bit of light is really visible due to log perception, so
-        // crush tiny weights but keep the curve continuous. This must be done
-        // before the trilinear weights, because those should be preserved.
-        const crushThreshold = 0.2;
-
-        if (weight < crushThreshold) {
-            weight *= weight * weight * (1.0 / (crushThreshold * crushThreshold));
-        }
+        // Bias the position at which visibility is computed; this
+        // avoids performing a shadow test *at* a surface, which is a
+        // dangerous location because that is exactly the line between
+        // shadowed and unshadowed. If the normal bias is too small,
+        // there will be light and dark leaks. If it is too large,
+        // then samples can pass through thin occluders to the other
+        // side (this can only happen if there are MULTIPLE occluders
+        // near each other, a wall surface won't pass through itself.)
+
+        // see "Scaling Probe-Based Real-Time Dynamic Global Illumunation for Production" by Zander Majercik et al
+        const TUNABLE_BIAS = 0.05;
+        let bias_scale = max(probe.distance_max * TUNABLE_BIAS, 1e-7);
+        let bias_vector = mix(normal, view_direction, 0.2) * bias_scale;
+
+        let lookup_position = position + bias_vector;
+
+        // the back-face term from the point itself, without the bias; the trilinear weight after the crush
+        var weight = probe_visibility_weight(
+            normalize(probe_position - position),
+            normal,
+            lpv_get_visibility_mask(lookup_position, probe_index),
+        );
 
         weight *= barycentric[i];
 
@@ -105,7 +70,8 @@ fn lpv_mask_weights_by_visibility(
 }
 `, [
         chunk_lpv_mesh_get_vertices,
-        chunk_lpv_get_visibility_mask
+        chunk_lpv_get_visibility_mask,
+        chunk_probe_visibility_weight,
     ]);
 
 chunk_lpv_mask_weights_by_visibility.requireResource(LPV_PROBES_RESOURCE);

package/src/shade/renderer/shader/chunk/light/probe/chunk_probe_visibility_weight.d.ts

@@ -0,0 +1,23 @@
+/**
+ * How much a probe's light reaches a receiving point, past the trilinear weight: the visibility terms
+ * of DDGI 2021 (Majercik et al., "Scaling Probe-Based Real-Time Dynamic Global Illumination for
+ * Production"), as LPV weighs its probes and the probe clipmap's pick weighs its corners.
+ *
+ * ```wgsl
+ * fn probe_visibility_chebyshev(moments: vec2<f32>, distance: f32) -> f32
+ * fn probe_visibility_weight(direction_to_probe: vec3<f32>, normal: vec3<f32>, visibility: f32) -> f32
+ * ```
+ *
+ * - `probe_visibility_chebyshev`: the chance the point is not occluded from the probe, by Chebyshev's
+ *   inequality over the probe's depth moments (mean, mean of squares) toward it, the distance in the
+ *   moments' own units; 1 nearer than the mean. The variance is held off zero.
+ * - `probe_visibility_weight`: a smooth back-face term, a "wrap shading" ((n·d + 1)/2)² + 0.2 that keeps
+ *   probes behind small details in play, times the visibility; then held off zero, and crushed below
+ *   0.2 along a continuous cubic, since a little light reads as more than it is. The trilinear weight
+ *   is the caller's, after the crush.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_visibility_weight: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_probe_visibility_weight.d.ts.map

package/src/shade/renderer/shader/chunk/light/probe/chunk_probe_visibility_weight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_visibility_weight.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/probe/chunk_probe_visibility_weight.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4CAFU,SAAS,CAiChB;0BArDuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/probe/chunk_probe_visibility_weight.js

@@ -0,0 +1,54 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * How much a probe's light reaches a receiving point, past the trilinear weight: the visibility terms
+ * of DDGI 2021 (Majercik et al., "Scaling Probe-Based Real-Time Dynamic Global Illumination for
+ * Production"), as LPV weighs its probes and the probe clipmap's pick weighs its corners.
+ *
+ * ```wgsl
+ * fn probe_visibility_chebyshev(moments: vec2<f32>, distance: f32) -> f32
+ * fn probe_visibility_weight(direction_to_probe: vec3<f32>, normal: vec3<f32>, visibility: f32) -> f32
+ * ```
+ *
+ * - `probe_visibility_chebyshev`: the chance the point is not occluded from the probe, by Chebyshev's
+ *   inequality over the probe's depth moments (mean, mean of squares) toward it, the distance in the
+ *   moments' own units; 1 nearer than the mean. The variance is held off zero.
+ * - `probe_visibility_weight`: a smooth back-face term, a "wrap shading" ((n·d + 1)/2)² + 0.2 that keeps
+ *   probes behind small details in play, times the visibility; then held off zero, and crushed below
+ *   0.2 along a continuous cubic, since a little light reads as more than it is. The trilinear weight
+ *   is the caller's, after the crush.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_visibility_weight = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_visibility_chebyshev(moments: vec2<f32>, distance: f32) -> f32 {
+    // http://www.punkuser.net/vsm/vsm_paper.pdf, equation 5
+    let variance = max(1e-6, abs(moments.y - moments.x * moments.x));
+    let d = distance - moments.x;
+
+    if (d <= 0.0) {
+        return 1.0;
+    }
+
+    return variance / (variance + d * d);
+}
+
+fn probe_visibility_weight(direction_to_probe: vec3<f32>, normal: vec3<f32>, visibility: f32) -> f32 {
+    // the small offset keeps a probe exactly behind the surface from going to zero
+    let backface = max(0.0001, (dot(direction_to_probe, normal) + 1.0) * 0.5);
+
+    var weight = (backface * backface + 0.2) * visibility;
+
+    weight = max(1e-6, weight);
+
+    const CRUSH = 0.2;
+
+    if (weight < CRUSH) {
+        weight *= weight * weight * (1.0 / (CRUSH * CRUSH));
+    }
+
+    return weight;
+}
+`);

package/src/shade/renderer/shader/chunk/math/chunk_f16_round_stochastic.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Each component onto a value a half float holds exactly: the half above it with the probability of how far
+ * past the half below it the component lies, else the half below. Stochastic rounding.
+ *
+ * ```wgsl
+ * fn f16_round_stochastic(v: vec4<f32>, u: vec4<f32>) -> vec4<f32>
+ * ```
+ *
+ * `u` is uniform noise in [0, 1), a component each. A component a half holds is kept whatever its noise, and
+ * the result is `v` in expectation.
+ *
+ * Stored through halves, a blend `mix(history, x, α)` then moves in expectation however small its step. Rounded,
+ * it stops short of `x` by up to a ULP/α: half of that rounded to nearest, a whole one rounded toward zero, and
+ * one-sided. WGSL leaves rounding an f32 to a half to the implementation. An RTX 4090 and an RDNA2 iGPU were
+ * measured to round toward zero on every path: `pack2x16float`, `textureStore` and a render target's write. The
+ * result here is a half already, which any store keeps exactly. UE 5.4's TSR stores its history through
+ * `QuantizeForFloatRenderTarget` for the same reason.
+ *
+ * Within the half's finite range: past 65504 the half above is not finite.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_f16_round_stochastic: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_f16_round_stochastic.d.ts.map

package/src/shade/renderer/shader/chunk/math/chunk_f16_round_stochastic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_f16_round_stochastic.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/chunk_f16_round_stochastic.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yCAFU,SAAS,CAoBhB;0BA1CuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/math/chunk_f16_round_stochastic.js

@@ -0,0 +1,43 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Each component onto a value a half float holds exactly: the half above it with the probability of how far
+ * past the half below it the component lies, else the half below. Stochastic rounding.
+ *
+ * ```wgsl
+ * fn f16_round_stochastic(v: vec4<f32>, u: vec4<f32>) -> vec4<f32>
+ * ```
+ *
+ * `u` is uniform noise in [0, 1), a component each. A component a half holds is kept whatever its noise, and
+ * the result is `v` in expectation.
+ *
+ * Stored through halves, a blend `mix(history, x, α)` then moves in expectation however small its step. Rounded,
+ * it stops short of `x` by up to a ULP/α: half of that rounded to nearest, a whole one rounded toward zero, and
+ * one-sided. WGSL leaves rounding an f32 to a half to the implementation. An RTX 4090 and an RDNA2 iGPU were
+ * measured to round toward zero on every path: `pack2x16float`, `textureStore` and a render target's write. The
+ * result here is a half already, which any store keeps exactly. UE 5.4's TSR stores its history through
+ * `QuantizeForFloatRenderTarget` for the same reason.
+ *
+ * Within the half's finite range: past 65504 the half above is not finite.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_f16_round_stochastic = CodeChunk.from(
+    //language=WGSL
+    `
+fn f16_round_stochastic(v: vec4<f32>, u: vec4<f32>) -> vec4<f32> {
+    let magnitude = abs(v);
+
+    // a half's ULP at each magnitude and its inverse, powers of two from the exponent's field: 2^(e - 10) in a
+    // normal half's binade, 2^-24 among the subnormals
+    let exponent = max(bitcast<vec4<u32>>(magnitude) >> vec4<u32>(23u), vec4<u32>(113u));
+    let ulp = bitcast<vec4<f32>>((exponent - vec4<u32>(10u)) << vec4<u32>(23u));
+    let per_ulp = bitcast<vec4<f32>>((vec4<u32>(264u) - exponent) << vec4<u32>(23u));
+
+    // exact: scaled by a power of two
+    let steps = magnitude * per_ulp;
+    let below = floor(steps);
+
+    return sign(v) * (below + select(vec4<f32>(0.0), vec4<f32>(1.0), u < steps - below)) * ulp;
+}
+`);

package/src/shade/renderer/shader/chunk/random/chunk_jitter_from_vectors.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Two numbers in [0, 1] from two vectors and the frame: a hash of their bits with the frame index mixed in,
+ * for a pass with no screen texel to take blue noise at, such as a forward fragment or the water. A point
+ * and its normal hash to the same pair within a frame and to another the next. Reads `view`.
+ *
+ * ```wgsl
+ * fn jitter_from_vectors(v0: vec3<f32>, v1: vec3<f32>) -> vec2<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_jitter_from_vectors: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_jitter_from_vectors.d.ts.map

package/src/shade/renderer/shader/chunk/random/chunk_jitter_from_vectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_jitter_from_vectors.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/random/chunk_jitter_from_vectors.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,wCAFU,SAAS,CAqBjB;0BAjCwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/random/chunk_jitter_from_vectors.js

@@ -0,0 +1,37 @@
+import { VIEW_RESOURCE } from "../../../view/VIEW_RESOURCE.js";
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_murmur3_vec3u } from "./murmur/chunk_murmur3_vec3u.js";
+
+/**
+ * Two numbers in [0, 1] from two vectors and the frame: a hash of their bits with the frame index mixed in,
+ * for a pass with no screen texel to take blue noise at, such as a forward fragment or the water. A point
+ * and its normal hash to the same pair within a frame and to another the next. Reads `view`.
+ *
+ * ```wgsl
+ * fn jitter_from_vectors(v0: vec3<f32>, v1: vec3<f32>) -> vec2<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_jitter_from_vectors = CodeChunk.from(
+    //language=WGSL
+    `
+fn jitter_from_vectors(v0:vec3<f32>, v1: vec3<f32>) -> vec2<f32>{
+    let u0 = bitcast<vec3<u32>>(v0);
+    let u1 = bitcast<vec3<u32>>(v1);
+
+    var h0 = u0 ^ u1;
+
+    // add temporal component
+    h0.x ^= view.frame_index;
+
+    let h1 = murmur3_vec3u(h0);
+
+    return unpack2x16unorm(h1);
+}
+    `, [
+        chunk_murmur3_vec3u,
+    ]
+);
+
+chunk_jitter_from_vectors.requireResource(VIEW_RESOURCE);

package/src/shade/renderer/shader/chunk/random/reservoir/chunk_pick2_wrs_mat2x4.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Two of eight, picked.
+ * @type {WebGPUStruct}
+ */
+export const PICK2_STRUCT: WebGPUStruct;
+/**
+ * Two of eight weighted items, picked by weighted reservoir sampling instead of blending all eight
+ * (Brick4's selection, PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.1):
+ *
+ * ```wgsl
+ * fn pick2_wrs_mat2x4(weights: mat2x4<f32>, noise: vec2<f32>) -> Pick2
+ * ```
+ *
+ * One draw of `sample_discrete_wrs_mat2x4` over the weights with `noise.x`; the drawn weight is zeroed
+ * and a second draw made with `noise.y`; the pair blends by the second's share of their weights. A
+ * single weight that is not zero is drawn once, the second draw's weight is zero, and the blend is 0.
+ * Noise is [0, 1).
+ *
+ * The drawn weights are read and cleared through masks rather than by indexing the matrix with a value,
+ * which would put it in local memory: 3% of the probe clipmap's diffuse on the AMD iGPU, measured.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_pick2_wrs_mat2x4: CodeChunk;
+import { WebGPUStruct } from "../../../type/WebGPUStruct.js";
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_pick2_wrs_mat2x4.d.ts.map

package/src/shade/renderer/shader/chunk/random/reservoir/chunk_pick2_wrs_mat2x4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_pick2_wrs_mat2x4.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/random/reservoir/chunk_pick2_wrs_mat2x4.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH,2BAFU,YAAY,CAOV;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,qCAFU,SAAS,CA4BhB;6BA3D0B,+BAA+B;0BADlC,gCAAgC"}

package/src/shade/renderer/shader/chunk/random/reservoir/chunk_pick2_wrs_mat2x4.js

@@ -0,0 +1,61 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { WebGPUStruct } from "../../../type/WebGPUStruct.js";
+import { f32, vec2u } from "../../../type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { chunk_sample_discrete_wrs_mat2x4 } from "./chunk_sample_discrete_wrs_mat2x4.js";
+
+/**
+ * Two of eight, picked.
+ * @type {WebGPUStruct}
+ */
+export const PICK2_STRUCT = WebGPUStruct.from({
+    /** the two picked, 0 to 7, the first drawn first */
+    indices: vec2u,
+    /** the second's share of the pair, w₂ / (w₁ + w₂): 0 where only one weight is not zero */
+    blend: f32,
+}, "Pick2");
+
+/**
+ * Two of eight weighted items, picked by weighted reservoir sampling instead of blending all eight
+ * (Brick4's selection, PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.1):
+ *
+ * ```wgsl
+ * fn pick2_wrs_mat2x4(weights: mat2x4<f32>, noise: vec2<f32>) -> Pick2
+ * ```
+ *
+ * One draw of `sample_discrete_wrs_mat2x4` over the weights with `noise.x`; the drawn weight is zeroed
+ * and a second draw made with `noise.y`; the pair blends by the second's share of their weights. A
+ * single weight that is not zero is drawn once, the second draw's weight is zero, and the blend is 0.
+ * Noise is [0, 1).
+ *
+ * The drawn weights are read and cleared through masks rather than by indexing the matrix with a value,
+ * which would put it in local memory: 3% of the probe clipmap's diffuse on the AMD iGPU, measured.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_pick2_wrs_mat2x4 = CodeChunk.from(
+    //language=WGSL
+    `
+fn pick2_wrs_mat2x4(weights: mat2x4<f32>, noise: vec2<f32>) -> ${PICK2_STRUCT.wgsl_ref} {
+    var u = noise.x;
+
+    let first = u32(sample_discrete_wrs_mat2x4(weights, &u));
+    let first_low = select(vec4<f32>(0.0), vec4<f32>(1.0), vec4<u32>(0u, 1u, 2u, 3u) == vec4<u32>(first));
+    let first_high = select(vec4<f32>(0.0), vec4<f32>(1.0), vec4<u32>(4u, 5u, 6u, 7u) == vec4<u32>(first));
+    let weight0 = dot(weights[0], first_low) + dot(weights[1], first_high);
+
+    // the first cleared out, and a second draw with fresh entropy
+    let remaining = mat2x4<f32>(weights[0] * (1.0 - first_low), weights[1] * (1.0 - first_high));
+
+    u = noise.y;
+
+    let second = u32(sample_discrete_wrs_mat2x4(remaining, &u));
+    let second_low = select(vec4<f32>(0.0), vec4<f32>(1.0), vec4<u32>(0u, 1u, 2u, 3u) == vec4<u32>(second));
+    let second_high = select(vec4<f32>(0.0), vec4<f32>(1.0), vec4<u32>(4u, 5u, 6u, 7u) == vec4<u32>(second));
+    let weight1 = dot(remaining[0], second_low) + dot(remaining[1], second_high);
+
+    return ${PICK2_STRUCT.wgsl_ref}(vec2<u32>(first, second), weight1 / max(1e-6, weight0 + weight1));
+}
+`, [
+    PICK2_STRUCT.declaration_chunk,
+    chunk_sample_discrete_wrs_mat2x4,
+]);

package/src/shade/renderer/shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_specular.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The radiance an L1 YCoCg SH holds toward `direction`, convolved with a GGX lobe of `alpha` (roughness²): the
+ * diffuse resolve ({@link chunk_resolve_irradiance_sh_to_diffuse}) with GGX's band-1 zonal factor
+ * (`sh2_approximate_GGX_zh`, MJP's fit) in place of the clamped cosine's 2/3. The SH is in the scale under which
+ * the diffuse resolve gives E/π, so this gives radiance.
+ *
+ * The chroma is the constant band's alone, rescaled by the ratio of the luma toward `direction` to the mean, as
+ * the diffuse resolve rescales it.
+ *
+ * - Where the zonal factor is 2/3 (alpha ≈ 0.8435) it is the diffuse resolve.
+ * - A field of constant radiance L gives L at every alpha.
+ *
+ * ```wgsl
+ * fn resolve_irradiance_sh_to_specular(shY: vec4<f32>, CoCg: vec2<f32>, direction: vec3<f32>, alpha: f32) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_resolve_irradiance_sh_to_specular: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_resolve_irradiance_sh_to_specular.d.ts.map

package/src/shade/renderer/shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_specular.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_resolve_irradiance_sh_to_specular.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_specular.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,sDAFU,SAAS,CAoBjB;0BAxCwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_specular.js

@@ -0,0 +1,41 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_YCoCg_to_rgb } from "../../color/YCoCg/chunk_YCoCg_to_rgb.js";
+import { chunk_sh2_approximate_GGX_zh } from "../chunk_sh2_approximate_GGX_zh.js";
+
+/**
+ * The radiance an L1 YCoCg SH holds toward `direction`, convolved with a GGX lobe of `alpha` (roughness²): the
+ * diffuse resolve ({@link chunk_resolve_irradiance_sh_to_diffuse}) with GGX's band-1 zonal factor
+ * (`sh2_approximate_GGX_zh`, MJP's fit) in place of the clamped cosine's 2/3. The SH is in the scale under which
+ * the diffuse resolve gives E/π, so this gives radiance.
+ *
+ * The chroma is the constant band's alone, rescaled by the ratio of the luma toward `direction` to the mean, as
+ * the diffuse resolve rescales it.
+ *
+ * - Where the zonal factor is 2/3 (alpha ≈ 0.8435) it is the diffuse resolve.
+ * - A field of constant radiance L gives L at every alpha.
+ *
+ * ```wgsl
+ * fn resolve_irradiance_sh_to_specular(shY: vec4<f32>, CoCg: vec2<f32>, direction: vec3<f32>, alpha: f32) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_resolve_irradiance_sh_to_specular = CodeChunk.from(
+    //language=WGSL
+    `
+fn resolve_irradiance_sh_to_specular(shY: vec4<f32>, CoCg: vec2<f32>, direction: vec3<f32>, alpha: f32) -> vec3<f32> {
+    let g1 = sh2_approximate_GGX_zh(alpha).y;
+
+    // 2 pi times the radiance SH2 the store holds: band 0's basis constant, and band 1's under the lobe's factor
+    let Y = max(0.0, 6.283185307179586 * (0.28209479177387814 * shY.w + g1 * 0.4886025119029199 * dot(shY.xyz, direction)));
+
+    // correct color-reproduction, as the diffuse resolve does
+    let _CoCg = CoCg * 0.28209479177387814 * Y / (shY.w + 1e-6);
+
+    return max(YCoCg_to_rgb(vec3(Y, _CoCg)), vec3<f32>(0.0));
+}
+    `, [
+        chunk_sh2_approximate_GGX_zh,
+        chunk_YCoCg_to_rgb,
+    ]
+);

package/src/shade/renderer/texture/util/texture_fill_rectangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture_fill_rectangle.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/util/texture_fill_rectangle.js"],"names":[],"mappings":"AAyMA;;;;;;;GAOG;AACH,8GAHW,MAAM,EAAE,cACR,MAAM,EAAE,QA2DlB"}
+{"version":3,"file":"texture_fill_rectangle.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/util/texture_fill_rectangle.js"],"names":[],"mappings":"AA6MA;;;;;;;GAOG;AACH,8GAHW,MAAM,EAAE,cACR,MAAM,EAAE,QAsElB"}