Multiple scattering for dielectrics and absorption for lambertians

[niccolot]

Hello, i' ve finished the 3 books (thank you a lot btw) and now i wanted to add some features on my own. I decided to expand a bit the scattering of lambertians and dielectrics as noted in the 1 book. I wanted to ask if you think they are solid (the images came out supposedly correctly but since it was just some minor touch up i have i little sensation of "if it was too simple maybe you missed something").

For the lambertians i' ve added a parameter R that probabilistically attenuates more or less the result:

bool Lambertian::scatter(
    [[maybe_unused]] const Ray& r_in, 
    const HitRecord& rec, 
    ScatterRecord& srec) const {
    
    scattered_rays_t scattered_ray;

    // reflection
    if (random_double() < r) {
        
        scattered_ray.pdf = std::make_shared<CosinePDF>(rec.normal());
        scattered_ray.skip_pdf = false;
        srec.scattered_rays.push_back(scattered_ray);
        srec.attenuation = tex->value(rec.u(), rec.v(), rec.point()) * r;
    } else {
        // absorption
        srec.attenuation = tex->value(rec.u(), rec.v(), rec.point()) * (1-r);
        scattered_ray.pdf = std::make_shared<CosinePDF>(rec.normal());
        scattered_ray.skip_pdf = false;
        srec.scattered_rays.push_back(scattered_ray);
    }
    
    return true;
}

For the dielectrics i' ve introduced multiple scattered rays (reflected and refracted) and i' ve modified a bit ray_color():

first i' ve implemented this in order to store multiple rays

typedef struct ScatteredRays {
    std::shared_ptr<PDF> pdf;
    bool skip_pdf;
    Ray skip_pdf_ray;
} scattered_rays_t; // scattered_rays_t

class ScatterRecord {
    public:
        Color attenuation;
        std::vector<scattered_rays_t> scattered_rays;
}; // class ScatterRecord

then the scattering function:

bool Dielectric::scatter(
    const Ray& r_in, 
    const HitRecord& rec, 
    ScatterRecord& srec) const {

    srec.attenuation = Color(1, 1, 1);

    double ri = rec.front_face() ? (1./refractive_index) : refractive_index;
    Vec3 unit_dir = unit_vector(r_in.direction());

    double cos_theta = std::fmin(dot(-unit_dir, rec.normal()), 1.);
    double sin_theta = std::sqrt(1. - cos_theta*cos_theta);

    // total internal reflection
    bool cannot_refract = ri*sin_theta > 1.0;
    
    if (cannot_refract || reflectance(cos_theta, ri) > random_double()) {
        Vec3 direction_reflect;
        scattered_rays_t reflected_ray;

        direction_reflect = reflect(unit_dir, rec.normal());

        reflected_ray.pdf = nullptr;
        reflected_ray.skip_pdf = true;
        reflected_ray.skip_pdf_ray = Ray(rec.point(), direction_reflect, r_in.time());
        srec.scattered_rays.push_back(reflected_ray);
    } else {
        Vec3 direction_reflect, direction_refract;
        scattered_rays_t reflected_ray, refracted_ray;

        direction_refract = refract(unit_dir, rec.normal(), ri);
        direction_reflect = reflect(unit_dir, rec.normal());

        reflected_ray.skip_pdf = true;
        refracted_ray.skip_pdf = true;

        reflected_ray.skip_pdf_ray = Ray(rec.point(), direction_reflect, r_in.time());
        refracted_ray.skip_pdf_ray = Ray(rec.point(), direction_refract, r_in.time());

        srec.scattered_rays.push_back(reflected_ray);
        srec.scattered_rays.push_back(refracted_ray);
    }

    return true;
}

and the ray_color function

Color color_from_scatter = Color();
    for (const auto& ray_t : srec.scattered_rays) {
        if (ray_t.skip_pdf) {
                return srec.attenuation * ray_color(ray_t.skip_pdf_ray, depth-1, world, lights);
            }

            auto light_ptr = std::make_shared<HittablePDF>(lights, rec.point());
            MixturePDF p(light_ptr, ray_t.pdf);
            Ray scattered = Ray(rec.point(), p.generate(), r.time());
            auto pdf_value = p.value(scattered.direction());
            double scattering_pdf = rec.material()->scattering_pdf(r,rec,scattered);
            Color sample_color = ray_color(scattered, depth-1, world, lights);
             
            color_from_scatter += (srec.attenuation * scattering_pdf * sample_color) / pdf_value;
    }
    
    return color_from_emission + color_from_scatter;

some results are

All the code is at https://github.com/niccolot/path_tracer/tree/multiple_scattering