Struct rs_pbrt::integrators::path::PathIntegrator

pub struct PathIntegrator {
    pub camera: Arc<Camera>,
    pub sampler: Box<Sampler>,
    /* private fields */
}

Path Tracing (Global Illumination) - uses the render loop of a SamplerIntegrator

Fields

camera: Arc<Camera>

sampler: Box<Sampler>

Implementations

impl PathIntegrator

pub fn new( max_depth: u32, camera: Arc<Camera>, sampler: Box<Sampler>, pixel_bounds: Bounds2i, rr_threshold: Float, light_sample_strategy: String ) -> Self

Examples found in repository

examples/parse_ass_file.rs (lines 215-222)

fn make_path_integrator(
    filter_width: Float,
    xres: i32,
    yres: i32,
    fov: Float,
    animated_cam_to_world: AnimatedTransform,
    maxdepth: i32,
    pixelsamples: i32,
) -> Option<Box<Integrator>> {
    let some_integrator: Option<Box<Integrator>>;
    let some_camera: Option<Arc<Camera>> =
        make_perspective_camera(filter_width, xres, yres, fov, animated_cam_to_world);
    if let Some(camera) = some_camera {
        let sampler_name: String = String::from("sobol");
        let mut sampler_params: ParamSet = ParamSet::default();
        sampler_params.add_int(String::from("pixelsamples"), pixelsamples);
        let some_sampler: Option<Box<Sampler>> =
            make_sampler(&sampler_name, &sampler_params, camera.get_film());
        if let Some(sampler) = some_sampler {
            // CreatePathIntegrator
            let integrator_params: ParamSet = ParamSet::default();
            let max_depth: i32 = integrator_params.find_one_int("maxdepth", maxdepth);
            let pixel_bounds: Bounds2i = camera.get_film().get_sample_bounds();
            let rr_threshold: Float = integrator_params.find_one_float("rrthreshold", 1.0 as Float);
            let light_strategy: String =
                integrator_params.find_one_string("lightsamplestrategy", String::from("spatial"));
            let integrator = Box::new(Integrator::Sampler(SamplerIntegrator::Path(
                PathIntegrator::new(
                    max_depth as u32,
                    camera,
                    sampler,
                    pixel_bounds,
                    rr_threshold,
                    light_strategy,
                ),
            )));
            some_integrator = Some(integrator);
        } else {
            panic!("Unable to create sampler.");
        }
    } else {
        panic!("Unable to create camera.");
    }
    some_integrator
}

pub fn preprocess(&mut self, scene: &Scene)

pub fn li( &self, r: &Ray, scene: &Scene, sampler: &mut Sampler, _depth: i32 ) -> Spectrum

pub fn get_camera(&self) -> Arc<Camera>

pub fn get_sampler(&self) -> &Sampler

pub fn get_pixel_bounds(&self) -> Bounds2i