@woosh/meep-engine 3.38.0 → 3.39.0

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

@@ -0,0 +1,41 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { f32, u32, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+
+/**
+ * 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.from({
+    position: vec3f,
+    distant: u32,
+    direction: vec3f,
+    near_clip: f32,
+    centre: vec3f,
+    light_type: u32,
+    index: u32,
+}, "ManifoldLight");
+
+/**
+ * `manifold_light_direction(light, x)`: the unit direction from `x` toward the light.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_light = CodeChunk.from(
+    //language=WGSL
+    `
+fn manifold_light_direction(light: ${MANIFOLD_LIGHT_STRUCT.wgsl_ref}, x: vec3<f32>) -> vec3<f32> {
+    if (light.distant != 0u) {
+        return light.direction;
+    }
+
+    return normalize(light.position - x);
+}
+    `,
+    [
+        MANIFOLD_LIGHT_STRUCT.declaration_chunk,
+    ]
+);

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

@@ -0,0 +1,20 @@
+/**
+ * A light as a manifold connection needs it, read from the light database the importing shader binds
+ * as `light_data`. The same lights `sample_light_record` samples, by the same rules:
+ *
+ * - `manifold_light_sample(light_type, index, jitter)`: a point within a point or spot light's
+ *   radius, with its centre, or a direction within a directional light's disk, as
+ *   {@link MANIFOLD_LIGHT_STRUCT}.
+ * - `manifold_light_intensity(light, x1, path_length)`: for a point or spot light, its intensity
+ *   toward `x1` (the spot's cone there) with the light's distance window at `path_length`, the length
+ *   of the whole refracted path from the light's centre — the light's attenuation is 1 / d² times
+ *   that window, and the 1 / d² is the beam's to give (\`manifold_beam_area\`), from the centre too.
+ *   For a directional light, its irradiance.
+ * - `manifold_light_shadow_length(light, x1)`: how far a shadow ray from `x1` runs toward it, stopping
+ *   short of a local light by its near clip.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_light_sample: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_manifold_light_sample.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_manifold_light_sample.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_light_sample.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;GAgBG;AACH,0CAFU,SAAS,CAwEjB;0BA9FwB,uCAAuC"}

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

@@ -0,0 +1,105 @@
+import { LIGHT_DATABASE_SPEC } from "../../../light/LIGHT_DATABASE_SPEC.js";
+import { chunk_cone_sample_direction } from "../../../shader/chunk/geometry/cone/chunk_cone_sample_direction.js";
+import { chunk_sphere_sample_volume } from "../../../shader/chunk/geometry/sphere/chunk_sphere_sample_volume.js";
+import { chunk_light_get_spot_attenuation } from "../../../shader/chunk/light/io/chunk_light_get_spot_attenuation.js";
+import {
+    chunk_light_sphere_distance_attenuation
+} from "../../../shader/chunk/light/io/chunk_light_sphere_distance_attenuation.js";
+import { LIGHT_SELECTION_TYPE } from "../../../shader/chunk/light/sample/LIGHT_SELECTION_STRUCT.js";
+import { F32_MAX_DEFINITION } from "../../../shader/chunk/math/F32_MAX_DEFINITION.js";
+import { chunk_hash_vec2f_to_vec3f } from "../../../shader/chunk/random/chunk_hash_vec2f_to_vec3f.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_manifold_light, MANIFOLD_LIGHT_STRUCT } from "./chunk_manifold_light.js";
+
+const POINT = LIGHT_DATABASE_SPEC.get('light_point');
+const SPOT = LIGHT_DATABASE_SPEC.get('light_spot');
+const DIRECTIONAL = LIGHT_DATABASE_SPEC.get('light_directional');
+
+/**
+ * A light as a manifold connection needs it, read from the light database the importing shader binds
+ * as `light_data`. The same lights `sample_light_record` samples, by the same rules:
+ *
+ * - `manifold_light_sample(light_type, index, jitter)`: a point within a point or spot light's
+ *   radius, with its centre, or a direction within a directional light's disk, as
+ *   {@link MANIFOLD_LIGHT_STRUCT}.
+ * - `manifold_light_intensity(light, x1, path_length)`: for a point or spot light, its intensity
+ *   toward `x1` (the spot's cone there) with the light's distance window at `path_length`, the length
+ *   of the whole refracted path from the light's centre — the light's attenuation is 1 / d² times
+ *   that window, and the 1 / d² is the beam's to give (\`manifold_beam_area\`), from the centre too.
+ *   For a directional light, its irradiance.
+ * - `manifold_light_shadow_length(light, x1)`: how far a shadow ray from `x1` runs toward it, stopping
+ *   short of a local light by its near clip.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_light_sample = CodeChunk.from(
+    //language=WGSL
+    `
+fn manifold_light_sample(light_type: u32, index: u32, jitter: vec2<f32>) -> ${MANIFOLD_LIGHT_STRUCT.wgsl_ref} {
+    var light: ${MANIFOLD_LIGHT_STRUCT.wgsl_ref};
+
+    light.light_type = light_type;
+    light.index = index;
+
+    if (light_type == ${LIGHT_SELECTION_TYPE.Point}u) {
+        let record = ${POINT.marshalling_method_read}(&light_data, index);
+
+        light.position = record.position + sphere_sample_volume(hash_vec2f_to_vec3f(jitter)) * record.radius;
+        light.centre = record.position;
+        light.near_clip = record.near_clip_distance;
+    } else if (light_type == ${LIGHT_SELECTION_TYPE.Spot}u) {
+        let record = ${SPOT.marshalling_method_read}(&light_data, index);
+
+        light.position = record.position + sphere_sample_volume(hash_vec2f_to_vec3f(jitter)) * record.radius;
+        light.centre = record.position;
+        light.near_clip = record.near_clip_distance;
+    } else {
+        let record = ${DIRECTIONAL.marshalling_method_read}(&light_data, index);
+
+        light.distant = 1u;
+        light.direction = cone_sample_direction(-record.direction, record.disk_radius, jitter);
+    }
+
+    return light;
+}
+
+fn manifold_light_intensity(light: ${MANIFOLD_LIGHT_STRUCT.wgsl_ref}, x1: vec3<f32>, path_length: f32) -> vec3<f32> {
+    if (light.light_type == ${LIGHT_SELECTION_TYPE.Point}u) {
+        let record = ${POINT.marshalling_method_read}(&light_data, light.index);
+
+        return record.color * light_sphere_distance_attenuation(path_length, record.radius, record.distance) * path_length * path_length;
+    }
+
+    if (light.light_type == ${LIGHT_SELECTION_TYPE.Spot}u) {
+        let record = ${SPOT.marshalling_method_read}(&light_data, light.index);
+
+        let cone = light_get_spot_attenuation(record.coneCos, record.penumbraCos, dot(normalize(x1 - record.position), record.direction));
+
+        return record.color * cone * light_sphere_distance_attenuation(path_length, record.radius, record.distance) * path_length * path_length;
+    }
+
+    return ${DIRECTIONAL.marshalling_method_read}(&light_data, light.index).color;
+}
+
+fn manifold_light_shadow_length(light: ${MANIFOLD_LIGHT_STRUCT.wgsl_ref}, x1: vec3<f32>) -> f32 {
+    if (light.distant != 0u) {
+        return F32_MAX;
+    }
+
+    return max(0.0, length(light.position - x1) - light.near_clip);
+}
+    `,
+    [
+        MANIFOLD_LIGHT_STRUCT.declaration_chunk,
+        chunk_manifold_light,
+        POINT.chunk_read,
+        SPOT.chunk_read,
+        DIRECTIONAL.chunk_read,
+        chunk_sphere_sample_volume,
+        chunk_hash_vec2f_to_vec3f,
+        chunk_cone_sample_direction,
+        chunk_light_sphere_distance_attenuation,
+        chunk_light_get_spot_attenuation,
+        F32_MAX_DEFINITION,
+    ]
+);

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

@@ -0,0 +1,28 @@
+/**
+ * One triangle of a smooth interface in world space: its corners, and its vertex normals carried by
+ * the instance's normal matrix and left unnormalized, so that interpolating them and normalizing
+ * gives exactly the normal the path tracer shades with (before any normal map).
+ */
+export const MANIFOLD_TRIANGLE_STRUCT: WebGPUStruct;
+/**
+ * The local model of a smooth interface that manifold next-event estimation walks on: a flat
+ * triangle carrying the normals interpolated across it. Pure functions of the triangle:
+ *
+ * - `manifold_triangle_barycentric(tri, p)`: barycentric coordinates `(b1, b2)` of a point of the
+ *   triangle's plane — or of its projection onto the plane — affine, so meaningful outside the
+ *   triangle too.
+ * - `manifold_triangle_point(tri, b)`: the point at barycentric coordinates `(b1, b2)`.
+ * - `manifold_triangle_normal(tri, p)`: the interpolated unit normal at a point of the plane,
+ *   oriented as the vertex normals are (outward for a closed mesh).
+ * - `manifold_triangle_normal_derivative(tri, p, dp)`: how that unit normal turns for a
+ *   displacement `dp` in the plane — the interface's curvature as the shading sees it, which is
+ *   what focuses light into caustics.
+ * - `manifold_triangle_geometric_normal(tri)`: the plane's unit normal, oriented by the winding.
+ * - `manifold_triangle_frame(tri)`: two orthonormal directions spanning the plane.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_triangle: CodeChunk;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_manifold_triangle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_manifold_triangle.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_triangle.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,oDAOuB;AAEvB;;;;;;;;;;;;;;;;;GAiBG;AACH,sCAFU,SAAS,CA8DjB;6BA9F2B,sCAAsC;0BAFzC,uCAAuC"}

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

@@ -0,0 +1,97 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+
+/**
+ * One triangle of a smooth interface in world space: its corners, and its vertex normals carried by
+ * the instance's normal matrix and left unnormalized, so that interpolating them and normalizing
+ * gives exactly the normal the path tracer shades with (before any normal map).
+ */
+export const MANIFOLD_TRIANGLE_STRUCT = WebGPUStruct.from({
+    p0: vec3f,
+    p1: vec3f,
+    p2: vec3f,
+    n0: vec3f,
+    n1: vec3f,
+    n2: vec3f,
+}, "ManifoldTriangle");
+
+/**
+ * The local model of a smooth interface that manifold next-event estimation walks on: a flat
+ * triangle carrying the normals interpolated across it. Pure functions of the triangle:
+ *
+ * - `manifold_triangle_barycentric(tri, p)`: barycentric coordinates `(b1, b2)` of a point of the
+ *   triangle's plane — or of its projection onto the plane — affine, so meaningful outside the
+ *   triangle too.
+ * - `manifold_triangle_point(tri, b)`: the point at barycentric coordinates `(b1, b2)`.
+ * - `manifold_triangle_normal(tri, p)`: the interpolated unit normal at a point of the plane,
+ *   oriented as the vertex normals are (outward for a closed mesh).
+ * - `manifold_triangle_normal_derivative(tri, p, dp)`: how that unit normal turns for a
+ *   displacement `dp` in the plane — the interface's curvature as the shading sees it, which is
+ *   what focuses light into caustics.
+ * - `manifold_triangle_geometric_normal(tri)`: the plane's unit normal, oriented by the winding.
+ * - `manifold_triangle_frame(tri)`: two orthonormal directions spanning the plane.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_triangle = CodeChunk.from(
+    //language=WGSL
+    `
+fn manifold_triangle_barycentric(tri: ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref}, p: vec3<f32>) -> vec2<f32> {
+    let e1 = tri.p1 - tri.p0;
+    let e2 = tri.p2 - tri.p0;
+    let d = p - tri.p0;
+
+    let a = dot(e1, e1);
+    let b = dot(e1, e2);
+    let c = dot(e2, e2);
+    let d1 = dot(d, e1);
+    let d2 = dot(d, e2);
+
+    let determinant = a * c - b * b;
+
+    return vec2<f32>(c * d1 - b * d2, a * d2 - b * d1) / determinant;
+}
+
+fn manifold_triangle_point(tri: ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref}, b: vec2<f32>) -> vec3<f32> {
+    return tri.p0 + (tri.p1 - tri.p0) * b.x + (tri.p2 - tri.p0) * b.y;
+}
+
+fn manifold_triangle_normal_unnormalized(tri: ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref}, p: vec3<f32>) -> vec3<f32> {
+    let b = manifold_triangle_barycentric(tri, p);
+
+    return tri.n0 * (1.0 - b.x - b.y) + tri.n1 * b.x + tri.n2 * b.y;
+}
+
+fn manifold_triangle_normal(tri: ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref}, p: vec3<f32>) -> vec3<f32> {
+    return normalize(manifold_triangle_normal_unnormalized(tri, p));
+}
+
+fn manifold_triangle_normal_derivative(tri: ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref}, p: vec3<f32>, dp: vec3<f32>) -> vec3<f32> {
+    let raw = manifold_triangle_normal_unnormalized(tri, p);
+    let length_raw = length(raw);
+    let n = raw / length_raw;
+
+    // barycentrics are affine in position: their change along dp is the coordinates of p0 + dp
+    let db = manifold_triangle_barycentric(tri, tri.p0 + dp);
+    let d_raw = (tri.n1 - tri.n0) * db.x + (tri.n2 - tri.n0) * db.y;
+
+    // the derivative of normalize(raw): the part of d_raw across n, over |raw|
+    return (d_raw - n * dot(n, d_raw)) / length_raw;
+}
+
+fn manifold_triangle_geometric_normal(tri: ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref}) -> vec3<f32> {
+    return normalize(cross(tri.p1 - tri.p0, tri.p2 - tri.p0));
+}
+
+fn manifold_triangle_frame(tri: ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref}) -> mat2x3<f32> {
+    let s = normalize(tri.p1 - tri.p0);
+    let t = normalize(cross(manifold_triangle_geometric_normal(tri), s));
+
+    return mat2x3<f32>(s, t);
+}
+    `,
+    [
+        MANIFOLD_TRIANGLE_STRUCT.declaration_chunk,
+    ]
+);

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

@@ -0,0 +1,12 @@
+/**
+ * `manifold_triangle_of_hit(instance, triangle)`: one triangle of a mesh instance as a
+ * {@link MANIFOLD_TRIANGLE_STRUCT}, read from the scene database and the geometries the importing
+ * shader binds (`scene_database`, `geometries` and the meshlet buffers, as for ray queries): corners
+ * by the instance's transform, vertex normals by its normal matrix — what `sample_material_data`
+ * shades with.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_triangle_of_hit: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_manifold_triangle_of_hit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_manifold_triangle_of_hit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_triangle_of_hit.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH,6CAFU,SAAS,CA6BjB;0BAvCwB,uCAAuC"}

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

@@ -0,0 +1,46 @@
+import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
+import {
+    chunk_geometry_read_triangle_vertices
+} from "../../../shader/chunk/geometry/format/chunk_geometry_read_triangle_vertices.js";
+import { chunk_compute_normal_matrix_from_m4 } from "../../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
+import { chunk_v3_matrix4_project } from "../../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { MANIFOLD_TRIANGLE_STRUCT } from "./chunk_manifold_triangle.js";
+
+/**
+ * `manifold_triangle_of_hit(instance, triangle)`: one triangle of a mesh instance as a
+ * {@link MANIFOLD_TRIANGLE_STRUCT}, read from the scene database and the geometries the importing
+ * shader binds (`scene_database`, `geometries` and the meshlet buffers, as for ray queries): corners
+ * by the instance's transform, vertex normals by its normal matrix — what `sample_material_data`
+ * shades with.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_manifold_triangle_of_hit = CodeChunk.from(
+    //language=WGSL
+    `
+fn manifold_triangle_of_hit(instance: u32, triangle: u32) -> ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref} {
+    let mesh = scene_read_mesh(&scene_database, instance);
+    let node = scene_read_node(&scene_database, mesh.node);
+
+    let vertices = geometry_read_triangle_vertices(geometries[mesh.geometry], triangle);
+    let normal_matrix = compute_normal_matrix_from_m4(node.global);
+
+    return ${MANIFOLD_TRIANGLE_STRUCT.wgsl_ref}(
+        v3_matrix4_project(vertices.a.position, node.global),
+        v3_matrix4_project(vertices.b.position, node.global),
+        v3_matrix4_project(vertices.c.position, node.global),
+        normal_matrix * vertices.a.normal,
+        normal_matrix * vertices.b.normal,
+        normal_matrix * vertices.c.normal,
+    );
+}
+    `,
+    [
+        MANIFOLD_TRIANGLE_STRUCT.declaration_chunk,
+        chunk_scene_database_access,
+        chunk_geometry_read_triangle_vertices,
+        chunk_compute_normal_matrix_from_m4,
+        chunk_v3_matrix4_project,
+    ]
+);

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

@@ -0,0 +1,25 @@
+/**
+ * Where light goes at a smooth refracting interface: the new direction, and whether it crossed.
+ */
+export const MEDIUM_INTERFACE_EVENT_STRUCT: WebGPUStruct;
+/**
+ * One event at a smooth dielectric interface: reflection with the exact Fresnel probability, or
+ * refraction by Snell's law — `medium_interface_event(incident, shading_normal, geometric_normal,
+ * eta)`, both normals facing the side `incident` arrives from, `eta` the index across the interface
+ * over the index it arrives in. Draws from `random()`.
+ *
+ * The event is taken about the shading normal, so a tessellated sphere refracts as a sphere. A
+ * shading normal is interpolated across flat triangles, though, and near an outline it can disagree
+ * with the triangle it lies on: the ray arrives behind it, or the direction it gives turns back
+ * into the surface after a reflection, or out of it after a refraction. Such light lands on the same
+ * triangle again and bounces there until the path's interface limit drops it — a dark band just
+ * inside the outline of a glass sphere, on the side the tessellation tilts the normals away. There
+ * the event is taken about the geometric normal instead, which always leaves on the right side.
+ * Either way light is reflected or transmitted whole, so no energy is lost or made.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_medium_interface: CodeChunk;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_medium_interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_medium_interface.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/media/chunk_medium_interface.js"],"names":[],"mappings":"AAMA;;GAEG;AACH,yDAG2B;AAE3B;;;;;;;;;;;;;;;;GAgBG;AACH,qCAFU,SAAS,CA6CjB;6BAtE2B,sCAAsC;0BAFzC,uCAAuC"}

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

@@ -0,0 +1,75 @@
+import { chunk_F_dielectric } from "../../../shader/chunk/brdf/fresnel/chunk_F_dielectric.js";
+import { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { bool, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+
+/**
+ * Where light goes at a smooth refracting interface: the new direction, and whether it crossed.
+ */
+export const MEDIUM_INTERFACE_EVENT_STRUCT = WebGPUStruct.from({
+    direction: vec3f,
+    refracted: bool,
+}, "MediumInterfaceEvent");
+
+/**
+ * One event at a smooth dielectric interface: reflection with the exact Fresnel probability, or
+ * refraction by Snell's law — `medium_interface_event(incident, shading_normal, geometric_normal,
+ * eta)`, both normals facing the side `incident` arrives from, `eta` the index across the interface
+ * over the index it arrives in. Draws from `random()`.
+ *
+ * The event is taken about the shading normal, so a tessellated sphere refracts as a sphere. A
+ * shading normal is interpolated across flat triangles, though, and near an outline it can disagree
+ * with the triangle it lies on: the ray arrives behind it, or the direction it gives turns back
+ * into the surface after a reflection, or out of it after a refraction. Such light lands on the same
+ * triangle again and bounces there until the path's interface limit drops it — a dark band just
+ * inside the outline of a glass sphere, on the side the tessellation tilts the normals away. There
+ * the event is taken about the geometric normal instead, which always leaves on the right side.
+ * Either way light is reflected or transmitted whole, so no energy is lost or made.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_medium_interface = CodeChunk.from(
+    //language=WGSL
+    `
+fn medium_interface_sample(incident: vec3<f32>, normal: vec3<f32>, eta: f32) -> ${MEDIUM_INTERFACE_EVENT_STRUCT.wgsl_ref} {
+    let reflectance = F_dielectric(dot(-incident, normal), eta);
+
+    if (random() >= reflectance) {
+        let transmitted = refract(incident, normal, 1.0 / eta);
+
+        // refract() gives the zero vector past the critical angle, which the reflectance has already
+        // made certain; rounding can still leave it a hair inside, where reflection is the answer
+        if (dot(transmitted, transmitted) > 0.0) {
+            return ${MEDIUM_INTERFACE_EVENT_STRUCT.wgsl_ref}(normalize(transmitted), true);
+        }
+    }
+
+    return ${MEDIUM_INTERFACE_EVENT_STRUCT.wgsl_ref}(reflect(incident, normal), false);
+}
+
+fn medium_interface_event(
+    incident: vec3<f32>,
+    shading_normal: vec3<f32>,
+    geometric_normal: vec3<f32>,
+    eta: f32,
+) -> ${MEDIUM_INTERFACE_EVENT_STRUCT.wgsl_ref} {
+    if (dot(-incident, shading_normal) > 0.0) {
+        let event = medium_interface_sample(incident, shading_normal, eta);
+
+        let side = dot(event.direction, geometric_normal);
+
+        if (select(side > 0.0, side < 0.0, event.refracted)) {
+            return event;
+        }
+    }
+
+    return medium_interface_sample(incident, geometric_normal, eta);
+}
+    `,
+    [
+        MEDIUM_INTERFACE_EVENT_STRUCT.declaration_chunk,
+        chunk_F_dielectric,
+        chunk_random,
+    ]
+);

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

@@ -0,0 +1,54 @@
+/**
+ * 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: number;
+/**
+ * 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: number;
+/**
+ * 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: number;
+/**
+ * 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;
+/**
+ * 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;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_medium_path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_medium_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/media/chunk_medium_path.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;;GAKG;AACH,sCAFU,MAAM,CAE0B;AAE1C;;;;GAIG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;;;;;GAOG;AACH,gDASmB;AAEnB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gCAFU,SAAS,CAsKjB;6BA3O2B,sCAAsC;0BAFzC,uCAAuC"}