Enum rs_pbrt::core::camera::Camera

pub enum Camera {
    Environment(Box<EnvironmentCamera>),
    Orthographic(Box<OrthographicCamera>),
    Perspective(Box<PerspectiveCamera>),
    Realistic(Box<RealisticCamera>),
}

Variants

Environment(Box<EnvironmentCamera>)

Orthographic(Box<OrthographicCamera>)

Perspective(Box<PerspectiveCamera>)

Realistic(Box<RealisticCamera>)

Implementations

impl Camera

pub fn generate_ray_differential( &self, sample: &CameraSample, ray: &mut Ray ) -> Float

pub fn we(&self, ray: &Ray, p_raster2: Option<&mut Point2f>) -> Spectrum

pub fn pdf_we(&self, ray: &Ray) -> (Float, Float)

pub fn sample_wi<'a, 'b>( &self, iref: &'a InteractionCommon, lens_intr: &'b mut InteractionCommon, u: Point2f, wi: &mut Vector3f, pdf: &mut Float, p_raster: &mut Point2f, vis: &mut VisibilityTester<'a, 'b> ) -> Spectrum

pub fn get_shutter_open(&self) -> Float

pub fn get_shutter_close(&self) -> Float

pub fn get_film(&self) -> Arc<Film>

Examples found in repository

examples/parse_ass_file.rs (line 205)

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 get_clipping_start(&self) -> Float

pub fn adjust_to_clipping_start(&self, sample: &CameraSample, ray: &mut Ray)