@woosh/meep-engine 3.37.0 → 3.39.0

package/src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js

@@ -27,10 +27,19 @@ import { MATERIAL_SHADING_INFO_STRUCT } from "../../shader/chunk/material/MATERI
 import { RECIPROCAL_PI_DECLARATION } from "../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
 import { chunk_random } from "../../shader/chunk/random/chunk_random.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { chunk_ray_shaded_query_occluded } from "./chunk_ray_shaded_query_occluded.js";
+import {
+    chunk_participating_media_volumes_iterate
+} from "../../volumetrics/chunk_participating_media_volumes_iterate.js";
 import { chunk_russian_roulette } from "./chunk_russian_roulette.js";
 import { chunk_sample_material_data } from "./chunk_sample_material_data.js";
 import { chunk_shading_closure_from_material_data } from "./chunk_shading_closure_from_material_data.js";
+import { chunk_medium_interface } from "./media/chunk_medium_interface.js";
+import { chunk_manifold_connect } from "./manifold/chunk_manifold_connect.js";
+import { chunk_medium_path } from "./media/chunk_medium_path.js";
+import { chunk_medium_scatter_nee } from "./media/chunk_medium_scatter_nee.js";
+import { chunk_medium_phase } from "./media/chunk_medium_phase.js";
+import { chunk_medium_stack, MEDIUM_CROSSING_STRUCT } from "./media/chunk_medium_stack.js";
+import { chunk_medium_transport, MEDIUM_PATH_STATE_STRUCT } from "./media/chunk_medium_transport.js";
 
 export const PATH_TRACE_RESULT_STRUCT = WebGPUStruct.from({
     irradiance: vec3f,
@@ -38,10 +47,104 @@ export const PATH_TRACE_RESULT_STRUCT = WebGPUStruct.from({
     bounces: u32,
 });
 
-
+/**
+ * Scattering events in media one path may take. Each costs a ray to the next surface and a shadow
+ * ray, and every thread of a group waits for its longest path, so this bounds the work a thread can
+ * hold its group for rather than leaving it to Russian roulette, which a medium that scatters much
+ * and absorbs little barely ends. Light still in such a medium after this many events is dropped.
+ * @type {number}
+ */
+export const PATH_MEDIUM_SCATTER_LIMIT = 32;
+
+/**
+ * Reflections and refractions at interfaces into media one path may take: entering and leaving a
+ * glass costs two, water in a glass four, total internal reflection one each. Not counted against
+ * the caller's bounce limit, which is for diffuse and glossy bounces. Light still bouncing between
+ * interfaces after this many is dropped: 0.3% of a white furnace built to trap it (a scattering
+ * n = 1.333 sphere), where 64 events dropped none measurable.
+ * @type {number}
+ */
+export const PATH_INTERFACE_EVENT_LIMIT = 16;
+
+/**
+ * Interface events a path takes about the interpolated shading normal; after them, about the
+ * triangle's own. A tessellated curved interface traps light the smooth one it stands for would
+ * not: a ray entering a sphere near its outline refracts to just under the critical angle, the
+ * normals interpolated across flat triangles tip it over at the far side, and from there the
+ * interpolated normals keep its angle from triangle to triangle, so it circles by total internal
+ * reflection until {@link PATH_INTERFACE_EVENT_LIMIT} drops it — a dark band inside the outline. The
+ * triangles' own normals break that symmetry and let it out. Every event still reflects or
+ * transmits the light whole.
+ *
+ * Measured on a white furnace with an n = 1.5 sphere of 5,000 triangles, at its left outline, the
+ * side the tessellation tilts: with 64 interface events, 4.4% low always smooth, 1.1% with 8 smooth
+ * events, 0.66% with 2 (and loss appearing on the other sides); with 16, 2.8% with 8 smooth events
+ * and 1.4% with 4. What remains is light the faceted surface itself holds past the limit.
+ * @type {number}
+ */
+export const PATH_INTERFACE_SMOOTH_EVENT_LIMIT = 4;
+
+/**
+ * Medium-bounding surfaces one path may pass straight through, where no interface is: a second
+ * mesh of the medium it is in, or a medium of lower priority.
+ * @type {number}
+ */
+export const PATH_MEDIUM_PASS_LIMIT = 8;
+
+/**
+ * How far above a surface's horizon, as the cosine to its geometric normal, the shadow ray toward a
+ * light behind the surface goes, inside a medium, to find the interface its light may bend through.
+ * @type {number}
+ */
+export const PATH_HORIZON_LIFT = 0.05;
+
+/**
+ * Traces one path and returns the radiance it carries back along `inRay`.
+ *
+ * Between surfaces the path crosses participating media: the medium the surfaces it entered through
+ * enclose (`StandardShadeMaterial.medium`, on the material's surface) and the scene's
+ * participating-media volumes. In them it may scatter (light sampled from the scattering point, then
+ * the medium's phase function sampled) or be absorbed — see chunk_medium_transport for the
+ * estimators, which track RGB with hero-channel MIS: every contribution is the path's throughput over
+ * the mean of its MIS state `r_u`, and `r_u` stays 1 where there are no media, leaving such paths
+ * exactly as they were.
+ *
+ * Light from a light behind one refracting interface — the sun under water, a lamp behind glass —
+ * reaches surfaces and scattering points by manifold next-event estimation (`manifold_connect`), up to
+ * `PATH_MANIFOLD_LIMIT` connections a path. A surface inside a medium chooses its light with no
+ * receiver cosine and traces its shadow ray whichever side of it the light is on, since the
+ * interface may bend the light round to its front. Two things still judge by the straight line to
+ * the light: a spot's cone, which can rule out a receiver its refracted beam reaches, and a surface
+ * outside every medium lit through an interface by a light inside one — a pool light on a ceiling.
+ *
+ * A surface inside a medium reflects by the ratio of its index to the medium's (its specular F0).
+ *
+ * A surface whose material has a medium is a refracting interface into it — exact Fresnel at the
+ * ratio of the two sides' `ior_factor`, total internal reflection, the radiance weight
+ * (n_from / n_to)² refraction carries — with probability `transmission_factor`, and the rest of its
+ * material otherwise. Without a medium, transmission is thin-walled, as it always was.
+ *
+ * `bounce_limit` counts diffuse and glossy surface bounces, as it always did; interface events and
+ * medium scattering have their own limits ({@link PATH_INTERFACE_EVENT_LIMIT},
+ * {@link PATH_MEDIUM_SCATTER_LIMIT}).
+ *
+ * The importing shader binds the ray-tracing group, `materials`, `textures`, `media`, `light_data`
+ * and `tEnvironment`.
+ */
 export const chunk_render_trace_path = CodeChunk.from(
     //language=WGSL
     `
+const PATH_MEDIUM_SCATTER_LIMIT: u32 = ${PATH_MEDIUM_SCATTER_LIMIT}u;
+const PATH_INTERFACE_EVENT_LIMIT: u32 = ${PATH_INTERFACE_EVENT_LIMIT}u;
+const PATH_INTERFACE_SMOOTH_EVENT_LIMIT: u32 = ${PATH_INTERFACE_SMOOTH_EVENT_LIMIT}u;
+const PATH_MEDIUM_PASS_LIMIT: u32 = ${PATH_MEDIUM_PASS_LIMIT}u;
+const PATH_HORIZON_LIFT: f32 = ${PATH_HORIZON_LIFT};
+
+// a path's throughput as a contribution: over the mean of its MIS state
+fn path_contribution_weight(state: ${MEDIUM_PATH_STATE_STRUCT.wgsl_ref}) -> vec3<f32> {
+    return state.beta / ((state.r_u.x + state.r_u.y + state.r_u.z) * (1.0 / 3.0));
+}
+
 fn render_trace_path(
     inRay: ${RAY_STRUCT.wgsl_ref},
     bounce_limit: u32
@@ -52,23 +155,84 @@ fn render_trace_path(
     
     var irradiance: vec3<f32>;
     
-    var throughput = vec3(1.0);
+    var state: ${MEDIUM_PATH_STATE_STRUCT.wgsl_ref};
+    state.beta = vec3<f32>(1.0);
+    state.r_u = vec3<f32>(1.0);
+    state.hero = min(u32(random() * 3.0), 2u);
+    state.capped = 0u;
         
     var ray = inRay;
         
+    // the media bounded by refracting surfaces the path is inside, and whether there are volumes
+    var stack = medium_stack_at(ray.origin);
+    let volumes_present = participating_media_volumes_count(&scene_database) > 0u;
+
     var bounce_index = 0u;
+    var interface_events = 0u;
+    var scatter_events = 0u;
+    var passes = 0u;
+    var manifold_connections = 0u;
+    var first_segment = true;
     
     const ENVIRONMENT_FIREFLY_CLAMP = 10.0; // miximum luninance of the environment
         
-    for(; bounce_index < bounce_limit; bounce_index++){
+    loop {
+        if (bounce_index >= bounce_limit) {
+            break;
+        }
            
         let hit = ray_query_nearest(ray);
         
-        if(bounce_index == 0){
+        if (first_segment) {
             // record distance to first intersection
             result.distance = hit.t;
+            first_segment = false;
         }
     
+        if (stack.depth > 0u || volumes_present) {
+            // through the medium to the surface, or to wherever the medium stops the path
+            let host = medium_host_of_stack(stack);
+            let collision = medium_free_flight(ray.origin, ray.direction, select(F32_MAX, hit.t, hit.t > 0.0), host, &state);
+
+            if (collision.event == MEDIUM_EVENT_ABSORBED) {
+                break;
+            }
+
+            if (collision.event == MEDIUM_EVENT_SCATTERED) {
+                scatter_events++;
+
+                if (scatter_events > PATH_MEDIUM_SCATTER_LIMIT) {
+                    break;
+                }
+
+                let position = ray.origin + ray.direction * collision.t;
+
+                irradiance += path_contribution_weight(state) * medium_scatter_nee(position, ray.direction, host, stack, volumes_present, &manifold_connections);
+
+                let scattered = medium_phase_sample(position, host, ray.direction);
+
+                state.beta *= scattered.weight;
+
+                ray.origin = position;
+                ray.direction = scattered.direction;
+                ray.tmax = F32_MAX;
+
+                // Russian roulette on what the path still carries, after a few events
+                let carried = path_contribution_weight(state);
+                let survival = saturate(max(carried.x, max(carried.y, carried.z)));
+
+                if (scatter_events > 3u) {
+                    if (random() > survival) {
+                        break;
+                    }
+
+                    state.beta /= survival;
+                }
+
+                continue;
+            }
+        }
+
         if(hit.t <= 0.0){
             // didn't hit anything
             
@@ -81,7 +245,7 @@ fn render_trace_path(
                 environment_sample *= ENVIRONMENT_FIREFLY_CLAMP / env_luma;
             }
             
-            irradiance += throughput * environment_sample;
+            irradiance += path_contribution_weight(state) * environment_sample;
                         
             break;
         }
@@ -122,15 +286,38 @@ fn render_trace_path(
         // following suggestion from "Triangle Intersection Offset: A Fast and Robust Method for Avoiding Self-Intersection" from Ray-Tracing Gems
         let hit_position = shading_geometry.position;
         
+        // a surface that bounds a medium is an interface into it, or not there at all
+        var at_interface = false;
+        var crossing: ${MEDIUM_CROSSING_STRUCT.wgsl_ref};
         
-        if(
-            shading_material.opacity < 1.0
+        if (material_info.medium != MEDIUM_NONE) {
+            crossing = medium_crossing(stack, mesh.material, material_data.front_facing);
+
+            if (!crossing.is_interface) {
+                // the same medium on both sides, or one of lower priority: straight on
+                stack = crossing.stack;
+                passes++;
+
+                if (passes > PATH_MEDIUM_PASS_LIMIT) {
+                    break;
+                }
+
+                ray.origin = offset_ray(hit_position, -shading_geometry.geometric_normal);
+                ray.tmax = F32_MAX;
+
+                continue;
+            }
+
+            at_interface = true;
+        }
+
+        if (
+            !at_interface
+            && shading_material.opacity < 1.0
             && random() > shading_material.opacity // roll for transmission
         ){
             // transmission
         
-            // TODO accummulate scattering
-        
             // hit a transparent surface, let's adjust the ray and resume
             let NoD = dot(shading_geometry.geometric_normal, ray.direction);
             
@@ -140,15 +327,81 @@ fn render_trace_path(
             // offset in the direction of the normal, along the ray, effectivelly pushing through the surface
             ray.origin = offset_ray(hit_position , offset_direction );
             
+            bounce_index++;
+
             continue;
         }
         
-        let incoming_throughput = throughput;
+        let incoming_weight = path_contribution_weight(state);
         
         // accummulate emissive component of the material
-        irradiance += incoming_throughput * shading_material.emissive;
+        irradiance += incoming_weight * shading_material.emissive;
         
+        if (at_interface && random() < material_data.transmission) {
+            // the interface itself: a smooth dielectric between the two sides' indices of refraction
+            interface_events++;
         
+            if (interface_events > PATH_INTERFACE_EVENT_LIMIT) {
+                break;
+            }
+
+            let n_outside = medium_ior_of_material(crossing.outside);
+            let n_inside = medium_ior_of_material(crossing.inside);
+            let n_from = select(n_inside, n_outside, material_data.front_facing);
+            let n_to = select(n_outside, n_inside, material_data.front_facing);
+
+            // both normals face the side the ray arrives from; a path still bouncing between interfaces
+            // after a few events is trapped by the tessellation, and the triangle's normal lets it out
+            let event = medium_interface_event(
+                ray.direction,
+                select(
+                    shading_geometry.shading_normal,
+                    shading_geometry.geometric_normal,
+                    interface_events > PATH_INTERFACE_SMOOTH_EVENT_LIMIT
+                ),
+                shading_geometry.geometric_normal,
+                n_to / n_from
+            );
+
+            ray.direction = event.direction;
+
+            if (!event.refracted) {
+                ray.origin = offset_ray(hit_position, shading_geometry.geometric_normal);
+            } else {
+                ray.origin = offset_ray(hit_position, -shading_geometry.geometric_normal);
+
+                // radiance over n² is what crosses an interface unchanged
+                let ratio = n_from / n_to;
+                state.beta *= ratio * ratio;
+
+                stack = crossing.stack;
+            }
+
+            ray.tmax = F32_MAX;
+
+            continue;
+        }
+
+        // MaterialX/OpenPBR substrate split: the (1 - F) energy that doesn't
+        // reflect feeds a substrate that mixes diffuse and transmission. The
+        // transmission scalar is read straight off material_data — it isn't
+        // carried in MATERIAL_SHADING_INFO_STRUCT because that struct is
+        // shared with non-path-tracer code paths that don't need it.
+        var transmission_weight = material_data.transmission;
+
+        if (at_interface) {
+            // the rest of a medium-bounding surface, picked with probability (1 - transmission): its
+            // diffuse undivided by it, and its transmission is the interface's, not a thin wall
+            shading_material.diffuse = material_data.albedo * (1.0 - material_data.metalness);
+            transmission_weight = 0.0;
+        } else if (stack.depth > 0u) {
+            // a surface reflects by the ratio of its index to the medium's it is seen from: a stone
+            // (1.5) under water (1.333) reflects 0.0035 head-on, not the 0.04 it does in air
+            let n_host = medium_ior_of_material(medium_stack_top(stack));
+
+            shading_material.specularF0 = dielectric_specular_color(material_data.ior / n_host, material_data.metalness, material_data.albedo);
+        }
+
         let incoming_ray_origin = ray.origin;
         let incoming_ray_direction = ray.direction;
         
@@ -172,76 +425,96 @@ fn render_trace_path(
         // probability. Folding the cosine into the proxy reduces the dynamic
         // range of selection PDFs and tames firefly amplification on grazing
         // and back-facing geometry.
-        let selection = select_light_importance(hit_position, N, random());
+        //
+        // Inside a medium, light can arrive bent by an interface the straight line to it crosses — the
+        // sun on an underwater slope that faces away from it in air — so there the selection takes no
+        // receiver cosine, and the shadow ray goes out whichever side of the surface the light is on.
+        let inside_medium = stack.depth > 0u;
+        let selection = select_light_importance(hit_position, select(N, vec3<f32>(0.0), inside_medium), random());
 
         if (selection.pdf > 0.0) {
 
             let jitter = vec2(random(), random());
             let light_record = sample_light_record(&light_data, selection.light_type, selection.index, hit_position, jitter);
 
-            let L = light_record.direction;
-            let NoL = dot( N, L );
+            // straight to the light, or — where a refracting interface is in the way — through it
+            var L = light_record.direction;
+            var arriving = vec3<f32>(0.0);
+
+            if (dot(N, L) > 0.0 || inside_medium) {
+                // a light behind the surface can only reach it bent by an interface, and the straight
+                // line toward it runs into the surface itself: the shadow ray goes along the surface's
+                // horizon toward it instead, a little above, to find that interface. Nothing reaches
+                // the surface along it straight.
+                let ng = shading_geometry.geometric_normal;
+                let below = inside_medium && dot(ng, L) <= 0.0;
 
-            if ( NoL > 0.0 ){
                 var shadow_ray: ${RAY_STRUCT.wgsl_ref};
                 shadow_ray.origin = ray.origin;
-                shadow_ray.direction = light_record.direction;
+                shadow_ray.direction = select(L, normalize(L - ng * (dot(ng, L) - PATH_HORIZON_LIFT)), below);
                 shadow_ray.tmax = light_record.distance;
 
-                // TODO make sure we sample opacity of the surface for the shadow ray, currently it only samples geometry and treats it as fully opaque
-
-                if(!ray_shaded_query_occluded(shadow_ray)){
-
-                    let H = normalize(L + V);
-                    let NoH = saturate( dot( N, H ) );
-                    let VoH = saturate( dot( V, H ) );
-                    let LoV = saturate( dot( L, V ) );
-
-                    // selection.pdf is the discrete selection probability;
-                    // light_record.pdf is the within-light density (1.0 for our analytical local lights today).
-                    let inv_pdf = 1.0 / (selection.pdf * light_record.pdf);
-                    let light_irradiance = light_record.emission * NoL * inv_pdf;
-
-                    var diffuse_brdf = oren_nayar_compensated_diffuse(
-                        NoV,
-                        NoL,
-                        LoV,
-                        roughness,
-                        shading_material.diffuse
-                    );
-
-                    var specular_brdf = BRDF_GGX(
-                        NoL,
-                        NoV,
-                        NoH*NoH,
-                        VoH,
-                        shading_material.specularF0,
-                        shading_material.specularF90,
-                        alpha
-                    );
-
-                    // Calculate the terminator term for the light direction [cite: 72]
-                    let G_terminator = shadow_terminator_term(L, shading_geometry.geometric_normal, shading_geometry.shading_normal);
-
-                    // Use the BRDF evaluated for the light direction, NOT the bounce direction.
-                    // oren_nayar_compensated_diffuse is unnormalized (see EON.js), the 1/PI
-                    // normalization is applied here, matching the deferred consumers and the
-                    // albedo/PI convention assumed by the cosine-weighted bounce below.
-                    irradiance += incoming_throughput * (diffuse_brdf * RECIPROCAL_PI + specular_brdf) * light_irradiance * G_terminator;
+                // what reaches the surface through media, thin glass and alpha holes;
+                // light_record.pdf is the within-light density (1.0 for our analytical local lights today)
+                let shadow = medium_shadow_transmittance(shadow_ray, stack, volumes_present, MEDIUM_SHADOW_HIT_LIMIT);
+
+                arriving = select(light_record.emission * shadow.transmittance / light_record.pdf, vec3<f32>(0.0), below);
+
+                if (shadow.refracting && manifold_connections < PATH_MANIFOLD_LIMIT) {
+                    manifold_connections += 1u;
+
+                    let connection = manifold_connect(ray.origin, stack, volumes_present, shadow, selection.light_type, selection.index, jitter);
+
+                    L = connection.direction;
+                    arriving = connection.irradiance;
                 }
             }
+
+            let NoL = dot( N, L );
+
+            if ( NoL > 0.0 && any(arriving > vec3<f32>(0.0)) ){
+
+                let H = normalize(L + V);
+                let NoH = saturate( dot( N, H ) );
+                let VoH = saturate( dot( V, H ) );
+                let LoV = saturate( dot( L, V ) );
+
+                // selection.pdf is the discrete selection probability
+                let light_irradiance = arriving * NoL / selection.pdf;
+
+                var diffuse_brdf = oren_nayar_compensated_diffuse(
+                    NoV,
+                    NoL,
+                    LoV,
+                    roughness,
+                    shading_material.diffuse
+                );
+
+                var specular_brdf = BRDF_GGX(
+                    NoL,
+                    NoV,
+                    NoH*NoH,
+                    VoH,
+                    shading_material.specularF0,
+                    shading_material.specularF90,
+                    alpha
+                );
+
+                // Calculate the terminator term for the light direction [cite: 72]
+                let G_terminator = shadow_terminator_term(L, shading_geometry.geometric_normal, shading_geometry.shading_normal);
+
+                // Use the BRDF evaluated for the light direction, NOT the bounce direction.
+                // oren_nayar_compensated_diffuse is unnormalized (see EON.js), the 1/PI
+                // normalization is applied here, matching the deferred consumers and the
+                // albedo/PI convention assumed by the cosine-weighted bounce below.
+                irradiance += incoming_weight * (diffuse_brdf * RECIPROCAL_PI + specular_brdf) * light_irradiance * G_terminator;
+            }
         }
                 
         let fresnel = F_Hauber(shading_material.specularF0, shading_material.specularF90, NoV);
         let specular_weight = rgb_to_luminance(fresnel);
         let diffuse_weight = rgb_to_luminance(shading_material.diffuse);
 
-        // MaterialX/OpenPBR substrate split: the (1 - F) energy that doesn't
-        // reflect feeds a substrate that mixes diffuse and transmission. The
-        // transmission scalar is read straight off material_data — it isn't
-        // carried in MATERIAL_SHADING_INFO_STRUCT because that struct is
-        // shared with non-path-tracer code paths that don't need it.
-        let transmission_weight = material_data.transmission;
         let substrate_weight = diffuse_weight + transmission_weight;
 
         let specular_probability = clamp(
@@ -275,8 +548,9 @@ fn render_trace_path(
             let termV = NoL * sqrt(fma(NoV * NoV, (1.0 - a2), a2));
             let termL = NoV * sqrt(fma(NoL * NoL, (1.0 - a2), a2));
 
-            // The specular weight simplifies to this:
-            let spec_weight = F * (termV / (termV + termL));
+            // The specular weight F G2 / G1(V) simplifies to this: G2 = 2 NoL NoV / (termV + termL),
+            // G1(V) = 2 NoV / (NoV + sqrt(a2 + (1 - a2) NoV²)) — one for a smooth lobe
+            let spec_weight = F * ((NoL * NoV + termV) / (termV + termL));
 
             weight = spec_weight / specular_probability;
         } else {
@@ -326,22 +600,29 @@ fn render_trace_path(
             weight *= G_terminator;
         }
                 
-        throughput *= weight;
+        state.beta *= weight;
         
         
         ray.tmax = F32_MAX;
         
     
-        // termination logic
+        // termination logic, on what the path carries
+        let mean_r_u = (state.r_u.x + state.r_u.y + state.r_u.z) * (1.0 / 3.0);
+        var carried = state.beta / mean_r_u;
+
         let killed = russian_roulette(
             bounce_index,
             bounce_limit,
-            &throughput
+            &carried
         );
         
         if(killed){
             break;
         }
+
+        state.beta = carried * mean_r_u;
+
+        bounce_index++;
     }
         
     result.bounces = bounce_index;
@@ -355,6 +636,8 @@ fn render_trace_path(
         GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
         MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
         PATH_TRACE_RESULT_STRUCT.declaration_chunk,
+        MEDIUM_PATH_STATE_STRUCT.declaration_chunk,
+        MEDIUM_CROSSING_STRUCT.declaration_chunk,
         RECIPROCAL_PI_DECLARATION,
         chunk_rgb_to_luminance,
         chunk_geometry_read_triangle_vertices,
@@ -374,7 +657,14 @@ fn render_trace_path(
         chunk_russian_roulette,
         chunk_F_Hauber,
         chunk_shadow_terminator_term_Dreamworks2020,
-        chunk_ray_shaded_query_occluded,
         chunk_scene_database_access,
+        chunk_participating_media_volumes_iterate,
+        chunk_medium_stack,
+        chunk_medium_transport,
+        chunk_medium_phase,
+        chunk_medium_interface,
+        chunk_medium_path,
+        chunk_medium_scatter_nee,
+        chunk_manifold_connect,
     ]
-);
+);

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,0CAFU,SAAS,CA+FlB;AAED,mDAuIC;0BAjPyB,oCAAoC"}
+{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,0CAFU,SAAS,CA+FlB;AAED,mDAwIC;0BAnPyB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js

@@ -2,7 +2,6 @@ import { chunk_compute_normal_matrix_from_m4 } from "../../shader/chunk/geometry
 import {
     chunk_mat4_linear_determinant
 } from "../../shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js";
-import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
 import { chunk_F_Hauber } from "../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
 import { chunk_albedo_unpremultiply } from "../../shader/chunk/material/chunk_albedo_unpremultiply.js";
 import {
@@ -27,6 +26,7 @@ import { chunk_v3_matrix4_project } from "../../shader/chunk/geometry/vec3/chunk
 import { chunk_random_vec3 } from "../../shader/chunk/random/chunk_random_vec3.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { INDIRECT_MATERIAL_STRUCT } from "../../material/resident/INDIRECT_MATERIAL_STRUCT.js";
+import { chunk_indirect_sample_tangent_normal } from "./chunk_indirect_sample_tangent_normal.js";
 import { chunk_indirect_sample_texture } from "./chunk_indirect_sample_texture.js";
 
 import { RAY_HIT_TRANSPARENT_SURFACE_DESCRIPTION_STRUCT } from "./RAY_HIT_TRANSPARENT_SURFACE_DESCRIPTION_STRUCT.js";
@@ -216,7 +216,7 @@ fn sample_material_data(
 
     let world_tangent_frame = build_orthonormal_matrix_nt(world_vertex_normal, vec4(world_tangent, tangent_handedness));
 
-    var normal_sample = decode_tangent_normal(indirect_sample_texture(material.texture_normal, material.sampler_normal, uv));
+    var normal_sample = indirect_sample_tangent_normal(material.texture_normal, material.sampler_normal, uv);
     
     var output: ${STANDARD_MATERIAL_DATA_STRUCT.wgsl_ref};
     
@@ -225,6 +225,7 @@ fn sample_material_data(
     output.opacity = texture_sample_diffuse.a * material.color_albedo.a;
     output.normal_shading = shading_normal;
     output.normal_geometric = world_face_normal;
+    output.front_facing = !is_back_facing;
     
     const bit_step = 1.0 / 255.0;
     
@@ -260,9 +261,9 @@ fn sample_material_data(
         chunk_compute_normal_matrix_from_m4,
         chunk_mat4_linear_determinant,
         chunk_build_orthonormal_matrix_nt,
-        chunk_decode_tangent_normal,
         chunk_compute_triangle_face_normal,
         chunk_indirect_sample_texture,
+        chunk_indirect_sample_tangent_normal,
         chunk_albedo_unpremultiply,
         chunk_random_vec3,
     ]

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_manifold_beam.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/path_tracer/shader/manifold/chunk_manifold_beam.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,kCAFU,SAAS,CA2EjB;0BAjGwB,uCAAuC"}