Book 3.8.3: What are we supposed to do with the returned material::scatter() pdf value?

[hollasch]

We add the double pdf value reference to the material::scatter() functions, but don't show the corresponding update to camera::ray_color(), let alone how to use it.

[9mm]

lol glad to see this, i was quite confused. i still honestly dont know what to do. are you able to give a quick answer now?

This is what I attempted to do... im assuming i initialize an empty value, but im not sure about the initial value, whether it should be 0 or 1 / 2 * pi

fn ray_color<T: Hittable>(&self, r: Ray, depth: u32, world: &T) -> Color {
    if depth == 0 {
        return Color::new(0, 0, 0);
    }

    let mut rec = HitRecord::default();

    if !world.hit(r, Interval::new(0.001, f64::INFINITY), &mut rec) {
        return self.background;
    }

    let mut scattered = Ray::default();
    let mut attenuation = Color::default();
    let mut pdf = 0.0; //1.0 / (2.0 * std::f64::consts::PI);

    let color_from_emission = rec
        .mat
        .as_ref()
        .expect("material is present")
        .emitted(rec.u, rec.v, rec.p);

    // clone the material, and move the hit record
    if !rec.mat.as_ref().expect("material is present").scatter(
        r,
        &rec,
        &mut attenuation,
        &mut scattered,
        &mut pdf,
    ) {
        return color_from_emission;
    }

    let scattering_pdf = rec
        .mat
        .as_ref()
        .expect("material is present")
        .scattering_pdf(r, &rec, &scattered);

    let color_from_scatter =
        (attenuation * scattering_pdf * self.ray_color(scattered, depth - 1, world)) / pdf;

    color_from_emission + color_from_scatter
}

[9mm]

In case anyone comes across this... just proceed to the next section and it mostly answers it. Heres my finished function (after this section) which seems to be caught up.

    fn ray_color<T: Hittable>(&self, r: Ray, depth: u32, world: &T) -> Color {
        if depth == 0 {
            return Color::new(0, 0, 0);
        }

        let mut rec = HitRecord::default();

        if !world.hit(r, Interval::new(0.001, f64::INFINITY), &mut rec) {
            return self.background;
        }

        let mut scattered = Ray::default();
        let mut attenuation = Color::default();
        let mut pdf = 0.0;

        let color_from_emission = rec
            .mat
            .as_ref()
            .expect("material is present")
            .emitted(rec.u, rec.v, rec.p);

        if !rec.mat.as_ref().expect("material is present").scatter(
            r,
            &rec,
            &mut attenuation,
            &mut scattered,
            &mut pdf,
        ) {
            return color_from_emission;
        }

        let mut rng = rand::thread_rng();
        let on_light = Point3::new(rng.gen_range(213.0..343.0), 554.0, rng.gen_range(227.0..332.0));
        let mut to_light = on_light - rec.p;
        let distance_squared = to_light.length_squared();
        to_light = unit_vector(to_light);

        if dot(to_light, rec.normal) < 0.0 {
            return color_from_emission;
        }

        let light_area = (343.0 - 213.0) * (332.0 - 227.0);
        let light_cosine = f64::abs(to_light.y);
        if light_cosine < 0.000001 {
            return color_from_emission;
        }

        pdf = distance_squared / (light_cosine * light_area);
        scattered = Ray::new(rec.p, to_light, r.time);

        let scattering_pdf = rec
            .mat
            .as_ref()
            .expect("material is present")
            .scattering_pdf(r, &rec, &scattered);

        let color_from_scatter =
            (attenuation * scattering_pdf * self.ray_color(scattered, depth - 1, world)) / pdf;

        color_from_emission + color_from_scatter
    }

impl Material for Lambertian {
    fn scatter(
        &self,
        ray_in: Ray,
        rec: &HitRecord,
        attenuation: &mut Color,
        scattered: &mut Ray,
        pdf: &mut f64,
    ) -> bool {
        let uvw = Onb::new_from_w(rec.normal);
        let scatter_direction = uvw.local_from_vec(random_cosine_direction());

        *scattered = Ray::new(rec.p, unit_vector(scatter_direction), ray_in.time);
        *attenuation = self.tex.value(rec.u, rec.v, rec.p);
        *pdf = dot(uvw.w(), scattered.direction) / std::f64::consts::PI;

        true
    }

    fn scattering_pdf(&self, ray_in: Ray, rec: &HitRecord, scattered: &Ray) -> f64 {
        const SCATTERING_PDF: f64 = 1.0 / (2.0 * std::f64::consts::PI);
        SCATTERING_PDF
    }
}

impl Material for Isotropic {
    fn scatter(
        &self,
        ray_in: Ray,
        rec: &HitRecord,
        attenuation: &mut Color,
        scattered: &mut Ray,
        pdf: &mut f64,
    ) -> bool {
        *scattered = Ray::new(rec.p, random_unit_vector(), ray_in.time);
        *attenuation = self.tex.value(rec.u, rec.v, rec.p);
        *pdf = 1.0 / (4.0 * std::f64::consts::PI);

        true
    }

    fn scattering_pdf(&self, _ray_in: Ray, _rec: &HitRecord, _scattered: &Ray) -> f64 {
        1.0 / (4.0 * std::f64::consts::PI)
    }
}

[spayne]

I noticed this matter::scatter return issue as well. I think the OP issue is just that material::scatter has a double &pdf parameter added that isn't used anywhere in this section. Nor in other sections. So it sits there as an unused feature.

It should probably be deleted to avoid confusion.

[spayne]

I see what @9mm is referring to now.

Section 12.1:

• States "Fortunately, we have decided that we should only call the pdf_value() if it is diffuse, so we can handle that implicitly." This is referring to that (dead code) to calculate the pdf_value back in 3.8.3
• And then goes on to replace the double &pdf with a new scatter_record& srec in "Listing 47 Refactoring the material class"

Then in Listing 50: the returned srec.pdf_ptr is used to make the mixture_pdf p.

I suppose the smallest change would be to warn the reader in 3.8.3 that double &pdf is not used but will be refactored and then used in section 12.