@woosh/meep-engine 3.8.0 → 3.10.0

package/src/shade/renderer/shader/chunk/color/xyz/chunk_rgb_to_xyz.js

@@ -1,21 +1,23 @@
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-
-/**
- * Transforms an RGB color in Rec.709 to CIE XYZ.
- * @type {CodeChunk}
- */
-export const chunk_rgb_to_xyz = CodeChunk.from(
-    //language=WGSL
-    `
-fn rgb_to_xyz(c: vec3<f32>) -> vec3<f32>{
-     const M = mat3x3(
-        0.4123907992659595, 0.3575843393838780, 0.1804807884018343,
-        0.2126390058715104, 0.7151686787677559, 0.0721923153607337,
-        0.0193308187155918, 0.1191947797946259, 0.9505321522496608
-    );
-    
-    return c * M;
-}
-    `
-);
-
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Transforms an RGB color in Rec.709 to CIE XYZ.
+ * @type {CodeChunk}
+ */
+export const chunk_rgb_to_xyz = CodeChunk.from(
+    //language=WGSL
+    `
+fn rgb_to_xyz(c: vec3<f32>) -> vec3<f32>{
+    // the same matrix as core/color/xyz/rgb_to_xyz.js, digit for digit; the middle row is
+    // REC709_LUMINANCE_R/G/B from core/color/REC709_PRIMARIES.js
+     const M = mat3x3(
+        0.41239079926595948129, 0.35758433938387796373, 0.18048078840183428751,
+        0.21263900587151035754, 0.71516867876775592746, 0.07219231536073371500,
+        0.01933081871559185069, 0.11919477979462598791, 0.95053215224966058086
+    );
+    
+    return c * M;
+}
+    `
+);
+

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

@@ -0,0 +1,9 @@
+/**
+ * Sign-preserving lower bound on magnitude: |result| >= eps, sign kept (zero counts as
+ * positive). For divisors that legitimately pass through zero — the quotient stays finite
+ * and keeps its direction as the divisor shrinks.
+ * @type {CodeChunk}
+ */
+export const chunk_magnitude_floor: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_magnitude_floor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_magnitude_floor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/chunk_magnitude_floor.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oCAFU,SAAS,CASjB;0BAfwB,6BAA6B"}

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

@@ -0,0 +1,16 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Sign-preserving lower bound on magnitude: |result| >= eps, sign kept (zero counts as
+ * positive). For divisors that legitimately pass through zero — the quotient stays finite
+ * and keeps its direction as the divisor shrinks.
+ * @type {CodeChunk}
+ */
+export const chunk_magnitude_floor = CodeChunk.from(
+    //language=WGSL
+    `
+fn magnitude_floor(x: f32, eps: f32) -> f32 {
+    return select(min(x, -eps), max(x, eps), x >= 0.0);
+}
+    `
+);

package/src/shade/renderer/shader/chunk/math/complex/chunk_complex_magnitude_floor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Lower bound on the magnitude of a complex number: a value with |z| < eps is snapped to
+ * the real value (eps, 0). The direction of a vanishing complex number is numerical noise,
+ * so only the magnitude needs preserving. For divisors and normalizers that legitimately
+ * pass through zero.
+ * @type {CodeChunk}
+ */
+export const chunk_complex_magnitude_floor: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_complex_magnitude_floor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_complex_magnitude_floor.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/complex/chunk_complex_magnitude_floor.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4CAFU,SAAS,CASjB;0BAhBwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/complex/chunk_complex_magnitude_floor.js

@@ -0,0 +1,17 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Lower bound on the magnitude of a complex number: a value with |z| < eps is snapped to
+ * the real value (eps, 0). The direction of a vanishing complex number is numerical noise,
+ * so only the magnitude needs preserving. For divisors and normalizers that legitimately
+ * pass through zero.
+ * @type {CodeChunk}
+ */
+export const chunk_complex_magnitude_floor = CodeChunk.from(
+    //language=WGSL
+    `
+fn complex_magnitude_floor(z: vec2<f32>, eps: f32) -> vec2<f32> {
+    return select(z, vec2<f32>(eps, 0.0), dot(z, z) < eps * eps);
+}
+    `
+);

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_complex_solve_cubic_blinn.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/complex/chunk_complex_solve_cubic_blinn.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,8CAFU,SAAS,CAoEjB;0BA/EwB,gCAAgC"}
+{"version":3,"file":"chunk_complex_solve_cubic_blinn.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/complex/chunk_complex_solve_cubic_blinn.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,8CAFU,SAAS,CAyEjB;0BArFwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/complex/chunk_complex_solve_cubic_blinn.js

@@ -1,5 +1,6 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 import { chunk_complex_cubic_root } from "./chunk_complex_cubic_root.js";
+import { chunk_complex_magnitude_floor } from "./chunk_complex_magnitude_floor.js";
 import { chunk_complex_multiply } from "./chunk_complex_multiply.js";
 import { chunk_complex_reciprocal } from "./chunk_complex_reciprocal.js";
 import { chunk_complex_square } from "./chunk_complex_square.js";
@@ -45,7 +46,11 @@ fn complex_solve_cubic_blinn(
     // faceforward: force discriminant_root OPPOSITE to depressed_d so the subtraction below adds
     // magnitudes (avoids catastrophic cancellation). The sign was inverted vs the HLSL reference.
     let discriminant_root_adj = select(discriminant_root, -discriminant_root, dot(discriminant_root, depressed_d) >= 0.0);
-    let cubed_root = discriminant_root_adj - depressed_d;
+    // cubed_root vanishes at a triple root, its cubic root with it, and the reciprocal
+    // below would then be inf/NaN. The snap keeps the reciprocal finite while
+    // depressed_c also vanishes there, so the roots still collapse to the correct
+    // limit -b_third.
+    let cubed_root = complex_magnitude_floor(discriminant_root_adj - depressed_d, 1e-20);
     let first_root = complex_cubic_root(0.5 * cubed_root);
     
     let cubic_roots = array<vec2<f32>, 3>(
@@ -76,5 +81,6 @@ fn complex_solve_cubic_blinn(
         chunk_complex_cubic_root,
         chunk_complex_multiply,
         chunk_complex_reciprocal,
+        chunk_complex_magnitude_floor,
     ]
 );

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_complex_square_root.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/complex/chunk_complex_square_root.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,wCAFU,SAAS,CAajB;0BArBwB,gCAAgC"}
+{"version":3,"file":"chunk_complex_square_root.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/complex/chunk_complex_square_root.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,wCAFU,SAAS,CAkBjB;0BA3BwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/complex/chunk_complex_square_root.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_complex_magnitude_floor } from "./chunk_complex_magnitude_floor.js";
 import { chunk_complex_square_root_unsafe } from "./chunk_complex_square_root_unsafe.js";
 
 /**
@@ -12,11 +13,16 @@ export const chunk_complex_square_root = CodeChunk.from(
     //language=WGSL
     `
 fn complex_square_root(z: vec2<f32>) -> vec2<f32>{
-    let z_positive_real_part = vec2<f32>(abs(z.x), z.y);
+    // The unsafe kernel evaluates 0 * inverseSqrt(0) = NaN at z = 0 — and a vanishing
+    // discriminant (a double root) lands exactly there. The snap degrades a double root
+    // into a pair 1e-10 apart instead of poisoning both.
+    let z_safe = complex_magnitude_floor(z, 1e-20);
+    let z_positive_real_part = vec2<f32>(abs(z_safe.x), z_safe.y);
     let computed_root = complex_square_root_unsafe(z_positive_real_part);
-    return select(computed_root.yx, computed_root, z.x >= 0.0);
+    return select(computed_root.yx, computed_root, z_safe.x >= 0.0);
 }
     `, [
-        chunk_complex_square_root_unsafe
+        chunk_complex_square_root_unsafe,
+        chunk_complex_magnitude_floor
     ]
 );

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_solve_cubic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_cubic.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,gCAFU,SAAS,CA2CjB;0BAnDwB,gCAAgC"}
+{"version":3,"file":"chunk_solve_cubic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_cubic.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,gCAFU,SAAS,CAgDjB;0BAzDwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_cubic.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_safe_sqrt } from "../chunk_safe_sqrt.js";
 
 /**
  * Code taken from the blog "Moments in Graphics" by Christoph Peters.
@@ -34,19 +35,24 @@ fn solve_cubic(coefficient: vec4<f32>) -> vec3<f32> {
         delta.x
     );
     
-    // Take the cubic root of a normalized complex number
-    let theta = atan2(sqrt(discriminant), -depressed.x) / 3.0;
+    // Take the cubic root of a normalized complex number.
+    // Both radicands are >= 0 whenever the promised three real roots exist; rounding can
+    // push either across zero near a repeated root, and sqrt would then poison every root
+    // with NaN.
+    let theta = atan2(safe_sqrt(discriminant), -depressed.x) / 3.0;
     let cubic_root = vec2<f32>(cos(theta), sin(theta));
-    
-    // Compute the three roots, scale appropriately and 
+
+    // Compute the three roots, scale appropriately and
     // revert the depression transform
     let root = vec3<f32>(
         cubic_root.x,
         dot(vec2<f32>(-0.5, -0.5 * sqrt(3.0)), cubic_root),
         dot(vec2<f32>(-0.5, 0.5 * sqrt(3.0)), cubic_root)
     );
-    
-    return 2.0 * sqrt(-depressed.y) * root + vec3<f32>(-coeff.z);
+
+    return 2.0 * safe_sqrt(-depressed.y) * root + vec3<f32>(-coeff.z);
 }
-    `
+    `, [
+        chunk_safe_sqrt
+    ]
 );

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_solve_cubic_blinn_smallest.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_cubic_blinn_smallest.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,+CAFU,SAAS,CAqCjB;0BA5CwB,gCAAgC"}
+{"version":3,"file":"chunk_solve_cubic_blinn_smallest.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_cubic_blinn_smallest.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,+CAFU,SAAS,CA4CjB;0BArDwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_cubic_blinn_smallest.js

@@ -1,4 +1,6 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_magnitude_floor } from "../chunk_magnitude_floor.js";
+import { chunk_safe_sqrt } from "../chunk_safe_sqrt.js";
 
 /**
  * Given coefficients of a cubic polynomial
@@ -26,9 +28,11 @@ fn solve_cubic_blinn_smallest(coeffs: vec4<f32>) -> f32 {
         delta.z,
         -coeff.x * delta.y + 2.0 * coeff.y * delta.z
     );
-    let theta = abs(atan2(coeff.x * sqrt(discriminant), -depressed.y)) / 3.0;
+    // Both radicands are >= 0 whenever the promised three real roots exist; rounding can
+    // push either across zero near a repeated root, and sqrt would then return NaN.
+    let theta = abs(atan2(coeff.x * safe_sqrt(discriminant), -depressed.y)) / 3.0;
     let sin_cos = vec2<f32>(sin(theta), cos(theta));
-    let tmp = 2.0 * sqrt(-depressed.x);
+    let tmp = 2.0 * safe_sqrt(-depressed.x);
     let x = vec2<f32>(
         tmp * sin_cos.y,
         tmp * (-0.5 * sin_cos.y - 0.5 * sqrt(3.0) * sin_cos.x)
@@ -39,7 +43,12 @@ fn solve_cubic_blinn_smallest(coeffs: vec4<f32>) -> f32 {
         x.x + x.y < 2.0 * coeff.y
     );
 
-    return s.x / s.y;
+    // s.y reaches 0 only when the smallest root escapes to infinity; keep it
+    // huge-but-finite rather than inf/NaN.
+    return s.x / magnitude_floor(s.y, 1e-10);
 }
-    `
+    `, [
+        chunk_safe_sqrt,
+        chunk_magnitude_floor
+    ]
 );

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_solve_quadratic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_quadratic.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oCAFU,SAAS,CA+BjB;0BArCwB,gCAAgC"}
+{"version":3,"file":"chunk_solve_quadratic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_quadratic.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,oCAFU,SAAS,CAqCjB;0BA5CwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_quadratic.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_safe_sqrt } from "../chunk_safe_sqrt.js";
 
 /**
  * Given coefficients of a quadratic polynomial A*x^2+B*x+C, this function
@@ -13,27 +14,33 @@ fn solve_quadratic(coeffs: vec3<f32>) -> vec2<f32>{
     let a = coeffs[0];
     let b = coeffs[1] * 0.5;
     let c = coeffs[2];
-    
+
     var x1: f32;
     var x2: f32;
-    
-    let tmp_discriminant = b * b - a * c;
-    let tmp = sqrt(tmp_discriminant);
-    
+
+    // >= 0 whenever the promised two real roots exist; rounding can cross zero at a
+    // double root.
+    let tmp = safe_sqrt(b * b - a * c);
+
+    // The citardauq denominators are >= 0 in their branches, and reach 0 only for a
+    // double root at x = 0 (b = tmp = 0 forces c = 0), where the division becomes
+    // 0/0 = NaN. The floor turns that root into an exact 0.
     if (b >= 0.0) {
-    
-        x1 = (-c) / (b + tmp);
+
+        x1 = (-c) / max(b + tmp, 1e-20);
         x2 = (-b - tmp) / a;
-    
+
     } else {
-    
+
         x1 = (-b + tmp) / a;
-        x2 = c / (-b + tmp);
-    
+        x2 = c / max(-b + tmp, 1e-20);
+
     }
-    
+
     return vec2<f32>(x1, x2);
 }
-    `
+    `, [
+        chunk_safe_sqrt
+    ]
 );
 

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_solve_quartic_neumark.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_quartic_neumark.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,0CAFU,SAAS,CAiEjB;0BA1EwB,gCAAgC"}
+{"version":3,"file":"chunk_solve_quartic_neumark.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_quartic_neumark.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,0CAFU,SAAS,CAqEjB;0BA9EwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/polynomial/chunk_solve_quartic_neumark.js

@@ -41,11 +41,15 @@ fn solve_quartic_neumark(coeffs: array<f32, 5>) -> vec4<f32> {
     var h: f32;
     var h_small: f32;
     
-    // Compute the coefficients of the quadratics adaptively using the two 
-    // proposed factorizations by Neumark. Choose the appropriate 
+    // Compute the coefficients of the quadratics adaptively using the two
+    // proposed factorizations by Neumark. Choose the appropriate
     // factorizations using the heuristic proposed by Herbison-Evans.
+    // Either radicand is >= 0 whenever the promised four real roots exist, and rounding
+    // can push it across zero near a repeated root; tmp also divides the linear terms, so
+    // it is floored to stay real AND nonzero — a paired root degrades into two roots a
+    // hair apart instead of an inf/NaN cascade.
     if (y < 0.0 || (zz + f_e) * bb_fy > zz_f_e * (bb + fy)) {
-        let tmp = sqrt(bb_fy);
+        let tmp = sqrt(max(bb_fy, 1e-20));
         g = (b + tmp) * 0.5;
         g_small = (b - tmp) * 0.5;
 
@@ -53,7 +57,7 @@ fn solve_quartic_neumark(coeffs: array<f32, 5>) -> vec4<f32> {
         h = z * 0.5 + tmp2;
         h_small = z * 0.5 - tmp2;
     } else {
-        let tmp = sqrt(zz_f_e);
+        let tmp = sqrt(max(zz_f_e, 1e-20));
         h = (z + tmp) * 0.5;
         h_small = (z - tmp) * 0.5;
 

package/src/shade/renderer/shader/chunk/mboit/NOTES.md

@@ -1,4 +1,38 @@
 Alan Wake 2 talk references moment-based OIT, they used it due to simplicity of implementation and integration.
 
 * https://github.com/fedoriusv/V3DGameEngine/blob/1f3ef7ad93ee023dfb8f00518f40e55a46b68fe4/Engine/Data/Shaders/transparency_mboit.hlsl#L244
-* https://github.com/AlicesoftHumika/UnityOIT/blob/612c3c04263acb22980f33fa3cb2d3653ed389ff/Assets/Shader/MBOIT/MomentOIT.hlsli#L123
+* https://github.com/AlicesoftHumika/UnityOIT/blob/612c3c04263acb22980f33fa3cb2d3653ed389ff/Assets/Shader/MBOIT/MomentOIT.hlsli#L123
+
+## Numerical guards
+
+The reference HLSL divides by quantities that legitimately reach zero; the live
+4-power-moment chunk guards its inline quadratic (magnitude clamp on `c[2]`, discriminant
+floor, citardauq root recovery), and the unused 6/8-power and trigonometric variants carry
+the same treatment so they are safe to wire up later:
+
+* Deflated-polynomial leading coefficients are clamped through `magnitude_floor` /
+  `complex_magnitude_floor` at 1e-4 **of the largest lower coefficient** before entering a
+  root solver. The ratio is a range budget, not a precision limit: the solvers normalize
+  by the leading coefficient, and normalized coefficients <= ~1e4 keep every solver
+  intermediate inside f32 range even when the pivot scaling has amplified the whole
+  vector, while the escaped support point out at ~1e4 carries negligible weight in the
+  reconstruction.
+* Divided-difference denominators (support-point separations) are floored at the same
+  1e-4 — coincident support points otherwise produce 0/0 = NaN.
+* Solver-internal radicands that are non-negative under the "all real roots" contract are
+  floored (`safe_sqrt`, or `max(x, 1e-20)` where the root also divides, as in Neumark's
+  `tmp`) — rounding pushes them across zero near repeated roots.
+* `complex_square_root` snaps `|z| < 1e-20` to `(1e-20, 0)`: the unsafe kernel evaluates
+  `0 * inverseSqrt(0) = NaN` at zero, exactly where a double root lands.
+  `complex_solve_cubic_blinn` snaps its `cubed_root` the same way (triple root).
+
+The generate chunks (power and trigonometric) return the fragment's raw contribution as a
+struct; summing belongs to additive blending. The reference's quantized-storage variant
+(quantize + normalize + offset against the already-accumulated moments, an ROV) is
+deliberately not ported — it cannot be expressed through additive blending.
+
+Specs sit next to the chunks. The division singularities are pinned with exactly-singular
+dyadic moment vectors, because the WGSL emulator computes in f64 — inputs must collapse
+the leading coefficient to exactly 0.0, not merely near it. The emulator also does not
+propagate writes through pointer-to-scalar parameters, which is why the generate chunks
+return structs instead of filling scalar out-parameters.

package/src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_2_trigonometric_moments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_compute_transmittance_from_2_trigonometric_moments.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_2_trigonometric_moments.js"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,uEAFU,SAAS,CAiGjB;0BA9GwB,mCAAmC"}
+{"version":3,"file":"chunk_compute_transmittance_from_2_trigonometric_moments.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_2_trigonometric_moments.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,uEAFU,SAAS,CA6GjB;0BA3HwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_2_trigonometric_moments.js

@@ -1,6 +1,7 @@
 import { CodeChunk } from "../../../../compiler/CodeChunk.js";
 import { chunk_complex_conjugate } from "../../../math/complex/chunk_complex_conjugate.js";
 import { chunk_complex_divide } from "../../../math/complex/chunk_complex_divide.js";
+import { chunk_complex_magnitude_floor } from "../../../math/complex/chunk_complex_magnitude_floor.js";
 import { chunk_complex_divide_real } from "../../../math/complex/chunk_complex_divide_real.js";
 import { chunk_complex_multiply } from "../../../math/complex/chunk_complex_multiply.js";
 import { chunk_complex_real_part } from "../../../math/complex/chunk_complex_real_part.js";
@@ -60,8 +61,17 @@ fn compute_transmittance_from_2_trigonometric_moments(
     c[1] -= complex_multiply(complex_conjugate(l21), c[2]);
     c[0] -= complex_multiply(complex_conjugate(l10), c[1]) + complex_multiply(complex_conjugate(l20), c[2]);
     
-    // Compute roots of the polynomial
-    let roots = complex_solve_quadratic(complex_conjugate(c[2]), complex_conjugate(c[1]), complex_conjugate(c[0]));
+    // Compute roots of the polynomial.
+    // c[2] -> 0 when the canonical distribution needs fewer support points than the
+    // solver assumes (e.g. the query sitting on a support point of a sparse pixel); the
+    // solver normalizes by it, which unguarded throws the spurious roots to inf/NaN and
+    // poisons the weights below. Floored, they land huge-but-finite off the circle where
+    // their contribution stays negligible. The floor is relative to the largest lower
+    // coefficient — the Toeplitz pivot scaling can amplify the whole vector — so the
+    // solver-normalized coefficients stay <= ~1e4 and every solver intermediate fits f32.
+    let c_scale = max(1.0, sqrt(max(dot(c[0], c[0]), dot(c[1], c[1]))));
+    let c_2 = complex_magnitude_floor(c[2], 1e-4 * c_scale);
+    let roots = complex_solve_quadratic(complex_conjugate(c_2), complex_conjugate(c[1]), complex_conjugate(c[0]));
     
     // Figure out how to weight the weights
     let depth_parameter = circle_to_parameter(circle_point);
@@ -77,9 +87,11 @@ fn compute_transmittance_from_2_trigonometric_moments(
     let f0 = weight_factor[0];
     let f1 = weight_factor[1];
     let f2 = weight_factor[2];
-    let f01 = complex_divide_real(f1 - f0, z[1] - z[0]);
-    let f12 = complex_divide_real(f2 - f1, z[2] - z[1]);
-    let f012 = complex_divide(f12 - f01, z[2] - z[0]);
+    // Coincident support points zero these separations, and complex division by (0, 0)
+    // is NaN. Floored, a merged pair contributes one bounded term instead.
+    let f01 = complex_divide_real(f1 - f0, complex_magnitude_floor(z[1] - z[0], 1e-4));
+    let f12 = complex_divide_real(f2 - f1, complex_magnitude_floor(z[2] - z[1], 1e-4));
+    let f012 = complex_divide(f12 - f01, complex_magnitude_floor(z[2] - z[0], 1e-4));
     
     var polynomial = array<vec2<f32>, 3>();
     polynomial[0] = f012;
@@ -104,6 +116,7 @@ fn compute_transmittance_from_2_trigonometric_moments(
         chunk_complex_divide,
         chunk_complex_solve_quadratic,
         chunk_complex_conjugate,
+        chunk_complex_magnitude_floor,
         //
         chunk_circle_to_parameter,
         chunk_get_root_weight_factor,

package/src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_3_trigonometric_moments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_compute_transmittance_from_3_trigonometric_moments.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_3_trigonometric_moments.js"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,uEAFU,SAAS,CAsHjB;0BAnIwB,mCAAmC"}
+{"version":3,"file":"chunk_compute_transmittance_from_3_trigonometric_moments.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_3_trigonometric_moments.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,uEAFU,SAAS,CAkIjB;0BAhJwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_3_trigonometric_moments.js

@@ -1,6 +1,7 @@
 import { CodeChunk } from "../../../../compiler/CodeChunk.js";
 import { chunk_complex_conjugate } from "../../../math/complex/chunk_complex_conjugate.js";
 import { chunk_complex_divide } from "../../../math/complex/chunk_complex_divide.js";
+import { chunk_complex_magnitude_floor } from "../../../math/complex/chunk_complex_magnitude_floor.js";
 import { chunk_complex_divide_real } from "../../../math/complex/chunk_complex_divide_real.js";
 import { chunk_complex_multiply } from "../../../math/complex/chunk_complex_multiply.js";
 import { chunk_complex_real_part } from "../../../math/complex/chunk_complex_real_part.js";
@@ -71,8 +72,17 @@ fn compute_transmittance_from_3_trigonometric_moments(
     c[1] -= complex_multiply(complex_conjugate(l21), c[2]) + complex_multiply(complex_conjugate(l31), c[3]);
     c[0] -= complex_multiply(complex_conjugate(l10), c[1]) + complex_multiply(complex_conjugate(l20), c[2]) + complex_multiply(complex_conjugate(l30), c[3]);
     
-    // Compute roots of the polynomial
-    let roots = complex_solve_cubic_blinn(complex_conjugate(c[3]), complex_conjugate(c[2]), complex_conjugate(c[1]), complex_conjugate(c[0]));
+    // Compute roots of the polynomial.
+    // c[3] -> 0 when the canonical distribution needs fewer support points than the
+    // solver assumes (e.g. the query sitting on a support point of a sparse pixel); the
+    // solver normalizes by it, which unguarded throws the spurious roots to inf/NaN and
+    // poisons the weights below. Floored, they land huge-but-finite off the circle where
+    // their contribution stays negligible. The floor is relative to the largest lower
+    // coefficient — the Toeplitz pivot scaling can amplify the whole vector — so the
+    // solver-normalized coefficients stay <= ~1e4 and every solver intermediate fits f32.
+    let c_scale = max(1.0, sqrt(max(dot(c[0], c[0]), max(dot(c[1], c[1]), dot(c[2], c[2])))));
+    let c_3 = complex_magnitude_floor(c[3], 1e-4 * c_scale);
+    let roots = complex_solve_cubic_blinn(complex_conjugate(c_3), complex_conjugate(c[2]), complex_conjugate(c[1]), complex_conjugate(c[0]));
     
     // Figure out how to weight the weights
     let depth_parameter = circle_to_parameter(circle_point);
@@ -89,12 +99,14 @@ fn compute_transmittance_from_3_trigonometric_moments(
     let f1 = weight_factor[1];
     let f2 = weight_factor[2];
     let f3 = weight_factor[3];
-    let f01 = complex_divide_real(f1 - f0, z[1] - z[0]);
-    let f12 = complex_divide_real(f2 - f1, z[2] - z[1]);
-    let f23 = complex_divide_real(f3 - f2, z[3] - z[2]);
-    let f012 = complex_divide(f12 - f01, z[2] - z[0]);
-    let f123 = complex_divide(f23 - f12, z[3] - z[1]);
-    let f0123 = complex_divide(f123 - f012, z[3] - z[0]);
+    // Coincident support points zero these separations, and complex division by (0, 0)
+    // is NaN. Floored, a merged pair contributes one bounded term instead.
+    let f01 = complex_divide_real(f1 - f0, complex_magnitude_floor(z[1] - z[0], 1e-4));
+    let f12 = complex_divide_real(f2 - f1, complex_magnitude_floor(z[2] - z[1], 1e-4));
+    let f23 = complex_divide_real(f3 - f2, complex_magnitude_floor(z[3] - z[2], 1e-4));
+    let f012 = complex_divide(f12 - f01, complex_magnitude_floor(z[2] - z[0], 1e-4));
+    let f123 = complex_divide(f23 - f12, complex_magnitude_floor(z[3] - z[1], 1e-4));
+    let f0123 = complex_divide(f123 - f012, complex_magnitude_floor(z[3] - z[0], 1e-4));
     
     var polynomial = array<vec2<f32>, 4>();
     polynomial[0] = f0123;
@@ -124,6 +136,7 @@ fn compute_transmittance_from_3_trigonometric_moments(
         chunk_complex_divide_real,
         chunk_complex_conjugate,
         chunk_complex_solve_cubic_blinn,
+        chunk_complex_magnitude_floor,
 
         //
         chunk_circle_to_parameter,

package/src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_4_trigonometric_moments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_compute_transmittance_from_4_trigonometric_moments.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_4_trigonometric_moments.js"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,uEAFU,SAAS,CA2IjB;0BAxJwB,mCAAmC"}
+{"version":3,"file":"chunk_compute_transmittance_from_4_trigonometric_moments.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_4_trigonometric_moments.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,uEAFU,SAAS,CAuJjB;0BArKwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_compute_transmittance_from_4_trigonometric_moments.js

@@ -1,6 +1,7 @@
 import { CodeChunk } from "../../../../compiler/CodeChunk.js";
 import { chunk_complex_conjugate } from "../../../math/complex/chunk_complex_conjugate.js";
 import { chunk_complex_divide } from "../../../math/complex/chunk_complex_divide.js";
+import { chunk_complex_magnitude_floor } from "../../../math/complex/chunk_complex_magnitude_floor.js";
 import { chunk_complex_divide_real } from "../../../math/complex/chunk_complex_divide_real.js";
 import { chunk_complex_multiply } from "../../../math/complex/chunk_complex_multiply.js";
 import { chunk_complex_real_part } from "../../../math/complex/chunk_complex_real_part.js";
@@ -82,8 +83,17 @@ fn compute_transmittance_from_4_trigonometric_moments(
     c[1] -= complex_multiply(complex_conjugate(l21), c[2]) + complex_multiply(complex_conjugate(l31), c[3]) + complex_multiply(complex_conjugate(l41), c[4]);
     c[0] -= complex_multiply(complex_conjugate(l10), c[1]) + complex_multiply(complex_conjugate(l20), c[2]) + complex_multiply(complex_conjugate(l30), c[3]) + complex_multiply(complex_conjugate(l40), c[4]);
     
-    // Compute roots of the polynomial
-    let roots = complex_solve_quartic_neumark(complex_conjugate(c[4]), complex_conjugate(c[3]), complex_conjugate(c[2]), complex_conjugate(c[1]), complex_conjugate(c[0]));
+    // Compute roots of the polynomial.
+    // c[4] -> 0 when the canonical distribution needs fewer support points than the
+    // solver assumes (e.g. the query sitting on a support point of a sparse pixel); the
+    // solver normalizes by it, which unguarded throws the spurious roots to inf/NaN and
+    // poisons the weights below. Floored, they land huge-but-finite off the circle where
+    // their contribution stays negligible. The floor is relative to the largest lower
+    // coefficient — the Toeplitz pivot scaling can amplify the whole vector — so the
+    // solver-normalized coefficients stay <= ~1e4 and every solver intermediate fits f32.
+    let c_scale = max(1.0, sqrt(max(max(dot(c[0], c[0]), dot(c[1], c[1])), max(dot(c[2], c[2]), dot(c[3], c[3])))));
+    let c_4 = complex_magnitude_floor(c[4], 1e-4 * c_scale);
+    let roots = complex_solve_quartic_neumark(complex_conjugate(c_4), complex_conjugate(c[3]), complex_conjugate(c[2]), complex_conjugate(c[1]), complex_conjugate(c[0]));
     
     // Figure out how to weight the weights
     let depth_parameter = circle_to_parameter(circle_point);
@@ -101,16 +111,18 @@ fn compute_transmittance_from_4_trigonometric_moments(
     let f2 = weight_factor[2];
     let f3 = weight_factor[3];
     let f4 = weight_factor[4];
-    let f01 = complex_divide_real(f1 - f0, z[1] - z[0]);
-    let f12 = complex_divide_real(f2 - f1, z[2] - z[1]);
-    let f23 = complex_divide_real(f3 - f2, z[3] - z[2]);
-    let f34 = complex_divide_real(f4 - f3, z[4] - z[3]);
-    let f012 = complex_divide(f12 - f01, z[2] - z[0]);
-    let f123 = complex_divide(f23 - f12, z[3] - z[1]);
-    let f234 = complex_divide(f34 - f23, z[4] - z[2]);
-    let f0123 = complex_divide(f123 - f012, z[3] - z[0]);
-    let f1234 = complex_divide(f234 - f123, z[4] - z[1]);
-    let f01234 = complex_divide(f1234 - f0123, z[4] - z[0]);
+    // Coincident support points zero these separations, and complex division by (0, 0)
+    // is NaN. Floored, a merged pair contributes one bounded term instead.
+    let f01 = complex_divide_real(f1 - f0, complex_magnitude_floor(z[1] - z[0], 1e-4));
+    let f12 = complex_divide_real(f2 - f1, complex_magnitude_floor(z[2] - z[1], 1e-4));
+    let f23 = complex_divide_real(f3 - f2, complex_magnitude_floor(z[3] - z[2], 1e-4));
+    let f34 = complex_divide_real(f4 - f3, complex_magnitude_floor(z[4] - z[3], 1e-4));
+    let f012 = complex_divide(f12 - f01, complex_magnitude_floor(z[2] - z[0], 1e-4));
+    let f123 = complex_divide(f23 - f12, complex_magnitude_floor(z[3] - z[1], 1e-4));
+    let f234 = complex_divide(f34 - f23, complex_magnitude_floor(z[4] - z[2], 1e-4));
+    let f0123 = complex_divide(f123 - f012, complex_magnitude_floor(z[3] - z[0], 1e-4));
+    let f1234 = complex_divide(f234 - f123, complex_magnitude_floor(z[4] - z[1], 1e-4));
+    let f01234 = complex_divide(f1234 - f0123, complex_magnitude_floor(z[4] - z[0], 1e-4));
     
     var polynomial = array<vec2<f32>, 5>();
     polynomial[0] = f01234;
@@ -146,6 +158,7 @@ fn compute_transmittance_from_4_trigonometric_moments(
         chunk_complex_divide_real,
         chunk_complex_conjugate,
         chunk_complex_solve_quartic_neumark,
+        chunk_complex_magnitude_floor,
         //
         chunk_circle_to_parameter,
         chunk_get_root_weight_factor,

package/src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_generate_trigonometric_moments_4.d.ts

@@ -1,6 +1,10 @@
 /**
- * This function handles the actual computation of the new vector of
- * trigonometric moments for NUM_MOMENTS = 4 with SINGLE_PRECISION = true.
+ * This function computes one fragment's contribution to the vector of
+ * trigonometric moments, for NUM_MOMENTS = 4 with SINGLE_PRECISION = true.
+ * b_12 packs the two complex moments as (re_1, im_1, re_2, im_2). The
+ * contribution is returned raw; summing across fragments is the caller's
+ * business (additive blending into float render targets, or component-wise
+ * addition in a loop).
  * @see https://github.com/AlicesoftHumika/UnityOIT/blob/612c3c04263acb22980f33fa3cb2d3653ed389ff/Assets/Shader/MBOIT/MomentOIT.hlsli#L123
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_generate_trigonometric_moments_4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_generate_trigonometric_moments_4.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_generate_trigonometric_moments_4.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,qDAFU,SAAS,CA2BjB;0BAlCwB,mCAAmC"}
+{"version":3,"file":"chunk_generate_trigonometric_moments_4.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/mboit/moments/geometric/chunk_generate_trigonometric_moments_4.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,qDAFU,SAAS,CA8BjB;0BAzCwB,mCAAmC"}