@woosh/meep-engine 3.38.0 → 3.40.0

package/src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_beam.js

@@ -0,0 +1,99 @@
+import { chunk_build_orthonormal_matrix_n } from "../../../shader/chunk/geometry/normal/chunk_build_orthonormal_matrix_n.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_manifold_triangle, MANIFOLD_TRIANGLE_STRUCT } from "./chunk_manifold_triangle.js";
+
+/**
+ * How wide a beam of light arrives at the receiver after refracting once through a smooth interface:
+ * the generalized geometric term of manifold next-event estimation (Hanika, Droske & Fascione 2015),
+ * computed by carrying the beam's first-order shape — ray differentials (Igehy 1999) — from the light,
+ * across the interface with the curvature its interpolated normals have, to the receiver.
+ *
+ * `manifold_beam_area(source, distant, x1, tri, x0, eta)`, the beam leaving `source` toward `x1` on
+ * `tri` and refracting there toward `x0`, `eta` the index of the light's side over the receiver's:
+ *
+ * - from a point light (`distant` false, `source` the light's position), the area across the beam at
+ *   `x0` per unit of solid angle leaving the light: irradiance across the beam is intensity over it.
+ *   With no interface between them it is the squared distance.
+ * - from a distant light (`distant` true, `source` any point on the incoming ray before `x1`), the
+ *   area across the beam at `x0` per unit area across it before the interface: irradiance across the
+ *   beam is the light's over it. Through a flat interface it is cos(transmitted) / cos(incident).
+ *
+ * Zero where the light cannot refract toward the receiver (total internal reflection), and where the
+ * beam focuses to a point.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_beam = CodeChunk.from(
+    //language=WGSL
+    `
+fn manifold_beam_area(
+    source: vec3<f32>,
+    distant: bool,
+    x1: vec3<f32>,
+    tri: ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref},
+    x0: vec3<f32>,
+    eta: f32,
+) -> f32 {
+    let to_interface = x1 - source;
+    let d = normalize(to_interface);
+    let t = length(to_interface);
+
+    let frame = build_orthonormal_matrix_n(d);
+
+    // a unit solid angle about a point light, or a unit area across a distant light's rays
+    var dp0 = select(vec3<f32>(0.0), frame[0], distant);
+    var dp1 = select(vec3<f32>(0.0), frame[1], distant);
+    let dd0 = select(frame[0], vec3<f32>(0.0), distant);
+    let dd1 = select(frame[1], vec3<f32>(0.0), distant);
+
+    // carried to the interface's plane
+    let ng = manifold_triangle_geometric_normal(tri);
+    let d_dot_ng = dot(d, ng);
+
+    dp0 += t * dd0;
+    dp1 += t * dd1;
+    dp0 -= d * (dot(dp0, ng) / d_dot_ng);
+    dp1 -= d * (dot(dp1, ng) / d_dot_ng);
+
+    // refracted, the interpolated normal facing the light
+    let flip = select(1.0, -1.0, dot(d, manifold_triangle_normal(tri, x1)) > 0.0);
+    let n = manifold_triangle_normal(tri, x1) * flip;
+    let dn0 = manifold_triangle_normal_derivative(tri, x1, dp0) * flip;
+    let dn1 = manifold_triangle_normal_derivative(tri, x1, dp1) * flip;
+
+    let c = -dot(d, n);
+    let k = 1.0 - eta * eta * (1.0 - c * c);
+
+    if (k <= 0.0) {
+        return 0.0;
+    }
+
+    let root_k = sqrt(k);
+
+    let transmitted = normalize(eta * d + (eta * c - root_k) * n);
+
+    // T = eta D + (eta c - sqrt(k)) N, c = -D.N, k = 1 - eta^2 (1 - c^2)
+    let dc0 = -(dot(dd0, n) + dot(d, dn0));
+    let dc1 = -(dot(dd1, n) + dot(d, dn1));
+    let dc_weight = eta - eta * eta * c / root_k;
+    let dt0 = eta * dd0 + dc_weight * dc0 * n + (eta * c - root_k) * dn0;
+    let dt1 = eta * dd1 + dc_weight * dc1 * n + (eta * c - root_k) * dn1;
+
+    // carried to the receiver, across the transmitted ray
+    let s = length(x0 - x1);
+
+    var q0 = dp0 + s * dt0;
+    var q1 = dp1 + s * dt1;
+
+    q0 -= transmitted * dot(q0, transmitted);
+    q1 -= transmitted * dot(q1, transmitted);
+
+    return length(cross(q0, q1));
+}
+    `,
+    [
+        MANIFOLD_TRIANGLE_STRUCT.declaration_chunk,
+        chunk_manifold_triangle,
+        chunk_build_orthonormal_matrix_n,
+    ]
+);

package/src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_connect.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Light arriving at a receiver through one refracting interface: the direction it arrives from, and
+ * its irradiance across that direction, per channel. Zero irradiance when no connection was made.
+ */
+export const MANIFOLD_CONNECTION_STRUCT: WebGPUStruct;
+/**
+ * Newton steps one connection takes, each one ray cast to put its target back on the surface; past
+ * the limit the connection is given up and contributes nothing. Through flat water from the straight
+ * seed, the sun takes 3 steps at 30 degrees from overhead, 5 at 60 and 80, 7 at 85; through glass,
+ * 5 at 75 and 8 at 85.
+ * @type {number}
+ */
+export const MANIFOLD_ITERATION_LIMIT: number;
+/**
+ * Halvings of one Newton step in the triangle's plane — the surface's local model, where trying a
+ * length costs no ray — before its target is cast for.
+ * @type {number}
+ */
+export const MANIFOLD_LINE_SEARCH_LIMIT: number;
+/**
+ * Ray casts one connection's probes take in all: one a step, and one more for each surface of
+ * another mesh a probe passes on its way to the interface it walks — an index-matched boundary
+ * inside the same water, a leaf. An index-matched box over the receiver puts two on every probe, so
+ * a connection through it has five steps. Past the limit the connection is given up.
+ * @type {number}
+ */
+export const MANIFOLD_PROBE_LIMIT: number;
+/**
+ * How far short of the interface, relative to its distance, the receiver's leg of a connection
+ * stops, so that it does not hit the vertex it connects through.
+ * @type {number}
+ */
+export const MANIFOLD_LEG_SLACK: number;
+/**
+ * Manifold next-event estimation through one smooth refracting interface (Hanika, Droske & Fascione
+ * 2015): `manifold_connect(x0, stack, volumes_present, seed, light_type, index, jitter)`, for a
+ * receiver at `x0` in the media `stack` whose shadow ray toward the light stopped at a refracting
+ * interface (`seed`, as `medium_shadow_transmittance` reports it).
+ *
+ * 1. The light is sampled as `sample_light_record` samples it, with the same `jitter`.
+ * 2. From where the shadow ray met the interface, Newton steps on the specular constraint
+ *    (`manifold_newton_step`) find the point where light from the light refracts toward `x0`, each
+ *    target put back on the surface by a ray from `x0` toward it, which passes other meshes and
+ *    must hit the same one ({@link MANIFOLD_PROBE_LIMIT} casts in all). From a seed far from the
+ *    solution — light far from the normal — a full step overshoots where the constraint flattens
+ *    out, so a step is halved in the triangle's plane until the constraint falls there, and halved
+ *    again if it does not fall on the surface; after a step that is taken, the next may grow back.
+ *    At most {@link MANIFOLD_ITERATION_LIMIT} steps, to `manifold_tolerance`.
+ * 3. Its two legs are shadow rays: `x0` to the vertex in the receiver's media, the vertex to the
+ *    light in the light's. Either meeting another refracting interface ends the connection: one
+ *    interface is what this connects through.
+ * 4. The irradiance is the light's intensity (or a distant light's irradiance) times the interface's
+ *    transmission — `1 - F` at the vertex, by the material's `transmission_factor` — and both legs'
+ *    transmittance, over the beam's area (`manifold_beam_area`), which carries the refraction's
+ *    spreading and the curvature's focusing.
+ *
+ * Where several vertices refract the same light to the same receiver (overlapping waves), the one
+ * the walk finds stands for all: biased there, as Hanika's estimator is. Normal maps are not part of
+ * the surface it walks: the vertex normals are.
+ *
+ * The importing shader binds what ray queries, `materials`, `media` and `light_data` need.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_connect: CodeChunk;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_manifold_connect.d.ts.map

package/src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_connect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_manifold_connect.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_connect.js"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,sDAGyB;AAEzB;;;;;;GAMG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;;GAIG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;;;;GAMG;AACH,mCAFU,MAAM,CAEuB;AAEvC;;;;GAIG;AACH,iCAFU,MAAM,CAEuB;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qCAFU,SAAS,CA+KjB;6BA/P2B,sCAAsC;0BAFzC,uCAAuC"}

package/src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_connect.js

@@ -0,0 +1,263 @@
+import { chunk_F_dielectric } from "../../../shader/chunk/brdf/fresnel/chunk_F_dielectric.js";
+import { chunk_offset_ray } from "../../../shader/chunk/geometry/ray/chunk_offset_ray.js";
+import { chunk_ray_query_nearest } from "../../../shader/chunk/geometry/ray/chunk_ray_query_nearest.js";
+import { RAY_STRUCT } from "../../../shader/chunk/geometry/ray/RAY_STRUCT.js";
+import { F32_MAX_DEFINITION } from "../../../shader/chunk/math/F32_MAX_DEFINITION.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { chunk_medium_path, MEDIUM_SHADOW_STRUCT } from "../media/chunk_medium_path.js";
+import { chunk_medium_stack, MEDIUM_STACK_STRUCT } from "../media/chunk_medium_stack.js";
+import { chunk_manifold_beam } from "./chunk_manifold_beam.js";
+import { chunk_manifold_constraint } from "./chunk_manifold_constraint.js";
+import { chunk_manifold_light } from "./chunk_manifold_light.js";
+import { chunk_manifold_light_sample } from "./chunk_manifold_light_sample.js";
+import { chunk_manifold_triangle } from "./chunk_manifold_triangle.js";
+import { chunk_manifold_triangle_of_hit } from "./chunk_manifold_triangle_of_hit.js";
+
+/**
+ * Light arriving at a receiver through one refracting interface: the direction it arrives from, and
+ * its irradiance across that direction, per channel. Zero irradiance when no connection was made.
+ */
+export const MANIFOLD_CONNECTION_STRUCT = WebGPUStruct.from({
+    direction: vec3f,
+    irradiance: vec3f,
+}, "ManifoldConnection");
+
+/**
+ * Newton steps one connection takes, each one ray cast to put its target back on the surface; past
+ * the limit the connection is given up and contributes nothing. Through flat water from the straight
+ * seed, the sun takes 3 steps at 30 degrees from overhead, 5 at 60 and 80, 7 at 85; through glass,
+ * 5 at 75 and 8 at 85.
+ * @type {number}
+ */
+export const MANIFOLD_ITERATION_LIMIT = 8;
+
+/**
+ * Halvings of one Newton step in the triangle's plane — the surface's local model, where trying a
+ * length costs no ray — before its target is cast for.
+ * @type {number}
+ */
+export const MANIFOLD_LINE_SEARCH_LIMIT = 6;
+
+/**
+ * Ray casts one connection's probes take in all: one a step, and one more for each surface of
+ * another mesh a probe passes on its way to the interface it walks — an index-matched boundary
+ * inside the same water, a leaf. An index-matched box over the receiver puts two on every probe, so
+ * a connection through it has five steps. Past the limit the connection is given up.
+ * @type {number}
+ */
+export const MANIFOLD_PROBE_LIMIT = 16;
+
+/**
+ * How far short of the interface, relative to its distance, the receiver's leg of a connection
+ * stops, so that it does not hit the vertex it connects through.
+ * @type {number}
+ */
+export const MANIFOLD_LEG_SLACK = 1e-4;
+
+/**
+ * Manifold next-event estimation through one smooth refracting interface (Hanika, Droske & Fascione
+ * 2015): `manifold_connect(x0, stack, volumes_present, seed, light_type, index, jitter)`, for a
+ * receiver at `x0` in the media `stack` whose shadow ray toward the light stopped at a refracting
+ * interface (`seed`, as `medium_shadow_transmittance` reports it).
+ *
+ * 1. The light is sampled as `sample_light_record` samples it, with the same `jitter`.
+ * 2. From where the shadow ray met the interface, Newton steps on the specular constraint
+ *    (`manifold_newton_step`) find the point where light from the light refracts toward `x0`, each
+ *    target put back on the surface by a ray from `x0` toward it, which passes other meshes and
+ *    must hit the same one ({@link MANIFOLD_PROBE_LIMIT} casts in all). From a seed far from the
+ *    solution — light far from the normal — a full step overshoots where the constraint flattens
+ *    out, so a step is halved in the triangle's plane until the constraint falls there, and halved
+ *    again if it does not fall on the surface; after a step that is taken, the next may grow back.
+ *    At most {@link MANIFOLD_ITERATION_LIMIT} steps, to `manifold_tolerance`.
+ * 3. Its two legs are shadow rays: `x0` to the vertex in the receiver's media, the vertex to the
+ *    light in the light's. Either meeting another refracting interface ends the connection: one
+ *    interface is what this connects through.
+ * 4. The irradiance is the light's intensity (or a distant light's irradiance) times the interface's
+ *    transmission — `1 - F` at the vertex, by the material's `transmission_factor` — and both legs'
+ *    transmittance, over the beam's area (`manifold_beam_area`), which carries the refraction's
+ *    spreading and the curvature's focusing.
+ *
+ * Where several vertices refract the same light to the same receiver (overlapping waves), the one
+ * the walk finds stands for all: biased there, as Hanika's estimator is. Normal maps are not part of
+ * the surface it walks: the vertex normals are.
+ *
+ * The importing shader binds what ray queries, `materials`, `media` and `light_data` need.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_connect = CodeChunk.from(
+    //language=WGSL
+    `
+const MANIFOLD_ITERATION_LIMIT: u32 = ${MANIFOLD_ITERATION_LIMIT}u;
+const MANIFOLD_LINE_SEARCH_LIMIT: u32 = ${MANIFOLD_LINE_SEARCH_LIMIT}u;
+const MANIFOLD_PROBE_LIMIT: u32 = ${MANIFOLD_PROBE_LIMIT}u;
+const MANIFOLD_LEG_SLACK: f32 = ${MANIFOLD_LEG_SLACK};
+
+fn manifold_connect(
+    x0: vec3<f32>,
+    stack: ${MEDIUM_STACK_STRUCT.wgsl_ref},
+    volumes_present: bool,
+    seed: ${MEDIUM_SHADOW_STRUCT.wgsl_ref},
+    light_type: u32,
+    index: u32,
+    jitter: vec2<f32>,
+) -> ${MANIFOLD_CONNECTION_STRUCT.wgsl_ref} {
+    let none = ${MANIFOLD_CONNECTION_STRUCT.wgsl_ref}(vec3<f32>(0.0), vec3<f32>(0.0));
+
+    let light = manifold_light_sample(light_type, index, jitter);
+    let distant = light.distant != 0u;
+
+    // the two sides, as the shadow ray met the interface: the receiver's is the one it came from
+    let crossing = medium_crossing(seed.stack, seed.material, seed.entering);
+    let n_outside = medium_ior_of_material(crossing.outside);
+    let n_inside = medium_ior_of_material(crossing.inside);
+    let n_receiver = select(n_inside, n_outside, seed.entering);
+    let n_light = select(n_outside, n_inside, seed.entering);
+
+    var tri = manifold_triangle_of_hit(seed.instance, seed.triangle);
+    var x1 = manifold_triangle_point(tri, seed.barycentrics);
+    var step = manifold_newton_step(tri, x0, x1, light, n_receiver, n_light);
+
+    // how much of the Newton step is taken
+    var reach = 1.0;
+    var casts = 0u;
+
+    for (var i = 0u; i < MANIFOLD_ITERATION_LIMIT; i++) {
+        if (!step.ok || step.residual < manifold_tolerance(x0, x1) || casts >= MANIFOLD_PROBE_LIMIT) {
+            break;
+        }
+
+        // halved in the triangle's plane, the surface's local model, until the constraint falls there
+        var aim = mix(x1, step.aim, reach);
+
+        for (var k = 0u; k < MANIFOLD_LINE_SEARCH_LIMIT; k++) {
+            let c = manifold_constraint(tri, x0, aim, light, n_receiver, n_light);
+
+            if (max(abs(c.x), abs(c.y)) < step.residual) {
+                break;
+            }
+
+            reach *= 0.5;
+            aim = mix(x1, step.aim, reach);
+        }
+
+        // put back on the surface by a ray from the receiver toward it, past other meshes
+        var probe: ${RAY_STRUCT.wgsl_ref};
+        probe.origin = x0;
+        probe.direction = normalize(aim - x0);
+        probe.tmax = F32_MAX;
+
+        var hit = ray_query_nearest(probe);
+        casts++;
+
+        while (hit.t > 0.0 && hit.instance != seed.instance && casts < MANIFOLD_PROBE_LIMIT) {
+            let past = manifold_triangle_of_hit(hit.instance, hit.triangle);
+            let ng_past = manifold_triangle_geometric_normal(past);
+
+            probe.origin = offset_ray(manifold_triangle_point(past, hit.barycentrics), ng_past * select(-1.0, 1.0, dot(ng_past, probe.direction) > 0.0));
+
+            hit = ray_query_nearest(probe);
+            casts++;
+        }
+
+        if (hit.t > 0.0 && hit.instance == seed.instance) {
+            let tri_next = manifold_triangle_of_hit(seed.instance, hit.triangle);
+            let x_next = manifold_triangle_point(tri_next, hit.barycentrics);
+            let step_next = manifold_newton_step(tri_next, x0, x_next, light, n_receiver, n_light);
+
+            if (step_next.residual < step.residual) {
+                tri = tri_next;
+                x1 = x_next;
+                step = step_next;
+                reach = min(1.0, 2.0 * reach);
+
+                continue;
+            }
+        }
+
+        // the surface is not its plane here, or the probe missed it: a shorter step
+        reach *= 0.5;
+    }
+
+    if (!(step.residual < manifold_tolerance(x0, x1))) {
+        return none;
+    }
+
+    let to_vertex = x1 - x0;
+    let d0 = length(to_vertex);
+    let toward_vertex = to_vertex / d0;
+    let toward_light = manifold_light_direction(light, x1);
+
+    // the receiver's leg, stopping short of the vertex
+    var leg: ${RAY_STRUCT.wgsl_ref};
+    leg.origin = x0;
+    leg.direction = toward_vertex;
+    leg.tmax = d0 * (1.0 - MANIFOLD_LEG_SLACK);
+
+    let first = medium_shadow_transmittance(leg, stack, volumes_present, MEDIUM_SCATTER_SHADOW_HIT_LIMIT);
+
+    if (first.refracting || all(first.transmittance <= vec3<f32>(0.0))) {
+        return none;
+    }
+
+    // across the interface the way the shadow ray met it, from the media the leg ends in
+    let across = medium_crossing(first.stack, seed.material, seed.entering);
+
+    // the light's leg, from the vertex on the light's side
+    let ng = manifold_triangle_geometric_normal(tri);
+
+    var leg_light: ${RAY_STRUCT.wgsl_ref};
+    leg_light.origin = offset_ray(x1, ng * select(-1.0, 1.0, dot(ng, toward_light) > 0.0));
+    leg_light.direction = toward_light;
+    leg_light.tmax = manifold_light_shadow_length(light, x1);
+
+    let second = medium_shadow_transmittance(leg_light, across.stack, volumes_present, MEDIUM_SCATTER_SHADOW_HIT_LIMIT);
+
+    if (second.refracting || all(second.transmittance <= vec3<f32>(0.0))) {
+        return none;
+    }
+
+    // what the interface lets through, from the light's side about the interpolated normal
+    let n = manifold_triangle_normal(tri, x1);
+    let cos_light = abs(dot(toward_light, n));
+    let transmitted = (1.0 - F_dielectric(cos_light, n_receiver / n_light)) * materials[seed.material].transmission_factor;
+
+    // a local light's intensity falls off from its centre, as sample_light_record has it: its
+    // sampled point aims the connection, and only spreads the light's shadows and caustics
+    let source = select(light.centre, x1 + toward_light, distant);
+    let area = manifold_beam_area(source, distant, x1, tri, x0, n_light / n_receiver);
+
+    if (area <= 0.0) {
+        return none;
+    }
+
+    let path_length = d0 + select(length(light.centre - x1), 0.0, distant);
+    let intensity = manifold_light_intensity(light, x1, path_length);
+
+    return ${MANIFOLD_CONNECTION_STRUCT.wgsl_ref}(
+        toward_vertex,
+        intensity * transmitted * first.transmittance * second.transmittance / area
+    );
+}
+    `,
+    [
+        RAY_STRUCT.declaration_chunk,
+        MEDIUM_STACK_STRUCT.declaration_chunk,
+        MEDIUM_SHADOW_STRUCT.declaration_chunk,
+        MANIFOLD_CONNECTION_STRUCT.declaration_chunk,
+        F32_MAX_DEFINITION,
+        chunk_offset_ray,
+        chunk_ray_query_nearest,
+        chunk_F_dielectric,
+        chunk_medium_stack,
+        chunk_medium_path,
+        chunk_manifold_triangle,
+        chunk_manifold_triangle_of_hit,
+        chunk_manifold_light,
+        chunk_manifold_light_sample,
+        chunk_manifold_constraint,
+        chunk_manifold_beam,
+    ]
+);

package/src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_constraint.d.ts

@@ -0,0 +1,55 @@
+/**
+ * One Newton step toward the point where light refracts from the light to the receiver: the point
+ * of the triangle's plane it aims for, the constraint's size where it started, and whether a step
+ * could be taken at all.
+ */
+export const MANIFOLD_STEP_STRUCT: WebGPUStruct;
+/**
+ * The finite-difference step of the constraint's Jacobian, relative to the distance over which the
+ * constraint turns: the receiver's from the interface, or a local light's where nearer.
+ * @type {number}
+ */
+export const MANIFOLD_DIFFERENCE_SCALE: number;
+/**
+ * The least finite-difference step, relative to the interface point's largest coordinate: about 170
+ * f32 ulps, so that the step resolves far from the origin.
+ * @type {number}
+ */
+export const MANIFOLD_DIFFERENCE_FLOOR: number;
+/**
+ * The constraint's size, about the sine of the angle off Snell's law, under which a connection has
+ * converged — near the origin; far from it, see {@link MANIFOLD_POSITION_NOISE}.
+ * @type {number}
+ */
+export const MANIFOLD_TOLERANCE: number;
+/**
+ * How finely f32 places a point, relative to its largest coordinate, as the constraint feels it: 8 to
+ * 16 ulps. Over the receiver's distance it is an angle the constraint cannot resolve, which the
+ * tolerance does not go below. Newton's residual settles at 0.5 to 1.4 ulps over that distance,
+ * 100 m to 10 km from the origin, 5 cm to 5 m from the interface.
+ * @type {number}
+ */
+export const MANIFOLD_POSITION_NOISE: number;
+/**
+ * Where on a smooth interface light from a light refracts toward a receiver: the specular constraint
+ * of manifold next-event estimation (Hanika, Droske & Fascione 2015) for one refracting vertex, and
+ * a Newton step on it within one triangle.
+ *
+ * - `manifold_constraint(tri, x0, x1, light, n_receiver, n_light)`: at `x1` on the triangle's plane,
+ *   with `wo` toward the receiver `x0` and `wi` toward the light, the generalized half vector
+ *   `n_light wi + n_receiver wo` is parallel to the normal exactly where Snell's law holds. The
+ *   constraint is its cross product with the interpolated normal, expressed in the plane's frame:
+ *   zero at a solution, and about the sine of the angle off it elsewhere.
+ * - `manifold_newton_step(tri, x0, x1, light, n_receiver, n_light)`: a Newton step from `x1` within
+ *   the plane, the Jacobian by forward differences (the constraint is cheap, the interpolated normal
+ *   affine across the plane). The target can leave the triangle; the caller projects it onto the
+ *   surface.
+ * - `manifold_tolerance(x0, x1)`: the residual under which a solution at `x1` has converged,
+ *   {@link MANIFOLD_TOLERANCE}, or what f32 resolves there if coarser.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_constraint: CodeChunk;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_manifold_constraint.d.ts.map

package/src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_constraint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_manifold_constraint.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_constraint.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,gDAImB;AAEnB;;;;GAIG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,iCAFU,MAAM,CAEuB;AAEvC;;;;;;GAMG;AACH,sCAFU,MAAM,CAE4B;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCAFU,SAAS,CAmFjB;6BAjJ2B,sCAAsC;0BAFzC,uCAAuC"}

package/src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_constraint.js

@@ -0,0 +1,148 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { bool, f32, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { chunk_manifold_light, MANIFOLD_LIGHT_STRUCT } from "./chunk_manifold_light.js";
+import { chunk_manifold_triangle, MANIFOLD_TRIANGLE_STRUCT } from "./chunk_manifold_triangle.js";
+
+/**
+ * One Newton step toward the point where light refracts from the light to the receiver: the point
+ * of the triangle's plane it aims for, the constraint's size where it started, and whether a step
+ * could be taken at all.
+ */
+export const MANIFOLD_STEP_STRUCT = WebGPUStruct.from({
+    aim: vec3f,
+    residual: f32,
+    ok: bool,
+}, "ManifoldStep");
+
+/**
+ * The finite-difference step of the constraint's Jacobian, relative to the distance over which the
+ * constraint turns: the receiver's from the interface, or a local light's where nearer.
+ * @type {number}
+ */
+export const MANIFOLD_DIFFERENCE_SCALE = 1e-3;
+
+/**
+ * The least finite-difference step, relative to the interface point's largest coordinate: about 170
+ * f32 ulps, so that the step resolves far from the origin.
+ * @type {number}
+ */
+export const MANIFOLD_DIFFERENCE_FLOOR = 1e-5;
+
+/**
+ * The constraint's size, about the sine of the angle off Snell's law, under which a connection has
+ * converged — near the origin; far from it, see {@link MANIFOLD_POSITION_NOISE}.
+ * @type {number}
+ */
+export const MANIFOLD_TOLERANCE = 1e-4;
+
+/**
+ * How finely f32 places a point, relative to its largest coordinate, as the constraint feels it: 8 to
+ * 16 ulps. Over the receiver's distance it is an angle the constraint cannot resolve, which the
+ * tolerance does not go below. Newton's residual settles at 0.5 to 1.4 ulps over that distance,
+ * 100 m to 10 km from the origin, 5 cm to 5 m from the interface.
+ * @type {number}
+ */
+export const MANIFOLD_POSITION_NOISE = 1e-6;
+
+/**
+ * Where on a smooth interface light from a light refracts toward a receiver: the specular constraint
+ * of manifold next-event estimation (Hanika, Droske & Fascione 2015) for one refracting vertex, and
+ * a Newton step on it within one triangle.
+ *
+ * - `manifold_constraint(tri, x0, x1, light, n_receiver, n_light)`: at `x1` on the triangle's plane,
+ *   with `wo` toward the receiver `x0` and `wi` toward the light, the generalized half vector
+ *   `n_light wi + n_receiver wo` is parallel to the normal exactly where Snell's law holds. The
+ *   constraint is its cross product with the interpolated normal, expressed in the plane's frame:
+ *   zero at a solution, and about the sine of the angle off it elsewhere.
+ * - `manifold_newton_step(tri, x0, x1, light, n_receiver, n_light)`: a Newton step from `x1` within
+ *   the plane, the Jacobian by forward differences (the constraint is cheap, the interpolated normal
+ *   affine across the plane). The target can leave the triangle; the caller projects it onto the
+ *   surface.
+ * - `manifold_tolerance(x0, x1)`: the residual under which a solution at `x1` has converged,
+ *   {@link MANIFOLD_TOLERANCE}, or what f32 resolves there if coarser.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_constraint = CodeChunk.from(
+    //language=WGSL
+    `
+const MANIFOLD_DIFFERENCE_SCALE: f32 = ${MANIFOLD_DIFFERENCE_SCALE};
+const MANIFOLD_DIFFERENCE_FLOOR: f32 = ${MANIFOLD_DIFFERENCE_FLOOR};
+const MANIFOLD_TOLERANCE: f32 = ${MANIFOLD_TOLERANCE};
+const MANIFOLD_POSITION_NOISE: f32 = ${MANIFOLD_POSITION_NOISE};
+
+fn manifold_tolerance(x0: vec3<f32>, x1: vec3<f32>) -> f32 {
+    let a = abs(x1);
+    let reach = max(max(a.x, a.y), a.z);
+
+    return max(MANIFOLD_TOLERANCE, MANIFOLD_POSITION_NOISE * reach / distance(x0, x1));
+}
+
+fn manifold_constraint(
+    tri: ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref},
+    x0: vec3<f32>,
+    x1: vec3<f32>,
+    light: ${MANIFOLD_LIGHT_STRUCT.wgsl_ref},
+    n_receiver: f32,
+    n_light: f32,
+) -> vec2<f32> {
+    let wo = normalize(x0 - x1);
+    let wi = manifold_light_direction(light, x1);
+
+    let h = normalize(n_light * wi + n_receiver * wo);
+    let c = cross(h, manifold_triangle_normal(tri, x1));
+
+    let frame = manifold_triangle_frame(tri);
+
+    return vec2<f32>(dot(c, frame[0]), dot(c, frame[1]));
+}
+
+fn manifold_newton_step(
+    tri: ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref},
+    x0: vec3<f32>,
+    x1: vec3<f32>,
+    light: ${MANIFOLD_LIGHT_STRUCT.wgsl_ref},
+    n_receiver: f32,
+    n_light: f32,
+) -> ${MANIFOLD_STEP_STRUCT.wgsl_ref} {
+    let frame = manifold_triangle_frame(tri);
+
+    // the constraint turns over the receiver's distance, or a local light's where nearer — not the
+    // triangle's size — and the step must stay many ulps of x1 wide to be resolved at all
+    let a = abs(x1);
+    let reach = select(min(distance(x0, x1), distance(light.position, x1)), distance(x0, x1), light.distant != 0u);
+    let h = max(MANIFOLD_DIFFERENCE_SCALE * reach, MANIFOLD_DIFFERENCE_FLOOR * max(max(a.x, a.y), a.z));
+
+    let c = manifold_constraint(tri, x0, x1, light, n_receiver, n_light);
+    let cs = manifold_constraint(tri, x0, x1 + frame[0] * h, light, n_receiver, n_light);
+    let ct = manifold_constraint(tri, x0, x1 + frame[1] * h, light, n_receiver, n_light);
+
+    let residual = max(abs(c.x), abs(c.y));
+
+    // columns: the constraint's change along the frame's two directions
+    let j0 = (cs - c) / h;
+    let j1 = (ct - c) / h;
+    let determinant = j0.x * j1.y - j1.x * j0.y;
+
+    if (abs(determinant) <= 1e-12) {
+        return ${MANIFOLD_STEP_STRUCT.wgsl_ref}(x1, residual, false);
+    }
+
+    // solve J delta = -c
+    let delta = vec2<f32>(
+        -(j1.y * c.x - j1.x * c.y),
+        -(-j0.y * c.x + j0.x * c.y)
+    ) / determinant;
+
+    return ${MANIFOLD_STEP_STRUCT.wgsl_ref}(x1 + frame[0] * delta.x + frame[1] * delta.y, residual, true);
+}
+    `,
+    [
+        MANIFOLD_STEP_STRUCT.declaration_chunk,
+        MANIFOLD_TRIANGLE_STRUCT.declaration_chunk,
+        MANIFOLD_LIGHT_STRUCT.declaration_chunk,
+        chunk_manifold_triangle,
+        chunk_manifold_light,
+    ]
+);

package/src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_light.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The light end of a manifold connection: a point on a local light (`position`), or the direction
+ * toward a distant one (`distant` 1, `direction`). `centre` is a local light's own position, which
+ * its intensity falls off from, as `sample_light_record` has it; the sampled point only spreads its
+ * shadows. `near_clip` is how far short of a local light a shadow ray stops; `light_type` and
+ * `index` name the light's row, for its intensity.
+ */
+export const MANIFOLD_LIGHT_STRUCT: WebGPUStruct;
+/**
+ * `manifold_light_direction(light, x)`: the unit direction from `x` toward the light.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_light: CodeChunk;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_manifold_light.d.ts.map

package/src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_light.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_manifold_light.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_light.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,iDAQoB;AAEpB;;;;GAIG;AACH,mCAFU,SAAS,CAgBjB;6BAtC2B,sCAAsC;0BAFzC,uCAAuC"}