@woosh/meep-engine 3.37.0 → 3.39.0

package/src/shade/renderer/path_tracer/shader/media/chunk_medium_path.js

@@ -0,0 +1,245 @@
+import { MEDIUM_STRUCT } from "../../../medium/MEDIUM_STRUCT.js";
+import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.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 { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { bool, u32, vec2f, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import {
+    chunk_participating_media_volumes_iterate
+} from "../../../volumetrics/chunk_participating_media_volumes_iterate.js";
+import { chunk_ray_hit_to_opacity } from "../chunk_ray_hit_to_opacity.js";
+import { chunk_medium_stack, MEDIUM_STACK_STRUCT } from "./chunk_medium_stack.js";
+import { chunk_medium_transport } from "./chunk_medium_transport.js";
+
+/**
+ * Surfaces a probe ray from a path's origin walks past while finding the media the origin is
+ * inside. A medium further out than this many surfaces is missed.
+ * @type {number}
+ */
+export const MEDIUM_PROBE_HIT_LIMIT = 8;
+
+/**
+ * Surfaces a shadow ray from a surface may pass through — alpha holes, thin glass, boundaries with
+ * no interface — before it counts as blocked; the bound `ray_shaded_query_occluded`, which it
+ * replaced, has.
+ * @type {number}
+ */
+export const MEDIUM_SHADOW_HIT_LIMIT = 32;
+
+/**
+ * The same for a shadow ray from a scattering point in a medium, of which a path takes up to
+ * `PATH_MEDIUM_SCATTER_LIMIT` where it takes one from a surface per bounce.
+ * @type {number}
+ */
+export const MEDIUM_SCATTER_SHADOW_HIT_LIMIT = 8;
+
+/**
+ * What a shadow ray found. `transmittance`: what of the light reaches its end, per channel; zero when
+ * it was stopped. `refracting`: whether what stopped it was a refracting interface — the one manifold
+ * next-event estimation can connect through — and then `instance`, `triangle`, `barycentrics` are
+ * the hit on it, `material` its material, `entering` whether the ray crossed it into what it bounds,
+ * and `stack` the media the ray was in there. When the ray got through, `stack` is the media at its
+ * end.
+ */
+export const MEDIUM_SHADOW_STRUCT = WebGPUStruct.from({
+    transmittance: vec3f,
+    refracting: bool,
+    stack: MEDIUM_STACK_STRUCT,
+    instance: u32,
+    triangle: u32,
+    barycentrics: vec2f,
+    material: u32,
+    entering: bool,
+}, "MediumShadow");
+
+/**
+ * What a path through media needs between its surfaces, for `render_trace_path`. The importing shader
+ * binds the ray-tracing group (`scene_database` among it), `materials`, `media` and `light_data`.
+ *
+ * - `medium_host_of_stack(stack)`: the medium the path is in, the zero record (vacuum) when none.
+ * - `medium_ior_of_material(material)`: the index of refraction on a side of an interface; 1 for
+ *   vacuum.
+ * - `medium_stack_at(position)`: the media bounded by refracting surfaces that contain a path's
+ *   origin, found by walking a probe ray straight up past every surface on it: a mesh whose boundary
+ *   the probe leaves more often than it entered contains the origin — counted per mesh, as the path's
+ *   stack counts them, so two overlapping meshes of one medium are two entries. Media bounded by
+ *   closed meshes only; in the stack's priority order, the same stack a path walking in from outside
+ *   would carry. Free when no medium is resident (`media.count == 0`).
+ * - `medium_shadow_transmittance(ray, stack, volumes_present, hit_limit)`: a {@link MEDIUM_SHADOW_STRUCT}
+ *   — what of a light reaches the end of a shadow ray, per channel, through media, thin glass and
+ *   alpha holes, passing at most `hit_limit` surfaces. A straight line cannot cross a refracting
+ *   interface, so the ray stops at one and says where, for manifold next-event estimation to connect
+ *   through. An interface between equal indices of refraction — a fog bounded by a mesh at
+ *   `ior_factor` 1 — refracts nothing and is crossed like any other surface.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_medium_path = CodeChunk.from(
+    //language=WGSL
+    `
+const MEDIUM_PROBE_HIT_LIMIT: u32 = ${MEDIUM_PROBE_HIT_LIMIT}u;
+const MEDIUM_SHADOW_HIT_LIMIT: u32 = ${MEDIUM_SHADOW_HIT_LIMIT}u;
+const MEDIUM_SCATTER_SHADOW_HIT_LIMIT: u32 = ${MEDIUM_SCATTER_SHADOW_HIT_LIMIT}u;
+
+fn medium_host_of_stack(stack: ${MEDIUM_STACK_STRUCT.wgsl_ref}) -> ${MEDIUM_STRUCT.wgsl_ref} {
+    let medium = medium_of_material(medium_stack_top(stack));
+
+    if (medium == MEDIUM_NONE) {
+        return ${MEDIUM_STRUCT.wgsl_ref}();
+    }
+
+    return media.records[medium];
+}
+
+fn medium_ior_of_material(material: u32) -> f32 {
+    if (material == MEDIUM_NONE) {
+        return 1.0;
+    }
+
+    return materials[material].ior_factor;
+}
+
+fn medium_stack_at(position: vec3<f32>) -> ${MEDIUM_STACK_STRUCT.wgsl_ref} {
+    var stack = ${MEDIUM_STACK_STRUCT.wgsl_ref}(vec3<u32>(MEDIUM_NONE), 0u);
+
+    if (media.count == 0u) {
+        return stack;
+    }
+
+    var probe: ${RAY_STRUCT.wgsl_ref};
+    probe.origin = position;
+    probe.direction = vec3<f32>(0.0, 1.0, 0.0);
+    probe.tmax = F32_MAX;
+
+    // as multisets, as the path's stack counts them: meshes whose boundary the probe has entered and
+    // not yet left, and meshes found containing the origin, innermost first
+    var entered = ${MEDIUM_STACK_STRUCT.wgsl_ref}(vec3<u32>(MEDIUM_NONE), 0u);
+    var inside = ${MEDIUM_STACK_STRUCT.wgsl_ref}(vec3<u32>(MEDIUM_NONE), 0u);
+
+    for (var i = 0u; i < MEDIUM_PROBE_HIT_LIMIT; i++) {
+        let hit = ray_query_nearest(probe);
+
+        if (hit.t <= 0.0) {
+            break;
+        }
+
+        let material = scene_read_mesh(&scene_database, hit.instance).material;
+        let surface = ray_hit_to_opacity(hit, probe.direction);
+        let facing = dot(surface.geometric_normal, probe.direction);
+
+        if (medium_of_material(material) != MEDIUM_NONE) {
+            if (facing < 0.0) {
+                entered = medium_stack_append(entered, material);
+            } else if (medium_stack_contains(entered, material)) {
+                // leaving a mesh the probe entered; one mesh of a material is as good as another
+                entered = medium_stack_remove(entered, material);
+            } else {
+                // leaving a mesh it never entered: the origin is inside it
+                inside = medium_stack_append(inside, material);
+            }
+        }
+
+        probe.origin = offset_ray(surface.position, surface.geometric_normal * select(-1.0, 1.0, facing > 0.0));
+    }
+
+    // entered outermost first, so that among equal priorities the innermost ends on top
+    for (var i = inside.depth; i > 0u; i--) {
+        stack = medium_stack_push(stack, medium_stack_entry(inside, i - 1u));
+    }
+
+    return stack;
+}
+
+fn medium_shadow_transmittance(
+    shadow_ray: ${RAY_STRUCT.wgsl_ref},
+    path_stack: ${MEDIUM_STACK_STRUCT.wgsl_ref},
+    volumes_present: bool,
+    hit_limit: u32,
+) -> ${MEDIUM_SHADOW_STRUCT.wgsl_ref} {
+    var result: ${MEDIUM_SHADOW_STRUCT.wgsl_ref};
+
+    var ray = shadow_ray;
+    var stack = path_stack;
+    var transmittance = vec3<f32>(1.0);
+
+    for (var i = 0u; i < hit_limit; i++) {
+        let hit = ray_query_nearest(ray);
+
+        let segment = select(ray.tmax, hit.t, hit.t > 0.0);
+
+        if (stack.depth > 0u || volumes_present) {
+            transmittance *= medium_transmittance(ray.origin, ray.direction, segment, medium_host_of_stack(stack));
+
+            if (all(transmittance <= vec3<f32>(0.0))) {
+                return result;
+            }
+        }
+
+        if (hit.t <= 0.0) {
+            result.transmittance = transmittance;
+            result.stack = stack;
+
+            return result;
+        }
+
+        let material = scene_read_mesh(&scene_database, hit.instance).material;
+        let surface = ray_hit_to_opacity(hit, ray.direction);
+        let facing = dot(surface.geometric_normal, ray.direction);
+
+        if (medium_of_material(material) != MEDIUM_NONE) {
+            let crossing = medium_crossing(stack, material, facing < 0.0);
+
+            if (crossing.is_interface) {
+                if (medium_ior_of_material(crossing.outside) != medium_ior_of_material(crossing.inside)) {
+                    // refraction bends the way to the light, so a straight shadow ray is not it: say
+                    // where, for a manifold connection
+                    result.refracting = true;
+                    result.stack = stack;
+                    result.instance = hit.instance;
+                    result.triangle = hit.triangle;
+                    result.barycentrics = hit.barycentrics;
+                    result.material = material;
+                    result.entering = facing < 0.0;
+
+                    return result;
+                }
+
+                // between equal indices nothing bends or reflects; the rest of the surface is
+                // opaque, as the path sees it
+                if (random() >= materials[material].transmission_factor) {
+                    return result;
+                }
+            }
+
+            stack = crossing.stack;
+        } else if (random() < surface.opacity) {
+            return result;
+        }
+
+        ray.origin = offset_ray(surface.position, surface.geometric_normal * select(-1.0, 1.0, facing > 0.0));
+        ray.tmax = ray.tmax - hit.t;
+    }
+
+    return result;
+}
+    `,
+    [
+        RAY_STRUCT.declaration_chunk,
+        MEDIUM_STRUCT.declaration_chunk,
+        MEDIUM_STACK_STRUCT.declaration_chunk,
+        F32_MAX_DEFINITION,
+        chunk_random,
+        chunk_offset_ray,
+        chunk_ray_query_nearest,
+        chunk_ray_hit_to_opacity,
+        chunk_scene_database_access,
+        chunk_participating_media_volumes_iterate,
+        chunk_medium_stack,
+        chunk_medium_transport,
+        MEDIUM_SHADOW_STRUCT.declaration_chunk,
+    ]
+);

package/src/shade/renderer/path_tracer/shader/media/chunk_medium_phase.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The phase function of a medium at a point, for one pair of directions:
+ *
+ * - `phase`: per channel, the scattering-weighted mixture of every component's phase function,
+ *   normalized over the sphere — what scatters into the direction, per unit of scattered light.
+ * - `pdf`: the density with which {@link chunk_medium_phase}'s sampler produces the direction. The
+ *   same for every channel: the component it samples is chosen in proportion to the component's
+ *   scattering averaged over channels.
+ */
+export const MEDIUM_PHASE_VALUE_STRUCT: WebGPUStruct;
+/**
+ * A sampled scattering direction and the weight a path's throughput takes for it, per channel:
+ * phase over pdf.
+ */
+export const MEDIUM_PHASE_SAMPLE_STRUCT: WebGPUStruct;
+/**
+ * Phase functions inside media, for the path tracer.
+ *
+ * A medium at a point is a mixture of components: the lobes of the medium the point is inside
+ * (`host`, a {@link MEDIUM_STRUCT}; the zero record is vacuum) and one Henyey-Greenstein lobe per
+ * participating-media volume containing the point, scattering `density_at * particle_spec.scattering`
+ * with the volume's `g` — read from the scene database the importing shader binds as
+ * `scene_database`. A component's phase is evaluated from both the cosine of the deflection and
+ * `sin2_half` = sin²(psi / 2): Draine lobes read the first, Fournier-Forand the second, which it needs
+ * to resolve its forward peak. From two unit directions, `sin2_half` is |a - b|² / 4.
+ *
+ * - `medium_lobe_phase(lobe, cos_theta, sin2_half)` and `medium_lobe_sample(lobe)` (returns
+ *   `(cos_theta, sin2_half)`, drawing from `random()`) for one GPU lobe.
+ * - `medium_phase_value(position, host, cos_theta, sin2_half)`: the mixture's phase per channel and
+ *   the sampler's pdf.
+ * - `medium_phase_sample(position, host, incident)`: a direction scattered from the propagation
+ *   direction `incident`, with weight phase / pdf per channel. One component is picked in proportion
+ *   to its channel-averaged scattering and sampled exactly; the weight is the whole mixture's
+ *   (one-sample MIS, balance heuristic, over components). The pick does not depend on any one
+ *   channel, so a hero-channel path's MIS state is untouched by it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_medium_phase: CodeChunk;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_medium_phase.d.ts.map

package/src/shade/renderer/path_tracer/shader/media/chunk_medium_phase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_medium_phase.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/media/chunk_medium_phase.js"],"names":[],"mappings":"AAoBA;;;;;;;;GAQG;AACH,qDAGuB;AAEvB;;;GAGG;AACH,sDAGwB;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,iCAFU,SAAS,CA2KjB;6BAhO2B,sCAAsC;0BACzC,uCAAuC"}

package/src/shade/renderer/path_tracer/shader/media/chunk_medium_phase.js

@@ -0,0 +1,236 @@
+import { chunk_medium_lobe_phase } from "../../../medium/chunk_medium_lobe_phase.js";
+import { MEDIUM_PHASE_LOBE_KIND } from "../../../medium/MEDIUM_PHASE_LOBE_KIND.js";
+import { MEDIUM_PHASE_LOBE_STRUCT, MEDIUM_STRUCT } from "../../../medium/MEDIUM_STRUCT.js";
+import { chunk_phase_fournier_forand } from "../../../shader/chunk/atmosphere/phase/ff/chunk_phase_fournier_forand.js";
+import { chunk_sample_fournier_forand } from "../../../shader/chunk/atmosphere/phase/ff/chunk_sample_fournier_forand.js";
+import { chunk_phase_draine } from "../../../shader/chunk/atmosphere/phase/jd/chunk_phase_draine.js";
+import { chunk_sample_draine } from "../../../shader/chunk/atmosphere/phase/jd/chunk_sample_draine.js";
+import { chunk_build_orthonormal_matrix_n } from "../../../shader/chunk/geometry/normal/chunk_build_orthonormal_matrix_n.js";
+import { PI_DECLARATION } from "../../../shader/chunk/math/PI_DECLARATION.js";
+import { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
+import { f32, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import {
+    chunk_participating_media_volume_sample
+} from "../../../volumetrics/chunk_participating_media_volume_sample.js";
+import {
+    chunk_participating_media_volumes_iterate
+} from "../../../volumetrics/chunk_participating_media_volumes_iterate.js";
+
+/**
+ * The phase function of a medium at a point, for one pair of directions:
+ *
+ * - `phase`: per channel, the scattering-weighted mixture of every component's phase function,
+ *   normalized over the sphere — what scatters into the direction, per unit of scattered light.
+ * - `pdf`: the density with which {@link chunk_medium_phase}'s sampler produces the direction. The
+ *   same for every channel: the component it samples is chosen in proportion to the component's
+ *   scattering averaged over channels.
+ */
+export const MEDIUM_PHASE_VALUE_STRUCT = WebGPUStruct.from({
+    phase: vec3f,
+    pdf: f32,
+}, "MediumPhaseValue");
+
+/**
+ * A sampled scattering direction and the weight a path's throughput takes for it, per channel:
+ * phase over pdf.
+ */
+export const MEDIUM_PHASE_SAMPLE_STRUCT = WebGPUStruct.from({
+    direction: vec3f,
+    weight: vec3f,
+}, "MediumPhaseSample");
+
+/**
+ * Phase functions inside media, for the path tracer.
+ *
+ * A medium at a point is a mixture of components: the lobes of the medium the point is inside
+ * (`host`, a {@link MEDIUM_STRUCT}; the zero record is vacuum) and one Henyey-Greenstein lobe per
+ * participating-media volume containing the point, scattering `density_at * particle_spec.scattering`
+ * with the volume's `g` — read from the scene database the importing shader binds as
+ * `scene_database`. A component's phase is evaluated from both the cosine of the deflection and
+ * `sin2_half` = sin²(psi / 2): Draine lobes read the first, Fournier-Forand the second, which it needs
+ * to resolve its forward peak. From two unit directions, `sin2_half` is |a - b|² / 4.
+ *
+ * - `medium_lobe_phase(lobe, cos_theta, sin2_half)` and `medium_lobe_sample(lobe)` (returns
+ *   `(cos_theta, sin2_half)`, drawing from `random()`) for one GPU lobe.
+ * - `medium_phase_value(position, host, cos_theta, sin2_half)`: the mixture's phase per channel and
+ *   the sampler's pdf.
+ * - `medium_phase_sample(position, host, incident)`: a direction scattered from the propagation
+ *   direction `incident`, with weight phase / pdf per channel. One component is picked in proportion
+ *   to its channel-averaged scattering and sampled exactly; the weight is the whole mixture's
+ *   (one-sample MIS, balance heuristic, over components). The pick does not depend on any one
+ *   channel, so a hero-channel path's MIS state is untouched by it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_medium_phase = CodeChunk.from(
+    //language=WGSL
+    `
+fn medium_lobe_sample(lobe: ${MEDIUM_PHASE_LOBE_STRUCT.wgsl_ref}) -> vec2<f32> {
+    if (lobe.kind == ${MEDIUM_PHASE_LOBE_KIND.FournierForand}u) {
+        let u = sample_fournier_forand_sin2_half(random(), lobe.p0, lobe.p1);
+
+        return vec2<f32>(1.0 - 2.0 * u, u);
+    }
+
+    let mu = sample_draine(lobe.p0, lobe.p1);
+
+    return vec2<f32>(mu, 0.5 * (1.0 - mu));
+}
+
+fn medium_channel_mean(v: vec3<f32>) -> f32 {
+    return (v.x + v.y + v.z) * (1.0 / 3.0);
+}
+
+fn medium_phase_value(
+    position: vec3<f32>,
+    host: ${MEDIUM_STRUCT.wgsl_ref},
+    cos_theta: f32,
+    sin2_half: f32,
+) -> ${MEDIUM_PHASE_VALUE_STRUCT.wgsl_ref} {
+    var scattering = vec3<f32>(0.0);
+    // sum over components of sigma_s,i * p_i, per channel
+    var weighted = vec3<f32>(0.0);
+    // sum over components of q_i * p_i, and of q_i, q_i the channel-averaged sigma_s,i
+    var pdf_weighted = 0.0;
+    var q_total = 0.0;
+
+    var medium = host;
+
+    for (var l = 0u; l < medium.lobe_count; l++) {
+        let lobe = medium.lobes[l];
+        let p = medium_lobe_phase(lobe, cos_theta, sin2_half);
+        let q = medium_channel_mean(lobe.scattering);
+
+        scattering += lobe.scattering;
+        weighted += lobe.scattering * p;
+        pdf_weighted += q * p;
+        q_total += q;
+    }
+
+    let volume_count = participating_media_volumes_count(&scene_database);
+
+    for (var v = 0u; v < volume_count; v++) {
+        let volume = participating_media_volume_read(&scene_database, v);
+
+        let density = participating_media_volume_density_at(volume, position);
+
+        if (density <= 0.0) {
+            continue;
+        }
+
+        let s = density * volume.particle_spec.scattering;
+        let p = phase_draine(cos_theta, volume.particle_spec.g, 0.0);
+        let q = medium_channel_mean(s);
+
+        scattering += s;
+        weighted += s * p;
+        pdf_weighted += q * p;
+        q_total += q;
+    }
+
+    let phase = select(weighted / scattering, vec3<f32>(0.0), scattering <= vec3<f32>(0.0));
+    let pdf = select(pdf_weighted / q_total, 0.0, q_total <= 0.0);
+
+    return ${MEDIUM_PHASE_VALUE_STRUCT.wgsl_ref}(phase, pdf);
+}
+
+fn medium_phase_sample(
+    position: vec3<f32>,
+    host: ${MEDIUM_STRUCT.wgsl_ref},
+    incident: vec3<f32>,
+) -> ${MEDIUM_PHASE_SAMPLE_STRUCT.wgsl_ref} {
+    var medium = host;
+
+    // pass 1: the total of the components' channel-averaged scattering
+    var q_total = 0.0;
+
+    for (var l = 0u; l < medium.lobe_count; l++) {
+        q_total += medium_channel_mean(medium.lobes[l].scattering);
+    }
+
+    let volume_count = participating_media_volumes_count(&scene_database);
+
+    for (var v = 0u; v < volume_count; v++) {
+        let volume = participating_media_volume_read(&scene_database, v);
+
+        q_total += medium_channel_mean(
+            participating_media_volume_density_at(volume, position) * volume.particle_spec.scattering
+        );
+    }
+
+    if (q_total <= 0.0) {
+        // nothing here scatters
+        return ${MEDIUM_PHASE_SAMPLE_STRUCT.wgsl_ref}(incident, vec3<f32>(0.0));
+    }
+
+    // pass 2: pick a component in proportion and sample it
+    let pick = random() * q_total;
+
+    var accumulated = 0.0;
+    var chosen = false;
+    var deflection = vec2<f32>(1.0, 0.0);
+
+    for (var l = 0u; l < medium.lobe_count; l++) {
+        accumulated += medium_channel_mean(medium.lobes[l].scattering);
+
+        if (!chosen && pick < accumulated) {
+            deflection = medium_lobe_sample(medium.lobes[l]);
+            chosen = true;
+        }
+    }
+
+    for (var v = 0u; v < volume_count && !chosen; v++) {
+        let volume = participating_media_volume_read(&scene_database, v);
+
+        accumulated += medium_channel_mean(
+            participating_media_volume_density_at(volume, position) * volume.particle_spec.scattering
+        );
+
+        if (!chosen && pick < accumulated) {
+            // Henyey-Greenstein is Draine at alpha = 0, accepted at the first proposal
+            let mu = sample_draine(volume.particle_spec.g, 0.0);
+
+            deflection = vec2<f32>(mu, 0.5 * (1.0 - mu));
+            chosen = true;
+        }
+    }
+
+    if (!chosen) {
+        // the running sum fell short of the total by rounding; the last sliver goes isotropic
+        let mu = 2.0 * random() - 1.0;
+
+        deflection = vec2<f32>(mu, 0.5 * (1.0 - mu));
+    }
+
+    let cos_theta = deflection.x;
+    let sin2_half = deflection.y;
+    let sin_theta = 2.0 * sqrt(max(0.0, sin2_half * (1.0 - sin2_half)));
+    let phi = 2.0 * PI * random();
+
+    let local = vec3<f32>(sin_theta * cos(phi), sin_theta * sin(phi), cos_theta);
+    let direction = normalize(build_orthonormal_matrix_n(incident) * local);
+
+    let value = medium_phase_value(position, host, cos_theta, sin2_half);
+    let weight = select(value.phase / value.pdf, vec3<f32>(0.0), value.pdf <= 0.0);
+
+    return ${MEDIUM_PHASE_SAMPLE_STRUCT.wgsl_ref}(direction, weight);
+}
+    `,
+    [
+        MEDIUM_STRUCT.declaration_chunk,
+        MEDIUM_PHASE_VALUE_STRUCT.declaration_chunk,
+        MEDIUM_PHASE_SAMPLE_STRUCT.declaration_chunk,
+        chunk_medium_lobe_phase,
+        PI_DECLARATION,
+        chunk_random,
+        chunk_phase_draine,
+        chunk_sample_draine,
+        chunk_phase_fournier_forand,
+        chunk_sample_fournier_forand,
+        chunk_build_orthonormal_matrix_n,
+        chunk_participating_media_volumes_iterate,
+        chunk_participating_media_volume_sample,
+    ]
+);

package/src/shade/renderer/path_tracer/shader/media/chunk_medium_scatter_nee.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Manifold connections one path may make — through a refracting interface to a light its straight
+ * shadow ray could not reach, at a surface or at a scattering point. Each is up to
+ * `MANIFOLD_ITERATION_LIMIT` ray casts and two shadow rays. Past the limit, light behind such an
+ * interface is lost to the rest of the path: every light is reached only by next-event estimation,
+ * none by sampling a direction. In a scattering medium behind an interface, that is the direct light
+ * of every scattering past the fourth — estimated, without Fresnel or refraction, at 18–22% of the
+ * sunlight scattered in the playground's milky sphere, 31% in deep water of albedo 0.9 and 55% at
+ * 0.99. As many connections as scattering events would cost about six shadow rays a scattering.
+ * @type {number}
+ */
+export const PATH_MANIFOLD_LIMIT: number;
+/**
+ * `medium_scatter_nee(position, incident, host, stack, volumes_present, connections)`: one light
+ * sample at a scattering point in a medium — light chosen for a point with no surface, phase function
+ * of the medium there, transmittance to the light — per unit of path weight. Where the shadow ray
+ * stops at a refracting interface, the light is connected through it (`manifold_connect`) while the
+ * path has connections left (`connections`, counted against {@link PATH_MANIFOLD_LIMIT}).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_medium_scatter_nee: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_medium_scatter_nee.d.ts.map

package/src/shade/renderer/path_tracer/shader/media/chunk_medium_scatter_nee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_medium_scatter_nee.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/media/chunk_medium_scatter_nee.js"],"names":[],"mappings":"AAWA;;;;;;;;;;GAUG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;;;;;GAQG;AACH,uCAFU,SAAS,CAiEjB;0BA3FwB,uCAAuC"}

package/src/shade/renderer/path_tracer/shader/media/chunk_medium_scatter_nee.js

@@ -0,0 +1,97 @@
+import { MEDIUM_STRUCT } from "../../../medium/MEDIUM_STRUCT.js";
+import { RAY_STRUCT } from "../../../shader/chunk/geometry/ray/RAY_STRUCT.js";
+import { chunk_sample_light_record } from "../../../shader/chunk/light/sample/chunk_sample_light_record.js";
+import { chunk_select_light_importance } from "../../../shader/chunk/light/sample/chunk_select_light_importance.js";
+import { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_manifold_connect } from "../manifold/chunk_manifold_connect.js";
+import { chunk_medium_path } from "./chunk_medium_path.js";
+import { chunk_medium_phase } from "./chunk_medium_phase.js";
+import { MEDIUM_STACK_STRUCT } from "./chunk_medium_stack.js";
+
+/**
+ * Manifold connections one path may make — through a refracting interface to a light its straight
+ * shadow ray could not reach, at a surface or at a scattering point. Each is up to
+ * `MANIFOLD_ITERATION_LIMIT` ray casts and two shadow rays. Past the limit, light behind such an
+ * interface is lost to the rest of the path: every light is reached only by next-event estimation,
+ * none by sampling a direction. In a scattering medium behind an interface, that is the direct light
+ * of every scattering past the fourth — estimated, without Fresnel or refraction, at 18–22% of the
+ * sunlight scattered in the playground's milky sphere, 31% in deep water of albedo 0.9 and 55% at
+ * 0.99. As many connections as scattering events would cost about six shadow rays a scattering.
+ * @type {number}
+ */
+export const PATH_MANIFOLD_LIMIT = 4;
+
+/**
+ * `medium_scatter_nee(position, incident, host, stack, volumes_present, connections)`: one light
+ * sample at a scattering point in a medium — light chosen for a point with no surface, phase function
+ * of the medium there, transmittance to the light — per unit of path weight. Where the shadow ray
+ * stops at a refracting interface, the light is connected through it (`manifold_connect`) while the
+ * path has connections left (`connections`, counted against {@link PATH_MANIFOLD_LIMIT}).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_medium_scatter_nee = CodeChunk.from(
+    //language=WGSL
+    `
+const PATH_MANIFOLD_LIMIT: u32 = ${PATH_MANIFOLD_LIMIT}u;
+
+fn medium_scatter_nee(
+    position: vec3<f32>,
+    incident: vec3<f32>,
+    host: ${MEDIUM_STRUCT.wgsl_ref},
+    stack: ${MEDIUM_STACK_STRUCT.wgsl_ref},
+    volumes_present: bool,
+    connections: ptr<function, u32>,
+) -> vec3<f32> {
+    // a point with no surface: the zero normal weighs every light by its irradiance alone
+    let selection = select_light_importance(position, vec3<f32>(0.0), random());
+
+    if (selection.pdf <= 0.0) {
+        return vec3<f32>(0.0);
+    }
+
+    let jitter = vec2<f32>(random(), random());
+    let light = sample_light_record(&light_data, selection.light_type, selection.index, position, jitter);
+
+    var shadow_ray: ${RAY_STRUCT.wgsl_ref};
+    shadow_ray.origin = position;
+    shadow_ray.direction = light.direction;
+    shadow_ray.tmax = light.distance;
+
+    let shadow = medium_shadow_transmittance(shadow_ray, stack, volumes_present, MEDIUM_SCATTER_SHADOW_HIT_LIMIT);
+
+    var to_light = light.direction;
+    var arriving = light.emission * shadow.transmittance / light.pdf;
+
+    if (shadow.refracting && *connections < PATH_MANIFOLD_LIMIT) {
+        *connections += 1u;
+
+        let connection = manifold_connect(position, stack, volumes_present, shadow, selection.light_type, selection.index, jitter);
+
+        to_light = connection.direction;
+        arriving = connection.irradiance;
+    }
+
+    if (all(arriving <= vec3<f32>(0.0))) {
+        return vec3<f32>(0.0);
+    }
+
+    let deflection = incident - to_light;
+    let value = medium_phase_value(position, host, dot(incident, to_light), 0.25 * dot(deflection, deflection));
+
+    return value.phase * arriving / selection.pdf;
+}
+    `,
+    [
+        RAY_STRUCT.declaration_chunk,
+        MEDIUM_STRUCT.declaration_chunk,
+        MEDIUM_STACK_STRUCT.declaration_chunk,
+        chunk_random,
+        chunk_select_light_importance,
+        chunk_sample_light_record,
+        chunk_medium_path,
+        chunk_medium_phase,
+        chunk_manifold_connect,
+    ]
+);