Struct rs_pbrt::core::paramset::ParamSet

pub struct ParamSet {

    pub key_word: String,
    pub name: String,
    pub tex_type: String,
    pub tex_name: String,
    pub bools: Vec<ParamSetItem<bool>>,
    pub ints: Vec<ParamSetItem<i32>>,
    pub floats: Vec<ParamSetItem<Float>>,
    pub point2fs: Vec<ParamSetItem<Point2f>>,
    pub vector2fs: Vec<ParamSetItem<Vector2f>>,
    pub point3fs: Vec<ParamSetItem<Point3f>>,
    pub vector3fs: Vec<ParamSetItem<Vector3f>>,
    pub normals: Vec<ParamSetItem<Normal3f>>,
    pub spectra: Vec<ParamSetItem<Spectrum>>,
    pub strings: Vec<ParamSetItem<String>>,
    pub textures: Vec<ParamSetItem<String>>,
}

Fields

key_word: String

name: String

tex_type: String

tex_name: String

bools: Vec<ParamSetItem<bool>>

ints: Vec<ParamSetItem<i32>>

floats: Vec<ParamSetItem<Float>>

point2fs: Vec<ParamSetItem<Point2f>>

vector2fs: Vec<ParamSetItem<Vector2f>>

point3fs: Vec<ParamSetItem<Point3f>>

vector3fs: Vec<ParamSetItem<Vector3f>>

normals: Vec<ParamSetItem<Normal3f>>

spectra: Vec<ParamSetItem<Spectrum>>

strings: Vec<ParamSetItem<String>>

textures: Vec<ParamSetItem<String>>

Implementations

impl ParamSet

pub fn reset( &mut self, key_word: String, name: String, tex_type: String, tex_name: String )

pub fn add_float(&mut self, name: String, value: Float)

Examples found in repository

examples/parse_ass_file.rs (line 158)

pub fn make_perspective_camera(
    filter_width: Float,
    xres: i32,
    yres: i32,
    fov: Float,
    animated_cam_to_world: AnimatedTransform,
) -> Option<Arc<Camera>> {
    let mut some_camera: Option<Arc<Camera>> = None;
    let mut filter_params: ParamSet = ParamSet::default();
    filter_params.add_float(String::from("xwidth"), filter_width);
    filter_params.add_float(String::from("ywidth"), filter_width);
    let some_filter = make_filter(&String::from("gaussian"), &filter_params);
    if let Some(filter) = some_filter {
        let film_name: String = String::from("image");
        let mut film_params: ParamSet = ParamSet::default();
        film_params.add_int(String::from("xresolution"), xres);
        film_params.add_int(String::from("yresolution"), yres);
        let crop_window: Bounds2f = Bounds2f {
            p_min: Point2f { x: 0.0, y: 0.0 },
            p_max: Point2f { x: 1.0, y: 1.0 },
        };
        let some_film: Option<Arc<Film>> =
            make_film(&film_name, &film_params, filter, &crop_window);
        if let Some(film) = some_film {
            let camera_name: String = String::from("perspective");
            let mut camera_params: ParamSet = ParamSet::default();
            camera_params.add_float(String::from("fov"), fov);
            some_camera = make_camera(
                &camera_name,
                &camera_params,
                animated_cam_to_world,
                film,
                0.0,
            );
        }
    }
    some_camera
}

pub fn add_floats(&mut self, name: String, values: Vec<Float>)

pub fn add_int(&mut self, name: String, value: i32)

Examples found in repository

examples/parse_ass_file.rs (line 164)

pub fn make_perspective_camera(
    filter_width: Float,
    xres: i32,
    yres: i32,
    fov: Float,
    animated_cam_to_world: AnimatedTransform,
) -> Option<Arc<Camera>> {
    let mut some_camera: Option<Arc<Camera>> = None;
    let mut filter_params: ParamSet = ParamSet::default();
    filter_params.add_float(String::from("xwidth"), filter_width);
    filter_params.add_float(String::from("ywidth"), filter_width);
    let some_filter = make_filter(&String::from("gaussian"), &filter_params);
    if let Some(filter) = some_filter {
        let film_name: String = String::from("image");
        let mut film_params: ParamSet = ParamSet::default();
        film_params.add_int(String::from("xresolution"), xres);
        film_params.add_int(String::from("yresolution"), yres);
        let crop_window: Bounds2f = Bounds2f {
            p_min: Point2f { x: 0.0, y: 0.0 },
            p_max: Point2f { x: 1.0, y: 1.0 },
        };
        let some_film: Option<Arc<Film>> =
            make_film(&film_name, &film_params, filter, &crop_window);
        if let Some(film) = some_film {
            let camera_name: String = String::from("perspective");
            let mut camera_params: ParamSet = ParamSet::default();
            camera_params.add_float(String::from("fov"), fov);
            some_camera = make_camera(
                &camera_name,
                &camera_params,
                animated_cam_to_world,
                film,
                0.0,
            );
        }
    }
    some_camera
}

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 add_ints(&mut self, name: String, values: Vec<i32>)

pub fn add_bool(&mut self, name: String, value: bool)

pub fn add_point2f(&mut self, name: String, value: Point2f)

pub fn add_point2fs(&mut self, name: String, values: Vec<Float>)

pub fn add_point3f(&mut self, name: String, value: Point3f)

pub fn add_point3fs(&mut self, name: String, values: Vec<Float>)

pub fn add_sampled_spectrum_files(&mut self, name: String, names: Vec<String>)

pub fn add_string(&mut self, name: String, value: String)

pub fn add_texture(&mut self, name: String, value: String)

pub fn add_vector3f(&mut self, name: String, value: Vector3f)

pub fn add_vector3fs(&mut self, name: String, values: Vec<Float>)

pub fn add_normal3f(&mut self, name: String, value: Normal3f)

pub fn add_normal3fs(&mut self, name: String, values: Vec<Float>)

pub fn add_rgb_spectrum(&mut self, name: String, value: Spectrum)

pub fn add_blackbody_spectrum(&mut self, name: String, values: Vec<Float>)

pub fn copy_from(&mut self, param_set: &ParamSet)

pub fn erase_spectrum(&mut self, name: String) -> bool

pub fn find_one_float(&self, name: &str, d: Float) -> Float

Examples found in repository

examples/parse_ass_file.rs (line 211)

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 find_one_int(&self, name: &str, d: i32) -> i32

Examples found in repository

examples/parse_ass_file.rs (line 209)

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 find_one_bool(&self, name: &str, d: bool) -> bool

pub fn find_one_point3f(&self, name: &str, d: Point3f) -> Point3f

pub fn find_one_vector3f(&self, name: &str, d: Vector3f) -> Vector3f

pub fn find_one_spectrum(&self, name: &str, d: Spectrum) -> Spectrum

pub fn find_one_string(&self, name: &str, d: String) -> String

Examples found in repository

examples/parse_ass_file.rs (line 213)

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 find_one_filename(&self, name: &str, d: String) -> String

pub fn find_texture(&self, name: &str) -> String

pub fn find_int(&self, name: &str) -> Vec<i32>

pub fn find_float(&self, name: &str) -> Vec<Float>

pub fn find_point2f(&self, name: &str) -> Vec<Point2f>

pub fn find_vector2f(&self, name: &str) -> Vec<Vector2f>

pub fn find_point3f(&self, name: &str) -> Vec<Point3f>

pub fn find_vector3f(&self, name: &str) -> Vec<Vector3f>

pub fn find_normal3f(&self, name: &str) -> Vec<Normal3f>

pub fn find_spectrum(&self, name: &str) -> Vec<Spectrum>

Trait Implementations

impl Default for ParamSet

fn default() -> ParamSet

Returns the “default value” for a type.