Some more refactoring, more error correction. When will this end?

src/integrators/base.rs

@@ -0,0 +1,71 @@
+use super::state::PathState;
+use crate::core::light::Light;
+use shared::core::geometry::Ray;
+use shared::core::interaction::{Interaction, InteractionTrait};
+use shared::core::primitive::Primitive;
+use shared::core::shape::ShapeIntersection;
+use shared::lights::LightSampler;
+use shared::spectra::SampledWavelengths;
+use shared::utils::sampling::power_heuristic;
+use shared::{Float, SHADOW_EPSILON};
+use std::sync::Arc;
+
+#[derive(Clone, Debug)]
+pub struct IntegratorBase {
+    pub aggregate: Arc<Primitive>,
+    pub lights: Vec<Arc<Light>>,
+    pub infinite_lights: Vec<Arc<Light>>,
+}
+
+impl IntegratorBase {
+    pub fn new(aggregate: Arc<Primitive>, lights: Vec<Arc<Light>>) -> Self {
+        let infinite_lights = lights
+            .iter()
+            .filter(|light| light.light_type().is_infinite())
+            .cloned()
+            .collect();
+
+        Self {
+            aggregate,
+            lights,
+            infinite_lights,
+        }
+    }
+
+    pub fn intersect(&self, ray: &Ray, t_max: Option<Float>) -> Option<ShapeIntersection> {
+        self.aggregate.intersect(ray, t_max)
+    }
+
+    pub fn intersect_p(&self, ray: &Ray, t_max: Option<Float>) -> bool {
+        self.aggregate.intersect_p(ray, t_max)
+    }
+
+    pub fn unoccluded(&self, p0: &Interaction, p1: &Interaction) -> bool {
+        !self.intersect_p(&p0.spawn_ray_to_interaction(p1), Some(1. - SHADOW_EPSILON))
+    }
+
+    pub fn add_infinite_light_contribution(
+        &self,
+        state: &mut PathState,
+        ray: &Ray,
+        lambda: &SampledWavelengths,
+        light_sampler: Option<&LightSampler>,
+        use_mis: bool,
+    ) {
+        for light in &self.infinite_lights {
+            let le = light.le(ray, lambda);
+            if le.is_black() {
+                continue;
+            }
+
+            if state.depth == 0 || state.specular_bounce || !use_mis {
+                state.l += state.beta * le;
+            } else if let Some(sampler) = light_sampler {
+                let p_l = sampler.pmf_with_context(&state.prev_ctx, light)
+                    * light.pdf_li(&state.prev_ctx, ray.d, true);
+                let w_b = power_heuristic(1, state.prev_pdf, 1, p_l);
+                state.l += state.beta * w_b * le;
+            }
+        }
+    }
+}

src/integrators/constants.rs

@@ -0,0 +1,42 @@
+use shared::core::geometry::Point2f;
+use shared::Float;
+
+pub const N_RHO_SAMPLES: usize = 16;
+
+pub static UC_RHO: [Float; N_RHO_SAMPLES] = [
+    0.75741637,
+    0.37870818,
+    0.7083487,
+    0.18935409,
+    0.9149363,
+    0.35417435,
+    0.5990858,
+    0.09467703,
+    0.8578725,
+    0.45746812,
+    0.686759,
+    0.17708716,
+    0.9674518,
+    0.2995429,
+    0.5083201,
+    0.047338516,
+];
+
+pub static U_RHO: [Point2f; N_RHO_SAMPLES] = [
+    Point2f::new(0.855985, 0.570367),
+    Point2f::new(0.381823, 0.851844),
+    Point2f::new(0.285328, 0.764262),
+    Point2f::new(0.733380, 0.114073),
+    Point2f::new(0.542663, 0.344465),
+    Point2f::new(0.127274, 0.414848),
+    Point2f::new(0.964700, 0.947162),
+    Point2f::new(0.594089, 0.643463),
+    Point2f::new(0.095109, 0.170369),
+    Point2f::new(0.825444, 0.263359),
+    Point2f::new(0.429467, 0.454469),
+    Point2f::new(0.244460, 0.816459),
+    Point2f::new(0.756135, 0.731258),
+    Point2f::new(0.516165, 0.152852),
+    Point2f::new(0.180888, 0.214174),
+    Point2f::new(0.898579, 0.503897),
+];

src/integrators/path.rs

@@ -0,0 +1,320 @@
+use super::RayIntegratorTrait;
+use super::base::IntegratorBase;
+use super::constants::*;
+use super::state::PathState;
+use crate::Arena;
+use shared::core::bsdf::{BSDF, BSDFSample};
+use shared::core::bxdf::{BxDFFlags, FArgs, TransportMode};
+use shared::core::camera::Camera;
+use shared::core::film::VisibleSurface;
+use shared::core::geometry::{Point2i, Ray, Vector3f, VectorLike};
+use shared::core::interaction::{Interaction, InteractionTrait, SurfaceInteraction};
+use shared::core::light::{Light, LightSampleContext};
+use shared::core::primitive::Primitive;
+use shared::core::sampler::{Sampler, SamplerTrait};
+use shared::lights::sampler::LightSampler;
+use shared::lights::sampler::LightSamplerTrait;
+use shared::spectra::{SampledSpectrum, SampledWavelengths};
+use shared::utils::math::square;
+use shared::utils::sampling::{
+    power_heuristic, sample_uniform_hemisphere, sample_uniform_sphere, uniform_hemisphere_pdf,
+    uniform_sphere_pdf,
+};
+use std::sync::Arc;
+
+#[derive(Clone, Copy)]
+pub struct PathConfig {
+    pub max_depth: usize,
+    pub regularize: bool,
+    pub sample_lights: bool,
+    pub sample_bsdf: bool,
+    pub handle_volumes: bool,
+    pub use_mis: bool,
+}
+
+impl PathConfig {
+    pub const SIMPLE: Self = Self {
+        max_depth: 5,
+        regularize: false,
+        sample_lights: true,
+        sample_bsdf: true,
+        handle_volumes: false,
+        use_mis: false,
+    };
+
+    pub const FULL: Self = Self {
+        max_depth: 8,
+        regularize: true,
+        sample_lights: true,
+        sample_bsdf: true,
+        handle_volumes: false,
+        use_mis: true,
+    };
+
+    pub const VOLUMETRIC: Self = Self {
+        max_depth: 8,
+        regularize: true,
+        sample_lights: true,
+        sample_bsdf: true,
+        handle_volumes: true,
+        use_mis: true,
+    };
+}
+
+pub struct PathIntegrator {
+    base: IntegratorBase,
+    camera: Arc<Camera>,
+    light_sampler: LightSampler,
+    config: PathConfig,
+}
+
+unsafe impl Send for PathIntegrator {}
+unsafe impl Sync for PathIntegrator {}
+
+impl PathIntegrator {
+    pub fn new(
+        aggregate: Arc<Primitive>,
+        lights: Vec<Arc<Light>>,
+        camera: Arc<Camera>,
+        config: PathConfig,
+    ) -> Self {
+        let base = IntegratorBase::new(aggregate, lights.clone());
+        let light_sampler = LightSampler::new(&lights);
+        Self {
+            base,
+            camera,
+            light_sampler,
+            config,
+        }
+    }
+
+    fn sample_direct(
+        &self,
+        intr: &SurfaceInteraction,
+        bsdf: &BSDF,
+        state: &PathState,
+        lambda: &SampledWavelengths,
+        sampler: &mut Sampler,
+    ) -> SampledSpectrum {
+        let ctx = LightSampleContext::from(intr);
+
+        let Some(sampled) = self
+            .light_sampler
+            .sample_with_context(&ctx, sampler.get1d())
+        else {
+            return SampledSpectrum::ZERO;
+        };
+
+        let Some(ls) = sampled.light.sample_li(&ctx, sampler.get2d(), lambda, true) else {
+            return SampledSpectrum::ZERO;
+        };
+
+        if ls.l.is_black() || ls.pdf == 0.0 {
+            return SampledSpectrum::ZERO;
+        }
+
+        let wo = intr.wo();
+        let wi = ls.wi;
+
+        let Some(f) = bsdf.f(wo, wi, TransportMode::Radiance) else {
+            return SampledSpectrum::ZERO;
+        };
+
+        let f = f * wi.abs_dot(intr.shading.n.into());
+        if f.is_black() {
+            return SampledSpectrum::ZERO;
+        }
+
+        if !self
+            .base
+            .unoccluded(&Interaction::Surface(intr.clone()), &ls.p_light)
+        {
+            return SampledSpectrum::ZERO;
+        }
+
+        let p_l = sampled.p * ls.pdf;
+
+        if !self.config.use_mis || sampled.light.light_type().is_delta_light() {
+            ls.l * f / p_l
+        } else {
+            let p_b = bsdf.pdf(wo, wi, FArgs::default());
+            let w_l = power_heuristic(1, p_l, 1, p_b);
+            w_l * ls.l * f / p_l
+        }
+    }
+
+    fn sample_direction(
+        &self,
+        wo: Vector3f,
+        bsdf: &BSDF,
+        isect: &SurfaceInteraction,
+        sampler: &mut Sampler,
+    ) -> Option<BSDFSample> {
+        if self.config.sample_bsdf {
+            bsdf.sample_f(wo, sampler.get1d(), sampler.get2d(), FArgs::default())
+        } else {
+            self.sample_uniform(wo, bsdf, isect, sampler)
+        }
+    }
+
+    fn sample_uniform(
+        &self,
+        wo: Vector3f,
+        bsdf: &BSDF,
+        isect: &SurfaceInteraction,
+        sampler: &mut Sampler,
+    ) -> Option<BSDFSample> {
+        let flags = bsdf.flags();
+
+        let (wi, pdf) = if flags.is_reflective() && flags.is_transmissive() {
+            (sample_uniform_sphere(sampler.get2d()), uniform_sphere_pdf())
+        } else {
+            let mut wi = sample_uniform_hemisphere(sampler.get2d());
+            let same_hemi = wo.dot(isect.n().into()) * wi.dot(isect.n().into()) > 0.0;
+
+            if (flags.is_reflective() && !same_hemi) || (flags.is_transmissive() && same_hemi) {
+                wi = -wi;
+            }
+            (wi, uniform_hemisphere_pdf())
+        };
+
+        let f = bsdf.f(wo, wi, TransportMode::Radiance)?;
+
+        Some(BSDFSample {
+            f,
+            wi,
+            pdf,
+            flags: BxDFFlags::empty(), // or appropriate flags
+            eta: 1.0,
+            pdf_is_proportional: false,
+        })
+    }
+
+    fn compute_visible_surface(
+        &self,
+        isect: &SurfaceInteraction,
+        bsdf: &BSDF,
+        lambda: &SampledWavelengths,
+    ) -> VisibleSurface {
+        let albedo = bsdf.rho_wo(isect.wo(), &UC_RHO, &U_RHO);
+        VisibleSurface::new(isect, &albedo, lambda)
+    }
+}
+
+impl RayIntegratorTrait for PathIntegrator {
+    fn li(
+        &self,
+        mut ray: Ray,
+        lambda: &SampledWavelengths,
+        sampler: &mut Sampler,
+        want_visible: bool,
+        _arena: &mut Arena,
+    ) -> (SampledSpectrum, Option<VisibleSurface>) {
+        let mut state = PathState::new();
+        let mut visible = None;
+
+        loop {
+            let Some(mut si) = self.base.intersect(&ray, None) else {
+                self.base.add_infinite_light_contribution(
+                    &mut state,
+                    &ray,
+                    lambda,
+                    Some(&self.light_sampler),
+                    self.config.use_mis,
+                );
+                break;
+            };
+
+            let isect = &mut si.intr;
+
+            // Emission from hit surface
+            let le = isect.le(-ray.d, lambda);
+            if !le.is_black() {
+                if state.depth == 0 || state.specular_bounce {
+                    state.l += state.beta * le;
+                } else if self.config.use_mis {
+                    if let Some(light) = &isect.area_light {
+                        let p_l = self.light_sampler.pmf_with_context(&state.prev_ctx, light)
+                            * light.pdf_li(&state.prev_ctx, ray.d, true);
+                        let w_b = power_heuristic(1, state.prev_pdf, 1, p_l);
+                        state.l += state.beta * w_b * le;
+                    }
+                }
+            }
+
+            // Get BSDF
+            let Some(mut bsdf) = isect.get_bsdf(&ray, lambda, &self.camera, sampler) else {
+                state.specular_bounce = true;
+                isect.skip_intersection(&mut ray, si.t_hit());
+                continue;
+            };
+
+            // Visible surface at primary hit
+            if state.depth == 0 && want_visible {
+                visible = Some(self.compute_visible_surface(isect, &bsdf, lambda));
+            }
+
+            // Depth check
+            if state.depth >= self.config.max_depth {
+                break;
+            }
+            state.depth += 1;
+
+            // Regularization
+            if self.config.regularize && state.any_non_specular_bounces {
+                bsdf.regularize();
+            }
+
+            // Direct lighting
+            if self.config.sample_lights && bsdf.flags().is_non_specular() {
+                state.l += state.beta * self.sample_direct(isect, &bsdf, &state, lambda, sampler);
+            }
+
+            // Sample BSDF for next direction
+            let wo = -ray.d;
+            let Some(bs) = self.sample_direction(wo, &bsdf, isect, sampler) else {
+                break;
+            };
+
+            state.beta *= bs.f * bs.wi.abs_dot(isect.shading.n.into()) / bs.pdf;
+            state.prev_pdf = if bs.pdf_is_proportional {
+                bsdf.pdf(wo, bs.wi, FArgs::default())
+            } else {
+                bs.pdf
+            };
+            state.specular_bounce = bs.is_specular();
+            state.any_non_specular_bounces |= !bs.is_specular();
+
+            if bs.is_transmissive() {
+                state.eta_scale *= square(bs.eta);
+            }
+
+            state.prev_ctx = LightSampleContext::from(&*isect);
+            ray = isect.spawn_ray_with_differentials(&ray, bs.wi, bs.flags, bs.eta);
+
+            // Russian roulette
+            if state.russian_roulette(sampler, 1) {
+                break;
+            }
+        }
+
+        (state.l, visible)
+    }
+
+    fn evaluate_pixel_sample(
+        &self,
+        p_pixel: Point2i,
+        sample_ind: usize,
+        sampler: &mut Sampler,
+        arena: &mut Arena,
+    ) {
+        crate::integrators::pipeline::evaluate_pixel_sample(
+            self,
+            self.camera.as_ref(),
+            sampler,
+            p_pixel,
+            sample_ind,
+            arena,
+        );
+    }
+}

src/integrators/pipeline.rs

@@ -1,12 +1,19 @@
+use super::RayIntegratorTrait;
+use super::base::IntegratorBase;
+use crate::Arena;
 use crate::core::image::{Image, ImageMetadata};
 use crate::spectra::get_spectra_context;
 use indicatif::{ProgressBar, ProgressStyle};
+use shared::Float;
+use shared::core::camera::Camera;
+use shared::core::geometry::{Bounds2i, Point2i};
+use shared::core::options::get_options;
+use shared::core::sampler::Sampler;
 use shared::core::sampler::get_camera_sample;
+use shared::spectra::SampledSpectrum;
 use std::io::Write;
 use std::path::Path;
 
-use super::*;
-
 struct PbrtProgress {
     bar: ProgressBar,
 }

src/integrators/state.rs

@@ -0,0 +1,45 @@
+use shared::Float;
+use shared::core::light::LightSampleContext;
+use shared::core::sampler::{Sampler, SamplerTrait};
+use shared::spectra::SampledSpectrum;
+
+pub struct PathState {
+    pub l: SampledSpectrum,
+    pub beta: SampledSpectrum,
+    pub depth: usize,
+    pub specular_bounce: bool,
+    pub any_non_specular_bounces: bool,
+    pub eta_scale: Float,
+    pub prev_ctx: LightSampleContext,
+}
+
+impl PathState {
+    pub fn new() -> Self {
+        Self {
+            l: SampledSpectrum::new(0.0),
+            beta: SampledSpectrum::new(1.0),
+            depth: 0,
+            specular_bounce: false,
+            any_non_specular_bounces: false,
+            eta_scale: 1.0,
+            prev_ctx: LightSampleContext::default(),
+        }
+    }
+
+    pub fn terminated(&self) -> bool {
+        self.beta.is_black()
+    }
+
+    /// Termination check
+    pub fn russian_roulette(&mut self, sampler: &mut Sampler, min_depth: usize) -> bool {
+        let rr_beta = self.beta * self.eta_scale;
+        if rr_beta.max_component_value() < 1.0 && self.depth > min_depth {
+            let q = (1.0 - rr_beta.max_component_value()).max(0.0);
+            if sampler.get1d() < q {
+                return true; // terminate
+            }
+            self.beta /= 1.0 - q;
+        }
+        false
+    }
+}